zitadel/backend/v3/domain/org_add.go

package domain

import (
	"context"

	"github.com/zitadel/zitadel/backend/v3/storage/eventstore"
)

// AddOrgCommand adds a new organization.
// I'm unsure if we should add the Admins here or if this should be a separate command.
type AddOrgCommand struct {
	ID     string              `json:"id"`
	Name   string              `json:"name"`
	Admins []*AddMemberCommand `json:"admins"`
}

func NewAddOrgCommand(name string, admins ...*AddMemberCommand) *AddOrgCommand {
	return &AddOrgCommand{
		Name:   name,
		Admins: admins,
	}
}

// String implements [Commander].
func (cmd *AddOrgCommand) String() string {
	return "AddOrgCommand"
}

// Execute implements Commander.
func (cmd *AddOrgCommand) Execute(ctx context.Context, opts *CommandOpts) (err error) {
	if len(cmd.Admins) == 0 {
		return ErrNoAdminSpecified
	}
	if err = cmd.ensureID(); err != nil {
		return err
	}

	close, err := opts.EnsureTx(ctx)
	if err != nil {
		return err
	}
	defer func() { err = close(ctx, err) }()
	err = orgRepo(opts.DB).Create(ctx, &Org{
		ID:   cmd.ID,
		Name: cmd.Name,
	})
	if err != nil {
		return err
	}

	for _, admin := range cmd.Admins {
		admin.orgID = cmd.ID
		if err = opts.Invoke(ctx, admin); err != nil {
			return err
		}
	}

	orgCache.Set(ctx, &Org{
		ID:   cmd.ID,
		Name: cmd.Name,
	})

	return nil
}

// Events implements [eventer].
func (cmd *AddOrgCommand) Events() []*eventstore.Event {
	return []*eventstore.Event{
		{
			AggregateType: "org",
			AggregateID:   cmd.ID,
			Type:          "org.added",
			Payload:       cmd,
		},
	}
}

var (
	_ Commander = (*AddOrgCommand)(nil)
	_ eventer   = (*AddOrgCommand)(nil)
)

func (cmd *AddOrgCommand) ensureID() (err error) {
	if cmd.ID != "" {
		return nil
	}
	cmd.ID, err = generateID()
	return err
}

// AddMemberCommand adds a new member to an organization.
// I'm not sure if we should make it more generic to also use it for instances.
type AddMemberCommand struct {
	orgID  string
	UserID string   `json:"userId"`
	Roles  []string `json:"roles"`
}

func NewAddMemberCommand(userID string, roles ...string) *AddMemberCommand {
	return &AddMemberCommand{
		UserID: userID,
		Roles:  roles,
	}
}

// String implements [Commander].
func (cmd *AddMemberCommand) String() string {
	return "AddMemberCommand"
}

// Execute implements Commander.
func (a *AddMemberCommand) Execute(ctx context.Context, opts *CommandOpts) (err error) {
	close, err := opts.EnsureTx(ctx)
	if err != nil {
		return err
	}
	defer func() { err = close(ctx, err) }()

	return orgRepo(opts.DB).Member().AddMember(ctx, a.orgID, a.UserID, a.Roles)
}

// Events implements [eventer].
func (a *AddMemberCommand) Events() []*eventstore.Event {
	return []*eventstore.Event{
		{
			AggregateType: "org",
			AggregateID:   a.UserID,
			Type:          "member.added",
			Payload:       a,
		},
	}
}

var (
	_ Commander = (*AddMemberCommand)(nil)
	_ eventer   = (*AddMemberCommand)(nil)
)