1
0
mirror of https://github.com/zitadel/zitadel.git synced 2024-12-14 03:54:21 +00:00
zitadel/internal/query/project_grant_member.go
Silvan d2ea9a1b8c
feat: member queries ()
* refactor(domain): add user type

* fix(projections): start with login names

* fix(login_policy): correct handling of user domain claimed event

* fix(projections): add members

* refactor: simplify member projections

* add migration for members

* add metadata to member projections

* refactor: login name projection

* fix: set correct suffixes on login name projections

* test(projections): login name reduces

* fix: correct cols in reduce member

* test(projections): org, iam, project members

* member additional cols and conds as opt,
add project grant members

* fix(migration): members

* fix(migration): correct database name

* migration version

* migs

* better naming for member cond and col

* split project and project grant members

* prepare member columns

* feat(queries): membership query

* test(queries): membership prepare

* fix(queries): multiple projections for latest sequence

* fix(api): use query for membership queries in auth and management

* feat: org member queries

* fix(api): use query for iam member calls

* fix(queries): org members

* fix(queries): project members

* fix(queries): project grant members

* fix(query): member queries and user avatar column

* member cols

* fix(queries): membership stmt

* fix user test

* fix user test

* fix(membership): correct display name

* fix(projection): additional member manipulation events

* additional member tests

* fix(projections): additional events of idp links

* fix: use query for memberships ()

* fix(api): use query for memberships

* remove comment

* handle err

* refactor(projections): idp user link user aggregate type

* fix(projections): handle old user events

* fix(api): add asset prefix

* no image for iam members
2021-12-16 13:25:38 +00:00

180 lines
4.7 KiB
Go

package query
import (
"context"
"database/sql"
sq "github.com/Masterminds/squirrel"
"github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/query/projection"
"github.com/lib/pq"
)
var (
projectGrantMemberTable = table{
name: projection.ProjectGrantMemberProjectionTable,
alias: "members",
}
ProjectGrantMemberUserID = Column{
name: projection.MemberUserIDCol,
table: projectGrantMemberTable,
}
ProjectGrantMemberRoles = Column{
name: projection.MemberRolesCol,
table: projectGrantMemberTable,
}
ProjectGrantMemberCreationDate = Column{
name: projection.MemberCreationDate,
table: projectGrantMemberTable,
}
ProjectGrantMemberChangeDate = Column{
name: projection.MemberChangeDate,
table: projectGrantMemberTable,
}
ProjectGrantMemberSequence = Column{
name: projection.MemberSequence,
table: projectGrantMemberTable,
}
ProjectGrantMemberResourceOwner = Column{
name: projection.MemberResourceOwner,
table: projectGrantMemberTable,
}
ProjectGrantMemberProjectID = Column{
name: projection.ProjectGrantMemberProjectIDCol,
table: projectGrantMemberTable,
}
ProjectGrantMemberGrantID = Column{
name: projection.ProjectGrantMemberGrantIDCol,
table: projectGrantMemberTable,
}
)
type ProjectGrantMembersQuery struct {
MembersQuery
ProjectID, GrantID string
}
func (q *ProjectGrantMembersQuery) toQuery(query sq.SelectBuilder) sq.SelectBuilder {
return q.MembersQuery.
toQuery(query).
Where(sq.Eq{
ProjectGrantMemberProjectID.identifier(): q.ProjectID,
ProjectGrantMemberGrantID.identifier(): q.GrantID,
})
}
func (q *Queries) ProjectGrantMembers(ctx context.Context, queries *ProjectGrantMembersQuery) (*Members, error) {
query, scan := prepareProjectGrantMembersQuery()
stmt, args, err := queries.toQuery(query).ToSql()
if err != nil {
return nil, errors.ThrowInvalidArgument(err, "QUERY-USNwM", "Errors.Query.InvalidRequest")
}
currentSequence, err := q.latestSequence(ctx, projectGrantMemberTable)
if err != nil {
return nil, err
}
rows, err := q.client.QueryContext(ctx, stmt, args...)
if err != nil {
return nil, errors.ThrowInternal(err, "QUERY-Pdg1I", "Errors.Internal")
}
members, err := scan(rows)
if err != nil {
return nil, err
}
members.LatestSequence = currentSequence
return members, err
}
func prepareProjectGrantMembersQuery() (sq.SelectBuilder, func(*sql.Rows) (*Members, error)) {
return sq.Select(
ProjectGrantMemberCreationDate.identifier(),
ProjectGrantMemberChangeDate.identifier(),
ProjectGrantMemberSequence.identifier(),
ProjectGrantMemberResourceOwner.identifier(),
ProjectGrantMemberUserID.identifier(),
ProjectGrantMemberRoles.identifier(),
LoginNameNameCol.identifier(),
HumanEmailCol.identifier(),
HumanFirstNameCol.identifier(),
HumanLastNameCol.identifier(),
HumanDisplayNameCol.identifier(),
MachineNameCol.identifier(),
HumanAvaterURLCol.identifier(),
countColumn.identifier(),
).From(projectGrantMemberTable.identifier()).
LeftJoin(join(HumanUserIDCol, ProjectGrantMemberUserID)).
LeftJoin(join(MachineUserIDCol, ProjectGrantMemberUserID)).
LeftJoin(join(LoginNameUserIDCol, ProjectGrantMemberUserID)).
Where(
sq.Eq{LoginNameIsPrimaryCol.identifier(): true},
).PlaceholderFormat(sq.Dollar),
func(rows *sql.Rows) (*Members, error) {
members := make([]*Member, 0)
var count uint64
for rows.Next() {
member := new(Member)
roles := pq.StringArray{}
var (
preferredLoginName = sql.NullString{}
email = sql.NullString{}
firstName = sql.NullString{}
lastName = sql.NullString{}
displayName = sql.NullString{}
machineName = sql.NullString{}
avatarURL = sql.NullString{}
)
err := rows.Scan(
&member.CreationDate,
&member.ChangeDate,
&member.Sequence,
&member.ResourceOwner,
&member.UserID,
&roles,
&preferredLoginName,
&email,
&firstName,
&lastName,
&displayName,
&machineName,
&avatarURL,
&count,
)
if err != nil {
return nil, err
}
member.Roles = roles
member.PreferredLoginName = preferredLoginName.String
member.Email = email.String
member.FirstName = firstName.String
member.LastName = lastName.String
member.AvatarURL = avatarURL.String
if displayName.Valid {
member.DisplayName = displayName.String
} else {
member.DisplayName = machineName.String
}
members = append(members, member)
}
if err := rows.Close(); err != nil {
return nil, errors.ThrowInternal(err, "QUERY-EqJFc", "Errors.Query.CloseRows")
}
return &Members{
Members: members,
SearchResponse: SearchResponse{
Count: count,
},
}, nil
}
}