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/org/model/org_member_view.go

@@ -0,0 +1,59 @@
+package model
+
+import (
+	"time"
+
+	"github.com/caos/zitadel/internal/model"
+)
+
+type OrgMemberView struct {
+	UserID       string
+	OrgID        string
+	UserName     string
+	Email        string
+	FirstName    string
+	LastName     string
+	Roles        []string
+	CreationDate time.Time
+	ChangeDate   time.Time
+	Sequence     uint64
+}
+
+type OrgMemberSearchRequest struct {
+	Offset        uint64
+	Limit         uint64
+	SortingColumn OrgMemberSearchKey
+	Asc           bool
+	Queries       []*OrgMemberSearchQuery
+}
+
+type OrgMemberSearchKey int32
+
+const (
+	ORGMEMBERSEARCHKEY_UNSPECIFIED OrgMemberSearchKey = iota
+	ORGMEMBERSEARCHKEY_USER_NAME
+	ORGMEMBERSEARCHKEY_EMAIL
+	ORGMEMBERSEARCHKEY_FIRST_NAME
+	ORGMEMBERSEARCHKEY_LAST_NAME
+	ORGMEMBERSEARCHKEY_ORG_ID
+	ORGMEMBERSEARCHKEY_USER_ID
+)
+
+type OrgMemberSearchQuery struct {
+	Key    OrgMemberSearchKey
+	Method model.SearchMethod
+	Value  string
+}
+
+type OrgMemberSearchResponse struct {
+	Offset      uint64
+	Limit       uint64
+	TotalResult uint64
+	Result      []*OrgMemberView
+}
+
+func (r *OrgMemberSearchRequest) EnsureLimit(limit uint64) {
+	if r.Limit == 0 || r.Limit > limit {
+		r.Limit = limit
+	}
+}

internal/org/model/org_view.go

@@ -0,0 +1,73 @@
+package model
+
+import (
+	"time"
+
+	"github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/model"
+)
+
+type OrgView struct {
+	ID            string
+	CreationDate  time.Time
+	ChangeDate    time.Time
+	State         OrgState
+	ResourceOwner string
+	Sequence      uint64
+
+	Name   string
+	Domain string
+}
+
+type OrgSearchRequest struct {
+	Offset        uint64
+	Limit         uint64
+	SortingColumn OrgSearchKey
+	Asc           bool
+	Queries       []*OrgSearchQuery
+}
+
+type OrgSearchKey int32
+
+const (
+	ORGSEARCHKEY_UNSPECIFIED OrgSearchKey = iota
+	ORGSEARCHKEY_ORG_ID
+	ORGSEARCHKEY_ORG_NAME
+	ORGSEARCHKEY_ORG_DOMAIN
+	ORGSEARCHKEY_STATE
+	ORGSEARCHKEY_RESOURCEOWNER
+)
+
+type OrgSearchQuery struct {
+	Key    OrgSearchKey
+	Method model.SearchMethod
+	Value  string
+}
+
+type OrgSearchResult struct {
+	Offset      uint64
+	Limit       uint64
+	TotalResult uint64
+	Result      []*OrgView
+}
+
+func (r *OrgSearchRequest) EnsureLimit(limit uint64) {
+	if r.Limit == 0 || r.Limit > limit {
+		r.Limit = limit
+	}
+}
+
+func OrgViewToOrg(o *OrgView) *Org {
+	return &Org{
+		ObjectRoot: models.ObjectRoot{
+			AggregateID:   o.ID,
+			ChangeDate:    o.ChangeDate,
+			CreationDate:  o.CreationDate,
+			ResourceOwner: o.ResourceOwner,
+			Sequence:      o.Sequence,
+		},
+		Domain: o.Domain,
+		Name:   o.Name,
+		State:  o.State,
+	}
+}

internal/org/repository/view/org.go

