feat: org command sides (#96)

* start org

* refactor(eventstore): filter in sql for querier

* feat(eventstore): Aggregate precondition

preconditions are checked right before insert. Insert is still transaction save

* feat(eventstore): check preconditions in repository

* test(eventstore): test precondition in models

* test(eventstore): precondition-tests

* start org

* refactor(eventstore): filter in sql for querier

* feat(eventstore): Aggregate precondition

preconditions are checked right before insert. Insert is still transaction save

* feat(admin): start implement org

* feat(eventstore): check preconditions in repository

* fix(eventstore): data as NULL if empty
refactor(eventstore): naming in sequence methods

* feat(admin): org command side

* feat(management): start org-repo

* feat(org): member

* fix: replace ObjectRoot.ID with ObjectRoot.AggregateID

* aggregateID

* add remove,change member

* refactor(org): namings

* refactor(eventstore): querier as type

* fix(precondition): rename validation from precondition to validation

* test(eventstore): isErr func instead of wantErr bool

* fix(tests): Data

* fix(eventstore): correct check for existing events in push,
simplify insert statement

* fix(eventstore): aggregate id public

* test(org): eventsourcing

* test(org): eventstore

* test(org): deactivate, reactivate, orgbyid

* test(org): getMemberByIDs

* tests

* running tests

* add user repo to admin

* thorw not found if no org found

* eventstore tests done

* lauft

* validate if user is already member of org

* modules

* delete unused file

* add member validation test

* return error if unable to validat member

* generate org id once,
set resourceowner of org

* Update internal/admin/repository/eventsourcing/eventstore/org.go

* Update internal/admin/repository/eventsourcing/eventstore/org.go

* Update internal/org/repository/eventsourcing/member_model.go

* Update internal/org/repository/eventsourcing/org.go

* Update internal/org/repository/eventsourcing/org.go

* Update internal/org/repository/eventsourcing/org_member.go

* Update internal/org/repository/eventsourcing/org_member.go

* Update internal/org/repository/eventsourcing/org_model.go

* Update internal/org/repository/eventsourcing/org.go

* Update internal/org/repository/eventsourcing/org_model.go

* Update internal/org/repository/eventsourcing/org_model.go

* typo

* correct user events

* usercreate for setuporg instead of userregister

* set data

* mod

* mod

* tests

* cleanup code

* code styling

* return member on add and change

* change username in startup

* girignore

* orgID as parameter in re-/deactive org

* startup config

* migration for admin_api-user

* probes fro admin

* move unique org

Co-authored-by: Fabiennne <fabienne.gerschwiler@gmail.com>

internal/admin/repository/eventsourcing/eventstore/org.go

@@ -0,0 +1,60 @@
+package eventstore
+
+import (
+	"context"
+
+	admin_model "github.com/caos/zitadel/internal/admin/model"
+	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore"
+	"github.com/caos/zitadel/internal/eventstore/sdk"
+	org_model "github.com/caos/zitadel/internal/org/model"
+	org_es "github.com/caos/zitadel/internal/org/repository/eventsourcing"
+	usr_es "github.com/caos/zitadel/internal/user/repository/eventsourcing"
+)
+
+type OrgRepo struct {
+	Eventstore     eventstore.Eventstore
+	OrgEventstore  *org_es.OrgEventstore
+	UserEventstore *usr_es.UserEventstore
+}
+
+func (repo *OrgRepo) SetUpOrg(ctx context.Context, setUp *admin_model.SetupOrg) (*admin_model.SetupOrg, error) {
+	org, aggregates, err := repo.OrgEventstore.PrepareCreateOrg(ctx, setUp.Org)
+	if err != nil {
+		return nil, err
+	}
+
+	user, userAggregate, err := repo.UserEventstore.PrepareCreateUser(ctx, setUp.User, org.AggregateID)
+	if err != nil {
+		return nil, err
+	}
+
+	aggregates = append(aggregates, userAggregate)
+	setupModel := &Setup{Org: org, User: user}
+
+	member := org_model.NewOrgMemberWithRoles(org.AggregateID, user.AggregateID, "ORG_ADMIN") //TODO: role as const
+	_, memberAggregate, err := repo.OrgEventstore.PrepareAddOrgMember(ctx, member)
+	if err != nil {
+		return nil, err
+	}
+	aggregates = append(aggregates, memberAggregate)
+
+	err = sdk.PushAggregates(ctx, repo.Eventstore.PushAggregates, setupModel.AppendEvents, aggregates...)
+	if err != nil {
+		return nil, err
+	}
+
+	return SetupToModel(setupModel), nil
+}
+
+func (repo *OrgRepo) OrgByID(ctx context.Context, id string) (*org_model.Org, error) {
+	return repo.OrgEventstore.OrgByID(ctx, org_model.NewOrg(id))
+}
+
+func (repo *OrgRepo) SearchOrgs(ctx context.Context) ([]*org_model.Org, error) {
+	return nil, errors.ThrowUnimplemented(nil, "EVENT-hFIHK", "search not implemented")
+}
+
+func (repo *OrgRepo) IsOrgUnique(ctx context.Context, name, domain string) (isUnique bool, err error) {
+	return repo.OrgEventstore.IsOrgUnique(ctx, name, domain)
+}

internal/admin/repository/eventsourcing/eventstore/setup_model.go

@@ -0,0 +1,37 @@
+package eventstore
+
+import (
+	admin_model "github.com/caos/zitadel/internal/admin/model"
+	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	org_model "github.com/caos/zitadel/internal/org/model"
+	org_es "github.com/caos/zitadel/internal/org/repository/eventsourcing"
+	usr_es "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
+)
+
+type Setup struct {
+	*org_es.Org
+	*usr_es.User
+}
+
+func (s *Setup) AppendEvents(events ...*es_models.Event) error {
+	for _, event := range events {
+		var err error
+		switch event.AggregateType {
+		case org_model.OrgAggregate:
+			err = s.Org.AppendEvent(event)
+		case usr_es.UserAggregate:
+			err = s.User.AppendEvent(event)
+		}
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func SetupToModel(setup *Setup) *admin_model.SetupOrg {
+	return &admin_model.SetupOrg{
+		Org:  org_es.OrgToModel(setup.Org),
+		User: usr_es.UserToModel(setup.User),
+	}
+}

internal/admin/repository/eventsourcing/eventstore/user.go

@@ -0,0 +1,23 @@
+package eventstore
+
+import (
+	"context"
+	usr_model "github.com/caos/zitadel/internal/user/model"
+	usr_event "github.com/caos/zitadel/internal/user/repository/eventsourcing"
+)
+
+type UserRepo struct {
+	UserEvents *usr_event.UserEventstore
+}
+
+func (repo *UserRepo) UserByID(ctx context.Context, id string) (project *usr_model.User, err error) {
+	return repo.UserEvents.UserByID(ctx, id)
+}
+
+func (repo *UserRepo) CreateUser(ctx context.Context, user *usr_model.User) (*usr_model.User, error) {
+	return repo.UserEvents.CreateUser(ctx, user)
+}
+
+func (repo *UserRepo) RegisterUser(ctx context.Context, user *usr_model.User, resourceOwner string) (*usr_model.User, error) {
+	return repo.UserEvents.RegisterUser(ctx, user, resourceOwner)
+}

internal/admin/repository/eventsourcing/repository.go

@@ -0,0 +1,68 @@
+package eventsourcing
+
+import (
+	"context"
+
+	"github.com/caos/zitadel/internal/admin/repository/eventsourcing/eventstore"
+	sd "github.com/caos/zitadel/internal/config/systemdefaults"
+	es_int "github.com/caos/zitadel/internal/eventstore"
+	es_org "github.com/caos/zitadel/internal/org/repository/eventsourcing"
+	es_usr "github.com/caos/zitadel/internal/user/repository/eventsourcing"
+)
+
+type Config struct {
+	Eventstore es_int.Config
+	//View       view.ViewConfig
+	//Spooler    spooler.SpoolerConfig
+}
+
+type EsRepository struct {
+	//spooler *es_spooler.Spooler
+	eventstore.OrgRepo
+}
+
+func Start(conf Config, systemDefaults sd.SystemDefaults) (*EsRepository, error) {
+	es, err := es_int.Start(conf.Eventstore)
+	if err != nil {
+		return nil, err
+	}
+
+	//view, sql, err := mgmt_view.StartView(conf.View)
+	//if err != nil {
+	//	return nil, err
+	//}
+
+	//conf.Spooler.View = view
+	//conf.Spooler.EsClient = es.Client
+	//conf.Spooler.SQL = sql
+	//spool := spooler.StartSpooler(conf.Spooler)
+
+	org := es_org.StartOrg(es_org.OrgConfig{Eventstore: es})
+
+	user, err := es_usr.StartUser(es_usr.UserConfig{
+		Eventstore: es,
+		Cache:      conf.Eventstore.Cache,
+	}, systemDefaults)
+	if err != nil {
+		return nil, err
+	}
+	return &EsRepository{
+		OrgRepo: eventstore.OrgRepo{
+			Eventstore:     es,
+			OrgEventstore:  org,
+			UserEventstore: user,
+		},
+	}, nil
+}
+
+func (repo *EsRepository) Health(ctx context.Context) error {
+	err := repo.Eventstore.Health(ctx)
+	if err != nil {
+		return err
+	}
+	err = repo.UserEventstore.Health(ctx)
+	if err != nil {
+		return err
+	}
+	return repo.OrgEventstore.Health(ctx)
+}