mirror of
https://github.com/zitadel/zitadel.git
synced 2024-12-15 04:18:01 +00:00
73d37459bb
* feat: label policy proto extension * feat: label policy and activate event * feat: label policy asset events * feat: label policy asset commands * feat: add storage key * feat: storage key validation * feat: label policy asset tests * feat: label policy query side * feat: avatar * feat: avatar event * feat: human avatar * feat: avatar read side * feat: font on iam label policy * feat: label policy font * feat: possiblity to create bucket on put file * uplaoder * login policy logo * set bucket prefix * feat: avatar upload * feat: avatar upload * feat: use assets on command side * feat: fix human avatar removed event * feat: remove human avatar * feat: mock asset storage * feat: remove human avatar * fix(operator): add configuration of asset storage to zitadel operator * feat(console): private labeling policy (#1697) * private labeling component, routing, preview * font, colors, upload, i18n * show logo * fix: uniqueness (#1710) * fix: uniqueconstraint to lower * feat: change org * feat: org change test * feat: change org * fix: tests * fix: handle domain claims correctly * feat: update org Co-authored-by: fabi <fabienne.gerschwiler@gmail.com> * fix: handle domain claimed event correctly for service users (#1711) * fix: handle domain claimed event correctly on user view * fix: ignore domain claimed events for email notifications * fix: change org * handle org changed in read models correctly * fix: change org in user grant handler Co-authored-by: fabi <fabienne.gerschwiler@gmail.com> * fix: correct value (#1695) * docs(api): correct link (#1712) * upload service Co-authored-by: Livio Amstutz <livio.a@gmail.com> Co-authored-by: fabi <fabienne.gerschwiler@gmail.com> Co-authored-by: Florian Forster <florian@caos.ch> * feat: fix tests, * feat: remove assets from label policy * fix npm, set environment * lint ts * remove stylelinting * fix(operator): add mapping for console with changed unit tests * fix(operator): add secrets as env variables to pod * feat: remove human avatar * fix(operator): add secrets as env variables to pod * feat: map label policy * feat: labelpolicy, admin, mgmt, adv settings (#1715) * fetch label policy, mgmt, admin service * feat: advanced beh, links, add, update * lint ts * feat: watermark * feat: remove human avatar * feat: remove human avatar * feat: remove human avatar * feat: remove human avatar * feat: remove human avatar * feat: remove human avatar * feat: remove human avatar * feat: custom css * css * css * css * css * css * getobject * feat: dynamic handler * feat: varibale css * content info * css overwrite * feat: variablen css * feat: generate css file * feat: dark mode * feat: dark mode * fix logo css * feat: upload logos * dark mode with cookie * feat: handle images in login * avatar css and begin font * feat: avatar * feat: user avatar * caching of static assets in login * add avatar.js to main.html * feat: header dont show logo if no url * feat: label policy colors * feat: mock asset storage * feat: mock asset storage * feat: fix tests * feat: user avatar * feat: header logo * avatar * avatar * make it compatible with go 1.15 * feat: remove unused logos * fix handler * fix: styling error handling * fonts * fix: download func * switch to mux * fix: change upload api to assets * fix build * fix: download avatar * fix: download logos * fix: my avatar * font * fix: remove error msg popup possibility * fix: docs * fix: svalidate colors * rem msg popup from frontend * fix: email with private labeling * fix: tests * fix: email templates * fix: change migration version * fix: fix duplicate imports * fix(console): assets, service url, upload, policy current and preview (#1781) * upload endpoint, layout * fetch current, preview, fix upload * cleanup private labeling * fix linting * begin generated asset handler * generate asset api in dockerfile * features for label policy * features for label policy * features * flag for asset generator * change asset generator flag * fix label policy view in grpc * fix: layout, activate policy (#1786) * theme switcher up on top * change layout * activate policy * feat(console): label policy back color, layout (#1788) * theme switcher up on top * change layout * activate policy * fix overwrite value fc * reset policy, reset service * autosave policy, preview desc, layout impv * layout, i18n * background colors, inject material styles * load images * clean, lint * fix layout * set custom hex * fix content size conversion * remove font format in generated css * fix features for assets * fix(console): label policy colors, image downloads, preview (#1804) * load images * colors, images binding * lint * refresh emitter * lint * propagate font colors * upload error handling * label policy feature check * add blob in csp for console * log * fix: feature edits for label policy, refresh state on upload (#1807) * show error on load image, stop spinner * fix merge * fix migration versions * fix assets * fix csp * fix background color * scss * fix build * lint scss * fix statik for console * fix features check for label policy * cleanup * lint * public links * fix notifications * public links * feat: merge main * feat: fix translation files * fix migration * set api domain * fix logo in email * font face in email * font face in email * validate assets on upload * cleanup * add missing translations * add missing translations Co-authored-by: Livio Amstutz <livio.a@gmail.com> Co-authored-by: Stefan Benz <stefan@caos.ch> Co-authored-by: Max Peintner <max@caos.ch> Co-authored-by: Florian Forster <florian@caos.ch>
522 lines
16 KiB
Go
522 lines
16 KiB
Go
package model
|
|
|
|
import (
|
|
"database/sql/driver"
|
|
"encoding/json"
|
|
"time"
|
|
|
|
"github.com/caos/logging"
|
|
"github.com/lib/pq"
|
|
|
|
req_model "github.com/caos/zitadel/internal/auth_request/model"
|
|
caos_errs "github.com/caos/zitadel/internal/errors"
|
|
"github.com/caos/zitadel/internal/eventstore/v1/models"
|
|
iam_model "github.com/caos/zitadel/internal/iam/model"
|
|
org_model "github.com/caos/zitadel/internal/org/model"
|
|
"github.com/caos/zitadel/internal/user/model"
|
|
es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
|
|
)
|
|
|
|
const (
|
|
UserKeyUserID = "id"
|
|
UserKeyUserName = "user_name"
|
|
UserKeyFirstName = "first_name"
|
|
UserKeyLastName = "last_name"
|
|
UserKeyNickName = "nick_name"
|
|
UserKeyDisplayName = "display_name"
|
|
UserKeyEmail = "email"
|
|
UserKeyState = "user_state"
|
|
UserKeyResourceOwner = "resource_owner"
|
|
UserKeyLoginNames = "login_names"
|
|
UserKeyPreferredLoginName = "preferred_login_name"
|
|
UserKeyType = "user_type"
|
|
)
|
|
|
|
type userType string
|
|
|
|
const (
|
|
userTypeHuman = "human"
|
|
userTypeMachine = "machine"
|
|
)
|
|
|
|
type UserView struct {
|
|
ID string `json:"-" gorm:"column:id;primary_key"`
|
|
CreationDate time.Time `json:"-" gorm:"column:creation_date"`
|
|
ChangeDate time.Time `json:"-" gorm:"column:change_date"`
|
|
ResourceOwner string `json:"-" gorm:"column:resource_owner"`
|
|
State int32 `json:"-" gorm:"column:user_state"`
|
|
LastLogin time.Time `json:"-" gorm:"column:last_login"`
|
|
LoginNames pq.StringArray `json:"-" gorm:"column:login_names"`
|
|
PreferredLoginName string `json:"-" gorm:"column:preferred_login_name"`
|
|
Sequence uint64 `json:"-" gorm:"column:sequence"`
|
|
Type userType `json:"-" gorm:"column:user_type"`
|
|
UserName string `json:"userName" gorm:"column:user_name"`
|
|
*MachineView
|
|
*HumanView
|
|
}
|
|
|
|
type UserState int32
|
|
|
|
const (
|
|
UserStateUnspecified UserState = iota
|
|
UserStateActive
|
|
UserStateInactive
|
|
UserStateDeleted
|
|
UserStateLocked
|
|
UserStateSuspend
|
|
UserStateInitial
|
|
)
|
|
|
|
type HumanView struct {
|
|
FirstName string `json:"firstName" gorm:"column:first_name"`
|
|
LastName string `json:"lastName" gorm:"column:last_name"`
|
|
NickName string `json:"nickName" gorm:"column:nick_name"`
|
|
DisplayName string `json:"displayName" gorm:"column:display_name"`
|
|
PreferredLanguage string `json:"preferredLanguage" gorm:"column:preferred_language"`
|
|
Gender int32 `json:"gender" gorm:"column:gender"`
|
|
AvatarKey string `json:"storeKey" gorm:"column:avatar_key"`
|
|
Email string `json:"email" gorm:"column:email"`
|
|
IsEmailVerified bool `json:"-" gorm:"column:is_email_verified"`
|
|
Phone string `json:"phone" gorm:"column:phone"`
|
|
IsPhoneVerified bool `json:"-" gorm:"column:is_phone_verified"`
|
|
Country string `json:"country" gorm:"column:country"`
|
|
Locality string `json:"locality" gorm:"column:locality"`
|
|
PostalCode string `json:"postalCode" gorm:"column:postal_code"`
|
|
Region string `json:"region" gorm:"column:region"`
|
|
StreetAddress string `json:"streetAddress" gorm:"column:street_address"`
|
|
OTPState int32 `json:"-" gorm:"column:otp_state"`
|
|
U2FTokens WebAuthNTokens `json:"-" gorm:"column:u2f_tokens"`
|
|
MFAMaxSetUp int32 `json:"-" gorm:"column:mfa_max_set_up"`
|
|
MFAInitSkipped time.Time `json:"-" gorm:"column:mfa_init_skipped"`
|
|
InitRequired bool `json:"-" gorm:"column:init_required"`
|
|
|
|
PasswordSet bool `json:"-" gorm:"column:password_set"`
|
|
PasswordChangeRequired bool `json:"-" gorm:"column:password_change_required"`
|
|
UsernameChangeRequired bool `json:"-" gorm:"column:username_change_required"`
|
|
PasswordChanged time.Time `json:"-" gorm:"column:password_change"`
|
|
PasswordlessTokens WebAuthNTokens `json:"-" gorm:"column:passwordless_tokens"`
|
|
}
|
|
|
|
type WebAuthNTokens []*WebAuthNView
|
|
|
|
type WebAuthNView struct {
|
|
ID string `json:"webAuthNTokenId"`
|
|
Name string `json:"webAuthNTokenName,omitempty"`
|
|
State int32 `json:"state,omitempty"`
|
|
}
|
|
|
|
func (t WebAuthNTokens) Value() (driver.Value, error) {
|
|
if t == nil {
|
|
return nil, nil
|
|
}
|
|
return json.Marshal(&t)
|
|
}
|
|
|
|
func (t *WebAuthNTokens) Scan(src interface{}) error {
|
|
if b, ok := src.([]byte); ok {
|
|
return json.Unmarshal(b, t)
|
|
}
|
|
if s, ok := src.(string); ok {
|
|
return json.Unmarshal([]byte(s), t)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (h *HumanView) IsZero() bool {
|
|
return h == nil || h.FirstName == ""
|
|
}
|
|
|
|
type MachineView struct {
|
|
Name string `json:"name" gorm:"column:machine_name"`
|
|
Description string `json:"description" gorm:"column:machine_description"`
|
|
}
|
|
|
|
func (m *MachineView) IsZero() bool {
|
|
return m == nil || m.Name == ""
|
|
}
|
|
|
|
func UserToModel(user *UserView) *model.UserView {
|
|
userView := &model.UserView{
|
|
ID: user.ID,
|
|
UserName: user.UserName,
|
|
ChangeDate: user.ChangeDate,
|
|
CreationDate: user.CreationDate,
|
|
ResourceOwner: user.ResourceOwner,
|
|
State: model.UserState(user.State),
|
|
LastLogin: user.LastLogin,
|
|
PreferredLoginName: user.PreferredLoginName,
|
|
LoginNames: user.LoginNames,
|
|
Sequence: user.Sequence,
|
|
}
|
|
if !user.HumanView.IsZero() {
|
|
userView.HumanView = &model.HumanView{
|
|
PasswordSet: user.PasswordSet,
|
|
PasswordChangeRequired: user.PasswordChangeRequired,
|
|
PasswordChanged: user.PasswordChanged,
|
|
PasswordlessTokens: WebauthnTokensToModel(user.PasswordlessTokens),
|
|
U2FTokens: WebauthnTokensToModel(user.U2FTokens),
|
|
FirstName: user.FirstName,
|
|
LastName: user.LastName,
|
|
NickName: user.NickName,
|
|
DisplayName: user.DisplayName,
|
|
AvatarKey: user.AvatarKey,
|
|
PreferredLanguage: user.PreferredLanguage,
|
|
Gender: model.Gender(user.Gender),
|
|
Email: user.Email,
|
|
IsEmailVerified: user.IsEmailVerified,
|
|
Phone: user.Phone,
|
|
IsPhoneVerified: user.IsPhoneVerified,
|
|
Country: user.Country,
|
|
Locality: user.Locality,
|
|
PostalCode: user.PostalCode,
|
|
Region: user.Region,
|
|
StreetAddress: user.StreetAddress,
|
|
OTPState: model.MFAState(user.OTPState),
|
|
MFAMaxSetUp: req_model.MFALevel(user.MFAMaxSetUp),
|
|
MFAInitSkipped: user.MFAInitSkipped,
|
|
InitRequired: user.InitRequired,
|
|
}
|
|
}
|
|
|
|
if !user.MachineView.IsZero() {
|
|
userView.MachineView = &model.MachineView{
|
|
Description: user.MachineView.Description,
|
|
Name: user.MachineView.Name,
|
|
}
|
|
}
|
|
return userView
|
|
}
|
|
|
|
func UsersToModel(users []*UserView) []*model.UserView {
|
|
result := make([]*model.UserView, len(users))
|
|
for i, p := range users {
|
|
result[i] = UserToModel(p)
|
|
}
|
|
return result
|
|
}
|
|
|
|
func WebauthnTokensToModel(tokens []*WebAuthNView) []*model.WebAuthNView {
|
|
if tokens == nil {
|
|
return nil
|
|
}
|
|
result := make([]*model.WebAuthNView, len(tokens))
|
|
for i, t := range tokens {
|
|
result[i] = WebauthnTokenToModel(t)
|
|
}
|
|
return result
|
|
}
|
|
|
|
func WebauthnTokenToModel(token *WebAuthNView) *model.WebAuthNView {
|
|
return &model.WebAuthNView{
|
|
TokenID: token.ID,
|
|
Name: token.Name,
|
|
State: model.MFAState(token.State),
|
|
}
|
|
}
|
|
|
|
func (u *UserView) GenerateLoginName(domain string, appendDomain bool) string {
|
|
if !appendDomain {
|
|
return u.UserName
|
|
}
|
|
return u.UserName + "@" + domain
|
|
}
|
|
|
|
func (u *UserView) SetLoginNames(policy *iam_model.OrgIAMPolicy, domains []*org_model.OrgDomain) {
|
|
loginNames := make([]string, 0)
|
|
for _, d := range domains {
|
|
if d.Verified {
|
|
loginNames = append(loginNames, u.GenerateLoginName(d.Domain, true))
|
|
}
|
|
}
|
|
if !policy.UserLoginMustBeDomain {
|
|
loginNames = append(loginNames, u.UserName)
|
|
}
|
|
u.LoginNames = loginNames
|
|
}
|
|
|
|
func (u *UserView) AppendEvent(event *models.Event) (err error) {
|
|
u.ChangeDate = event.CreationDate
|
|
u.Sequence = event.Sequence
|
|
switch event.Type {
|
|
case es_model.MachineAdded:
|
|
u.CreationDate = event.CreationDate
|
|
u.setRootData(event)
|
|
u.Type = userTypeMachine
|
|
err = u.setData(event)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
case es_model.UserAdded,
|
|
es_model.UserRegistered,
|
|
es_model.HumanRegistered,
|
|
es_model.HumanAdded:
|
|
u.CreationDate = event.CreationDate
|
|
u.setRootData(event)
|
|
u.Type = userTypeHuman
|
|
err = u.setData(event)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = u.setPasswordData(event)
|
|
case es_model.UserRemoved:
|
|
u.State = int32(model.UserStateDeleted)
|
|
case es_model.UserPasswordChanged,
|
|
es_model.HumanPasswordChanged:
|
|
err = u.setPasswordData(event)
|
|
case es_model.HumanPasswordlessTokenAdded:
|
|
err = u.addPasswordlessToken(event)
|
|
case es_model.HumanPasswordlessTokenVerified:
|
|
err = u.updatePasswordlessToken(event)
|
|
case es_model.HumanPasswordlessTokenRemoved:
|
|
err = u.removePasswordlessToken(event)
|
|
case es_model.UserProfileChanged,
|
|
es_model.HumanProfileChanged,
|
|
es_model.UserAddressChanged,
|
|
es_model.HumanAddressChanged,
|
|
es_model.MachineChanged:
|
|
err = u.setData(event)
|
|
case es_model.DomainClaimed:
|
|
if u.HumanView != nil {
|
|
u.HumanView.UsernameChangeRequired = true
|
|
}
|
|
err = u.setData(event)
|
|
case es_model.UserUserNameChanged:
|
|
if u.HumanView != nil {
|
|
u.HumanView.UsernameChangeRequired = false
|
|
}
|
|
err = u.setData(event)
|
|
case es_model.UserEmailChanged,
|
|
es_model.HumanEmailChanged:
|
|
u.IsEmailVerified = false
|
|
err = u.setData(event)
|
|
case es_model.UserEmailVerified,
|
|
es_model.HumanEmailVerified:
|
|
u.IsEmailVerified = true
|
|
case es_model.UserPhoneChanged,
|
|
es_model.HumanPhoneChanged:
|
|
u.IsPhoneVerified = false
|
|
err = u.setData(event)
|
|
case es_model.UserPhoneVerified,
|
|
es_model.HumanPhoneVerified:
|
|
u.IsPhoneVerified = true
|
|
case es_model.UserPhoneRemoved,
|
|
es_model.HumanPhoneRemoved:
|
|
u.Phone = ""
|
|
u.IsPhoneVerified = false
|
|
case es_model.UserDeactivated:
|
|
u.State = int32(model.UserStateInactive)
|
|
case es_model.UserReactivated,
|
|
es_model.UserUnlocked:
|
|
u.State = int32(model.UserStateActive)
|
|
case es_model.UserLocked:
|
|
u.State = int32(model.UserStateLocked)
|
|
case es_model.MFAOTPAdded,
|
|
es_model.HumanMFAOTPAdded:
|
|
u.OTPState = int32(model.MFAStateNotReady)
|
|
case es_model.MFAOTPVerified,
|
|
es_model.HumanMFAOTPVerified:
|
|
u.OTPState = int32(model.MFAStateReady)
|
|
u.MFAInitSkipped = time.Time{}
|
|
case es_model.MFAOTPRemoved,
|
|
es_model.HumanMFAOTPRemoved:
|
|
u.OTPState = int32(model.MFAStateUnspecified)
|
|
case es_model.HumanMFAU2FTokenAdded:
|
|
err = u.addU2FToken(event)
|
|
case es_model.HumanMFAU2FTokenVerified:
|
|
err = u.updateU2FToken(event)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
u.MFAInitSkipped = time.Time{}
|
|
case es_model.HumanMFAU2FTokenRemoved:
|
|
err = u.removeU2FToken(event)
|
|
case es_model.MFAInitSkipped,
|
|
es_model.HumanMFAInitSkipped:
|
|
u.MFAInitSkipped = event.CreationDate
|
|
case es_model.InitializedUserCodeAdded,
|
|
es_model.InitializedHumanCodeAdded:
|
|
u.InitRequired = true
|
|
case es_model.InitializedUserCheckSucceeded,
|
|
es_model.InitializedHumanCheckSucceeded:
|
|
u.InitRequired = false
|
|
case es_model.HumanAvatarAdded:
|
|
u.setData(event)
|
|
case es_model.HumanAvatarRemoved:
|
|
u.AvatarKey = ""
|
|
}
|
|
u.ComputeObject()
|
|
return err
|
|
}
|
|
|
|
func (u *UserView) setRootData(event *models.Event) {
|
|
u.ID = event.AggregateID
|
|
u.ResourceOwner = event.ResourceOwner
|
|
}
|
|
|
|
func (u *UserView) setData(event *models.Event) error {
|
|
if err := json.Unmarshal(event.Data, u); err != nil {
|
|
logging.Log("MODEL-lso9e").WithError(err).Error("could not unmarshal event data")
|
|
return caos_errs.ThrowInternal(nil, "MODEL-8iows", "could not unmarshal data")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (u *UserView) setPasswordData(event *models.Event) error {
|
|
password := new(es_model.Password)
|
|
if err := json.Unmarshal(event.Data, password); err != nil {
|
|
logging.Log("MODEL-sdw4r").WithError(err).Error("could not unmarshal event data")
|
|
return caos_errs.ThrowInternal(nil, "MODEL-6jhsw", "could not unmarshal data")
|
|
}
|
|
u.PasswordSet = password.Secret != nil
|
|
u.PasswordChangeRequired = password.ChangeRequired
|
|
u.PasswordChanged = event.CreationDate
|
|
return nil
|
|
}
|
|
|
|
func (u *UserView) addPasswordlessToken(event *models.Event) error {
|
|
token, err := webAuthNViewFromEvent(event)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i, t := range u.PasswordlessTokens {
|
|
if t.State == int32(model.MFAStateNotReady) {
|
|
u.PasswordlessTokens[i].ID = token.ID
|
|
return nil
|
|
}
|
|
}
|
|
token.State = int32(model.MFAStateNotReady)
|
|
u.PasswordlessTokens = append(u.PasswordlessTokens, token)
|
|
return nil
|
|
}
|
|
|
|
func (u *UserView) updatePasswordlessToken(event *models.Event) error {
|
|
token, err := webAuthNViewFromEvent(event)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i, t := range u.PasswordlessTokens {
|
|
if t.ID == token.ID {
|
|
u.PasswordlessTokens[i].Name = token.Name
|
|
u.PasswordlessTokens[i].State = int32(model.MFAStateReady)
|
|
return nil
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (u *UserView) removePasswordlessToken(event *models.Event) error {
|
|
token, err := webAuthNViewFromEvent(event)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i, t := range u.PasswordlessTokens {
|
|
if t.ID == token.ID {
|
|
u.PasswordlessTokens[i] = u.PasswordlessTokens[len(u.PasswordlessTokens)-1]
|
|
u.PasswordlessTokens[len(u.PasswordlessTokens)-1] = nil
|
|
u.PasswordlessTokens = u.PasswordlessTokens[:len(u.PasswordlessTokens)-1]
|
|
return nil
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (u *UserView) addU2FToken(event *models.Event) error {
|
|
token, err := webAuthNViewFromEvent(event)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i, t := range u.U2FTokens {
|
|
if t.State == int32(model.MFAStateNotReady) {
|
|
u.U2FTokens[i].ID = token.ID
|
|
return nil
|
|
}
|
|
}
|
|
token.State = int32(model.MFAStateNotReady)
|
|
u.U2FTokens = append(u.U2FTokens, token)
|
|
return nil
|
|
}
|
|
|
|
func (u *UserView) updateU2FToken(event *models.Event) error {
|
|
token, err := webAuthNViewFromEvent(event)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i, t := range u.U2FTokens {
|
|
if t.ID == token.ID {
|
|
u.U2FTokens[i].Name = token.Name
|
|
u.U2FTokens[i].State = int32(model.MFAStateReady)
|
|
return nil
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (u *UserView) removeU2FToken(event *models.Event) error {
|
|
token, err := webAuthNViewFromEvent(event)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i := len(u.U2FTokens) - 1; i >= 0; i-- {
|
|
if u.U2FTokens[i].ID == token.ID {
|
|
u.U2FTokens[i] = u.U2FTokens[len(u.U2FTokens)-1]
|
|
u.U2FTokens[len(u.U2FTokens)-1] = nil
|
|
u.U2FTokens = u.U2FTokens[:len(u.U2FTokens)-1]
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func webAuthNViewFromEvent(event *models.Event) (*WebAuthNView, error) {
|
|
token := new(WebAuthNView)
|
|
err := json.Unmarshal(event.Data, token)
|
|
if err != nil {
|
|
return nil, caos_errs.ThrowInternal(err, "MODEL-FSaq1", "could not unmarshal data")
|
|
}
|
|
return token, err
|
|
}
|
|
|
|
func (u *UserView) ComputeObject() {
|
|
if !u.MachineView.IsZero() {
|
|
if u.State == int32(model.UserStateUnspecified) {
|
|
u.State = int32(model.UserStateActive)
|
|
}
|
|
return
|
|
}
|
|
if u.State == int32(model.UserStateUnspecified) || u.State == int32(model.UserStateInitial) {
|
|
if u.IsEmailVerified {
|
|
u.State = int32(model.UserStateActive)
|
|
} else {
|
|
u.State = int32(model.UserStateInitial)
|
|
}
|
|
}
|
|
u.ComputeMFAMaxSetUp()
|
|
}
|
|
|
|
func (u *UserView) ComputeMFAMaxSetUp() {
|
|
for _, token := range u.PasswordlessTokens {
|
|
if token.State == int32(model.MFAStateReady) {
|
|
u.MFAMaxSetUp = int32(req_model.MFALevelMultiFactor)
|
|
return
|
|
}
|
|
}
|
|
for _, token := range u.U2FTokens {
|
|
if token.State == int32(model.MFAStateReady) {
|
|
u.MFAMaxSetUp = int32(req_model.MFALevelSecondFactor)
|
|
return
|
|
}
|
|
}
|
|
if u.OTPState == int32(model.MFAStateReady) {
|
|
u.MFAMaxSetUp = int32(req_model.MFALevelSecondFactor)
|
|
return
|
|
}
|
|
u.MFAMaxSetUp = int32(req_model.MFALevelNotSetUp)
|
|
}
|
|
|
|
func (u *UserView) SetEmptyUserType() {
|
|
if u.MachineView != nil && u.MachineView.Name == "" {
|
|
u.MachineView = nil
|
|
} else {
|
|
u.HumanView = nil
|
|
}
|
|
}
|