TheArchive/zitadel
1
0
Fork 0
mirror of https://github.com/zitadel/zitadel.git synced 2025-08-11 18:17:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: org queries (#136)

Browse Source 
* 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
This commit is contained in:
Silvan
2020-05-26 16:46:16 +02:00
committed by GitHub
parent a6aba86b54
commit 3025ac577b
52 changed files with 1732 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

69
pkg/admin/api/grpc/org.go
View File

@@ -2,6 +2,10 @@ package grpc
import (
"context"
"github.com/caos/zitadel/internal/model"
org_model "github.com/caos/zitadel/internal/org/model"
)
func (s *Server) GetOrgByID(ctx context.Context, orgID *OrgID) (_ *Org, err error) {
@@ -13,14 +17,15 @@ func (s *Server) GetOrgByID(ctx context.Context, orgID *OrgID) (_ *Org, err erro
}
func (s *Server) SearchOrgs(ctx context.Context, request *OrgSearchRequest) (_ *OrgSearchResponse, err error) {
orgs, err := s.org.SearchOrgs(ctx)
result, err := s.org.SearchOrgs(ctx, orgSearchRequestToModel(request))
if err != nil {
return nil, err
}
return &OrgSearchResponse{Result: orgsFromModel(orgs),
Limit: request.Limit,
Offset: request.Offset,
// TotalResult: , TODO: total result from search
return &OrgSearchResponse{
Result: orgViewsFromModel(result.Result),
Limit: request.Limit,
Offset: request.Offset,
TotalResult: result.TotalResult,
}, nil
}
@@ -37,3 +42,57 @@ func (s *Server) SetUpOrg(ctx context.Context, orgSetUp *OrgSetUpRequest) (_ *Or
}
return setUpOrgResponseFromModel(setUp), err
}
func orgSearchRequestToModel(req *OrgSearchRequest) *org_model.OrgSearchRequest {
return &org_model.OrgSearchRequest{
Limit: req.Limit,
Asc: req.Asc,
Offset: req.Offset,
Queries: orgQueriesToModel(req.Queries),
SortingColumn: orgQueryKeyToModel(req.SortingColumn),
}
}
func orgQueriesToModel(queries []*OrgSearchQuery) []*org_model.OrgSearchQuery {
modelQueries := make([]*org_model.OrgSearchQuery, len(queries))
for i, query := range queries {
modelQueries[i] = orgQueryToModel(query)
}
return modelQueries
}
func orgQueryToModel(query *OrgSearchQuery) *org_model.OrgSearchQuery {
return &org_model.OrgSearchQuery{
Key: orgQueryKeyToModel(query.Key),
Value: query.Value,
Method: orgQueryMethodToModel(query.Method),
}
}
func orgQueryKeyToModel(key OrgSearchKey) org_model.OrgSearchKey {
switch key {
case OrgSearchKey_ORGSEARCHKEY_DOMAIN:
return org_model.ORGSEARCHKEY_ORG_DOMAIN
case OrgSearchKey_ORGSEARCHKEY_ORG_NAME:
return org_model.ORGSEARCHKEY_ORG_NAME
case OrgSearchKey_ORGSEARCHKEY_STATE:
return org_model.ORGSEARCHKEY_STATE
default:
return org_model.ORGSEARCHKEY_UNSPECIFIED
}
}
func orgQueryMethodToModel(method OrgSearchMethod) model.SearchMethod {
switch method {
case OrgSearchMethod_ORGSEARCHMETHOD_CONTAINS:
return model.SEARCHMETHOD_CONTAINS
case OrgSearchMethod_ORGSEARCHMETHOD_EQUALS:
return model.SEARCHMETHOD_EQUALS
case OrgSearchMethod_ORGSEARCHMETHOD_STARTS_WITH:
return model.SEARCHMETHOD_STARTS_WITH
default:
return 0
}
}

21
pkg/admin/api/grpc/org_converter.go
View File

@@ -65,10 +65,10 @@ func setUpOrgResponseFromModel(setUp *admin_model.SetupOrg) *OrgSetUpResponse {
}
}
func orgsFromModel(orgs []*org_model.Org) []*Org {
func orgViewsFromModel(orgs []*org_model.OrgView) []*Org {
result := make([]*Org, len(orgs))
for i, org := range orgs {
result[i] = orgFromModel(org)
result[i] = orgViewFromModel(org)
}
return result
@@ -91,6 +91,23 @@ func orgFromModel(org *org_model.Org) *Org {
}
}
func orgViewFromModel(org *org_model.OrgView) *Org {
creationDate, err := ptypes.TimestampProto(org.CreationDate)
logging.Log("GRPC-GTHsZ").OnError(err).Debug("unable to get timestamp from time")
changeDate, err := ptypes.TimestampProto(org.ChangeDate)
logging.Log("GRPC-dVnoj").OnError(err).Debug("unable to get timestamp from time")
return &Org{
Domain: org.Domain,
ChangeDate: changeDate,
CreationDate: creationDate,
Id: org.ID,
Name: org.Name,
State: orgStateFromModel(org.State),
}
}
func userFromModel(user *usr_model.User) *User {
creationDate, err := ptypes.TimestampProto(user.CreationDate)
logging.Log("GRPC-8duwe").OnError(err).Debug("unable to parse timestamp")

2
pkg/management/api/grpc/org.go
View File

@@ -19,7 +19,7 @@ func (s *Server) GetOrgByDomainGlobal(ctx context.Context, in *OrgDomain) (*Org,
if err != nil {
return nil, err
}
return orgFromModel(org), nil
return orgFromView(org), nil
}
func (s *Server) DeactivateOrg(ctx context.Context, in *OrgID) (*Org, error) {

17
pkg/management/api/grpc/org_converter.go
View File

@@ -31,6 +31,23 @@ func orgFromModel(org *org_model.Org) *Org {
}
}
func orgFromView(org *org_model.OrgView) *Org {
creationDate, err := ptypes.TimestampProto(org.CreationDate)
logging.Log("GRPC-GTHsZ").OnError(err).Debug("unable to get timestamp from time")
changeDate, err := ptypes.TimestampProto(org.ChangeDate)
logging.Log("GRPC-dVnoj").OnError(err).Debug("unable to get timestamp from time")
return &Org{
Domain: org.Domain,
ChangeDate: changeDate,
CreationDate: creationDate,
Id: org.ID,
Name: org.Name,
State: orgStateFromModel(org.State),
}
}
func orgStateFromModel(state org_model.OrgState) OrgState {
switch state {
case org_model.ORGSTATE_ACTIVE:

15
pkg/management/api/grpc/org_member.go
View File

@@ -3,22 +3,25 @@ package grpc
import (
"context"
"github.com/caos/zitadel/internal/errors"
"github.com/golang/protobuf/ptypes/empty"
)
func (s *Server) GetOrgMemberRoles(ctx context.Context, _ *empty.Empty) (*OrgMemberRoles, error) {
return nil, errors.ThrowUnimplemented(nil, "GRPC-wz4vc", "Not implemented")
return &OrgMemberRoles{Roles: s.org.GetOrgMemberRoles()}, nil
}
func (s *Server) SearchOrgMembers(ctx context.Context, in *OrgMemberSearchRequest) (*OrgMemberSearchResponse, error) {
return nil, errors.ThrowUnimplemented(nil, "GRPC-wkdl3", "Not implemented")
members, err := s.org.SearchOrgMembers(ctx, orgMemberSearchRequestToModel(in))
if err != nil {
return nil, err
}
return orgMemberSearchResponseFromModel(members), nil
}
func (s *Server) AddOrgMember(ctx context.Context, member *AddOrgMemberRequest) (*OrgMember, error) {
repositoryMember := addOrgMemberToModel(member)
addedMember, err := s.orgMember.AddOrgMember(ctx, repositoryMember)
addedMember, err := s.org.AddOrgMember(ctx, repositoryMember)
if err != nil {
return nil, err
}
@@ -28,7 +31,7 @@ func (s *Server) AddOrgMember(ctx context.Context, member *AddOrgMemberRequest)
func (s *Server) ChangeOrgMember(ctx context.Context, member *ChangeOrgMemberRequest) (*OrgMember, error) {
repositoryMember := changeOrgMemberToModel(member)
changedMember, err := s.orgMember.ChangeOrgMember(ctx, repositoryMember)
changedMember, err := s.org.ChangeOrgMember(ctx, repositoryMember)
if err != nil {
return nil, err
}
@@ -36,6 +39,6 @@ func (s *Server) ChangeOrgMember(ctx context.Context, member *ChangeOrgMemberReq
}
func (s *Server) RemoveOrgMember(ctx context.Context, member *RemoveOrgMemberRequest) (*empty.Empty, error) {
err := s.orgMember.RemoveOrgMember(ctx, member.OrgId, member.UserId)
err := s.org.RemoveOrgMember(ctx, member.OrgId, member.UserId)
return &empty.Empty{}, err
}

94
pkg/management/api/grpc/org_member_converter.go
View File

@@ -2,6 +2,7 @@ package grpc
import (
"github.com/caos/logging"
"github.com/caos/zitadel/internal/model"
org_model "github.com/caos/zitadel/internal/org/model"
"github.com/golang/protobuf/ptypes"
)
@@ -35,3 +36,96 @@ func orgMemberFromModel(member *org_model.OrgMember) *OrgMember {
Sequence: member.Sequence,
}
}
func orgMemberSearchRequestToModel(request *OrgMemberSearchRequest) *org_model.OrgMemberSearchRequest {
return &org_model.OrgMemberSearchRequest{
Limit: request.Limit,
Offset: request.Offset,
Queries: orgMemberSearchQueriesToModel(request.Queries),
}
}
func orgMemberSearchQueriesToModel(queries []*OrgMemberSearchQuery) []*org_model.OrgMemberSearchQuery {
modelQueries := make([]*org_model.OrgMemberSearchQuery, len(queries))
for i, query := range queries {
modelQueries[i] = orgMemberSearchQueryToModel(query)
}
return modelQueries
}
func orgMemberSearchQueryToModel(query *OrgMemberSearchQuery) *org_model.OrgMemberSearchQuery {
return &org_model.OrgMemberSearchQuery{
Key: orgMemberSearchKeyToModel(query.Key),
Method: orgMemberSearchMethodToModel(query.Method),
Value: query.Value,
}
}
func orgMemberSearchKeyToModel(key OrgMemberSearchKey) org_model.OrgMemberSearchKey {
switch key {
case OrgMemberSearchKey_ORGMEMBERSEARCHKEY_EMAIL:
return org_model.ORGMEMBERSEARCHKEY_EMAIL
case OrgMemberSearchKey_ORGMEMBERSEARCHKEY_FIRST_NAME:
return org_model.ORGMEMBERSEARCHKEY_FIRST_NAME
case OrgMemberSearchKey_ORGMEMBERSEARCHKEY_LAST_NAME:
return org_model.ORGMEMBERSEARCHKEY_LAST_NAME
case OrgMemberSearchKey_ORGMEMBERSEARCHKEY_USER_ID:
return org_model.ORGMEMBERSEARCHKEY_USER_ID
default:
return org_model.ORGMEMBERSEARCHKEY_UNSPECIFIED
}
}
func orgMemberSearchMethodToModel(key SearchMethod) model.SearchMethod {
switch key {
case SearchMethod_SEARCHMETHOD_CONTAINS:
return model.SEARCHMETHOD_CONTAINS
case SearchMethod_SEARCHMETHOD_CONTAINS_IGNORE_CASE:
return model.SEARCHMETHOD_CONTAINS_IGNORE_CASE
case SearchMethod_SEARCHMETHOD_EQUALS:
return model.SEARCHMETHOD_EQUALS
case SearchMethod_SEARCHMETHOD_EQUALS_IGNORE_CASE:
return model.SEARCHMETHOD_EQUALS_IGNORE_CASE
case SearchMethod_SEARCHMETHOD_STARTS_WITH:
return model.SEARCHMETHOD_STARTS_WITH
case SearchMethod_SEARCHMETHOD_STARTS_WITH_IGNORE_CASE:
return model.SEARCHMETHOD_STARTS_WITH_IGNORE_CASE
default:
return -1
}
}
func orgMemberSearchResponseFromModel(resp *org_model.OrgMemberSearchResponse) *OrgMemberSearchResponse {
return &OrgMemberSearchResponse{
Limit: resp.Limit,
Offset: resp.Offset,
TotalResult: resp.TotalResult,
Result: orgMembersFromView(resp.Result),
}
}
func orgMembersFromView(viewMembers []*org_model.OrgMemberView) []*OrgMember {
members := make([]*OrgMember, len(viewMembers))
for i, member := range viewMembers {
members[i] = orgMemberFromView(member)
}
return members
}
func orgMemberFromView(member *org_model.OrgMemberView) *OrgMember {
changeDate, err := ptypes.TimestampProto(member.ChangeDate)
logging.Log("GRPC-S9LAZ").OnError(err).Debug("unable to parse changedate")
creationDate, err := ptypes.TimestampProto(member.CreationDate)
logging.Log("GRPC-oJN56").OnError(err).Debug("unable to parse creation date")
return &OrgMember{
ChangeDate: changeDate,
CreationDate: creationDate,
Roles: member.Roles,
Sequence: member.Sequence,
UserId: member.UserID,
}
}

6
pkg/management/api/grpc/project_grant.go
View File

@@ -2,16 +2,12 @@ package grpc
import (
"context"
"github.com/caos/zitadel/internal/api"
grpc_util "github.com/caos/zitadel/internal/api/grpc"
"github.com/caos/zitadel/internal/errors"
"github.com/golang/protobuf/ptypes/empty"
)
func (s *Server) GetProjectGrantMemberRoles(ctx context.Context, _ *empty.Empty) (*ProjectGrantMemberRoles, error) {
return nil, errors.ThrowUnimplemented(nil, "GRPC-mGo89", "Not implemented")
}
func (s *Server) SearchProjectGrants(ctx context.Context, in *ProjectGrantSearchRequest) (*ProjectGrantSearchResponse, error) {
request := projectGrantSearchRequestsToModel(in)
orgID := grpc_util.GetHeader(ctx, api.ZitadelOrgID)

5
pkg/management/api/grpc/project_grant_member.go
View File

@@ -2,9 +2,14 @@ package grpc
import (
"context"
"github.com/golang/protobuf/ptypes/empty"
)
func (s *Server) GetProjectGrantMemberRoles(ctx context.Context, _ *empty.Empty) (*ProjectGrantMemberRoles, error) {
return &ProjectGrantMemberRoles{Roles: s.project.GetProjectGrantMemberRoles()}, nil
}
func (s *Server) SearchProjectGrantMembers(ctx context.Context, in *ProjectGrantMemberSearchRequest) (*ProjectGrantMemberSearchResponse, error) {
response, err := s.project.SearchProjectGrantMembers(ctx, projectGrantMemberSearchRequestsToModel(in))
if err != nil {

4
pkg/management/api/grpc/project_member.go
View File

@@ -2,12 +2,12 @@ package grpc
import (
"context"
"github.com/caos/zitadel/internal/errors"
"github.com/golang/protobuf/ptypes/empty"
)
func (s *Server) GetProjectMemberRoles(ctx context.Context, _ *empty.Empty) (*ProjectMemberRoles, error) {
return nil, errors.ThrowUnimplemented(nil, "GRPC-qw34d", "Not implemented")
return &ProjectMemberRoles{Roles: s.project.GetProjectMemberRoles()}, nil
}
func (s *Server) SearchProjectMembers(ctx context.Context, in *ProjectMemberSearchRequest) (*ProjectMemberSearchResponse, error) {

2
pkg/management/api/grpc/server.go
View File

@@ -17,7 +17,6 @@ type Server struct {
project repository.ProjectRepository
policy repository.PolicyRepository
org repository.OrgRepository
orgMember repository.OrgMemberRepository
user repository.UserRepository
usergrant repository.UserGrantRepository
verifier *mgmt_auth.TokenVerifier
@@ -30,7 +29,6 @@ func StartServer(conf grpc_util.ServerConfig, authZ auth.Config, repo repository
project: repo,
policy: repo,
org: repo,
orgMember: repo,
user: repo,
usergrant: repo,
authZ: authZ,

6
pkg/management/management.go
View File

@@ -16,7 +16,11 @@ type Config struct {
}
func Start(ctx context.Context, config Config, authZ auth.Config, systemDefaults sd.SystemDefaults) {
repo, err := eventsourcing.Start(config.Repository, systemDefaults)
roles := make([]string, len(authZ.RolePermissionMappings))
for i, role := range authZ.RolePermissionMappings {
roles[i] = role.Role
}
repo, err := eventsourcing.Start(config.Repository, systemDefaults, roles)
logging.Log("MAIN-9uBxp").OnError(err).Panic("unable to start app")
api.Start(ctx, config.API, authZ, repo)