feat: port reduction (#323)

* move mgmt pkg

* begin package restructure

* rename auth package to authz

* begin start api

* move auth

* move admin

* fix merge

* configs and interceptors

* interceptor

* revert generate-grpc.sh

* some cleanups

* console

* move console

* fix tests and merging

* js linting

* merge

* merging and configs

* change k8s base to current ports

* fixes

* cleanup

* regenerate proto

* remove unnecessary whitespace

* missing param

* go mod tidy

* fix merging

* move login pkg

* cleanup

* move api pkgs again

* fix pkg naming

* fix generate-static.sh for login

* update workflow

* fixes

* logging

* remove duplicate

* comment for optional gateway interfaces

* regenerate protos

* fix proto imports for grpc web

* protos

* grpc web generate

* grpc web generate

* fix changes

* add translation interceptor

* fix merging

* regenerate mgmt proto

internal/api/grpc/admin/administrator.go

@@ -0,0 +1,36 @@
+package admin
+
+import (
+	"context"
+
+	"github.com/golang/protobuf/ptypes/empty"
+
+	view_model "github.com/caos/zitadel/internal/view/model"
+	"github.com/caos/zitadel/pkg/grpc/admin"
+)
+
+func (s *Server) GetViews(ctx context.Context, _ *empty.Empty) (_ *admin.Views, err error) {
+	views, err := s.administrator.GetViews(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return &admin.Views{Views: viewsFromModel(views)}, nil
+}
+
+func (s *Server) ClearView(ctx context.Context, viewID *admin.ViewID) (_ *empty.Empty, err error) {
+	err = s.administrator.ClearView(ctx, viewID.Database, viewID.ViewName)
+	return &empty.Empty{}, err
+}
+
+func (s *Server) GetFailedEvents(ctx context.Context, _ *empty.Empty) (_ *admin.FailedEvents, err error) {
+	failedEvents, err := s.administrator.GetFailedEvents(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return &admin.FailedEvents{FailedEvents: failedEventsFromModel(failedEvents)}, nil
+}
+
+func (s *Server) RemoveFailedEvent(ctx context.Context, failedEventID *admin.FailedEventID) (_ *empty.Empty, err error) {
+	err = s.administrator.RemoveFailedEvent(ctx, &view_model.FailedEvent{Database: failedEventID.Database, ViewName: failedEventID.ViewName, FailedSequence: failedEventID.FailedSequence})
+	return &empty.Empty{}, err
+}

internal/api/grpc/admin/administrator_converter.go

@@ -0,0 +1,42 @@
+package admin
+
+import (
+	view_model "github.com/caos/zitadel/internal/view/model"
+	"github.com/caos/zitadel/pkg/grpc/admin"
+)
+
+func viewsFromModel(views []*view_model.View) []*admin.View {
+	result := make([]*admin.View, len(views))
+	for i, view := range views {
+		result[i] = viewFromModel(view)
+	}
+
+	return result
+}
+
+func failedEventsFromModel(failedEvents []*view_model.FailedEvent) []*admin.FailedEvent {
+	result := make([]*admin.FailedEvent, len(failedEvents))
+	for i, view := range failedEvents {
+		result[i] = failedEventFromModel(view)
+	}
+
+	return result
+}
+
+func viewFromModel(view *view_model.View) *admin.View {
+	return &admin.View{
+		Database: view.Database,
+		ViewName: view.ViewName,
+		Sequence: view.CurrentSequence,
+	}
+}
+
+func failedEventFromModel(failedEvent *view_model.FailedEvent) *admin.FailedEvent {
+	return &admin.FailedEvent{
+		Database:       failedEvent.Database,
+		ViewName:       failedEvent.ViewName,
+		FailedSequence: failedEvent.FailedSequence,
+		FailureCount:   failedEvent.FailureCount,
+		ErrorMessage:   failedEvent.ErrMsg,
+	}
+}

internal/api/grpc/admin/iam_member.go

@@ -0,0 +1,43 @@
+package admin
+
+import (
+	"context"
+
+	"github.com/golang/protobuf/ptypes/empty"
+
+	"github.com/caos/zitadel/pkg/grpc/admin"
+)
+
+func (s *Server) GetIamMemberRoles(ctx context.Context, _ *empty.Empty) (*admin.IamMemberRoles, error) {
+	return &admin.IamMemberRoles{Roles: s.iam.GetIamMemberRoles()}, nil
+}
+
+func (s *Server) SearchIamMembers(ctx context.Context, in *admin.IamMemberSearchRequest) (*admin.IamMemberSearchResponse, error) {
+	members, err := s.iam.SearchIamMembers(ctx, iamMemberSearchRequestToModel(in))
+	if err != nil {
+		return nil, err
+	}
+	return iamMemberSearchResponseFromModel(members), nil
+}
+
+func (s *Server) AddIamMember(ctx context.Context, member *admin.AddIamMemberRequest) (*admin.IamMember, error) {
+	addedMember, err := s.iam.AddIamMember(ctx, addIamMemberToModel(member))
+	if err != nil {
+		return nil, err
+	}
+
+	return iamMemberFromModel(addedMember), nil
+}
+
+func (s *Server) ChangeIamMember(ctx context.Context, member *admin.ChangeIamMemberRequest) (*admin.IamMember, error) {
+	changedMember, err := s.iam.ChangeIamMember(ctx, changeIamMemberToModel(member))
+	if err != nil {
+		return nil, err
+	}
+	return iamMemberFromModel(changedMember), nil
+}
+
+func (s *Server) RemoveIamMember(ctx context.Context, member *admin.RemoveIamMemberRequest) (*empty.Empty, error) {
+	err := s.iam.RemoveIamMember(ctx, member.UserId)
+	return &empty.Empty{}, err
+}

internal/api/grpc/admin/iam_member_converter.go

@@ -0,0 +1,140 @@
+package admin
+
+import (
+	"github.com/caos/logging"
+	"github.com/golang/protobuf/ptypes"
+
+	iam_model "github.com/caos/zitadel/internal/iam/model"
+	"github.com/caos/zitadel/internal/model"
+	"github.com/caos/zitadel/pkg/grpc/admin"
+)
+
+func addIamMemberToModel(member *admin.AddIamMemberRequest) *iam_model.IamMember {
+	memberModel := &iam_model.IamMember{
+		UserID: member.UserId,
+	}
+	memberModel.Roles = member.Roles
+
+	return memberModel
+}
+
+func changeIamMemberToModel(member *admin.ChangeIamMemberRequest) *iam_model.IamMember {
+	memberModel := &iam_model.IamMember{
+		UserID: member.UserId,
+	}
+	memberModel.Roles = member.Roles
+
+	return memberModel
+}
+
+func iamMemberFromModel(member *iam_model.IamMember) *admin.IamMember {
+	creationDate, err := ptypes.TimestampProto(member.CreationDate)
+	logging.Log("GRPC-Lsp76").OnError(err).Debug("date parse failed")
+
+	changeDate, err := ptypes.TimestampProto(member.ChangeDate)
+	logging.Log("GRPC-3fG5s").OnError(err).Debug("date parse failed")
+
+	return &admin.IamMember{
+		UserId:       member.UserID,
+		CreationDate: creationDate,
+		ChangeDate:   changeDate,
+		Roles:        member.Roles,
+		Sequence:     member.Sequence,
+	}
+}
+
+func iamMemberSearchRequestToModel(request *admin.IamMemberSearchRequest) *iam_model.IamMemberSearchRequest {
+	return &iam_model.IamMemberSearchRequest{
+		Limit:   request.Limit,
+		Offset:  request.Offset,
+		Queries: iamMemberSearchQueriesToModel(request.Queries),
+	}
+}
+
+func iamMemberSearchQueriesToModel(queries []*admin.IamMemberSearchQuery) []*iam_model.IamMemberSearchQuery {
+	modelQueries := make([]*iam_model.IamMemberSearchQuery, len(queries))
+	for i, query := range queries {
+		modelQueries[i] = iamMemberSearchQueryToModel(query)
+	}
+
+	return modelQueries
+}
+
+func iamMemberSearchQueryToModel(query *admin.IamMemberSearchQuery) *iam_model.IamMemberSearchQuery {
+	return &iam_model.IamMemberSearchQuery{
+		Key:    iamMemberSearchKeyToModel(query.Key),
+		Method: iamMemberSearchMethodToModel(query.Method),
+		Value:  query.Value,
+	}
+}
+
+func iamMemberSearchKeyToModel(key admin.IamMemberSearchKey) iam_model.IamMemberSearchKey {
+	switch key {
+	case admin.IamMemberSearchKey_IAMMEMBERSEARCHKEY_EMAIL:
+		return iam_model.IamMemberSearchKeyEmail
+	case admin.IamMemberSearchKey_IAMMEMBERSEARCHKEY_FIRST_NAME:
+		return iam_model.IamMemberSearchKeyFirstName
+	case admin.IamMemberSearchKey_IAMMEMBERSEARCHKEY_LAST_NAME:
+		return iam_model.IamMemberSearchKeyLastName
+	case admin.IamMemberSearchKey_IAMMEMBERSEARCHKEY_USER_ID:
+		return iam_model.IamMemberSearchKeyUserID
+	default:
+		return iam_model.IamMemberSearchKeyUnspecified
+	}
+}
+
+func iamMemberSearchMethodToModel(key admin.SearchMethod) model.SearchMethod {
+	switch key {
+	case admin.SearchMethod_SEARCHMETHOD_CONTAINS:
+		return model.SearchMethodContains
+	case admin.SearchMethod_SEARCHMETHOD_CONTAINS_IGNORE_CASE:
+		return model.SearchMethodContainsIgnoreCase
+	case admin.SearchMethod_SEARCHMETHOD_EQUALS:
+		return model.SearchMethodEquals
+	case admin.SearchMethod_SEARCHMETHOD_EQUALS_IGNORE_CASE:
+		return model.SearchMethodEqualsIgnoreCase
+	case admin.SearchMethod_SEARCHMETHOD_STARTS_WITH:
+		return model.SearchMethodStartsWith
+	case admin.SearchMethod_SEARCHMETHOD_STARTS_WITH_IGNORE_CASE:
+		return model.SearchMethodStartsWithIgnoreCase
+	default:
+		return -1
+	}
+}
+
+func iamMemberSearchResponseFromModel(resp *iam_model.IamMemberSearchResponse) *admin.IamMemberSearchResponse {
+	return &admin.IamMemberSearchResponse{
+		Limit:       resp.Limit,
+		Offset:      resp.Offset,
+		TotalResult: resp.TotalResult,
+		Result:      iamMembersFromView(resp.Result),
+	}
+}
+func iamMembersFromView(viewMembers []*iam_model.IamMemberView) []*admin.IamMemberView {
+	members := make([]*admin.IamMemberView, len(viewMembers))
+
+	for i, member := range viewMembers {
+		members[i] = iamMemberFromView(member)
+	}
+
+	return members
+}
+
+func iamMemberFromView(member *iam_model.IamMemberView) *admin.IamMemberView {
+	changeDate, err := ptypes.TimestampProto(member.ChangeDate)
+	logging.Log("GRPC-Lso9c").OnError(err).Debug("unable to parse changedate")
+	creationDate, err := ptypes.TimestampProto(member.CreationDate)
+	logging.Log("GRPC-6szE").OnError(err).Debug("unable to parse creation date")
+
+	return &admin.IamMemberView{
+		ChangeDate:   changeDate,
+		CreationDate: creationDate,
+		Roles:        member.Roles,
+		Sequence:     member.Sequence,
+		UserId:       member.UserID,
+		UserName:     member.UserName,
+		Email:        member.Email,
+		FirstName:    member.FirstName,
+		LastName:     member.LastName,
+	}
+}

internal/api/grpc/admin/org.go

@@ -0,0 +1,73 @@
+package admin
+
+import (
+	"context"
+
+	"github.com/golang/protobuf/ptypes/empty"
+
+	"github.com/caos/zitadel/pkg/grpc/admin"
+)
+
+func (s *Server) GetOrgByID(ctx context.Context, orgID *admin.OrgID) (_ *admin.Org, err error) {
+	org, err := s.org.OrgByID(ctx, orgID.Id)
+	if err != nil {
+		return nil, err
+	}
+	return orgFromModel(org), nil
+}
+
+func (s *Server) SearchOrgs(ctx context.Context, request *admin.OrgSearchRequest) (_ *admin.OrgSearchResponse, err error) {
+	result, err := s.org.SearchOrgs(ctx, orgSearchRequestToModel(request))
+	if err != nil {
+		return nil, err
+	}
+	return &admin.OrgSearchResponse{
+		Result:      orgViewsFromModel(result.Result),
+		Limit:       request.Limit,
+		Offset:      request.Offset,
+		TotalResult: result.TotalResult,
+	}, nil
+}
+
+func (s *Server) IsOrgUnique(ctx context.Context, request *admin.UniqueOrgRequest) (org *admin.UniqueOrgResponse, err error) {
+	isUnique, err := s.org.IsOrgUnique(ctx, request.Name, request.Domain)
+
+	return &admin.UniqueOrgResponse{IsUnique: isUnique}, err
+}
+
+func (s *Server) SetUpOrg(ctx context.Context, orgSetUp *admin.OrgSetUpRequest) (_ *admin.OrgSetUpResponse, err error) {
+	setUp, err := s.org.SetUpOrg(ctx, setUpRequestToModel(orgSetUp))
+	if err != nil {
+		return nil, err
+	}
+	return setUpOrgResponseFromModel(setUp), err
+}
+
+func (s *Server) GetOrgIamPolicy(ctx context.Context, in *admin.OrgIamPolicyID) (_ *admin.OrgIamPolicy, err error) {
+	policy, err := s.org.GetOrgIamPolicyByID(ctx, in.OrgId)
+	if err != nil {
+		return nil, err
+	}
+	return orgIamPolicyFromModel(policy), err
+}
+
+func (s *Server) CreateOrgIamPolicy(ctx context.Context, in *admin.OrgIamPolicyRequest) (_ *admin.OrgIamPolicy, err error) {
+	policy, err := s.org.CreateOrgIamPolicy(ctx, orgIamPolicyRequestToModel(in))
+	if err != nil {
+		return nil, err
+	}
+	return orgIamPolicyFromModel(policy), err
+}
+
+func (s *Server) UpdateOrgIamPolicy(ctx context.Context, in *admin.OrgIamPolicyRequest) (_ *admin.OrgIamPolicy, err error) {
+	policy, err := s.org.ChangeOrgIamPolicy(ctx, orgIamPolicyRequestToModel(in))
+	if err != nil {
+		return nil, err
+	}
+	return orgIamPolicyFromModel(policy), err
+}
+
+func (s *Server) DeleteOrgIamPolicy(ctx context.Context, in *admin.OrgIamPolicyID) (_ *empty.Empty, err error) {
+	err = s.org.RemoveOrgIamPolicy(ctx, in.OrgId)
+	return &empty.Empty{}, err
+}

internal/api/grpc/admin/org_converter.go

@@ -0,0 +1,284 @@
+package admin
+
+import (
+	"github.com/caos/logging"
+	"github.com/golang/protobuf/ptypes"
+	"golang.org/x/text/language"
+
+	admin_model "github.com/caos/zitadel/internal/admin/model"
+	"github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/model"
+	org_model "github.com/caos/zitadel/internal/org/model"
+	usr_model "github.com/caos/zitadel/internal/user/model"
+	"github.com/caos/zitadel/pkg/grpc/admin"
+)
+
+func setUpRequestToModel(setUp *admin.OrgSetUpRequest) *admin_model.SetupOrg {
+	return &admin_model.SetupOrg{
+		Org:  orgCreateRequestToModel(setUp.Org),
+		User: userCreateRequestToModel(setUp.User),
+	}
+}
+
+func orgCreateRequestToModel(org *admin.CreateOrgRequest) *org_model.Org {
+	o := &org_model.Org{
+		Domains: []*org_model.OrgDomain{},
+		Name:    org.Name,
+	}
+	if org.Domain != "" {
+		o.Domains = append(o.Domains, &org_model.OrgDomain{Domain: org.Domain})
+	}
+
+	return o
+}
+
+func userCreateRequestToModel(user *admin.CreateUserRequest) *usr_model.User {
+	preferredLanguage, err := language.Parse(user.PreferredLanguage)
+	logging.Log("GRPC-30hwz").OnError(err).Debug("unable to parse language")
+	result := &usr_model.User{
+		Profile: &usr_model.Profile{
+			UserName:          user.UserName,
+			FirstName:         user.FirstName,
+			LastName:          user.LastName,
+			NickName:          user.NickName,
+			PreferredLanguage: preferredLanguage,
+			Gender:            genderToModel(user.Gender),
+		},
+		Password: &usr_model.Password{
+			SecretString: user.Password,
+		},
+		Email: &usr_model.Email{
+			EmailAddress:    user.Email,
+			IsEmailVerified: user.IsEmailVerified,
+		},
+		Address: &usr_model.Address{
+			Country:       user.Country,
+			Locality:      user.Locality,
+			PostalCode:    user.PostalCode,
+			Region:        user.Region,
+			StreetAddress: user.StreetAddress,
+		},
+	}
+	if user.Phone != "" {
+		result.Phone = &usr_model.Phone{PhoneNumber: user.Phone, IsPhoneVerified: user.IsPhoneVerified}
+	}
+	return result
+}
+
+func setUpOrgResponseFromModel(setUp *admin_model.SetupOrg) *admin.OrgSetUpResponse {
+	return &admin.OrgSetUpResponse{
+		Org:  orgFromModel(setUp.Org),
+		User: userFromModel(setUp.User),
+	}
+}
+
+func orgViewsFromModel(orgs []*org_model.OrgView) []*admin.Org {
+	result := make([]*admin.Org, len(orgs))
+	for i, org := range orgs {
+		result[i] = orgViewFromModel(org)
+	}
+
+	return result
+}
+
+func orgFromModel(org *org_model.Org) *admin.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 &admin.Org{
+		ChangeDate:   changeDate,
+		CreationDate: creationDate,
+		Id:           org.AggregateID,
+		Name:         org.Name,
+		State:        orgStateFromModel(org.State),
+	}
+}
+
+func orgViewFromModel(org *org_model.OrgView) *admin.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 &admin.Org{
+		ChangeDate:   changeDate,
+		CreationDate: creationDate,
+		Id:           org.ID,
+		Name:         org.Name,
+		State:        orgStateFromModel(org.State),
+	}
+}
+
+func userFromModel(user *usr_model.User) *admin.User {
+	creationDate, err := ptypes.TimestampProto(user.CreationDate)
+	logging.Log("GRPC-8duwe").OnError(err).Debug("unable to parse timestamp")
+
+	changeDate, err := ptypes.TimestampProto(user.ChangeDate)
+	logging.Log("GRPC-ckoe3d").OnError(err).Debug("unable to parse timestamp")
+
+	converted := &admin.User{
+		Id:                user.AggregateID,
+		State:             userStateFromModel(user.State),
+		CreationDate:      creationDate,
+		ChangeDate:        changeDate,
+		Sequence:          user.Sequence,
+		UserName:          user.UserName,
+		FirstName:         user.FirstName,
+		LastName:          user.LastName,
+		DisplayName:       user.DisplayName,
+		NickName:          user.NickName,
+		PreferredLanguage: user.PreferredLanguage.String(),
+		Gender:            genderFromModel(user.Gender),
+	}
+	if user.Email != nil {
+		converted.Email = user.EmailAddress
+		converted.IsEmailVerified = user.IsEmailVerified
+	}
+	if user.Phone != nil {
+		converted.Phone = user.PhoneNumber
+		converted.IsPhoneVerified = user.IsPhoneVerified
+	}
+	if user.Address != nil {
+		converted.Country = user.Country
+		converted.Locality = user.Locality
+		converted.PostalCode = user.PostalCode
+		converted.Region = user.Region
+		converted.StreetAddress = user.StreetAddress
+	}
+	return converted
+}
+
+func orgStateFromModel(state org_model.OrgState) admin.OrgState {
+	switch state {
+	case org_model.OrgStateActive:
+		return admin.OrgState_ORGSTATE_ACTIVE
+	case org_model.OrgStateInactive:
+		return admin.OrgState_ORGSTATE_INACTIVE
+	default:
+		return admin.OrgState_ORGSTATE_UNSPECIFIED
+	}
+}
+
+func genderFromModel(gender usr_model.Gender) admin.Gender {
+	switch gender {
+	case usr_model.GenderFemale:
+		return admin.Gender_GENDER_FEMALE
+	case usr_model.GenderMale:
+		return admin.Gender_GENDER_MALE
+	case usr_model.GenderDiverse:
+		return admin.Gender_GENDER_DIVERSE
+	default:
+		return admin.Gender_GENDER_UNSPECIFIED
+	}
+}
+
+func genderToModel(gender admin.Gender) usr_model.Gender {
+	switch gender {
+	case admin.Gender_GENDER_FEMALE:
+		return usr_model.GenderFemale
+	case admin.Gender_GENDER_MALE:
+		return usr_model.GenderMale
+	case admin.Gender_GENDER_DIVERSE:
+		return usr_model.GenderDiverse
+	default:
+		return usr_model.GenderUnspecified
+	}
+}
+
+func userStateFromModel(state usr_model.UserState) admin.UserState {
+	switch state {
+	case usr_model.UserStateActive:
+		return admin.UserState_USERSTATE_ACTIVE
+	case usr_model.UserStateInactive:
+		return admin.UserState_USERSTATE_INACTIVE
+	case usr_model.UserStateLocked:
+		return admin.UserState_USERSTATE_LOCKED
+	default:
+		return admin.UserState_USERSTATE_UNSPECIFIED
+	}
+}
+
+func orgSearchRequestToModel(req *admin.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 []*admin.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 *admin.OrgSearchQuery) *org_model.OrgSearchQuery {
+	return &org_model.OrgSearchQuery{
+		Key:    orgQueryKeyToModel(query.Key),
+		Value:  query.Value,
+		Method: orgQueryMethodToModel(query.Method),
+	}
+}
+
+func orgQueryKeyToModel(key admin.OrgSearchKey) org_model.OrgSearchKey {
+	switch key {
+	case admin.OrgSearchKey_ORGSEARCHKEY_DOMAIN:
+		return org_model.OrgSearchKeyOrgDomain
+	case admin.OrgSearchKey_ORGSEARCHKEY_ORG_NAME:
+		return org_model.OrgSearchKeyOrgName
+	case admin.OrgSearchKey_ORGSEARCHKEY_STATE:
+		return org_model.OrgSearchKeyState
+	default:
+		return org_model.OrgSearchKeyUnspecified
+	}
+}
+
+func orgQueryMethodToModel(method admin.OrgSearchMethod) model.SearchMethod {
+	switch method {
+	case admin.OrgSearchMethod_ORGSEARCHMETHOD_CONTAINS:
+		return model.SearchMethodContains
+	case admin.OrgSearchMethod_ORGSEARCHMETHOD_EQUALS:
+		return model.SearchMethodEquals
+	case admin.OrgSearchMethod_ORGSEARCHMETHOD_STARTS_WITH:
+		return model.SearchMethodStartsWith
+	default:
+		return 0
+	}
+}
+
+func orgIamPolicyFromModel(policy *org_model.OrgIamPolicy) *admin.OrgIamPolicy {
+	creationDate, err := ptypes.TimestampProto(policy.CreationDate)
+	logging.Log("GRPC-ush36").OnError(err).Debug("unable to get timestamp from time")
+
+	changeDate, err := ptypes.TimestampProto(policy.ChangeDate)
+	logging.Log("GRPC-Ps9fW").OnError(err).Debug("unable to get timestamp from time")
+
+	return &admin.OrgIamPolicy{
+		OrgId:                 policy.AggregateID,
+		Description:           policy.Description,
+		UserLoginMustBeDomain: policy.UserLoginMustBeDomain,
+		Default:               policy.Default,
+		CreationDate:          creationDate,
+		ChangeDate:            changeDate,
+	}
+}
+
+func orgIamPolicyRequestToModel(policy *admin.OrgIamPolicyRequest) *org_model.OrgIamPolicy {
+	return &org_model.OrgIamPolicy{
+		ObjectRoot: models.ObjectRoot{
+			AggregateID: policy.OrgId,
+		},
+		Description:           policy.Description,
+		UserLoginMustBeDomain: policy.UserLoginMustBeDomain,
+	}
+}

internal/api/grpc/admin/probes.go

@@ -0,0 +1,22 @@
+package admin
+
+import (
+	"context"
+
+	"github.com/golang/protobuf/ptypes/empty"
+	pb_struct "github.com/golang/protobuf/ptypes/struct"
+
+	"github.com/caos/zitadel/internal/errors"
+)
+
+func (s *Server) Healthz(_ context.Context, e *empty.Empty) (*empty.Empty, error) {
+	return &empty.Empty{}, nil
+}
+
+func (s *Server) Ready(ctx context.Context, e *empty.Empty) (*empty.Empty, error) {
+	return &empty.Empty{}, s.repo.Health(ctx)
+}
+
+func (s *Server) Validate(ctx context.Context, _ *empty.Empty) (*pb_struct.Struct, error) {
+	return nil, errors.ThrowUnimplemented(nil, "GRPC-98Gse", "Not implemented")
+}

internal/api/grpc/admin/server.go

@@ -0,0 +1,61 @@
+package admin
+
+import (
+	"google.golang.org/grpc"
+
+	"github.com/caos/zitadel/internal/admin/repository"
+	"github.com/caos/zitadel/internal/admin/repository/eventsourcing"
+	"github.com/caos/zitadel/internal/api/authz"
+	"github.com/caos/zitadel/internal/api/grpc/server"
+	"github.com/caos/zitadel/pkg/grpc/admin"
+)
+
+const (
+	adminName = "Admin-API"
+)
+
+var _ admin.AdminServiceServer = (*Server)(nil)
+
+type Server struct {
+	org           repository.OrgRepository
+	iam           repository.IamRepository
+	administrator repository.AdministratorRepository
+	repo          repository.Repository
+}
+
+type Config struct {
+	Repository eventsourcing.Config
+}
+
+func CreateServer(repo repository.Repository) *Server {
+	return &Server{
+		org:           repo,
+		iam:           repo,
+		administrator: repo,
+		repo:          repo,
+	}
+}
+
+func (s *Server) RegisterServer(grpcServer *grpc.Server) {
+	admin.RegisterAdminServiceServer(grpcServer, s)
+}
+
+func (s *Server) AppName() string {
+	return adminName
+}
+
+func (s *Server) MethodPrefix() string {
+	return admin.AdminService_MethodPrefix
+}
+
+func (s *Server) AuthMethods() authz.MethodMapping {
+	return admin.AdminService_AuthMethods
+}
+
+func (s *Server) RegisterGateway() server.GatewayFunc {
+	return admin.RegisterAdminServiceHandlerFromEndpoint
+}
+
+func (s *Server) GatewayPathPrefix() string {
+	return "/admin/v1"
+}