2020-05-18 10:06:36 +00:00
|
|
|
package handler
|
|
|
|
|
|
|
|
import (
|
2022-06-03 12:37:24 +00:00
|
|
|
"context"
|
|
|
|
|
2022-04-26 23:01:45 +00:00
|
|
|
"github.com/zitadel/logging"
|
2022-03-23 08:02:39 +00:00
|
|
|
|
2022-04-26 23:01:45 +00:00
|
|
|
"github.com/zitadel/zitadel/internal/domain"
|
|
|
|
"github.com/zitadel/zitadel/internal/errors"
|
|
|
|
"github.com/zitadel/zitadel/internal/eventstore"
|
|
|
|
v1 "github.com/zitadel/zitadel/internal/eventstore/v1"
|
|
|
|
"github.com/zitadel/zitadel/internal/eventstore/v1/models"
|
|
|
|
"github.com/zitadel/zitadel/internal/eventstore/v1/query"
|
2022-06-03 12:37:24 +00:00
|
|
|
es_sdk "github.com/zitadel/zitadel/internal/eventstore/v1/sdk"
|
2022-04-26 23:01:45 +00:00
|
|
|
"github.com/zitadel/zitadel/internal/eventstore/v1/spooler"
|
2022-06-03 12:37:24 +00:00
|
|
|
org_model "github.com/zitadel/zitadel/internal/org/model"
|
|
|
|
org_es_model "github.com/zitadel/zitadel/internal/org/repository/eventsourcing/model"
|
|
|
|
"github.com/zitadel/zitadel/internal/org/repository/view"
|
|
|
|
query2 "github.com/zitadel/zitadel/internal/query"
|
2022-10-26 13:06:48 +00:00
|
|
|
"github.com/zitadel/zitadel/internal/repository/instance"
|
2022-06-03 12:37:24 +00:00
|
|
|
"github.com/zitadel/zitadel/internal/repository/org"
|
2022-04-26 23:01:45 +00:00
|
|
|
"github.com/zitadel/zitadel/internal/repository/user"
|
|
|
|
view_model "github.com/zitadel/zitadel/internal/user/repository/view/model"
|
2020-05-18 10:06:36 +00:00
|
|
|
)
|
|
|
|
|
2020-12-18 15:47:45 +00:00
|
|
|
const (
|
|
|
|
userSessionTable = "auth.user_sessions"
|
|
|
|
)
|
|
|
|
|
2020-05-18 10:06:36 +00:00
|
|
|
type UserSession struct {
|
|
|
|
handler
|
2021-02-23 14:13:04 +00:00
|
|
|
subscription *v1.Subscription
|
2022-06-03 12:37:24 +00:00
|
|
|
queries *query2.Queries
|
2020-05-18 10:06:36 +00:00
|
|
|
}
|
|
|
|
|
2022-11-22 06:36:48 +00:00
|
|
|
func newUserSession(ctx context.Context, handler handler, queries *query2.Queries) *UserSession {
|
2020-12-18 15:47:45 +00:00
|
|
|
h := &UserSession{
|
2021-02-22 13:08:47 +00:00
|
|
|
handler: handler,
|
2022-06-03 12:37:24 +00:00
|
|
|
queries: queries,
|
2020-12-18 15:47:45 +00:00
|
|
|
}
|
|
|
|
|
2022-11-22 06:36:48 +00:00
|
|
|
h.subscribe(ctx)
|
2020-12-18 15:47:45 +00:00
|
|
|
|
|
|
|
return h
|
|
|
|
}
|
|
|
|
|
2022-11-22 06:36:48 +00:00
|
|
|
func (u *UserSession) subscribe(ctx context.Context) {
|
|
|
|
u.subscription = u.es.Subscribe(u.AggregateTypes()...)
|
2020-12-18 15:47:45 +00:00
|
|
|
go func() {
|
2022-11-22 06:36:48 +00:00
|
|
|
for event := range u.subscription.Events {
|
|
|
|
query.ReduceEvent(ctx, u, event)
|
2020-12-18 15:47:45 +00:00
|
|
|
}
|
|
|
|
}()
|
|
|
|
}
|
2020-05-18 10:06:36 +00:00
|
|
|
|
|
|
|
func (u *UserSession) ViewModel() string {
|
|
|
|
return userSessionTable
|
|
|
|
}
|
|
|
|
|
2021-07-06 11:36:35 +00:00
|
|
|
func (u *UserSession) Subscription() *v1.Subscription {
|
|
|
|
return u.subscription
|
|
|
|
}
|
|
|
|
|
2020-12-18 15:47:45 +00:00
|
|
|
func (_ *UserSession) AggregateTypes() []models.AggregateType {
|
2022-10-26 13:06:48 +00:00
|
|
|
return []models.AggregateType{user.AggregateType, org.AggregateType, instance.AggregateType}
|
2020-12-18 15:47:45 +00:00
|
|
|
}
|
|
|
|
|
2022-04-19 06:26:12 +00:00
|
|
|
func (u *UserSession) CurrentSequence(instanceID string) (uint64, error) {
|
|
|
|
sequence, err := u.view.GetLatestUserSessionSequence(instanceID)
|
2020-12-18 15:47:45 +00:00
|
|
|
if err != nil {
|
|
|
|
return 0, err
|
|
|
|
}
|
|
|
|
return sequence.CurrentSequence, nil
|
|
|
|
}
|
|
|
|
|
2022-11-22 06:36:48 +00:00
|
|
|
func (u *UserSession) EventQuery(instanceIDs []string) (*models.SearchQuery, error) {
|
|
|
|
sequences, err := u.view.GetLatestUserSessionSequences(instanceIDs)
|
2020-05-18 10:06:36 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2022-07-22 10:08:39 +00:00
|
|
|
return newSearchQuery(sequences, u.AggregateTypes(), instanceIDs), nil
|
2020-05-18 10:06:36 +00:00
|
|
|
}
|
|
|
|
|
2020-06-23 12:47:47 +00:00
|
|
|
func (u *UserSession) Reduce(event *models.Event) (err error) {
|
2020-05-19 05:07:58 +00:00
|
|
|
var session *view_model.UserSessionView
|
2022-03-31 09:36:26 +00:00
|
|
|
switch eventstore.EventType(event.Type) {
|
|
|
|
case user.UserV1PasswordCheckSucceededType,
|
|
|
|
user.UserV1PasswordCheckFailedType,
|
|
|
|
user.UserV1MFAOTPCheckSucceededType,
|
|
|
|
user.UserV1MFAOTPCheckFailedType,
|
|
|
|
user.UserV1SignedOutType,
|
|
|
|
user.HumanPasswordCheckSucceededType,
|
|
|
|
user.HumanPasswordCheckFailedType,
|
|
|
|
user.UserIDPLoginCheckSucceededType,
|
|
|
|
user.HumanMFAOTPCheckSucceededType,
|
|
|
|
user.HumanMFAOTPCheckFailedType,
|
|
|
|
user.HumanU2FTokenCheckSucceededType,
|
|
|
|
user.HumanU2FTokenCheckFailedType,
|
|
|
|
user.HumanPasswordlessTokenCheckSucceededType,
|
|
|
|
user.HumanPasswordlessTokenCheckFailedType,
|
|
|
|
user.HumanSignedOutType:
|
2020-05-19 05:07:58 +00:00
|
|
|
eventData, err := view_model.UserSessionFromEvent(event)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2022-04-19 06:26:12 +00:00
|
|
|
session, err = u.view.UserSessionByIDs(eventData.UserAgentID, event.AggregateID, event.InstanceID)
|
2020-05-19 05:07:58 +00:00
|
|
|
if err != nil {
|
|
|
|
if !errors.IsNotFound(err) {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
session = &view_model.UserSessionView{
|
|
|
|
CreationDate: event.CreationDate,
|
|
|
|
ResourceOwner: event.ResourceOwner,
|
|
|
|
UserAgentID: eventData.UserAgentID,
|
|
|
|
UserID: event.AggregateID,
|
2022-03-31 09:36:26 +00:00
|
|
|
State: int32(domain.UserSessionStateActive),
|
2022-03-23 08:02:39 +00:00
|
|
|
InstanceID: event.InstanceID,
|
2020-05-19 05:07:58 +00:00
|
|
|
}
|
|
|
|
}
|
2020-06-05 05:50:04 +00:00
|
|
|
return u.updateSession(session, event)
|
2022-03-31 09:36:26 +00:00
|
|
|
case user.UserV1PasswordChangedType,
|
|
|
|
user.UserV1MFAOTPRemovedType,
|
|
|
|
user.UserV1ProfileChangedType,
|
|
|
|
user.UserLockedType,
|
|
|
|
user.UserDeactivatedType,
|
|
|
|
user.HumanPasswordChangedType,
|
|
|
|
user.HumanMFAOTPRemovedType,
|
|
|
|
user.HumanProfileChangedType,
|
|
|
|
user.HumanAvatarAddedType,
|
|
|
|
user.HumanAvatarRemovedType,
|
|
|
|
user.UserDomainClaimedType,
|
|
|
|
user.UserUserNameChangedType,
|
|
|
|
user.UserIDPLinkRemovedType,
|
|
|
|
user.UserIDPLinkCascadeRemovedType,
|
|
|
|
user.HumanPasswordlessTokenRemovedType,
|
|
|
|
user.HumanU2FTokenRemovedType:
|
2022-04-19 06:26:12 +00:00
|
|
|
sessions, err := u.view.UserSessionsByUserID(event.AggregateID, event.InstanceID)
|
2020-06-05 05:50:04 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2020-08-13 07:43:47 +00:00
|
|
|
if len(sessions) == 0 {
|
2020-12-18 15:47:45 +00:00
|
|
|
return u.view.ProcessedUserSessionSequence(event)
|
2020-08-13 07:43:47 +00:00
|
|
|
}
|
2020-06-05 05:50:04 +00:00
|
|
|
for _, session := range sessions {
|
2020-12-07 11:09:10 +00:00
|
|
|
if err := session.AppendEvent(event); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2022-06-03 12:37:24 +00:00
|
|
|
if err := u.fillUserInfo(session); err != nil {
|
2020-06-05 05:50:04 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
2020-12-18 15:47:45 +00:00
|
|
|
return u.view.PutUserSessions(sessions, event)
|
2022-06-03 12:37:24 +00:00
|
|
|
case org.OrgDomainPrimarySetEventType:
|
|
|
|
return u.fillLoginNamesOnOrgUsers(event)
|
2022-03-31 09:36:26 +00:00
|
|
|
case user.UserRemovedType:
|
2022-04-19 06:26:12 +00:00
|
|
|
return u.view.DeleteUserSessions(event.AggregateID, event.InstanceID, event)
|
2022-10-26 13:06:48 +00:00
|
|
|
case instance.InstanceRemovedEventType:
|
|
|
|
return u.view.DeleteInstanceUserSessions(event)
|
2020-05-18 10:06:36 +00:00
|
|
|
default:
|
2020-12-18 15:47:45 +00:00
|
|
|
return u.view.ProcessedUserSessionSequence(event)
|
2020-05-18 10:06:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *UserSession) OnError(event *models.Event, err error) error {
|
2022-11-22 06:36:48 +00:00
|
|
|
logging.WithFields("id", event.AggregateID).WithError(err).Warn("something went wrong in user session handler")
|
2020-05-18 10:06:36 +00:00
|
|
|
return spooler.HandleError(event, err, u.view.GetLatestUserSessionFailedEvent, u.view.ProcessedUserSessionFailedEvent, u.view.ProcessedUserSessionSequence, u.errorCountUntilSkip)
|
|
|
|
}
|
|
|
|
|
2022-11-22 06:36:48 +00:00
|
|
|
func (u *UserSession) OnSuccess(instanceIDs []string) error {
|
|
|
|
return spooler.HandleSuccess(u.view.UpdateUserSessionSpoolerRunTimestamp, instanceIDs)
|
2020-12-02 07:50:59 +00:00
|
|
|
}
|
|
|
|
|
2020-06-05 05:50:04 +00:00
|
|
|
func (u *UserSession) updateSession(session *view_model.UserSessionView, event *models.Event) error {
|
2020-12-07 11:09:10 +00:00
|
|
|
if err := session.AppendEvent(event); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2022-06-03 12:37:24 +00:00
|
|
|
if err := u.fillUserInfo(session); err != nil {
|
2020-06-17 06:06:40 +00:00
|
|
|
return err
|
2020-06-05 05:50:04 +00:00
|
|
|
}
|
2020-12-18 15:47:45 +00:00
|
|
|
return u.view.PutUserSession(session, event)
|
2020-06-05 05:50:04 +00:00
|
|
|
}
|
|
|
|
|
2022-06-03 12:37:24 +00:00
|
|
|
func (u *UserSession) fillUserInfo(session *view_model.UserSessionView) error {
|
|
|
|
user, err := u.view.UserByID(session.UserID, session.InstanceID)
|
2020-05-18 10:06:36 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
session.UserName = user.UserName
|
2020-06-17 06:06:40 +00:00
|
|
|
session.LoginName = user.PreferredLoginName
|
|
|
|
session.DisplayName = user.DisplayName
|
feat: label policy (#1708)
* 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>
2021-06-04 12:53:51 +00:00
|
|
|
session.AvatarKey = user.AvatarKey
|
2020-05-18 10:06:36 +00:00
|
|
|
return nil
|
|
|
|
}
|
2022-06-03 12:37:24 +00:00
|
|
|
|
|
|
|
func (u *UserSession) fillLoginNamesOnOrgUsers(event *models.Event) error {
|
|
|
|
sessions, err := u.view.UserSessionsByOrgID(event.ResourceOwner, event.InstanceID)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if len(sessions) == 0 {
|
|
|
|
return u.view.ProcessedUserSessionSequence(event)
|
|
|
|
}
|
|
|
|
userLoginMustBeDomain, primaryDomain, err := u.loginNameInformation(context.Background(), event.ResourceOwner, event.InstanceID)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if !userLoginMustBeDomain {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
for _, session := range sessions {
|
|
|
|
session.LoginName = session.UserName + "@" + primaryDomain
|
|
|
|
}
|
|
|
|
return u.view.PutUserSessions(sessions, event)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *UserSession) loginNameInformation(ctx context.Context, orgID string, instanceID string) (userLoginMustBeDomain bool, primaryDomain string, err error) {
|
|
|
|
org, err := u.getOrgByID(ctx, orgID, instanceID)
|
|
|
|
if err != nil {
|
|
|
|
return false, "", err
|
|
|
|
}
|
|
|
|
if org.DomainPolicy == nil {
|
|
|
|
policy, err := u.queries.DefaultDomainPolicy(withInstanceID(ctx, org.InstanceID))
|
|
|
|
if err != nil {
|
|
|
|
return false, "", err
|
|
|
|
}
|
|
|
|
userLoginMustBeDomain = policy.UserLoginMustBeDomain
|
|
|
|
}
|
|
|
|
return userLoginMustBeDomain, org.GetPrimaryDomain().Domain, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *UserSession) getOrgByID(ctx context.Context, orgID, instanceID string) (*org_model.Org, error) {
|
|
|
|
query, err := view.OrgByIDQuery(orgID, instanceID, 0)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
esOrg := &org_es_model.Org{
|
|
|
|
ObjectRoot: models.ObjectRoot{
|
|
|
|
AggregateID: orgID,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
err = es_sdk.Filter(ctx, u.Eventstore().FilterEvents, esOrg.AppendEvents, query)
|
|
|
|
if err != nil && !errors.IsNotFound(err) {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
if esOrg.Sequence == 0 {
|
|
|
|
return nil, errors.ThrowNotFound(nil, "EVENT-3m9vs", "Errors.Org.NotFound")
|
|
|
|
}
|
|
|
|
|
|
|
|
return org_es_model.OrgToModel(esOrg), nil
|
|
|
|
}
|