@@ -0,0 +1,101 @@
+package view
+
+import (
+	"encoding/json"
+	"time"
+
+	"github.com/caos/logging"
+	"github.com/caos/zitadel/internal/errors"
+	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	org_es_model "github.com/caos/zitadel/internal/org/model"
+	org_model "github.com/caos/zitadel/internal/org/model"
+)
+
+const (
+	OrgKeyOrgDomain     = "domain"
+	OrgKeyOrgID         = "id"
+	OrgKeyOrgName       = "name"
+	OrgKeyResourceOwner = "resource_owner"
+	OrgKeyState         = "org_state"
+)
+
+type OrgView struct {
+	ID            string    `json:"-" gorm:"column:id;primary_key"`
+	CreationDate  time.Time `json:"-" gorm:"column:creation_date"`
+	ChangeDate    time.Time `json:"-" gorm:"column:change_date"`
+	ResourceOwner string    `json:"-" gorm:"column:resource_owner"`
+	State         int32     `json:"-" gorm:"column:org_state"`
+	Sequence      uint64    `json:"-" gorm:"column:sequence"`
+
+	Name   string `json:"name" gorm:"column:name"`
+	Domain string `json:"domain" gorm:"column:domain"`
+}
+
+func OrgFromModel(org *org_model.OrgView) *OrgView {
+	return &OrgView{
+		Domain:        org.Domain,
+		ChangeDate:    org.ChangeDate,
+		CreationDate:  org.CreationDate,
+		ID:            org.ID,
+		Name:          org.Name,
+		ResourceOwner: org.ResourceOwner,
+		Sequence:      org.Sequence,
+		State:         int32(org.State),
+	}
+}
+
+func OrgToModel(org *OrgView) *org_model.OrgView {
+	return &org_model.OrgView{
+		Domain:        org.Domain,
+		ChangeDate:    org.ChangeDate,
+		CreationDate:  org.CreationDate,
+		ID:            org.ID,
+		Name:          org.Name,
+		ResourceOwner: org.ResourceOwner,
+		Sequence:      org.Sequence,
+		State:         org_model.OrgState(org.State),
+	}
+}
+
+func OrgsToModel(orgs []*OrgView) []*org_model.OrgView {
+	modelOrgs := make([]*org_model.OrgView, len(orgs))
+
+	for i, org := range orgs {
+		modelOrgs[i] = OrgToModel(org)
+	}
+
+	return modelOrgs
+}
+
+func (o *OrgView) AppendEvent(event *es_models.Event) (err error) {
+	switch event.Type {
+	case org_es_model.OrgAdded:
+		o.CreationDate = event.CreationDate
+		o.State = int32(org_model.ORGSTATE_ACTIVE)
+		o.setRootData(event)
+		err = o.SetData(event)
+	case org_es_model.OrgChanged:
+		o.setRootData(event)
+		err = o.SetData(event)
+	case org_es_model.OrgDeactivated:
+		o.State = int32(org_model.ORGSTATE_INACTIVE)
+	case org_es_model.OrgReactivated:
+		o.State = int32(org_model.ORGSTATE_ACTIVE)
+	}
+	return err
+}
+
+func (o *OrgView) setRootData(event *es_models.Event) {
+	o.ChangeDate = event.CreationDate
+	o.Sequence = event.Sequence
+	o.ID = event.AggregateID
+	o.ResourceOwner = event.ResourceOwner
+}
+
+func (o *OrgView) SetData(event *es_models.Event) error {
+	if err := json.Unmarshal(event.Data, o); err != nil {
+		logging.Log("VIEW-5W7Op").WithError(err).Error("could not unmarshal event data")
+		return errors.ThrowInternal(err, "VIEW-HZKME", "Could not unmarshal data")
+	}
+	return nil
+}

internal/org/repository/view/org_member.go

