mirror of
https://github.com/zitadel/zitadel.git
synced 2024-12-13 11:34:26 +00:00
1a00faf132
* fix: return orgDomain validationType * added missing translations for orgDomain activity * claim org domain * show message if domain token was requested * fix tests * fix tests Co-authored-by: Max Peintner <max@caos.ch>
238 lines
7.7 KiB
Go
238 lines
7.7 KiB
Go
package management
|
|
|
|
import (
|
|
"encoding/json"
|
|
|
|
"github.com/caos/logging"
|
|
"github.com/golang/protobuf/ptypes"
|
|
"google.golang.org/protobuf/encoding/protojson"
|
|
"google.golang.org/protobuf/types/known/structpb"
|
|
|
|
org_model "github.com/caos/zitadel/internal/org/model"
|
|
"github.com/caos/zitadel/pkg/grpc/management"
|
|
"github.com/caos/zitadel/pkg/grpc/message"
|
|
)
|
|
|
|
func orgsFromModel(orgs []*org_model.Org) []*management.Org {
|
|
orgList := make([]*management.Org, len(orgs))
|
|
for i, org := range orgs {
|
|
orgList[i] = orgFromModel(org)
|
|
}
|
|
return orgList
|
|
}
|
|
|
|
func orgFromModel(org *org_model.Org) *management.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 &management.Org{
|
|
ChangeDate: changeDate,
|
|
CreationDate: creationDate,
|
|
Id: org.AggregateID,
|
|
Name: org.Name,
|
|
State: orgStateFromModel(org.State),
|
|
}
|
|
}
|
|
|
|
func orgViewFromModel(org *org_model.OrgView) *management.OrgView {
|
|
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 &management.OrgView{
|
|
ChangeDate: changeDate,
|
|
CreationDate: creationDate,
|
|
Id: org.ID,
|
|
Name: org.Name,
|
|
State: orgStateFromModel(org.State),
|
|
}
|
|
}
|
|
|
|
func orgStateFromModel(state org_model.OrgState) management.OrgState {
|
|
switch state {
|
|
case org_model.OrgStateActive:
|
|
return management.OrgState_ORGSTATE_ACTIVE
|
|
case org_model.OrgStateInactive:
|
|
return management.OrgState_ORGSTATE_INACTIVE
|
|
default:
|
|
return management.OrgState_ORGSTATE_UNSPECIFIED
|
|
}
|
|
}
|
|
|
|
func addOrgDomainToModel(domain *management.AddOrgDomainRequest) *org_model.OrgDomain {
|
|
return &org_model.OrgDomain{Domain: domain.Domain}
|
|
}
|
|
|
|
func orgDomainValidationToModel(domain *management.OrgDomainValidationRequest) *org_model.OrgDomain {
|
|
return &org_model.OrgDomain{
|
|
Domain: domain.Domain,
|
|
ValidationType: orgDomainValidationTypeToModel(domain.Type),
|
|
}
|
|
}
|
|
|
|
func validateOrgDomainToModel(domain *management.ValidateOrgDomainRequest) *org_model.OrgDomain {
|
|
return &org_model.OrgDomain{Domain: domain.Domain}
|
|
}
|
|
|
|
func orgDomainValidationTypeToModel(key management.OrgDomainValidationType) org_model.OrgDomainValidationType {
|
|
switch key {
|
|
case management.OrgDomainValidationType_ORGDOMAINVALIDATIONTYPE_HTTP:
|
|
return org_model.OrgDomainValidationTypeHTTP
|
|
case management.OrgDomainValidationType_ORGDOMAINVALIDATIONTYPE_DNS:
|
|
return org_model.OrgDomainValidationTypeDNS
|
|
default:
|
|
return org_model.OrgDomainValidationTypeUnspecified
|
|
}
|
|
}
|
|
|
|
func orgDomainValidationTypeFromModel(key org_model.OrgDomainValidationType) management.OrgDomainValidationType {
|
|
switch key {
|
|
case org_model.OrgDomainValidationTypeHTTP:
|
|
return management.OrgDomainValidationType_ORGDOMAINVALIDATIONTYPE_HTTP
|
|
case org_model.OrgDomainValidationTypeDNS:
|
|
return management.OrgDomainValidationType_ORGDOMAINVALIDATIONTYPE_DNS
|
|
default:
|
|
return management.OrgDomainValidationType_ORGDOMAINVALIDATIONTYPE_UNSPECIFIED
|
|
}
|
|
}
|
|
|
|
func primaryOrgDomainToModel(domain *management.PrimaryOrgDomainRequest) *org_model.OrgDomain {
|
|
return &org_model.OrgDomain{Domain: domain.Domain}
|
|
}
|
|
|
|
func orgDomainFromModel(domain *org_model.OrgDomain) *management.OrgDomain {
|
|
creationDate, err := ptypes.TimestampProto(domain.CreationDate)
|
|
logging.Log("GRPC-u8Ksj").OnError(err).Debug("unable to get timestamp from time")
|
|
|
|
changeDate, err := ptypes.TimestampProto(domain.ChangeDate)
|
|
logging.Log("GRPC-9osFS").OnError(err).Debug("unable to get timestamp from time")
|
|
|
|
return &management.OrgDomain{
|
|
ChangeDate: changeDate,
|
|
CreationDate: creationDate,
|
|
OrgId: domain.AggregateID,
|
|
Domain: domain.Domain,
|
|
Verified: domain.Verified,
|
|
Primary: domain.Primary,
|
|
}
|
|
}
|
|
|
|
func orgDomainViewFromModel(domain *org_model.OrgDomainView) *management.OrgDomainView {
|
|
creationDate, err := ptypes.TimestampProto(domain.CreationDate)
|
|
logging.Log("GRPC-7sjDs").OnError(err).Debug("unable to get timestamp from time")
|
|
|
|
changeDate, err := ptypes.TimestampProto(domain.ChangeDate)
|
|
logging.Log("GRPC-8iSji").OnError(err).Debug("unable to get timestamp from time")
|
|
|
|
return &management.OrgDomainView{
|
|
ChangeDate: changeDate,
|
|
CreationDate: creationDate,
|
|
OrgId: domain.OrgID,
|
|
Domain: domain.Domain,
|
|
Verified: domain.Verified,
|
|
Primary: domain.Primary,
|
|
ValidationType: orgDomainValidationTypeFromModel(domain.ValidationType),
|
|
}
|
|
}
|
|
|
|
func orgDomainSearchRequestToModel(request *management.OrgDomainSearchRequest) *org_model.OrgDomainSearchRequest {
|
|
return &org_model.OrgDomainSearchRequest{
|
|
Limit: request.Limit,
|
|
Offset: request.Offset,
|
|
Queries: orgDomainSearchQueriesToModel(request.Queries),
|
|
}
|
|
}
|
|
|
|
func orgDomainSearchQueriesToModel(queries []*management.OrgDomainSearchQuery) []*org_model.OrgDomainSearchQuery {
|
|
modelQueries := make([]*org_model.OrgDomainSearchQuery, len(queries))
|
|
|
|
for i, query := range queries {
|
|
modelQueries[i] = orgDomainSearchQueryToModel(query)
|
|
}
|
|
|
|
return modelQueries
|
|
}
|
|
|
|
func orgDomainSearchQueryToModel(query *management.OrgDomainSearchQuery) *org_model.OrgDomainSearchQuery {
|
|
return &org_model.OrgDomainSearchQuery{
|
|
Key: orgDomainSearchKeyToModel(query.Key),
|
|
Method: searchMethodToModel(query.Method),
|
|
Value: query.Value,
|
|
}
|
|
}
|
|
|
|
func orgDomainSearchKeyToModel(key management.OrgDomainSearchKey) org_model.OrgDomainSearchKey {
|
|
switch key {
|
|
case management.OrgDomainSearchKey_ORGDOMAINSEARCHKEY_DOMAIN:
|
|
return org_model.OrgDomainSearchKeyDomain
|
|
default:
|
|
return org_model.OrgDomainSearchKeyUnspecified
|
|
}
|
|
}
|
|
|
|
func orgDomainSearchResponseFromModel(resp *org_model.OrgDomainSearchResponse) *management.OrgDomainSearchResponse {
|
|
timestamp, err := ptypes.TimestampProto(resp.Timestamp)
|
|
logging.Log("GRPC-Mxi9w").OnError(err).Debug("unable to get timestamp from time")
|
|
return &management.OrgDomainSearchResponse{
|
|
Limit: resp.Limit,
|
|
Offset: resp.Offset,
|
|
TotalResult: resp.TotalResult,
|
|
Result: orgDomainsFromModel(resp.Result),
|
|
ProcessedSequence: resp.Sequence,
|
|
ViewTimestamp: timestamp,
|
|
}
|
|
}
|
|
func orgDomainsFromModel(viewDomains []*org_model.OrgDomainView) []*management.OrgDomainView {
|
|
domains := make([]*management.OrgDomainView, len(viewDomains))
|
|
|
|
for i, domain := range viewDomains {
|
|
domains[i] = orgDomainViewFromModel(domain)
|
|
}
|
|
|
|
return domains
|
|
}
|
|
|
|
func orgChangesToResponse(response *org_model.OrgChanges, offset uint64, limit uint64) (_ *management.Changes) {
|
|
return &management.Changes{
|
|
Limit: limit,
|
|
Offset: offset,
|
|
Changes: orgChangesToMgtAPI(response),
|
|
}
|
|
}
|
|
|
|
func orgChangesToMgtAPI(changes *org_model.OrgChanges) (_ []*management.Change) {
|
|
result := make([]*management.Change, len(changes.Changes))
|
|
|
|
for i, change := range changes.Changes {
|
|
b, err := json.Marshal(change.Data)
|
|
data := &structpb.Struct{}
|
|
err = protojson.Unmarshal(b, data)
|
|
if err != nil {
|
|
}
|
|
result[i] = &management.Change{
|
|
ChangeDate: change.ChangeDate,
|
|
EventType: message.NewLocalizedEventType(change.EventType),
|
|
Sequence: change.Sequence,
|
|
Data: data,
|
|
Editor: change.ModifierName,
|
|
EditorId: change.ModifierId,
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func orgIamPolicyFromModel(policy *org_model.OrgIamPolicy) *management.OrgIamPolicy {
|
|
return &management.OrgIamPolicy{
|
|
OrgId: policy.AggregateID,
|
|
Description: policy.Description,
|
|
UserLoginMustBeDomain: policy.UserLoginMustBeDomain,
|
|
Default: policy.Default,
|
|
}
|
|
}
|