feat: User login commands (#1228)

* feat: change login to command side

* feat: change login to command side

* fix: fix push on user

* feat: user command side

* feat: sign out

* feat: command side login

* feat: command side login

* feat: fix register user

* feat: fix register user

* feat: fix web auth n events

* feat: add machine keys

* feat: send codes

* feat: move authrequest to domain

* feat: move authrequest to domain

* feat: webauthn working

* feat: external users

* feat: external users login

* feat: notify users

* fix: tests

* feat: cascade remove user grants on project remove

* fix: webauthn

* fix: pr requests

* fix: register human with member

* fix: fix bugs

* fix: fix bugs

internal/iam/model/idp_provider_view.go

@@ -2,6 +2,7 @@ package model
 
 import (
 	"github.com/caos/zitadel/internal/model"
+	"github.com/caos/zitadel/internal/v2/domain"
 	"time"
 )
 
@@ -60,3 +61,63 @@ func (r *IDPProviderSearchRequest) EnsureLimit(limit uint64) {
 func (r *IDPProviderSearchRequest) AppendAggregateIDQuery(aggregateID string) {
 	r.Queries = append(r.Queries, &IDPProviderSearchQuery{Key: IDPProviderSearchKeyAggregateID, Method: model.SearchMethodEquals, Value: aggregateID})
 }
+
+func IdpProviderViewsToDomain(idpProviders []*IDPProviderView) []*domain.IDPProvider {
+	providers := make([]*domain.IDPProvider, len(idpProviders))
+	for i, provider := range idpProviders {
+		p := &domain.IDPProvider{
+			IDPConfigID:   provider.IDPConfigID,
+			Type:          idpProviderTypeToDomain(provider.IDPProviderType),
+			Name:          provider.Name,
+			IDPConfigType: idpConfigTypeToDomain(provider.IDPConfigType),
+			StylingType:   idpStylingTypeToDomain(provider.StylingType),
+			IDPState:      idpStateToDomain(provider.IDPState),
+		}
+		providers[i] = p
+	}
+	return providers
+}
+
+func idpProviderTypeToDomain(idpType IDPProviderType) domain.IdentityProviderType {
+	switch idpType {
+	case IDPProviderTypeSystem:
+		return domain.IdentityProviderTypeSystem
+	case IDPProviderTypeOrg:
+		return domain.IdentityProviderTypeOrg
+	default:
+		return domain.IdentityProviderTypeSystem
+	}
+}
+
+func idpConfigTypeToDomain(idpType IdpConfigType) domain.IDPConfigType {
+	switch idpType {
+	case IDPConfigTypeOIDC:
+		return domain.IDPConfigTypeOIDC
+	case IDPConfigTypeSAML:
+		return domain.IDPConfigTypeSAML
+	default:
+		return domain.IDPConfigTypeOIDC
+	}
+}
+
+func idpStylingTypeToDomain(stylingType IDPStylingType) domain.IDPConfigStylingType {
+	switch stylingType {
+	case IDPStylingTypeGoogle:
+		return domain.IDPConfigStylingTypeGoogle
+	default:
+		return domain.IDPConfigStylingTypeUnspecified
+	}
+}
+
+func idpStateToDomain(state IDPConfigState) domain.IDPConfigState {
+	switch state {
+	case IDPConfigStateActive:
+		return domain.IDPConfigStateActive
+	case IDPConfigStateInactive:
+		return domain.IDPConfigStateInactive
+	case IDPConfigStateRemoved:
+		return domain.IDPConfigStateRemoved
+	default:
+		return domain.IDPConfigStateActive
+	}
+}

internal/iam/model/login_policy_view.go

@@ -1,7 +1,9 @@
 package model
 
 import (
+	"github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/model"
+	"github.com/caos/zitadel/internal/v2/domain"
 	"time"
 )
 
@@ -64,3 +66,57 @@ func (p *LoginPolicyView) HasMultiFactors() bool {
 	}
 	return true
 }
+
+func (p *LoginPolicyView) ToLoginPolicyDomain() *domain.LoginPolicy {
+	return &domain.LoginPolicy{
+		ObjectRoot: models.ObjectRoot{
+			AggregateID:  p.AggregateID,
+			CreationDate: p.CreationDate,
+			ChangeDate:   p.ChangeDate,
+			Sequence:     p.Sequence,
+		},
+		Default:               p.Default,
+		AllowUsernamePassword: p.AllowUsernamePassword,
+		AllowRegister:         p.AllowRegister,
+		AllowExternalIDP:      p.AllowExternalIDP,
+		ForceMFA:              p.ForceMFA,
+		PasswordlessType:      passwordLessTypeToDomain(p.PasswordlessType),
+		SecondFactors:         secondFactorsToDomain(p.SecondFactors),
+		MultiFactors:          multiFactorsToDomain(p.MultiFactors),
+	}
+}
+
+func passwordLessTypeToDomain(passwordless PasswordlessType) domain.PasswordlessType {
+	switch passwordless {
+	case PasswordlessTypeNotAllowed:
+		return domain.PasswordlessTypeNotAllowed
+	case PasswordlessTypeAllowed:
+		return domain.PasswordlessTypeAllowed
+	default:
+		return domain.PasswordlessTypeNotAllowed
+	}
+}
+
+func secondFactorsToDomain(types []SecondFactorType) []domain.SecondFactorType {
+	secondfactors := make([]domain.SecondFactorType, len(types))
+	for i, secondfactorType := range types {
+		switch secondfactorType {
+		case SecondFactorTypeU2F:
+			secondfactors[i] = domain.SecondFactorTypeU2F
+		case SecondFactorTypeOTP:
+			secondfactors[i] = domain.SecondFactorTypeOTP
+		}
+	}
+	return secondfactors
+}
+
+func multiFactorsToDomain(types []MultiFactorType) []domain.MultiFactorType {
+	multifactors := make([]domain.MultiFactorType, len(types))
+	for i, multifactorType := range types {
+		switch multifactorType {
+		case MultiFactorTypeU2FWithPIN:
+			multifactors[i] = domain.MultiFactorTypeU2FWithPIN
+		}
+	}
+	return multifactors
+}