@@ -0,0 +1,99 @@
+package view
+
+import (
+	"encoding/json"
+	"time"
+
+	"github.com/caos/logging"
+	caos_errs "github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/org/model"
+	"github.com/lib/pq"
+)
+
+const (
+	OrgMemberKeyUserID    = "user_id"
+	OrgMemberKeyOrgID     = "org_id"
+	OrgMemberKeyUserName  = "user_name"
+	OrgMemberKeyEmail     = "email"
+	OrgMemberKeyFirstName = "first_name"
+	OrgMemberKeyLastName  = "last_name"
+)
+
+type OrgMemberView struct {
+	UserID    string         `json:"userId" gorm:"column:user_id;primary_key"`
+	OrgID     string         `json:"-" gorm:"column:org_id;primary_key"`
+	UserName  string         `json:"-" gorm:"column:user_name"`
+	Email     string         `json:"-" gorm:"column:email_address"`
+	FirstName string         `json:"-" gorm:"column:first_name"`
+	LastName  string         `json:"-" gorm:"column:last_name"`
+	Roles     pq.StringArray `json:"roles" gorm:"column:roles"`
+	Sequence  uint64         `json:"-" gorm:"column:sequence"`
+
+	CreationDate time.Time `json:"-" gorm:"column:creation_date"`
+	ChangeDate   time.Time `json:"-" gorm:"column:change_date"`
+}
+
+func OrgMemberViewFromModel(member *model.OrgMemberView) *OrgMemberView {
+	return &OrgMemberView{
+		UserID:       member.UserID,
+		OrgID:        member.OrgID,
+		UserName:     member.UserName,
+		Email:        member.Email,
+		FirstName:    member.FirstName,
+		LastName:     member.LastName,
+		Roles:        member.Roles,
+		Sequence:     member.Sequence,
+		CreationDate: member.CreationDate,
+		ChangeDate:   member.ChangeDate,
+	}
+}
+
+func OrgMemberToModel(member *OrgMemberView) *model.OrgMemberView {
+	return &model.OrgMemberView{
+		UserID:       member.UserID,
+		OrgID:        member.OrgID,
+		UserName:     member.UserName,
+		Email:        member.Email,
+		FirstName:    member.FirstName,
+		LastName:     member.LastName,
+		Roles:        member.Roles,
+		Sequence:     member.Sequence,
+		CreationDate: member.CreationDate,
+		ChangeDate:   member.ChangeDate,
+	}
+}
+
+func OrgMembersToModel(roles []*OrgMemberView) []*model.OrgMemberView {
+	result := make([]*model.OrgMemberView, len(roles))
+	for i, r := range roles {
+		result[i] = OrgMemberToModel(r)
+	}
+	return result
+}
+
+func (r *OrgMemberView) AppendEvent(event *models.Event) (err error) {
+	r.Sequence = event.Sequence
+	r.ChangeDate = event.CreationDate
+	switch event.Type {
+	case model.OrgMemberAdded:
+		r.setRootData(event)
+		r.CreationDate = event.CreationDate
+		err = r.SetData(event)
+	case model.OrgMemberChanged:
+		err = r.SetData(event)
+	}
+	return err
+}
+
+func (r *OrgMemberView) setRootData(event *models.Event) {
+	r.OrgID = event.AggregateID
+}
+
+func (r *OrgMemberView) SetData(event *models.Event) error {
+	if err := json.Unmarshal(event.Data, r); err != nil {
+		logging.Log("EVEN-slo9s").WithError(err).Error("could not unmarshal event data")
+		return caos_errs.ThrowInternal(err, "MODEL-lub6s", "Could not unmarshal data")
+	}
+	return nil
+}

internal/org/repository/view/org_member_query.go

