feat: org queries (#136)

* search orgs

* org by domain

* member spooler

* member

* get roles

* tests

* types duration

* use default func for renew

* correct database

* reorder migrations

* delete unused consts

* move get roles to internal

* use prepared org by domain

* implement org in other objects

* add eventstores

internal/management/repository/eventsourcing/handler/granted_project.go

@@ -9,8 +9,9 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
-	"github.com/caos/zitadel/internal/project/model"
-	"github.com/caos/zitadel/internal/project/repository/eventsourcing"
+	org_model "github.com/caos/zitadel/internal/org/model"
+	org_event "github.com/caos/zitadel/internal/org/repository/eventsourcing"
+	proj_model "github.com/caos/zitadel/internal/project/model"
 	proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
 	es_model "github.com/caos/zitadel/internal/project/repository/eventsourcing/model"
 	view_model "github.com/caos/zitadel/internal/project/repository/view/model"
@@ -20,6 +21,7 @@ type GrantedProject struct {
 	handler
 	eventstore    eventstore.Eventstore
 	projectEvents *proj_event.ProjectEventstore
+	orgEvents     *org_event.OrgEventstore
 }
 
 const (
@@ -37,7 +39,7 @@ func (p *GrantedProject) EventQuery() (*models.SearchQuery, error) {
 	if err != nil {
 		return nil, err
 	}
-	return eventsourcing.ProjectQuery(sequence), nil
+	return proj_event.ProjectQuery(sequence), nil
 }
 
 func (p *GrantedProject) Process(event *models.Event) (err error) {
@@ -71,7 +73,12 @@ func (p *GrantedProject) Process(event *models.Event) (err error) {
 			return err
 		}
 		grantedProject.Name = project.Name
-		//TODO: read org
+
+		org, err := p.orgEvents.OrgByID(context.TODO(), org_model.NewOrg(grantedProject.OrgID))
+		if err != nil {
+			return err
+		}
+		p.fillOrgData(grantedProject, org)
 	case es_model.ProjectGrantChanged:
 		grant := new(view_model.ProjectGrant)
 		err := grant.SetData(event)
@@ -99,11 +106,12 @@ func (p *GrantedProject) Process(event *models.Event) (err error) {
 	return p.view.PutGrantedProject(grantedProject)
 }
 
-func (p *GrantedProject) getOrg(orgID string) {
-	//TODO: Get Org
+func (p *GrantedProject) fillOrgData(grantedProject *view_model.GrantedProjectView, org *org_model.Org) {
+	grantedProject.OrgDomain = org.Domain
+	grantedProject.OrgName = org.Name
 }
 
-func (p *GrantedProject) getProject(projectID string) (*model.Project, error) {
+func (p *GrantedProject) getProject(projectID string) (*proj_model.Project, error) {
 	return p.projectEvents.ProjectByID(context.Background(), projectID)
 }
 

internal/management/repository/eventsourcing/handler/handler.go

@@ -1,13 +1,15 @@
 package handler
 
 import (
+	"time"
+
 	"github.com/caos/zitadel/internal/config/types"
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
 	"github.com/caos/zitadel/internal/management/repository/eventsourcing/view"
+	org_event "github.com/caos/zitadel/internal/org/repository/eventsourcing"
 	proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
 	usr_event "github.com/caos/zitadel/internal/user/repository/eventsourcing"
-	"time"
 )
 
 type Configs map[string]*Config
@@ -26,17 +28,20 @@ type handler struct {
 type EventstoreRepos struct {
 	ProjectEvents *proj_event.ProjectEventstore
 	UserEvents    *usr_event.UserEventstore
+	OrgEvents     *org_event.OrgEventstore
 }
 
 func Register(configs Configs, bulkLimit, errorCount uint64, view *view.View, eventstore eventstore.Eventstore, repos EventstoreRepos) []spooler.Handler {
 	return []spooler.Handler{
-		&GrantedProject{handler: handler{view, bulkLimit, configs.cycleDuration("GrantedProject"), errorCount}, eventstore: eventstore, projectEvents: repos.ProjectEvents},
+		&GrantedProject{handler: handler{view, bulkLimit, configs.cycleDuration("GrantedProject"), errorCount}, eventstore: eventstore, projectEvents: repos.ProjectEvents, orgEvents: repos.OrgEvents},
 		&ProjectRole{handler: handler{view, bulkLimit, configs.cycleDuration("ProjectRole"), errorCount}, projectEvents: repos.ProjectEvents},
 		&ProjectMember{handler: handler{view, bulkLimit, configs.cycleDuration("ProjectMember"), errorCount}, userEvents: repos.UserEvents},
 		&ProjectGrantMember{handler: handler{view, bulkLimit, configs.cycleDuration("ProjectGrantMember"), errorCount}, userEvents: repos.UserEvents},
-		&Application{handler: handler{view, bulkLimit, configs.cycleDuration("Application"), errorCount}},
-		&User{handler: handler{view, bulkLimit, configs.cycleDuration("User"), errorCount}},
-		&UserGrant{handler: handler{view, bulkLimit, configs.cycleDuration("UserGrant"), errorCount}, projectEvents: repos.ProjectEvents, userEvents: repos.UserEvents},
+		&Application{handler: handler{view, bulkLimit, configs.cycleDuration("Application"), errorCount}, projectEvents: repos.ProjectEvents},
+		&User{handler: handler{view, bulkLimit, configs.cycleDuration("User"), errorCount}, eventstore: eventstore},
+		&UserGrant{handler: handler{view, bulkLimit, configs.cycleDuration("UserGrant"), errorCount}, projectEvents: repos.ProjectEvents, userEvents: repos.UserEvents, orgEvents: repos.OrgEvents},
+		&Org{handler: handler{view, bulkLimit, configs.cycleDuration("Org"), errorCount}},
+		&OrgMember{handler: handler{view, bulkLimit, configs.cycleDuration("OrgMember"), errorCount}, userEvents: repos.UserEvents},
 	}
 }
 

internal/management/repository/eventsourcing/handler/org.go

@@ -0,0 +1,65 @@
+package handler
+
+import (
+	"time"
+
+	"github.com/caos/logging"
+	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/spooler"
+	org_model "github.com/caos/zitadel/internal/org/model"
+	"github.com/caos/zitadel/internal/org/repository/eventsourcing"
+	"github.com/caos/zitadel/internal/org/repository/view"
+)
+
+type Org struct {
+	handler
+}
+
+const (
+	orgTable = "management.orgs"
+)
+
+func (o *Org) MinimumCycleDuration() time.Duration { return o.cycleDuration }
+
+func (o *Org) ViewModel() string {
+	return orgTable
+}
+
+func (o *Org) EventQuery() (*es_models.SearchQuery, error) {
+	sequence, err := o.view.GetLatestOrgSequence()
+	if err != nil {
+		return nil, err
+	}
+	return eventsourcing.OrgQuery(sequence), nil
+}
+
+func (o *Org) Process(event *es_models.Event) error {
+	org := new(view.OrgView)
+
+	switch event.Type {
+	case org_model.OrgAdded:
+		org.AppendEvent(event)
+	case org_model.OrgChanged:
+		err := org.SetData(event)
+		if err != nil {
+			return err
+		}
+		org, err = o.view.OrgByID(org.ID)
+		if err != nil {
+			return err
+		}
+		err = org.AppendEvent(event)
+		if err != nil {
+			return err
+		}
+	default:
+		return o.view.ProcessedOrgSequence(event.Sequence)
+	}
+
+	return o.view.PutOrg(org)
+}
+
+func (o *Org) OnError(event *es_models.Event, spoolerErr error) error {
+	logging.LogWithFields("SPOOL-ls9ew", "id", event.AggregateID).WithError(spoolerErr).Warn("something went wrong in project app handler")
+	return spooler.HandleError(event, spoolerErr, o.view.GetLatestOrgFailedEvent, o.view.ProcessedOrgFailedEvent, o.view.ProcessedOrgSequence, o.errorCountUntilSkip)
+}

internal/management/repository/eventsourcing/handler/org_member.go

@@ -0,0 +1,127 @@
+package handler
+
+import (
+	"context"
+	"time"
+
+	"github.com/caos/logging"
+	"github.com/caos/zitadel/internal/eventstore/models"
+	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/spooler"
+	org_model "github.com/caos/zitadel/internal/org/model"
+	view_model "github.com/caos/zitadel/internal/org/repository/view"
+	usr_model "github.com/caos/zitadel/internal/user/model"
+	usr_event "github.com/caos/zitadel/internal/user/repository/eventsourcing"
+	usr_es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
+)
+
+type OrgMember struct {
+	handler
+	userEvents *usr_event.UserEventstore
+}
+
+const (
+	orgMemberTable = "management.org_members"
+)
+
+func (m *OrgMember) MinimumCycleDuration() time.Duration { return m.cycleDuration }
+
+func (m *OrgMember) ViewModel() string {
+	return orgMemberTable
+}
+
+func (m *OrgMember) EventQuery() (*models.SearchQuery, error) {
+	sequence, err := m.view.GetLatestOrgMemberSequence()
+	if err != nil {
+		return nil, err
+	}
+	return es_models.NewSearchQuery().
+		AggregateTypeFilter(org_model.OrgAggregate, usr_es_model.UserAggregate).
+		LatestSequenceFilter(sequence), nil
+}
+
+func (m *OrgMember) Process(event *models.Event) (err error) {
+	switch event.AggregateType {
+	case org_model.OrgAggregate:
+		err = m.processOrgMember(event)
+	case usr_es_model.UserAggregate:
+		err = m.processUser(event)
+	}
+	return err
+}
+
+func (m *OrgMember) processOrgMember(event *models.Event) (err error) {
+	member := new(view_model.OrgMemberView)
+	switch event.Type {
+	case org_model.OrgMemberAdded:
+		member.AppendEvent(event)
+		m.fillData(member)
+	case org_model.OrgMemberChanged:
+		err := member.SetData(event)
+		if err != nil {
+			return err
+		}
+		member, err = m.view.OrgMemberByIDs(event.AggregateID, member.UserID)
+		if err != nil {
+			return err
+		}
+		member.AppendEvent(event)
+	case org_model.OrgMemberRemoved:
+		err := member.SetData(event)
+		if err != nil {
+			return err
+		}
+		return m.view.DeleteOrgMember(event.AggregateID, member.UserID, event.Sequence)
+	default:
+		return m.view.ProcessedOrgMemberSequence(event.Sequence)
+	}
+	if err != nil {
+		return err
+	}
+	return m.view.PutOrgMember(member, member.Sequence)
+}
+
+func (m *OrgMember) processUser(event *models.Event) (err error) {
+	switch event.Type {
+	case usr_es_model.UserProfileChanged,
+		usr_es_model.UserEmailChanged:
+		members, err := m.view.OrgMembersByUserID(event.AggregateID)
+		if err != nil {
+			return err
+		}
+		user, err := m.userEvents.UserByID(context.Background(), event.AggregateID)
+		if err != nil {
+			return err
+		}
+		for _, member := range members {
+			m.fillUserData(member, user)
+			err = m.view.PutOrgMember(member, event.Sequence)
+			if err != nil {
+				return err
+			}
+		}
+	default:
+		return m.view.ProcessedOrgMemberSequence(event.Sequence)
+	}
+	return nil
+}
+
+func (m *OrgMember) fillData(member *view_model.OrgMemberView) (err error) {
+	user, err := m.userEvents.UserByID(context.Background(), member.UserID)
+	if err != nil {
+		return err
+	}
+	m.fillUserData(member, user)
+	return nil
+}
+
+func (m *OrgMember) fillUserData(member *view_model.OrgMemberView, user *usr_model.User) {
+	member.UserName = user.UserName
+	member.FirstName = user.FirstName
+	member.LastName = user.LastName
+	member.Email = user.EmailAddress
+}
+func (m *OrgMember) OnError(event *models.Event, err error) error {
+	logging.LogWithFields("SPOOL-u73es", "id", event.AggregateID).WithError(err).Warn("something went wrong in orgmember handler")
+	return spooler.HandleError(event, err, m.view.GetLatestOrgMemberFailedEvent, m.view.ProcessedOrgMemberFailedEvent, m.view.ProcessedOrgMemberSequence, m.errorCountUntilSkip)
+}

internal/management/repository/eventsourcing/handler/user_grant.go

@@ -2,7 +2,11 @@ package handler
 
 import (
 	"context"
+	"time"
+
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	org_model "github.com/caos/zitadel/internal/org/model"
+	org_events "github.com/caos/zitadel/internal/org/repository/eventsourcing"
 	proj_model "github.com/caos/zitadel/internal/project/model"
 	proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
 	proj_es_model "github.com/caos/zitadel/internal/project/repository/eventsourcing/model"
@@ -10,7 +14,6 @@ import (
 	usr_events "github.com/caos/zitadel/internal/user/repository/eventsourcing"
 	usr_es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
 	grant_es_model "github.com/caos/zitadel/internal/usergrant/repository/eventsourcing/model"
-	"time"
 
 	"github.com/caos/logging"
 
@@ -25,6 +28,7 @@ type UserGrant struct {
 	eventstore    eventstore.Eventstore
 	projectEvents *proj_event.ProjectEventstore
 	userEvents    *usr_events.UserEventstore
+	orgEvents     *org_events.OrgEventstore
 }
 
 const (
@@ -67,7 +71,7 @@ func (u *UserGrant) processUserGrant(event *models.Event) (err error) {
 		if err != nil {
 			return err
 		}
-		err = u.fillData(grant)
+		err = u.fillData(grant, event.ResourceOwner)
 	case grant_es_model.UserGrantChanged,
 		grant_es_model.UserGrantDeactivated,
 		grant_es_model.UserGrantReactivated:
@@ -133,7 +137,7 @@ func (u *UserGrant) processProject(event *models.Event) (err error) {
 	return nil
 }
 
-func (u *UserGrant) fillData(grant *view_model.UserGrantView) (err error) {
+func (u *UserGrant) fillData(grant *view_model.UserGrantView, resourceOwner string) (err error) {
 	user, err := u.userEvents.UserByID(context.Background(), grant.UserID)
 	if err != nil {
 		return err
@@ -144,7 +148,12 @@ func (u *UserGrant) fillData(grant *view_model.UserGrantView) (err error) {
 		return err
 	}
 	u.fillProjectData(grant, project)
-	u.fillOrgData(grant)
+
+	org, err := u.orgEvents.OrgByID(context.TODO(), org_model.NewOrg(resourceOwner))
+	if err != nil {
+		return err
+	}
+	u.fillOrgData(grant, org)
 	return nil
 }
 
@@ -159,8 +168,9 @@ func (u *UserGrant) fillProjectData(grant *view_model.UserGrantView, project *pr
 	grant.ProjectName = project.Name
 }
 
-func (u *UserGrant) fillOrgData(grant *view_model.UserGrantView) {
-	//TODO: get ORG
+func (u *UserGrant) fillOrgData(grant *view_model.UserGrantView, org *org_model.Org) {
+	grant.OrgDomain = org.Domain
+	grant.OrgName = org.Name
 }
 
 func (u *UserGrant) OnError(event *models.Event, err error) error {