@@ -0,0 +1,69 @@
+package view
+
+import (
+	global_model "github.com/caos/zitadel/internal/model"
+	proj_model "github.com/caos/zitadel/internal/org/model"
+	"github.com/caos/zitadel/internal/view"
+)
+
+type OrgMemberSearchRequest proj_model.OrgMemberSearchRequest
+type OrgMemberSearchQuery proj_model.OrgMemberSearchQuery
+type OrgMemberSearchKey proj_model.OrgMemberSearchKey
+
+func (req OrgMemberSearchRequest) GetLimit() uint64 {
+	return req.Limit
+}
+
+func (req OrgMemberSearchRequest) GetOffset() uint64 {
+	return req.Offset
+}
+
+func (req OrgMemberSearchRequest) GetSortingColumn() view.ColumnKey {
+	if req.SortingColumn == proj_model.ORGMEMBERSEARCHKEY_UNSPECIFIED {
+		return nil
+	}
+	return OrgMemberSearchKey(req.SortingColumn)
+}
+
+func (req OrgMemberSearchRequest) GetAsc() bool {
+	return req.Asc
+}
+
+func (req OrgMemberSearchRequest) GetQueries() []view.SearchQuery {
+	result := make([]view.SearchQuery, len(req.Queries))
+	for i, q := range req.Queries {
+		result[i] = OrgMemberSearchQuery{Key: q.Key, Value: q.Value, Method: q.Method}
+	}
+	return result
+}
+
+func (req OrgMemberSearchQuery) GetKey() view.ColumnKey {
+	return OrgMemberSearchKey(req.Key)
+}
+
+func (req OrgMemberSearchQuery) GetMethod() global_model.SearchMethod {
+	return req.Method
+}
+
+func (req OrgMemberSearchQuery) GetValue() interface{} {
+	return req.Value
+}
+
+func (key OrgMemberSearchKey) ToColumnName() string {
+	switch proj_model.OrgMemberSearchKey(key) {
+	case proj_model.ORGMEMBERSEARCHKEY_EMAIL:
+		return OrgMemberKeyEmail
+	case proj_model.ORGMEMBERSEARCHKEY_FIRST_NAME:
+		return OrgMemberKeyFirstName
+	case proj_model.ORGMEMBERSEARCHKEY_LAST_NAME:
+		return OrgMemberKeyLastName
+	case proj_model.ORGMEMBERSEARCHKEY_USER_NAME:
+		return OrgMemberKeyUserName
+	case proj_model.ORGMEMBERSEARCHKEY_USER_ID:
+		return OrgMemberKeyUserID
+	case proj_model.ORGMEMBERSEARCHKEY_ORG_ID:
+		return OrgMemberKeyOrgID
+	default:
+		return ""
+	}
+}

internal/org/repository/view/org_member_view.go

@@ -0,0 +1,58 @@
+package view
+
+import (
+	global_model "github.com/caos/zitadel/internal/model"
+	org_model "github.com/caos/zitadel/internal/org/model"
+	"github.com/caos/zitadel/internal/view"
+	"github.com/jinzhu/gorm"
+)
+
+func OrgMemberByIDs(db *gorm.DB, table, orgID, userID string) (*OrgMemberView, error) {
+	member := new(OrgMemberView)
+
+	orgIDQuery := &OrgMemberSearchQuery{Key: org_model.ORGMEMBERSEARCHKEY_ORG_ID, Value: orgID, Method: global_model.SEARCHMETHOD_EQUALS}
+	userIDQuery := &OrgMemberSearchQuery{Key: org_model.ORGMEMBERSEARCHKEY_USER_ID, Value: userID, Method: global_model.SEARCHMETHOD_EQUALS}
+	query := view.PrepareGetByQuery(table, orgIDQuery, userIDQuery)
+	err := query(db, member)
+	return member, err
+}
+
+func SearchOrgMembers(db *gorm.DB, table string, req *org_model.OrgMemberSearchRequest) ([]*OrgMemberView, int, error) {
+	members := make([]*OrgMemberView, 0)
+	query := view.PrepareSearchQuery(table, OrgMemberSearchRequest{Limit: req.Limit, Offset: req.Offset, Queries: req.Queries})
+	count, err := query(db, &members)
+	if err != nil {
+		return nil, 0, err
+	}
+	return members, count, nil
+}
+func OrgMembersByUserID(db *gorm.DB, table string, userID string) ([]*OrgMemberView, error) {
+	members := make([]*OrgMemberView, 0)
+	queries := []*org_model.OrgMemberSearchQuery{
+		{
+			Key:    org_model.ORGMEMBERSEARCHKEY_USER_ID,
+			Value:  userID,
+			Method: global_model.SEARCHMETHOD_EQUALS,
+		},
+	}
+	query := view.PrepareSearchQuery(table, OrgMemberSearchRequest{Queries: queries})
+	_, err := query(db, &members)
+	if err != nil {
+		return nil, err
+	}
+	return members, nil
+}
+
+func PutOrgMember(db *gorm.DB, table string, role *OrgMemberView) error {
+	save := view.PrepareSave(table)
+	return save(db, role)
+}
+
+func DeleteOrgMember(db *gorm.DB, table, orgID, userID string) error {
+	member, err := OrgMemberByIDs(db, table, orgID, userID)
+	if err != nil {
+		return err
+	}
+	delete := view.PrepareDeleteByObject(table, member)
+	return delete(db)
+}

internal/org/repository/view/org_query.go

@@ -0,0 +1,67 @@
+package view
+
+import (
+	global_model "github.com/caos/zitadel/internal/model"
+	usr_model "github.com/caos/zitadel/internal/org/model"
+	"github.com/caos/zitadel/internal/view"
+)
+
+type OrgSearchRequest usr_model.OrgSearchRequest
+type OrgSearchQuery usr_model.OrgSearchQuery
+type OrgSearchKey usr_model.OrgSearchKey
+
+func (req OrgSearchRequest) GetLimit() uint64 {
+	return req.Limit
+}
+
+func (req OrgSearchRequest) GetOffset() uint64 {
+	return req.Offset
+}
+
+func (req OrgSearchRequest) GetSortingColumn() view.ColumnKey {
+	if req.SortingColumn == usr_model.ORGSEARCHKEY_UNSPECIFIED {
+		return nil
+	}
+	return OrgSearchKey(req.SortingColumn)
+}
+
+func (req OrgSearchRequest) GetAsc() bool {
+	return req.Asc
+}
+
+func (req OrgSearchRequest) GetQueries() []view.SearchQuery {
+	result := make([]view.SearchQuery, len(req.Queries))
+	for i, q := range req.Queries {
+		result[i] = OrgSearchQuery{Key: q.Key, Value: q.Value, Method: q.Method}
+	}
+	return result
+}
+
+func (req OrgSearchQuery) GetKey() view.ColumnKey {
+	return OrgSearchKey(req.Key)
+}
+
+func (req OrgSearchQuery) GetMethod() global_model.SearchMethod {
+	return req.Method
+}
+
+func (req OrgSearchQuery) GetValue() interface{} {
+	return req.Value
+}
+
+func (key OrgSearchKey) ToColumnName() string {
+	switch usr_model.OrgSearchKey(key) {
+	case usr_model.ORGSEARCHKEY_ORG_DOMAIN:
+		return OrgKeyOrgDomain
+	case usr_model.ORGSEARCHKEY_ORG_ID:
+		return OrgKeyOrgID
+	case usr_model.ORGSEARCHKEY_ORG_NAME:
+		return OrgKeyOrgName
+	case usr_model.ORGSEARCHKEY_RESOURCEOWNER:
+		return OrgKeyResourceOwner
+	case usr_model.ORGSEARCHKEY_STATE:
+		return OrgKeyState
+	default:
+		return ""
+	}
+}

internal/org/repository/view/org_view.go

@@ -0,0 +1,41 @@
+package view
+
+import (
+	org_model "github.com/caos/zitadel/internal/org/model"
+	"github.com/caos/zitadel/internal/view"
+	"github.com/jinzhu/gorm"
+)
+
+func OrgByID(db *gorm.DB, table, orgID string) (*OrgView, error) {
+	org := new(OrgView)
+	query := view.PrepareGetByKey(table, OrgSearchKey(org_model.ORGSEARCHKEY_ORG_ID), orgID)
+	err := query(db, org)
+	return org, err
+}
+
+func SearchOrgs(db *gorm.DB, table string, req *org_model.OrgSearchRequest) ([]*OrgView, int, error) {
+	orgs := make([]*OrgView, 0)
+	query := view.PrepareSearchQuery(table, OrgSearchRequest{Limit: req.Limit, Offset: req.Offset, Queries: req.Queries})
+	count, err := query(db, &orgs)
+	if err != nil {
+		return nil, 0, err
+	}
+	return orgs, count, nil
+}
+
+func GetGlobalOrgByDomain(db *gorm.DB, table, domain string) (*OrgView, error) {
+	org := new(OrgView)
+	query := view.PrepareGetByKey(table, OrgSearchKey(org_model.ORGSEARCHKEY_ORG_DOMAIN), domain)
+	err := query(db, org)
+	return org, err
+}
+
+func PutOrg(db *gorm.DB, table string, org *OrgView) error {
+	save := view.PrepareSave(table)
+	return save(db, org)
+}
+
+func DeleteOrg(db *gorm.DB, table, orgID string) error {
+	delete := view.PrepareDeleteByKey(table, OrgSearchKey(org_model.ORGSEARCHKEY_ORG_ID), orgID)
+	return delete(db)
+}