andwati/zitadel
1
0
Fork 0
mirror of https://github.com/andwati/zitadel.git synced 2026-11-08 07:05:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat(console): grpc web interceptors, cleanup services (#631)

Browse Source 
* managementservice, authservice, change all refs

* refactor grpc auth

* fix references

* interceptor logic

* new interceptor

* appinitializers, environment loader, interceptors

* remove circular dep

* init authconfig in grpc service

* authconfig

* lint

* update mgmt service

* fix references

* update clientid, fix interceptor

* rm unused authconfig

* todo auth interceptor
This commit is contained in:
Max Peintner
2020-08-29 10:43:35 +02:00
committed by GitHub
parent 40b8faaddd
commit eeea1f1c4b
81 changed files with 1877 additions and 2639 deletions
Download Patch File Download Diff File Expand all files Collapse all files
console/src/app/services/admin.service.ts
+19 -91
View File
@@ -1,8 +1,6 @@
import { Injectable } from '@angular/core';
import { Empty } from 'google-protobuf/google/protobuf/empty_pb';
import { Metadata } from 'grpc-web';
import { AdminServicePromiseClient } from '../proto/generated/admin_grpc_web_pb';
import {
AddIamMemberRequest,
ChangeIamMemberRequest,
@@ -24,29 +22,13 @@ import {
ViewID,
Views,
} from '../proto/generated/admin_pb';
import { GrpcBackendService } from './grpc-backend.service';
import { GrpcService, RequestFactory, ResponseMapper } from './grpc.service';
import { GrpcService } from './grpc.service';
@Injectable({
providedIn: 'root',
})
export class AdminService {
constructor(private readonly grpcService: GrpcService, private grpcBackendService: GrpcBackendService) { }
public async request<TReq, TResp, TMappedResp>(
requestFn: RequestFactory<AdminServicePromiseClient, TReq, TResp>,
request: TReq,
responseMapper: ResponseMapper<TResp, TMappedResp>,
metadata?: Metadata,
): Promise<TMappedResp> {
const mappedRequestFn = requestFn(this.grpcService.admin).bind(this.grpcService.mgmt);
const response = await this.grpcBackendService.runRequest(
mappedRequestFn,
request,
metadata,
);
return responseMapper(response);
}
constructor(private readonly grpcService: GrpcService) { }
public async SetUpOrg(
createOrgRequest: CreateOrgRequest,
@@ -57,46 +39,29 @@ export class AdminService {
req.setOrg(createOrgRequest);
req.setUser(registerUserRequest);
return await this.request(
c => c.setUpOrg,
req,
f => f,
);
return this.grpcService.admin.setUpOrg(req);
}
public async GetIamMemberRoles(): Promise<IamMemberRoles> {
return await this.request(
c => c.getIamMemberRoles,
new Empty(),
f => f,
);
const req = new Empty();
return this.grpcService.admin.getIamMemberRoles(req);
}
public async GetViews(): Promise<Views> {
return await this.request(
c => c.getViews,
new Empty(),
f => f,
);
const req = new Empty();
return this.grpcService.admin.getViews(req);
}
public async GetFailedEvents(): Promise<FailedEvents> {
return await this.request(
c => c.getFailedEvents,
new Empty(),
f => f,
);
const req = new Empty();
return this.grpcService.admin.getFailedEvents(req);
}
public async ClearView(viewname: string, db: string): Promise<Empty> {
const req: ViewID = new ViewID();
req.setDatabase(db);
req.setViewName(viewname);
return await this.request(
c => c.clearView,
req,
f => f,
);
return this.grpcService.admin.clearView(req);
}
public async RemoveFailedEvent(viewname: string, db: string, sequence: number): Promise<Empty> {
@@ -104,11 +69,7 @@ export class AdminService {
req.setDatabase(db);
req.setViewName(viewname);
req.setFailedSequence(sequence);
return await this.request(
c => c.removeFailedEvent,
req,
f => f,
);
return this.grpcService.admin.removeFailedEvent(req);
}
public async SearchIamMembers(
@@ -122,11 +83,7 @@ export class AdminService {
if (queryList) {
req.setQueriesList(queryList);
}
return await this.request(
c => c.searchIamMembers,
req,
f => f,
);
return this.grpcService.admin.searchIamMembers(req);
}
public async RemoveIamMember(
@@ -135,11 +92,7 @@ export class AdminService {
const req = new RemoveIamMemberRequest();
req.setUserId(userId);
return await this.request(
c => c.removeIamMember,
req,
f => f,
);
return this.grpcService.admin.removeIamMember(req);
}
public async AddIamMember(
@@ -150,11 +103,7 @@ export class AdminService {
req.setUserId(userId);
req.setRolesList(rolesList);
return await this.request(
c => c.addIamMember,
req,
f => f,
);
return this.grpcService.admin.addIamMember(req);
}
public async ChangeIamMember(
@@ -165,22 +114,14 @@ export class AdminService {
req.setUserId(userId);
req.setRolesList(rolesList);
return await this.request(
c => c.changeIamMember,
req,
f => f,
);
return this.grpcService.admin.changeIamMember(req);
}
public async GetOrgIamPolicy(orgId: string): Promise<OrgIamPolicy> {
const req = new OrgIamPolicyID();
req.setOrgId(orgId);
return await this.request(
c => c.getOrgIamPolicy,
req,
f => f,
);
return this.grpcService.admin.getOrgIamPolicy(req);
}
public async CreateOrgIamPolicy(
@@ -192,11 +133,7 @@ export class AdminService {
req.setDescription(description);
req.setUserLoginMustBeDomain(userLoginMustBeDomain);
return await this.request(
c => c.createOrgIamPolicy,
req,
f => f,
);
return this.grpcService.admin.createOrgIamPolicy(req);
}
public async UpdateOrgIamPolicy(
@@ -207,12 +144,7 @@ export class AdminService {
req.setOrgId(orgId);
req.setDescription(description);
req.setUserLoginMustBeDomain(userLoginMustBeDomain);
return await this.request(
c => c.updateOrgIamPolicy,
req,
f => f,
);
return this.grpcService.admin.updateOrgIamPolicy(req);
}
public async deleteOrgIamPolicy(
@@ -220,10 +152,6 @@ export class AdminService {
): Promise<Empty> {
const req = new OrgIamPolicyID();
req.setOrgId(orgId);
return await this.request(
c => c.deleteOrgIamPolicy,
req,
f => f,
);
return this.grpcService.admin.deleteOrgIamPolicy(req);
}
}
console/src/app/services/auth-user.service.ts
-298
View File
@@ -1,298 +0,0 @@
import { Injectable } from '@angular/core';
import { Empty } from 'google-protobuf/google/protobuf/empty_pb';
import { Metadata } from 'grpc-web';
import { AuthServicePromiseClient } from '../proto/generated/auth_grpc_web_pb';
import {
Changes,
ChangesRequest,
Gender,
MfaOtpResponse,
MultiFactors,
MyPermissions,
MyProjectOrgSearchQuery,
MyProjectOrgSearchRequest,
MyProjectOrgSearchResponse,
PasswordChange,
PasswordComplexityPolicy,
UpdateUserAddressRequest,
UpdateUserEmailRequest,
UpdateUserPhoneRequest,
UpdateUserProfileRequest,
UserAddress,
UserEmail,
UserPhone,
UserProfile,
UserProfileView,
UserSessionViews,
UserView,
VerifyMfaOtp,
VerifyUserPhoneRequest,
} from '../proto/generated/auth_pb';
import { GrpcBackendService } from './grpc-backend.service';
import { GrpcService, RequestFactory, ResponseMapper } from './grpc.service';
@Injectable({
providedIn: 'root',
})
export class AuthUserService {
constructor(private readonly grpcClient: GrpcService,
private grpcBackendService: GrpcBackendService,
) { }
public async request<TReq, TResp, TMappedResp>(
requestFn: RequestFactory<AuthServicePromiseClient, TReq, TResp>,
request: TReq,
responseMapper: ResponseMapper<TResp, TMappedResp>,
metadata?: Metadata,
): Promise<TMappedResp> {
const mappedRequestFn = requestFn(this.grpcClient.auth).bind(this.grpcClient.auth);
const response = await this.grpcBackendService.runRequest(
mappedRequestFn,
request,
metadata,
);
return responseMapper(response);
}
public async GetMyUserProfile(): Promise<UserProfileView> {
return await this.request(
c => c.getMyUserProfile,
new Empty(),
f => f,
);
}
public async GetMyPasswordComplexityPolicy(): Promise<PasswordComplexityPolicy> {
return await this.request(
c => c.getMyPasswordComplexityPolicy,
new Empty(),
f => f,
);
}
public async GetMyUser(): Promise<UserView> {
return await this.request(
c => c.getMyUser,
new Empty(),
f => f,
);
}
public async GetMyMfas(): Promise<MultiFactors> {
return await this.request(
c => c.getMyMfas,
new Empty(),
f => f,
);
}
public async SearchMyProjectOrgs(
limit: number,
offset: number,
queryList?: MyProjectOrgSearchQuery[],
): Promise<MyProjectOrgSearchResponse> {
const req: MyProjectOrgSearchRequest = new MyProjectOrgSearchRequest();
req.setOffset(offset);
req.setLimit(limit);
if (queryList) {
req.setQueriesList(queryList);
}
return await this.request(
c => c.searchMyProjectOrgs,
req,
f => f,
);
}
public async SaveMyUserProfile(
firstName?: string,
lastName?: string,
nickName?: string,
preferredLanguage?: string,
gender?: Gender,
): Promise<UserProfile> {
const req = new UpdateUserProfileRequest();
if (firstName) {
req.setFirstName(firstName);
}
if (lastName) {
req.setLastName(lastName);
}
if (nickName) {
req.setNickName(nickName);
}
if (gender) {
req.setGender(gender);
}
if (preferredLanguage) {
req.setPreferredLanguage(preferredLanguage);
}
return await this.request(
c => c.updateMyUserProfile,
req,
f => f,
);
}
public async getMyUserSessions(): Promise<UserSessionViews> {
return await this.request(
c => c.getMyUserSessions,
new Empty(),
f => f,
);
}
public async GetMyUserEmail(): Promise<UserEmail> {
return await this.request(
c => c.getMyUserEmail,
new Empty(),
f => f,
);
}
public async SaveMyUserEmail(email: string): Promise<UserEmail> {
const req = new UpdateUserEmailRequest();
req.setEmail(email);
return await this.request(
c => c.changeMyUserEmail,
req,
f => f,
);
}
public async RemoveMyUserPhone(): Promise<Empty> {
return await this.request(
c => c.removeMyUserPhone,
new Empty(),
f => f,
);
}
public async GetMyzitadelPermissions(): Promise<MyPermissions> {
return await this.request(
c => c.getMyZitadelPermissions,
new Empty(),
f => f,
);
}
public async GetMyUserPhone(): Promise<UserPhone> {
// return this.grpcClient.auth.getMyUserPhone(new Empty());
return await this.request(
c => c.getMyUserPhone,
new Empty(),
(f: UserPhone) => f,
);
}
public async SaveMyUserPhone(phone: string): Promise<UserPhone> {
const req = new UpdateUserPhoneRequest();
req.setPhone(phone);
return await this.request(
c => c.changeMyUserPhone,
req,
f => f,
);
}
public async GetMyUserAddress(): Promise<UserAddress> {
return await this.request(
c => c.getMyUserAddress,
new Empty(),
f => f,
);
}
public async ResendEmailVerification(): Promise<Empty> {
const req = new Empty();
return await this.request(
c => c.resendMyEmailVerificationMail,
req,
f => f,
);
}
public async ResendPhoneVerification(): Promise<Empty> {
const req = new Empty();
return await this.request(
c => c.resendMyPhoneVerificationCode,
req,
f => f,
);
}
public async ChangeMyPassword(oldPassword: string, newPassword: string): Promise<Empty> {
const req = new PasswordChange();
req.setOldPassword(oldPassword);
req.setNewPassword(newPassword);
return await this.request(
c => c.changeMyPassword,
req,
f => f,
);
}
public async AddMfaOTP(): Promise<MfaOtpResponse> {
return await this.request(
c => c.addMfaOTP,
new Empty(),
f => f,
);
}
public async RemoveMfaOTP(): Promise<Empty> {
return await this.request(
c => c.removeMfaOTP,
new Empty(),
f => f,
);
}
public async VerifyMfaOTP(code: string): Promise<Empty> {
const req = new VerifyMfaOtp();
req.setCode(code);
return await this.request(
c => c.verifyMfaOTP,
req,
f => f,
);
}
public async VerifyMyUserPhone(code: string): Promise<Empty> {
const req = new VerifyUserPhoneRequest();
req.setCode(code);
return await this.request(
c => c.verifyMyUserPhone,
req,
f => f,
);
}
public async SaveMyUserAddress(address: UserAddress.AsObject): Promise<UserAddress> {
const req = new UpdateUserAddressRequest();
req.setStreetAddress(address.streetAddress);
req.setPostalCode(address.postalCode);
req.setLocality(address.locality);
req.setRegion(address.region);
req.setCountry(address.country);
return await this.request(
c => c.updateMyUserAddress,
req,
f => f,
);
}
public async GetMyUserChanges(limit: number, sequenceoffset: number): Promise<Changes> {
const req = new ChangesRequest();
req.setLimit(limit);
req.setSequenceOffset(sequenceoffset);
return await this.request(
c => c.getMyUserChanges,
req,
f => f,
);
}
}
console/src/app/services/auth.service.ts
-175
View File
@@ -1,175 +0,0 @@
import { Injectable } from '@angular/core';
import { AuthConfig, OAuthService } from 'angular-oauth2-oidc';
import { BehaviorSubject, from, merge, Observable, of, Subject } from 'rxjs';
import { catchError, filter, finalize, first, map, mergeMap, switchMap, take, timeout } from 'rxjs/operators';
import { Org, UserProfileView } from '../proto/generated/auth_pb';
import { AuthUserService } from './auth-user.service';
import { GrpcService } from './grpc.service';
import { StatehandlerService } from './statehandler.service';
import { StorageKey, StorageService } from './storage.service';
@Injectable({
providedIn: 'root',
})
export class AuthService {
private cachedOrgs: Org.AsObject[] = [];
private _activeOrgChanged: Subject<Org.AsObject> = new Subject();
public user!: Observable<UserProfileView.AsObject>;
private _authenticated: boolean = false;
private readonly _authenticationChanged: BehaviorSubject<
boolean
> = new BehaviorSubject(this.authenticated);
private zitadelPermissions: BehaviorSubject<string[]> = new BehaviorSubject(['user.resourceowner']);
constructor(
private grpcService: GrpcService,
private config: AuthConfig,
private oauthService: OAuthService,
private userService: AuthUserService,
private storage: StorageService,
private statehandler: StatehandlerService,
) {
this.user = merge(
of(this.oauthService.getAccessToken()).pipe(
filter(token => token ? true : false),
),
this.oauthService.events.pipe(
filter(e => e.type === 'token_received'),
timeout(this.oauthService.waitForTokenInMsec || 0),
catchError(_ => of(null)), // timeout is not an error
map(_ => this.oauthService.getAccessToken()),
),
).pipe(
take(1),
mergeMap(() => {
return from(this.userService.GetMyUserProfile().then(userprofile => userprofile.toObject()));
}),
finalize(() => {
this.loadPermissions();
}),
);
this.activeOrgChanged.subscribe(() => {
this.loadPermissions();
});
}
private loadPermissions(): void {
merge([
// this.authenticationChanged,
this.activeOrgChanged.pipe(map(org => !!org)),
]).pipe(
first(),
switchMap(() => from(this.userService.GetMyzitadelPermissions())),
map(rolesResp => rolesResp.toObject().permissionsList),
).subscribe(roles => {
this.zitadelPermissions.next(roles);
});
}
public isAllowed(roles: string[] | RegExp[]): Observable<boolean> {
if (roles && roles.length > 0) {
return this.zitadelPermissions.pipe(switchMap(zroles => {
return of(this.hasRoles(zroles, roles));
}));
} else {
return of(false);
}
}
public hasRoles(userRoles: string[], requestedRoles: string[] | RegExp[]): boolean {
return requestedRoles.findIndex((regexp: any) => {
return userRoles.findIndex(role => {
return (new RegExp(regexp)).test(role);
}) > -1;
}) > -1;
}
public get authenticated(): boolean {
return this._authenticated;
}
public get authenticationChanged(): Observable<boolean> {
return this._authenticationChanged;
}
public getOIDCUser(): Observable<any> {
return from(this.oauthService.loadUserProfile());
}
public async authenticate(
config?: Partial<AuthConfig>,
setState: boolean = true,
force: boolean = false,
): Promise<boolean> {
this.config.issuer = config?.issuer || this.grpcService.issuer;
this.config.clientId = config?.clientId || this.grpcService.clientid;
this.config.redirectUri = config?.redirectUri || this.grpcService.redirectUri;
this.config.postLogoutRedirectUri = config?.postLogoutRedirectUri || this.grpcService.postLogoutRedirectUri;
this.config.customQueryParams = config?.customQueryParams;
this.oauthService.configure(this.config);
// this.oauthService.setupAutomaticSilentRefresh();
this.oauthService.strictDiscoveryDocumentValidation = false;
await this.oauthService.loadDiscoveryDocumentAndTryLogin();
this._authenticated = this.oauthService.hasValidAccessToken();
if (!this.oauthService.hasValidIdToken() || !this.authenticated || config || force) {
const newState = setState ? await this.statehandler.createState().toPromise() : undefined;
this.oauthService.initCodeFlow(newState);
}
this._authenticationChanged.next(this.authenticated);
return this.authenticated;
}
public signout(): void {
this.oauthService.logOut();
this._authenticated = false;
this._authenticationChanged.next(false);
}
public get activeOrgChanged(): Observable<Org.AsObject> {
return this._activeOrgChanged;
}
public async GetActiveOrg(id?: string): Promise<Org.AsObject> {
if (id) {
const org = this.storage.getItem<Org.AsObject>(StorageKey.organization);
if (org && this.cachedOrgs.find(tmp => tmp.id === org.id)) {
return org;
}
return Promise.reject(new Error('no cached org'));
} else {
let orgs = this.cachedOrgs;
if (orgs.length === 0) {
orgs = (await this.userService.SearchMyProjectOrgs(10, 0)).toObject().resultList;
this.cachedOrgs = orgs;
}
const org = this.storage.getItem<Org.AsObject>(StorageKey.organization);
if (org && orgs.find(tmp => tmp.id === org.id)) {
return org;
}
if (orgs.length === 0) {
return Promise.reject(new Error('No organizations found!'));
}
const orgToSet = orgs.find(element => element.id !== '0' && element.name !== '');
if (orgToSet) {
this.setActiveOrg(orgToSet);
return Promise.resolve(orgToSet);
}
return Promise.resolve(orgs[0]);
}
}
public setActiveOrg(org: Org.AsObject): void {
this.storage.setItem(StorageKey.organization, org);
this._activeOrgChanged.next(org);
}
}
console/src/app/services/authentication.service.ts
+69
View File
@@ -0,0 +1,69 @@
import { Injectable } from '@angular/core';
import { AuthConfig, OAuthService } from 'angular-oauth2-oidc';
import { BehaviorSubject, from, Observable } from 'rxjs';
import { StatehandlerService } from './statehandler.service';
@Injectable({
providedIn: 'root',
})
export class AuthenticationService {
private authConfig!: AuthConfig;
private _authenticated: boolean = false;
private readonly _authenticationChanged: BehaviorSubject<
boolean
> = new BehaviorSubject(this.authenticated);
constructor(
private oauthService: OAuthService,
private statehandler: StatehandlerService,
) { }
public initConfig(data: AuthConfig): void {
this.authConfig = data;
}
public get authenticated(): boolean {
return this._authenticated;
}
public get authenticationChanged(): Observable<boolean> {
return this._authenticationChanged;
}
public getOIDCUser(): Observable<any> {
return from(this.oauthService.loadUserProfile());
}
public async authenticate(
config?: Partial<AuthConfig>,
setState: boolean = true,
force: boolean = false,
): Promise<boolean> {
if (config) {
this.authConfig = config;
}
console.log(this.authConfig);
this.oauthService.configure(this.authConfig);
this.oauthService.strictDiscoveryDocumentValidation = false;
await this.oauthService.loadDiscoveryDocumentAndTryLogin();
this._authenticated = this.oauthService.hasValidAccessToken();
if (!this.oauthService.hasValidIdToken() || !this.authenticated || config || force) {
const newState = setState ? await this.statehandler.createState().toPromise() : undefined;
this.oauthService.initCodeFlow(newState);
}
this._authenticationChanged.next(this.authenticated);
return this.authenticated;
}
public signout(): void {
this.oauthService.logOut();
this._authenticated = false;
this._authenticationChanged.next(false);
}
}
console/src/app/services/grpc-auth.service.ts
+317
View File
@@ -0,0 +1,317 @@
import { Injectable } from '@angular/core';
import { OAuthService } from 'angular-oauth2-oidc';
import { Empty } from 'google-protobuf/google/protobuf/empty_pb';
import { BehaviorSubject, from, merge, Observable, of, Subject } from 'rxjs';
import { catchError, filter, finalize, first, map, mergeMap, switchMap, take, timeout } from 'rxjs/operators';
import {
Changes,
ChangesRequest,
Gender,
MfaOtpResponse,
MultiFactors,
MyPermissions,
MyProjectOrgSearchQuery,
MyProjectOrgSearchRequest,
MyProjectOrgSearchResponse,
Org,
PasswordChange,
PasswordComplexityPolicy,
UpdateUserAddressRequest,
UpdateUserEmailRequest,
UpdateUserPhoneRequest,
UpdateUserProfileRequest,
UserAddress,
UserEmail,
UserPhone,
UserProfile,
UserProfileView,
UserSessionViews,
UserView,
VerifyMfaOtp,
VerifyUserPhoneRequest,
} from '../proto/generated/auth_pb';
import { GrpcService } from './grpc.service';
import { StorageKey, StorageService } from './storage.service';
@Injectable({
providedIn: 'root',
})
export class GrpcAuthService {
private _activeOrgChanged: Subject<Org.AsObject> = new Subject();
public user!: Observable<UserProfileView.AsObject>;
private zitadelPermissions: BehaviorSubject<string[]> = new BehaviorSubject(['user.resourceowner']);
private cachedOrgs: Org.AsObject[] = [];
constructor(
private readonly grpcService: GrpcService,
private oauthService: OAuthService,
private storage: StorageService,
) {
this.user = merge(
of(this.oauthService.getAccessToken()).pipe(
filter(token => token ? true : false),
),
this.oauthService.events.pipe(
filter(e => e.type === 'token_received'),
timeout(this.oauthService.waitForTokenInMsec || 0),
catchError(_ => of(null)), // timeout is not an error
map(_ => this.oauthService.getAccessToken()),
),
).pipe(
take(1),
mergeMap(() => {
return from(this.GetMyUserProfile().then(userprofile => userprofile.toObject()));
}),
finalize(() => {
this.loadPermissions();
}),
);
this.activeOrgChanged.subscribe(() => {
this.loadPermissions();
});
}
public async GetActiveOrg(id?: string): Promise<Org.AsObject> {
if (id) {
const org = this.storage.getItem<Org.AsObject>(StorageKey.organization);
if (org && this.cachedOrgs.find(tmp => tmp.id === org.id)) {
return org;
}
return Promise.reject(new Error('no cached org'));
} else {
let orgs = this.cachedOrgs;
if (orgs.length === 0) {
orgs = (await this.SearchMyProjectOrgs(10, 0)).toObject().resultList;
this.cachedOrgs = orgs;
}
const org = this.storage.getItem<Org.AsObject>(StorageKey.organization);
if (org && orgs.find(tmp => tmp.id === org.id)) {
return org;
}
if (orgs.length === 0) {
return Promise.reject(new Error('No organizations found!'));
}
const orgToSet = orgs.find(element => element.id !== '0' && element.name !== '');
if (orgToSet) {
this.setActiveOrg(orgToSet);
return Promise.resolve(orgToSet);
}
return Promise.resolve(orgs[0]);
}
}
public get activeOrgChanged(): Observable<Org.AsObject> {
return this._activeOrgChanged;
}
public setActiveOrg(org: Org.AsObject): void {
this.storage.setItem(StorageKey.organization, org);
this._activeOrgChanged.next(org);
}
private loadPermissions(): void {
merge([
// this.authenticationChanged,
this.activeOrgChanged.pipe(map(org => !!org)),
]).pipe(
first(),
switchMap(() => from(this.GetMyzitadelPermissions())),
map(rolesResp => rolesResp.toObject().permissionsList),
).subscribe(roles => {
this.zitadelPermissions.next(roles);
});
}
public isAllowed(roles: string[] | RegExp[]): Observable<boolean> {
if (roles && roles.length > 0) {
return this.zitadelPermissions.pipe(switchMap(zroles => {
return of(this.hasRoles(zroles, roles));
}));
} else {
return of(false);
}
}
public hasRoles(userRoles: string[], requestedRoles: string[] | RegExp[]): boolean {
return requestedRoles.findIndex((regexp: any) => {
return userRoles.findIndex(role => {
return (new RegExp(regexp)).test(role);
}) > -1;
}) > -1;
}
public async GetMyUserProfile(): Promise<UserProfileView> {
return this.grpcService.auth.getMyUserProfile(new Empty());
}
public async GetMyPasswordComplexityPolicy(): Promise<PasswordComplexityPolicy> {
return this.grpcService.auth.getMyPasswordComplexityPolicy(
new Empty(),
);
}
public async GetMyUser(): Promise<UserView> {
return this.grpcService.auth.getMyUser(
new Empty(),
);
}
public async GetMyMfas(): Promise<MultiFactors> {
return this.grpcService.auth.getMyMfas(
new Empty(),
);
}
public async SearchMyProjectOrgs(
limit: number,
offset: number,
queryList?: MyProjectOrgSearchQuery[],
): Promise<MyProjectOrgSearchResponse> {
const req: MyProjectOrgSearchRequest = new MyProjectOrgSearchRequest();
req.setOffset(offset);
req.setLimit(limit);
if (queryList) {
req.setQueriesList(queryList);
}
return this.grpcService.auth.searchMyProjectOrgs(req);
}
public async SaveMyUserProfile(
firstName?: string,
lastName?: string,
nickName?: string,
preferredLanguage?: string,
gender?: Gender,
): Promise<UserProfile> {
const req = new UpdateUserProfileRequest();
if (firstName) {
req.setFirstName(firstName);
}
if (lastName) {
req.setLastName(lastName);
}
if (nickName) {
req.setNickName(nickName);
}
if (gender) {
req.setGender(gender);
}
if (preferredLanguage) {
req.setPreferredLanguage(preferredLanguage);
}
return this.grpcService.auth.updateMyUserProfile(req);
}
public async getMyUserSessions(): Promise<UserSessionViews> {
return this.grpcService.auth.getMyUserSessions(
new Empty(),
);
}
public async GetMyUserEmail(): Promise<UserEmail> {
return this.grpcService.auth.getMyUserEmail(
new Empty(),
);
}
public async SaveMyUserEmail(email: string): Promise<UserEmail> {
const req = new UpdateUserEmailRequest();
req.setEmail(email);
return this.grpcService.auth.changeMyUserEmail(req);
}
public async RemoveMyUserPhone(): Promise<Empty> {
return this.grpcService.auth.removeMyUserPhone(
new Empty(),
);
}
public async GetMyzitadelPermissions(): Promise<MyPermissions> {
return this.grpcService.auth.getMyZitadelPermissions(
new Empty(),
);
}
public async GetMyUserPhone(): Promise<UserPhone> {
return this.grpcService.auth.getMyUserPhone(
new Empty(),
);
}
public async SaveMyUserPhone(phone: string): Promise<UserPhone> {
const req = new UpdateUserPhoneRequest();
req.setPhone(phone);
return this.grpcService.auth.changeMyUserPhone(req);
}
public async GetMyUserAddress(): Promise<UserAddress> {
return this.grpcService.auth.getMyUserAddress(
new Empty(),
);
}
public async ResendEmailVerification(): Promise<Empty> {
const req = new Empty();
return this.grpcService.auth.resendMyEmailVerificationMail(req);
}
public async ResendPhoneVerification(): Promise<Empty> {
const req = new Empty();
return this.grpcService.auth.resendMyPhoneVerificationCode(req);
}
public async ChangeMyPassword(oldPassword: string, newPassword: string): Promise<Empty> {
const req = new PasswordChange();
req.setOldPassword(oldPassword);
req.setNewPassword(newPassword);
return this.grpcService.auth.changeMyPassword(req);
}
public async AddMfaOTP(): Promise<MfaOtpResponse> {
return this.grpcService.auth.addMfaOTP(
new Empty(),
);
}
public async RemoveMfaOTP(): Promise<Empty> {
return this.grpcService.auth.removeMfaOTP(
new Empty(),
);
}
public async VerifyMfaOTP(code: string): Promise<Empty> {
const req = new VerifyMfaOtp();
req.setCode(code);
return this.grpcService.auth.verifyMfaOTP(req);
}
public async VerifyMyUserPhone(code: string): Promise<Empty> {
const req = new VerifyUserPhoneRequest();
req.setCode(code);
return this.grpcService.auth.verifyMyUserPhone(req);
}
public async SaveMyUserAddress(address: UserAddress.AsObject): Promise<UserAddress> {
const req = new UpdateUserAddressRequest();
req.setStreetAddress(address.streetAddress);
req.setPostalCode(address.postalCode);
req.setLocality(address.locality);
req.setRegion(address.region);
req.setCountry(address.country);
return this.grpcService.auth.updateMyUserAddress(req);
}
public async GetMyUserChanges(limit: number, sequenceoffset: number): Promise<Changes> {
const req = new ChangesRequest();
req.setLimit(limit);
req.setSequenceOffset(sequenceoffset);
return this.grpcService.auth.getMyUserChanges(req);
}
}
console/src/app/services/grpc-backend.service.ts
-27
View File
@@ -1,27 +0,0 @@
import { Inject, Injectable } from '@angular/core';
import { Metadata } from 'grpc-web';
import { GrpcDefaultHandler, GrpcHandler, GrpcInterceptorHandler, GrpcRequestFn } from './grpc-handler';
import { GRPC_INTERCEPTORS, GrpcInterceptor } from './interceptors/grpc-interceptor';
@Injectable({
providedIn: 'root',
})
export class GrpcBackendService {
constructor(
@Inject(GRPC_INTERCEPTORS) private readonly interceptors: GrpcInterceptor[],
) { }
public async runRequest<TReq, TResp>(
requestFn: GrpcRequestFn<TReq, TResp>,
request: TReq,
metadata: Metadata = {},
): Promise<TResp> {
const defaultHandler: GrpcHandler = new GrpcDefaultHandler(requestFn);
const chain = this.interceptors.reduceRight(
(next, interceptor) => new GrpcInterceptorHandler(next, interceptor),
defaultHandler,
);
return chain.handle(request, metadata);
}
}
console/src/app/services/grpc-handler.ts
-31
View File
@@ -1,31 +0,0 @@
import { Metadata } from 'grpc-web';
import { GrpcInterceptor } from './interceptors/grpc-interceptor';
export type GrpcRequestFn<TReq, TResp> = (
request: TReq,
metadata?: Metadata,
) => Promise<TResp>;
export interface GrpcHandler {
handle(req: unknown, metadata: Metadata): Promise<any>;
}
export class GrpcInterceptorHandler implements GrpcHandler {
constructor(
private readonly next: GrpcHandler,
private interceptor: GrpcInterceptor,
) { }
public handle(req: unknown, metadata: Metadata): Promise<unknown> {
return this.interceptor.intercept(req, metadata, this.next);
}
}
export class GrpcDefaultHandler<TReq, TResp> implements GrpcHandler {
constructor(private readonly requestFn: GrpcRequestFn<TReq, TResp>) { }
public handle(req: TReq, metadata: Metadata): Promise<TResp> {
return this.requestFn(req, metadata);
}
}
console/src/app/services/grpc.service.ts
+43 -21
View File
@@ -1,21 +1,20 @@
import { PlatformLocation } from '@angular/common';
import { HttpClient } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { AuthConfig } from 'angular-oauth2-oidc';
import { AdminServicePromiseClient } from '../proto/generated/admin_grpc_web_pb';
import { AuthServicePromiseClient } from '../proto/generated/auth_grpc_web_pb';
import { ManagementServicePromiseClient } from '../proto/generated/management_grpc_web_pb';
import { GrpcRequestFn } from './grpc-handler';
import { AuthenticationService } from './authentication.service';
import { AuthInterceptor } from './interceptors/auth.interceptor';
import { OrgInterceptor } from './interceptors/org.interceptor';
import { StorageService } from './storage.service';
@Injectable({
providedIn: 'root',
})
export class GrpcService {
public issuer: string = '';
public clientid: string = '';
public redirectUri: string = '';
public postLogoutRedirectUri: string = '';
public auth!: AuthServicePromiseClient;
public mgmt!: ManagementServicePromiseClient;
public admin!: AdminServicePromiseClient;
@@ -23,22 +22,51 @@ export class GrpcService {
constructor(
private http: HttpClient,
private platformLocation: PlatformLocation,
private authenticationService: AuthenticationService,
private storageService: StorageService,
) { }
public async loadAppEnvironment(): Promise<any> {
return this.http.get('./assets/environment.json')
.toPromise().then((data: any) => {
if (data && data.authServiceUrl && data.mgmtServiceUrl && data.issuer) {
this.auth = new AuthServicePromiseClient(data.authServiceUrl);
this.mgmt = new ManagementServicePromiseClient(data.mgmtServiceUrl);
this.admin = new AdminServicePromiseClient(data.adminServiceUrl);
const interceptors = {
'unaryInterceptors': [
new AuthInterceptor(this.authenticationService, this.storageService),
new OrgInterceptor(this.storageService),
],
};
this.issuer = data.issuer;
if (data.clientid) {
this.clientid = data.clientid;
this.redirectUri = window.location.origin + this.platformLocation.getBaseHrefFromDOM() + 'auth/callback';
this.postLogoutRedirectUri = window.location.origin + this.platformLocation.getBaseHrefFromDOM() + 'signedout';
}
this.auth = new AuthServicePromiseClient(
data.authServiceUrl,
null,
// @ts-ignore
interceptors,
);
this.mgmt = new ManagementServicePromiseClient(
data.mgmtServiceUrl,
null,
// @ts-ignore
interceptors,
);
this.admin = new AdminServicePromiseClient(
data.adminServiceUrl,
null,
// @ts-ignore
interceptors,
);
const authConfig: AuthConfig = {
scope: 'openid profile email',
responseType: 'code',
oidc: true,
clientId: data.clientid,
issuer: data.issuer,
redirectUri: window.location.origin + this.platformLocation.getBaseHrefFromDOM() + 'auth/callback',
postLogoutRedirectUri: window.location.origin + this.platformLocation.getBaseHrefFromDOM() + 'signedout',
};
this.authenticationService.initConfig(authConfig);
}
return Promise.resolve(data);
}).catch(() => {
@@ -46,9 +74,3 @@ export class GrpcService {
});
}
}
export type RequestFactory<TClient, TReq, TResp> = (
client: TClient,
) => GrpcRequestFn<TReq, TResp>;
export type ResponseMapper<TResp, TMappedResp> = (resp: TResp) => TMappedResp;
console/src/app/services/interceptors/auth.interceptor.ts
+40
View File
@@ -0,0 +1,40 @@
import { Injectable } from '@angular/core';
import { Request, UnaryInterceptor, UnaryResponse } from 'grpc-web';
import { filter, first } from 'rxjs/operators';
import { AuthenticationService } from '../authentication.service';
import { StorageService } from '../storage.service';
const authorizationKey = 'Authorization';
const bearerPrefix = 'Bearer';
const accessTokenStorageKey = 'access_token';
@Injectable({ providedIn: 'root' })
export class AuthInterceptor<TReq = unknown, TResp = unknown> implements UnaryInterceptor<TReq, TResp> {
constructor(private authenticationService: AuthenticationService, private storageService: StorageService) { }
public async intercept(request: Request<TReq, TResp>, invoker: any): Promise<UnaryResponse<TReq, TResp>> {
await this.authenticationService.authenticationChanged.pipe(
filter((authed) => !!authed),
first(),
).toPromise();
const metadata = request.getMetadata();
const accessToken = this.storageService.getItem(accessTokenStorageKey);
metadata[authorizationKey] = `${bearerPrefix} ${accessToken}`;
return invoker(request).then((response: any) => {
// const message = response.getResponseMessage();
const respMetadata = response.getMetadata();
// TODO: intercept unauthenticated an authenticate
// const status = respMetadata['grpc-status'];
// console.log(respMetadata, status);
// if (status?.code === 16) {
// this.authenticationService.authenticate();
// }
return response;
});
}
}
console/src/app/services/interceptors/grpc-auth.interceptor.ts
-30
View File
@@ -1,30 +0,0 @@
import { Injectable } from '@angular/core';
import { Metadata } from 'grpc-web';
import { GrpcHandler } from '../grpc-handler';
import { StorageService } from '../storage.service';
import { GrpcInterceptor } from './grpc-interceptor';
const authorizationKey = 'Authorization';
const bearerPrefix = 'Bearer ';
const accessTokenStorageField = 'access_token';
@Injectable({ providedIn: 'root' })
export class GrpcAuthInterceptor implements GrpcInterceptor {
constructor(private readonly authStorage: StorageService) { }
public async intercept(
req: unknown,
metadata: Metadata,
next: GrpcHandler,
): Promise<any> {
if (!metadata[authorizationKey]) {
const accessToken = this.authStorage.getItem(accessTokenStorageField);
if (accessToken) {
metadata[authorizationKey] = bearerPrefix + accessToken;
}
}
return await next.handle(req, metadata);
}
}
console/src/app/services/interceptors/grpc-interceptor.ts
+6 -12
View File
@@ -1,12 +1,6 @@
import { InjectionToken } from '@angular/core';
import { Metadata } from 'grpc-web';
import { GrpcHandler } from '../grpc-handler';
export const GRPC_INTERCEPTORS = new InjectionToken<GrpcInterceptor[]>(
'GRPC_INTERCEPTORS',
);
export interface GrpcInterceptor {
intercept(req: unknown, metadata: Metadata, next: GrpcHandler): Promise<any>;
}
import { InjectionToken } from '@angular/core';
import { UnaryInterceptor } from 'grpc-web';
export const GRPC_INTERCEPTORS = new InjectionToken<Array<UnaryInterceptor<any, any>>>(
'GRPC_INTERCEPTORS',
);
console/src/app/services/interceptors/grpc-org.interceptor.ts
-26
View File
@@ -1,26 +0,0 @@
import { Injectable } from '@angular/core';
import { Metadata } from 'grpc-web';
import { Org } from '../../proto/generated/auth_pb';
import { GrpcHandler } from '../grpc-handler';
import { StorageService } from '../storage.service';
import { GrpcInterceptor } from './grpc-interceptor';
const orgKey = 'x-zitadel-orgid';
@Injectable({ providedIn: 'root' })
export class GrpcOrgInterceptor implements GrpcInterceptor {
constructor(private readonly storageService: StorageService) { }
public async intercept(
req: unknown,
metadata: Metadata,
next: GrpcHandler,
): Promise<any> {
const org: Org.AsObject | null = (this.storageService.getItem('organization'));
if (!metadata[orgKey] && org) {
metadata[orgKey] = org.id ?? '';
}
return await next.handle(req, metadata);
}
}
console/src/app/services/interceptors/org.interceptor.ts
+26
View File
@@ -0,0 +1,26 @@
import { Injectable } from '@angular/core';
import { Request, UnaryInterceptor, UnaryResponse } from 'grpc-web';
import { Org } from 'src/app/proto/generated/auth_pb';
import { StorageService } from '../storage.service';
const orgKey = 'x-zitadel-orgid';
@Injectable({ providedIn: 'root' })
export class OrgInterceptor<TReq = unknown, TResp = unknown> implements UnaryInterceptor<TReq, TResp> {
constructor(private readonly storageService: StorageService) { }
public intercept(request: Request<TReq, TResp>, invoker: any): Promise<UnaryResponse<TReq, TResp>> {
const metadata = request.getMetadata();
const org: Org.AsObject | null = (this.storageService.getItem('organization'));
if (org) {
metadata[orgKey] = `${org.id}`;
}
return invoker(request).then((response: any) => {
return response;
});
}
}
console/src/app/services/mgmt-user.service.ts
-534
View File
@@ -1,534 +0,0 @@
import { Injectable } from '@angular/core';
import { Empty } from 'google-protobuf/google/protobuf/empty_pb';
import { Metadata } from 'grpc-web';
import { ManagementServicePromiseClient } from '../proto/generated/management_grpc_web_pb';
import {
ChangeRequest,
Changes,
CreateUserRequest,
LoginName,
Gender,
MultiFactors,
NotificationType,
PasswordRequest,
ProjectGrantMemberSearchQuery,
ProjectGrantMemberSearchRequest,
ProjectGrantMemberSearchResponse,
ProjectMemberSearchQuery,
ProjectMemberSearchRequest,
ProjectMemberSearchResponse,
ProjectRoleAdd,
SetPasswordNotificationRequest,
UpdateUserAddressRequest,
UpdateUserEmailRequest,
UpdateUserPhoneRequest,
UpdateUserProfileRequest,
User,
UserAddress,
UserEmail,
UserGrant,
UserGrantCreate,
UserGrantID,
UserGrantRemoveBulk,
UserGrantSearchQuery,
UserGrantSearchRequest,
UserGrantSearchResponse,
UserGrantUpdate,
UserGrantView,
UserID,
UserMembershipSearchQuery,
UserMembershipSearchRequest,
UserMembershipSearchResponse,
UserPhone,
UserProfile,
UserSearchQuery,
UserSearchRequest,
UserSearchResponse,
UserView,
} from '../proto/generated/management_pb';
import { GrpcBackendService } from './grpc-backend.service';
import { GrpcService, RequestFactory, ResponseMapper } from './grpc.service';
@Injectable({
providedIn: 'root',
})
export class MgmtUserService {
constructor(private grpcService: GrpcService, private grpcBackendService: GrpcBackendService) { }
public async request<TReq, TResp, TMappedResp>(
requestFn: RequestFactory<ManagementServicePromiseClient, TReq, TResp>,
request: TReq,
responseMapper: ResponseMapper<TResp, TMappedResp>,
metadata?: Metadata,
): Promise<TMappedResp> {
const mappedRequestFn = requestFn(this.grpcService.mgmt).bind(this.grpcService.mgmt);
const response = await this.grpcBackendService.runRequest(
mappedRequestFn,
request,
metadata,
);
return responseMapper(response);
}
public async CreateUser(user: CreateUserRequest.AsObject): Promise<User> {
const req = new CreateUserRequest();
req.setEmail(user.email);
req.setUserName(user.userName);
req.setFirstName(user.firstName);
req.setLastName(user.lastName);
req.setNickName(user.nickName);
req.setPassword(user.password);
req.setPreferredLanguage(user.preferredLanguage);
req.setGender(user.gender);
req.setPhone(user.phone);
req.setStreetAddress(user.streetAddress);
req.setPostalCode(user.postalCode);
req.setLocality(user.locality);
req.setRegion(user.region);
req.setCountry(user.country);
return await this.request(
c => c.createUser,
req,
f => f,
);
}
public async GetUserByID(id: string): Promise<UserView> {
const req = new UserID();
req.setId(id);
return await this.request(
c => c.getUserByID,
req,
f => f,
);
}
public async SearchProjectMembers(
limit: number, offset: number, queryList?: ProjectMemberSearchQuery[]): Promise<ProjectMemberSearchResponse> {
const req = new ProjectMemberSearchRequest();
req.setLimit(limit);
req.setOffset(offset);
if (queryList) {
req.setQueriesList(queryList);
}
return await this.request(
c => c.searchProjectMembers,
req,
f => f,
);
}
public async SearchUserMemberships(userId: string,
limit: number, offset: number, queryList?: UserMembershipSearchQuery[]): Promise<UserMembershipSearchResponse> {
const req = new UserMembershipSearchRequest();
req.setLimit(limit);
req.setOffset(offset);
req.setUserId(userId);
if (queryList) {
req.setQueriesList(queryList);
}
return await this.request(
c => c.searchUserMemberships,
req,
f => f,
);
}
public async GetUserProfile(id: string): Promise<UserProfile> {
const req = new UserID();
req.setId(id);
return await this.request(
c => c.getUserProfile,
req,
f => f,
);
}
public async getUserMfas(id: string): Promise<MultiFactors> {
const req = new UserID();
req.setId(id);
return await this.request(
c => c.getUserMfas,
req,
f => f,
);
}
public async SaveUserProfile(
id: string,
firstName?: string,
lastName?: string,
nickName?: string,
preferredLanguage?: string,
gender?: Gender,
): Promise<UserProfile> {
const req = new UpdateUserProfileRequest();
req.setId(id);
if (firstName) {
req.setFirstName(firstName);
}
if (lastName) {
req.setLastName(lastName);
}
if (nickName) {
req.setNickName(nickName);
}
if (gender) {
req.setGender(gender);
}
if (preferredLanguage) {
req.setPreferredLanguage(preferredLanguage);
}
return await this.request(
c => c.updateUserProfile,
req,
f => f,
);
}
public async GetUserEmail(id: string): Promise<UserEmail> {
const req = new UserID();
req.setId(id);
return await this.request(
c => c.getUserEmail,
req,
f => f,
);
}
public async SaveUserEmail(id: string, email: string): Promise<UserEmail> {
const req = new UpdateUserEmailRequest();
req.setId(id);
req.setEmail(email);
return await this.request(
c => c.changeUserEmail,
req,
f => f,
);
}
public async GetUserPhone(id: string): Promise<UserPhone> {
const req = new UserID();
req.setId(id);
return await this.request(
c => c.getUserPhone,
req,
f => f,
);
}
public async SaveUserPhone(id: string, phone: string): Promise<UserPhone> {
const req = new UpdateUserPhoneRequest();
req.setId(id);
req.setPhone(phone);
return await this.request(
c => c.changeUserPhone,
req,
f => f,
);
}
public async RemoveUserPhone(id: string): Promise<Empty> {
const req = new UserID();
req.setId(id);
return await this.request(
c => c.removeUserPhone,
req,
f => f,
);
}
public async DeactivateUser(id: string): Promise<UserPhone> {
const req = new UserID();
req.setId(id);
return await this.request(
c => c.deactivateUser,
req,
f => f,
);
}
public async CreateUserGrant(
userId: string,
roleNamesList: string[],
projectId?: string,
grantId?: string,
): Promise<UserGrant> {
const req = new UserGrantCreate();
if (projectId) { req.setProjectId(projectId); }
if (grantId) { req.setGrantId(grantId); }
req.setUserId(userId);
req.setRoleKeysList(roleNamesList);
return await this.request(
c => c.createUserGrant,
req,
f => f,
);
}
public async ReactivateUser(id: string): Promise<UserPhone> {
const req = new UserID();
req.setId(id);
return await this.request(
c => c.reactivateUser,
req,
f => f,
);
}
public async AddRole(id: string, key: string, displayName: string, group: string): Promise<Empty> {
const req = new ProjectRoleAdd();
req.setId(id);
req.setKey(key);
if (displayName) {
req.setDisplayName(displayName);
}
req.setGroup(group);
return await this.request(
c => c.addProjectRole,
req,
f => f,
);
}
public async GetUserAddress(id: string): Promise<UserAddress> {
const req = new UserID();
req.setId(id);
return await this.request(
c => c.getUserAddress,
req,
f => f,
);
}
public async ResendEmailVerification(id: string): Promise<any> {
const req = new UserID();
req.setId(id);
return await this.request(
c => c.resendEmailVerificationMail,
req,
f => f,
);
}
public async ResendPhoneVerification(id: string): Promise<any> {
const req = new UserID();
req.setId(id);
return await this.request(
c => c.resendPhoneVerificationCode,
req,
f => f,
);
}
public async SetInitialPassword(id: string, password: string): Promise<any> {
const req = new PasswordRequest();
req.setId(id);
req.setPassword(password);
return await this.request(
c => c.setInitialPassword,
req,
f => f,
);
}
public async SendSetPasswordNotification(id: string, type: NotificationType): Promise<any> {
const req = new SetPasswordNotificationRequest();
req.setId(id);
req.setType(type);
return await this.request(
c => c.sendSetPasswordNotification,
req,
f => f,
);
}
public async SaveUserAddress(address: UserAddress.AsObject): Promise<UserAddress> {
const req = new UpdateUserAddressRequest();
req.setId(address.id);
req.setStreetAddress(address.streetAddress);
req.setPostalCode(address.postalCode);
req.setLocality(address.locality);
req.setRegion(address.region);
req.setCountry(address.country);
return await this.request(
c => c.updateUserAddress,
req,
f => f,
);
}
public async SearchProjectGrantMembers(
limit: number,
offset: number,
query?: ProjectGrantMemberSearchQuery[],
): Promise<ProjectGrantMemberSearchResponse> {
const req = new ProjectGrantMemberSearchRequest();
req.setLimit(limit);
req.setOffset(offset);
if (query) {
req.setQueriesList(query);
}
return await this.request(
c => c.searchProjectGrantMembers,
req,
f => f,
);
}
public async SearchUsers(limit: number, offset: number, queryList?: UserSearchQuery[]): Promise<UserSearchResponse> {
const req = new UserSearchRequest();
req.setLimit(limit);
req.setOffset(offset);
if (queryList) {
req.setQueriesList(queryList);
}
return await this.request(
c => c.searchUsers,
req,
f => f,
);
}
public async GetUserByLoginNameGlobal(loginName: string): Promise<UserView> {
const req = new LoginName();
req.setLoginName(loginName);
return await this.request(
c => c.getUserByLoginNameGlobal,
req,
f => f,
);
}
// USER GRANTS
public async SearchUserGrants(
limit: number,
offset: number,
queryList?: UserGrantSearchQuery[],
): Promise<UserGrantSearchResponse> {
const req = new UserGrantSearchRequest();
req.setLimit(limit);
req.setOffset(offset);
if (queryList) {
req.setQueriesList(queryList);
}
return await this.request(
c => c.searchUserGrants,
req,
f => f,
);
}
public async UserGrantByID(
id: string,
userId: string,
): Promise<UserGrantView> {
const req = new UserGrantID();
req.setId(id);
req.setUserId(userId);
return await this.request(
c => c.userGrantByID,
req,
f => f,
);
}
public async UpdateUserGrant(
id: string,
userId: string,
roleKeysList: string[],
): Promise<UserGrant> {
const req = new UserGrantUpdate();
req.setId(id);
req.setRoleKeysList(roleKeysList);
req.setUserId(userId);
return await this.request(
c => c.updateUserGrant,
req,
f => f,
);
}
public async RemoveUserGrant(
id: string,
userId: string,
): Promise<Empty> {
const req = new UserGrantID();
req.setId(id);
req.setUserId(userId);
return await this.request(
c => c.removeUserGrant,
req,
f => f,
);
}
public async BulkRemoveUserGrant(
idsList: string[],
): Promise<Empty> {
const req = new UserGrantRemoveBulk();
req.setIdsList(idsList);
return await this.request(
c => c.bulkRemoveUserGrant,
req,
f => f,
);
}
//
public async ApplicationChanges(id: string, limit: number, offset: number): Promise<Changes> {
const req = new ChangeRequest();
req.setId(id);
req.setLimit(limit);
req.setSequenceOffset(offset);
return await this.request(
c => c.applicationChanges,
req,
f => f,
);
}
public async OrgChanges(id: string, limit: number, offset: number): Promise<Changes> {
const req = new ChangeRequest();
req.setId(id);
req.setLimit(limit);
req.setSequenceOffset(offset);
return await this.request(
c => c.orgChanges,
req,
f => f,
);
}
public async ProjectChanges(id: string, limit: number, offset: number): Promise<Changes> {
const req = new ChangeRequest();
req.setId(id);
req.setLimit(limit);
req.setSequenceOffset(offset);
return await this.request(
c => c.projectChanges,
req,
f => f,
);
}
public async UserChanges(id: string, limit: number, sequenceoffset: number): Promise<Changes> {
const req = new ChangeRequest();
req.setId(id);
req.setLimit(limit);
req.setSequenceOffset(sequenceoffset);
return await this.request(
c => c.userChanges,
req,
f => f,
);
}
}
console/src/app/services/mgmt.service.ts
+1066
View File
File diff suppressed because it is too large Load Diff
console/src/app/services/org.service.ts
-454
View File
@@ -1,454 +0,0 @@
import { Injectable } from '@angular/core';
import { Empty } from 'google-protobuf/google/protobuf/empty_pb';
import { Metadata } from 'grpc-web';
import { ManagementServicePromiseClient } from '../proto/generated/management_grpc_web_pb';
import {
AddOrgDomainRequest,
AddOrgMemberRequest,
ChangeOrgMemberRequest,
Domain,
Iam,
Org,
OrgCreateRequest,
OrgDomain,
OrgDomainSearchQuery,
OrgDomainSearchRequest,
OrgDomainSearchResponse,
OrgDomainValidationRequest,
OrgDomainValidationResponse,
OrgDomainValidationType,
OrgIamPolicy,
OrgID,
OrgMember,
OrgMemberRoles,
OrgMemberSearchRequest,
OrgMemberSearchResponse,
PasswordAgePolicy,
PasswordAgePolicyCreate,
PasswordAgePolicyID,
PasswordAgePolicyUpdate,
PasswordComplexityPolicy,
PasswordComplexityPolicyCreate,
PasswordComplexityPolicyID,
PasswordComplexityPolicyUpdate,
PasswordLockoutPolicy,
PasswordLockoutPolicyCreate,
PasswordLockoutPolicyID,
PasswordLockoutPolicyUpdate,
ProjectGrant,
ProjectGrantCreate,
RemoveOrgDomainRequest,
RemoveOrgMemberRequest,
ValidateOrgDomainRequest,
} from '../proto/generated/management_pb';
import { GrpcBackendService } from './grpc-backend.service';
import { GrpcService, RequestFactory, ResponseMapper } from './grpc.service';
@Injectable({
providedIn: 'root',
})
export class OrgService {
constructor(private readonly grpcService: GrpcService, private grpcBackendService: GrpcBackendService) { }
public async request<TReq, TResp, TMappedResp>(
requestFn: RequestFactory<ManagementServicePromiseClient, TReq, TResp>,
request: TReq,
responseMapper: ResponseMapper<TResp, TMappedResp>,
metadata?: Metadata,
): Promise<TMappedResp> {
const mappedRequestFn = requestFn(this.grpcService.mgmt).bind(this.grpcService.mgmt);
const response = await this.grpcBackendService.runRequest(
mappedRequestFn,
request,
metadata,
);
return responseMapper(response);
}
public async GetIam(): Promise<Iam> {
const req: Empty = new Empty();
return await this.request(
c => c.getIam,
req,
f => f,
);
}
public async GetDefaultPasswordComplexityPolicy(): Promise<PasswordComplexityPolicy> {
const req: Empty = new Empty();
return await this.request(
c => c.getDefaultPasswordComplexityPolicy,
req,
f => f,
);
}
public async GetMyOrg(): Promise<Org> {
return await this.request(
c => c.getMyOrg,
new Empty(),
f => f,
);
}
public async AddMyOrgDomain(domain: string): Promise<OrgDomain> {
const req: AddOrgDomainRequest = new AddOrgDomainRequest();
req.setDomain(domain);
return await this.request(
c => c.addMyOrgDomain,
req,
f => f,
);
}
public async RemoveMyOrgDomain(domain: string): Promise<Empty> {
const req: RemoveOrgDomainRequest = new RemoveOrgDomainRequest();
req.setDomain(domain);
return await this.request(
c => c.removeMyOrgDomain,
req,
f => f,
);
}
public async SearchMyOrgDomains(offset: number, limit: number, queryList?: OrgDomainSearchQuery[]):
Promise<OrgDomainSearchResponse> {
const req: OrgDomainSearchRequest = new OrgDomainSearchRequest();
req.setLimit(limit);
req.setOffset(offset);
if (queryList) {
req.setQueriesList(queryList);
}
return await this.request(
c => c.searchMyOrgDomains,
req,
f => f,
);
}
public async GenerateMyOrgDomainValidation(domain: string, type: OrgDomainValidationType):
Promise<OrgDomainValidationResponse> {
const req: OrgDomainValidationRequest = new OrgDomainValidationRequest();
req.setDomain(domain);
req.setType(type);
return await this.request(
c => c.generateMyOrgDomainValidation,
req,
f => f,
);
}
public async ValidateMyOrgDomain(domain: string):
Promise<Empty> {
const req: ValidateOrgDomainRequest = new ValidateOrgDomainRequest();
req.setDomain(domain);
return await this.request(
c => c.validateMyOrgDomain,
req,
f => f,
);
}
public async SearchMyOrgMembers(limit: number, offset: number): Promise<OrgMemberSearchResponse> {
const req = new OrgMemberSearchRequest();
req.setLimit(limit);
req.setOffset(offset);
return await this.request(
c => c.searchMyOrgMembers,
req,
f => f,
);
}
public async getOrgByDomainGlobal(domain: string): Promise<Org> {
const req = new Domain();
req.setDomain(domain);
return await this.request(
c => c.getOrgByDomainGlobal,
req,
f => f,
);
}
public async CreateOrg(name: string): Promise<Org> {
const req = new OrgCreateRequest();
req.setName(name);
return await this.request(
c => c.createOrg,
req,
f => f,
);
}
public async AddMyOrgMember(userId: string, rolesList: string[]): Promise<Empty> {
const req = new AddOrgMemberRequest();
req.setUserId(userId);
if (rolesList) {
req.setRolesList(rolesList);
}
return await this.request(
c => c.addMyOrgMember,
req,
f => f,
);
}
public async ChangeMyOrgMember(userId: string, rolesList: string[]): Promise<OrgMember> {
const req = new ChangeOrgMemberRequest();
req.setUserId(userId);
req.setRolesList(rolesList);
return await this.request(
c => c.changeMyOrgMember,
req,
f => f,
);
}
public async RemoveMyOrgMember(userId: string): Promise<Empty> {
const req = new RemoveOrgMemberRequest();
req.setUserId(userId);
return await this.request(
c => c.removeMyOrgMember,
req,
f => f,
);
}
public async DeactivateMyOrg(): Promise<Org> {
return await this.request(
c => c.deactivateMyOrg,
new Empty(),
f => f,
);
}
public async ReactivateMyOrg(): Promise<Org> {
const req = new OrgID();
return await this.request(
c => c.reactivateMyOrg,
new Empty(),
f => f,
);
}
public async CreateProjectGrant(
projectId: string,
orgId: string,
roleKeysList: string[],
): Promise<ProjectGrant> {
const req = new ProjectGrantCreate();
req.setProjectId(projectId);
req.setGrantedOrgId(orgId);
req.setRoleKeysList(roleKeysList);
return await this.request(
c => c.createProjectGrant,
req,
f => f,
);
}
public async GetOrgMemberRoles(): Promise<OrgMemberRoles> {
const req = new Empty();
return await this.request(
c => c.getOrgMemberRoles,
req,
f => f,
);
}
// Policy
public async GetMyOrgIamPolicy(): Promise<OrgIamPolicy> {
return await this.request(
c => c.getMyOrgIamPolicy,
new Empty(),
f => f,
);
}
public async GetPasswordAgePolicy(): Promise<PasswordAgePolicy> {
const req = new Empty();
return await this.request(
c => c.getPasswordAgePolicy,
req,
f => f,
);
}
public async CreatePasswordAgePolicy(
description: string,
maxAgeDays: number,
expireWarnDays: number,
): Promise<PasswordAgePolicy> {
const req = new PasswordAgePolicyCreate();
req.setDescription(description);
req.setMaxAgeDays(maxAgeDays);
req.setExpireWarnDays(expireWarnDays);
return await this.request(
c => c.createPasswordAgePolicy,
req,
f => f,
);
}
public async DeletePasswordAgePolicy(id: string): Promise<Empty> {
const req = new PasswordAgePolicyID();
req.setId(id);
return await this.request(
c => c.deletePasswordAgePolicy,
req,
f => f,
);
}
public async UpdatePasswordAgePolicy(
description: string,
maxAgeDays: number,
expireWarnDays: number,
): Promise<PasswordAgePolicy> {
const req = new PasswordAgePolicyUpdate();
req.setDescription(description);
req.setMaxAgeDays(maxAgeDays);
req.setExpireWarnDays(expireWarnDays);
return await this.request(
c => c.updatePasswordAgePolicy,
req,
f => f,
);
}
public async GetPasswordComplexityPolicy(): Promise<PasswordComplexityPolicy> {
return await this.request(
c => c.getPasswordComplexityPolicy,
new Empty(),
f => f,
);
}
public async CreatePasswordComplexityPolicy(
description: string,
hasLowerCase: boolean,
hasUpperCase: boolean,
hasNumber: boolean,
hasSymbol: boolean,
minLength: number,
): Promise<PasswordComplexityPolicy> {
const req = new PasswordComplexityPolicyCreate();
req.setDescription(description);
req.setHasLowercase(hasLowerCase);
req.setHasUppercase(hasUpperCase);
req.setHasNumber(hasNumber);
req.setHasSymbol(hasSymbol);
req.setMinLength(minLength);
return await this.request(
c => c.createPasswordComplexityPolicy,
req,
f => f,
);
}
public async DeletePasswordComplexityPolicy(id: string): Promise<Empty> {
const req = new PasswordComplexityPolicyID();
req.setId(id);
return await this.request(
c => c.deletePasswordComplexityPolicy,
req,
f => f,
);
}
public async UpdatePasswordComplexityPolicy(
description: string,
hasLowerCase: boolean,
hasUpperCase: boolean,
hasNumber: boolean,
hasSymbol: boolean,
minLength: number,
): Promise<PasswordComplexityPolicy> {
const req = new PasswordComplexityPolicyUpdate();
req.setDescription(description);
req.setHasLowercase(hasLowerCase);
req.setHasUppercase(hasUpperCase);
req.setHasNumber(hasNumber);
req.setHasSymbol(hasSymbol);
req.setMinLength(minLength);
return await this.request(
c => c.updatePasswordComplexityPolicy,
req,
f => f,
);
}
public async GetPasswordLockoutPolicy(): Promise<PasswordLockoutPolicy> {
const req = new Empty();
return await this.request(
c => c.getPasswordLockoutPolicy,
req,
f => f,
);
}
public async CreatePasswordLockoutPolicy(
description: string,
maxAttempts: number,
showLockoutFailures: boolean,
): Promise<PasswordLockoutPolicy> {
const req = new PasswordLockoutPolicyCreate();
req.setDescription(description);
req.setMaxAttempts(maxAttempts);
req.setShowLockOutFailures(showLockoutFailures);
return await this.request(
c => c.createPasswordLockoutPolicy,
req,
f => f,
);
}
public async DeletePasswordLockoutPolicy(id: string): Promise<Empty> {
const req = new PasswordLockoutPolicyID();
req.setId(id);
return await this.request(
c => c.deletePasswordLockoutPolicy,
req,
f => f,
);
}
public async UpdatePasswordLockoutPolicy(
description: string,
maxAttempts: number,
showLockoutFailures: boolean,
): Promise<PasswordLockoutPolicy> {
const req = new PasswordLockoutPolicyUpdate();
req.setDescription(description);
req.setMaxAttempts(maxAttempts);
req.setShowLockOutFailures(showLockoutFailures);
return await this.request(
c => c.updatePasswordLockoutPolicy,
req,
f => f,
);
}
public getLocalizedComplexityPolicyPatternErrorString(policy: PasswordComplexityPolicy.AsObject): string {
if (policy.hasNumber && policy.hasSymbol) {
return 'ORG.POLICY.PWD_COMPLEXITY.SYMBOLANDNUMBERERROR';
} else if (policy.hasNumber) {
return 'ORG.POLICY.PWD_COMPLEXITY.NUMBERERROR';
} else if (policy.hasSymbol) {
return 'ORG.POLICY.PWD_COMPLEXITY.SYMBOLERROR';
} else {
return 'ORG.POLICY.PWD_COMPLEXITY.PATTERNERROR';
}
}
}
console/src/app/services/project.service.ts
-604
View File
@@ -1,604 +0,0 @@
import { Injectable } from '@angular/core';
import { Empty } from 'google-protobuf/google/protobuf/empty_pb';
import { Metadata } from 'grpc-web';
import { ManagementServicePromiseClient } from '../proto/generated/management_grpc_web_pb';
import {
Application,
ApplicationID,
ApplicationSearchQuery,
ApplicationSearchRequest,
ApplicationSearchResponse,
ApplicationUpdate,
ApplicationView,
GrantedProjectSearchRequest,
OIDCApplicationCreate,
OIDCConfig,
OIDCConfigUpdate,
Project,
ProjectCreateRequest,
ProjectGrant,
ProjectGrantCreate,
ProjectGrantID,
ProjectGrantMember,
ProjectGrantMemberAdd,
ProjectGrantMemberChange,
ProjectGrantMemberRemove,
ProjectGrantMemberRoles,
ProjectGrantMemberSearchQuery,
ProjectGrantMemberSearchRequest,
ProjectGrantSearchRequest,
ProjectGrantSearchResponse,
ProjectGrantUpdate,
ProjectGrantView,
ProjectID,
ProjectMember,
ProjectMemberAdd,
ProjectMemberChange,
ProjectMemberRemove,
ProjectMemberRoles,
ProjectMemberSearchRequest,
ProjectMemberSearchResponse,
ProjectRole,
ProjectRoleAdd,
ProjectRoleAddBulk,
ProjectRoleChange,
ProjectRoleRemove,
ProjectRoleSearchQuery,
ProjectRoleSearchRequest,
ProjectRoleSearchResponse,
ProjectSearchQuery,
ProjectSearchRequest,
ProjectSearchResponse,
ProjectUpdateRequest,
ProjectView,
ZitadelDocs,
} from '../proto/generated/management_pb';
import { GrpcBackendService } from './grpc-backend.service';
import { GrpcService, RequestFactory, ResponseMapper } from './grpc.service';
@Injectable({
providedIn: 'root',
})
export class ProjectService {
constructor(private readonly grpcService: GrpcService, private grpcBackendService: GrpcBackendService) { }
public async request<TReq, TResp, TMappedResp>(
requestFn: RequestFactory<ManagementServicePromiseClient, TReq, TResp>,
request: TReq,
responseMapper: ResponseMapper<TResp, TMappedResp>,
metadata?: Metadata,
): Promise<TMappedResp> {
const mappedRequestFn = requestFn(this.grpcService.mgmt).bind(this.grpcService.mgmt);
const response = await this.grpcBackendService.runRequest(
mappedRequestFn,
request,
metadata,
);
return responseMapper(response);
}
public async SearchProjects(
limit: number, offset: number, queryList?: ProjectSearchQuery[]): Promise<ProjectSearchResponse> {
const req = new ProjectSearchRequest();
req.setLimit(limit);
req.setOffset(offset);
if (queryList) {
req.setQueriesList(queryList);
}
return await this.request(
c => c.searchProjects,
req,
f => f,
);
}
public async SearchGrantedProjects(
limit: number, offset: number, queryList?: ProjectSearchQuery[]): Promise<ProjectGrantSearchResponse> {
const req = new GrantedProjectSearchRequest();
req.setLimit(limit);
req.setOffset(offset);
if (queryList) {
req.setQueriesList(queryList);
}
return await this.request(
c => c.searchGrantedProjects,
req,
f => f,
);
}
public async GetZitadelDocs(): Promise<ZitadelDocs> {
const req = new Empty();
return await this.request(
c => c.getZitadelDocs,
req,
f => f,
);
}
public async GetProjectById(projectId: string): Promise<ProjectView> {
const req = new ProjectID();
req.setId(projectId);
return await this.request(
c => c.projectByID,
req,
f => f,
);
}
public async GetGrantedProjectByID(projectId: string, id: string): Promise<ProjectGrantView> {
const req = new ProjectGrantID();
req.setId(id);
req.setProjectId(projectId);
return await this.request(
c => c.getGrantedProjectByID,
req,
f => f,
);
}
public async CreateProject(project: ProjectCreateRequest.AsObject): Promise<Project> {
const req = new ProjectCreateRequest();
req.setName(project.name);
return await this.request(
c => c.createProject,
req,
f => f,
);
}
public async UpdateProject(id: string, name: string): Promise<Project> {
const req = new ProjectUpdateRequest();
req.setName(name);
req.setId(id);
return await this.request(
c => c.updateProject,
req,
f => f,
);
}
public async UpdateProjectGrant(id: string, projectId: string, rolesList: string[]): Promise<ProjectGrant> {
const req = new ProjectGrantUpdate();
req.setRoleKeysList(rolesList);
req.setId(id);
req.setProjectId(projectId);
return await this.request(
c => c.updateProjectGrant,
req,
f => f,
);
}
public async RemoveProjectGrant(id: string, projectId: string): Promise<Empty> {
const req = new ProjectGrantID();
req.setId(id);
req.setProjectId(projectId);
return await this.request(
c => c.removeProjectGrant,
req,
f => f,
);
}
public async DeactivateProject(projectId: string): Promise<Project> {
const req = new ProjectID();
req.setId(projectId);
return await this.request(
c => c.deactivateProject,
req,
f => f,
);
}
public async ReactivateProject(projectId: string): Promise<Project> {
const req = new ProjectID();
req.setId(projectId);
return await this.request(
c => c.reactivateProject,
req,
f => f,
);
}
public async SearchProjectGrants(projectId: string, limit: number, offset: number): Promise<ProjectGrantSearchResponse> {
const req = new ProjectGrantSearchRequest();
req.setProjectId(projectId);
req.setLimit(limit);
req.setOffset(offset);
return await this.request(
c => c.searchProjectGrants,
req,
f => f,
);
}
public async GetProjectGrantMemberRoles(): Promise<ProjectGrantMemberRoles> {
const req = new Empty();
return await this.request(
c => c.getProjectGrantMemberRoles,
req,
f => f,
);
}
public async AddProjectMember(id: string, userId: string, rolesList: string[]): Promise<Empty> {
const req = new ProjectMemberAdd();
req.setId(id);
req.setUserId(userId);
req.setRolesList(rolesList);
return await this.request(
c => c.addProjectMember,
req,
f => f,
);
}
public async ChangeProjectMember(id: string, userId: string, rolesList: string[]): Promise<ProjectMember> {
const req = new ProjectMemberChange();
req.setId(id);
req.setUserId(userId);
req.setRolesList(rolesList);
return await this.request(
c => c.changeProjectMember,
req,
f => f,
);
}
public async AddProjectGrantMember(
projectId: string,
grantId: string,
userId: string,
rolesList: string[],
): Promise<Empty> {
const req = new ProjectGrantMemberAdd();
req.setProjectId(projectId);
req.setGrantId(grantId);
req.setUserId(userId);
req.setRolesList(rolesList);
return await this.request(
c => c.addProjectGrantMember,
req,
f => f,
);
}
public async ChangeProjectGrantMember(
projectId: string,
grantId: string,
userId: string,
rolesList: string[],
): Promise<ProjectGrantMember> {
const req = new ProjectGrantMemberChange();
req.setProjectId(projectId);
req.setGrantId(grantId);
req.setUserId(userId);
req.setRolesList(rolesList);
return await this.request(
c => c.changeProjectGrantMember,
req,
f => f,
);
}
public async SearchProjectGrantMembers(
projectId: string,
grantId: string,
limit: number,
offset: number,
queryList?: ProjectGrantMemberSearchQuery[],
): Promise<ProjectMemberSearchResponse> {
const req = new ProjectGrantMemberSearchRequest();
req.setLimit(limit);
req.setOffset(offset);
if (queryList) {
req.setQueriesList(queryList);
}
req.setProjectId(projectId);
req.setGrantId(grantId);
return await this.request(
c => c.searchProjectGrantMembers,
req,
f => f,
);
}
public async RemoveProjectGrantMember(
projectId: string,
grantId: string,
userId: string,
): Promise<Empty> {
const req = new ProjectGrantMemberRemove();
req.setGrantId(grantId);
req.setUserId(userId);
req.setProjectId(projectId);
return await this.request(
c => c.removeProjectGrantMember,
req,
f => f,
);
}
public async CreateProjectGrant(orgId: string, projectId: string, roleKeys: string[]): Promise<ProjectGrant> {
const req = new ProjectGrantCreate();
req.setGrantedOrgId(orgId);
req.setProjectId(projectId);
req.setRoleKeysList(roleKeys);
return await this.request(
c => c.createProjectGrant,
req,
f => f,
);
}
public async ReactivateApplication(projectId: string, appId: string): Promise<Application> {
const req = new ApplicationID();
req.setId(appId);
req.setProjectId(projectId);
return await this.request(
c => c.reactivateApplication,
req,
f => f,
);
}
public async DeactivateApplication(projectId: string, appId: string): Promise<Application> {
const req = new ApplicationID();
req.setId(appId);
req.setProjectId(projectId);
return await this.request(
c => c.deactivateApplication,
req,
f => f,
);
}
public async RegenerateOIDCClientSecret(id: string, projectId: string): Promise<any> {
const req = new ApplicationID();
req.setId(id);
req.setProjectId(projectId);
return await this.request(
c => c.regenerateOIDCClientSecret,
req,
f => f,
);
}
public async SearchProjectRoles(
projectId: string,
limit: number,
offset: number,
queryList?: ProjectRoleSearchQuery[],
): Promise<ProjectRoleSearchResponse> {
const req = new ProjectRoleSearchRequest();
req.setProjectId(projectId);
req.setLimit(limit);
req.setOffset(offset);
if (queryList) {
req.setQueriesList(queryList);
}
return await this.request(
c => c.searchProjectRoles,
req,
f => f,
);
}
public async AddProjectRole(role: ProjectRoleAdd.AsObject): Promise<Empty> {
const req = new ProjectRoleAdd();
req.setId(role.id);
if (role.displayName) {
req.setDisplayName(role.displayName);
}
req.setKey(role.key);
req.setGroup(role.group);
return await this.request(
c => c.addProjectRole,
req,
f => f,
);
}
public async BulkAddProjectRole(
id: string,
rolesList: ProjectRoleAdd[],
): Promise<Empty> {
const req = new ProjectRoleAddBulk();
req.setId(id);
req.setProjectRolesList(rolesList);
return await this.request(
c => c.bulkAddProjectRole,
req,
f => f,
);
}
public async RemoveProjectRole(projectId: string, key: string): Promise<Empty> {
const req = new ProjectRoleRemove();
req.setId(projectId);
req.setKey(key);
return await this.request(
c => c.removeProjectRole,
req,
f => f,
);
}
public async ChangeProjectRole(projectId: string, key: string, displayName: string, group: string):
Promise<ProjectRole> {
const req = new ProjectRoleChange();
req.setId(projectId);
req.setKey(key);
req.setGroup(group);
req.setDisplayName(displayName);
return await this.request(
c => c.changeProjectRole,
req,
f => f,
);
}
public async RemoveProjectMember(id: string, userId: string): Promise<Empty> {
const req = new ProjectMemberRemove();
req.setId(id);
req.setUserId(userId);
return await this.request(
c => c.removeProjectMember,
req,
f => f,
);
}
public async SearchProjectMembers(projectId: string,
limit: number, offset: number): Promise<ProjectMemberSearchResponse> {
const req = new ProjectMemberSearchRequest();
req.setProjectId(projectId);
req.setLimit(limit);
req.setOffset(offset);
return await this.request(
c => c.searchProjectMembers,
req,
f => f,
);
}
public async SearchApplications(
projectId: string,
limit: number,
offset: number,
queryList?: ApplicationSearchQuery[]): Promise<ApplicationSearchResponse> {
const req = new ApplicationSearchRequest();
req.setProjectId(projectId);
req.setLimit(limit);
req.setOffset(offset);
if (queryList) {
req.setQueriesList(queryList);
}
return await this.request(
c => c.searchApplications,
req,
f => f,
);
}
public async GetApplicationById(projectId: string, applicationId: string): Promise<ApplicationView> {
const req = new ApplicationID();
req.setProjectId(projectId);
req.setId(applicationId);
return await this.request(
c => c.applicationByID,
req,
f => f,
);
}
public async GetProjectMemberRoles(): Promise<ProjectMemberRoles> {
const req = new Empty();
return await this.request(
c => c.getProjectMemberRoles,
req,
f => f,
);
}
public async ProjectGrantByID(id: string, projectId: string): Promise<ProjectGrantView> {
const req = new ProjectGrantID();
req.setId(id);
req.setProjectId(projectId);
return await this.request(
c => c.projectGrantByID,
req,
f => f,
);
}
public async RemoveProject(id: string): Promise<Empty> {
const req = new ProjectID();
req.setId(id);
return await this.request(
c => c.removeProject,
req,
f => f,
);
}
public async DeactivateProjectGrant(id: string, projectId: string): Promise<ProjectGrant> {
const req = new ProjectGrantID();
req.setId(id);
req.setProjectId(projectId);
return await this.request(
c => c.deactivateProjectGrant,
req,
f => f,
);
}
public async ReactivateProjectGrant(id: string, projectId: string): Promise<ProjectGrant> {
const req = new ProjectGrantID();
req.setId(id);
req.setProjectId(projectId);
return await this.request(
c => c.reactivateProjectGrant,
req,
f => f,
);
}
public async CreateOIDCApp(app: OIDCApplicationCreate.AsObject): Promise<Application> {
const req = new OIDCApplicationCreate();
req.setProjectId(app.projectId);
req.setName(app.name);
req.setRedirectUrisList(app.redirectUrisList);
req.setResponseTypesList(app.responseTypesList);
req.setGrantTypesList(app.grantTypesList);
req.setApplicationType(app.applicationType);
req.setAuthMethodType(app.authMethodType);
req.setPostLogoutRedirectUrisList(app.postLogoutRedirectUrisList);
return await this.request(
c => c.createOIDCApplication,
req,
f => f,
);
}
public async UpdateApplication(projectId: string, appId: string, name: string): Promise<Application> {
const req = new ApplicationUpdate();
req.setId(appId);
req.setName(name);
req.setProjectId(projectId);
return await this.request(
c => c.updateApplication,
req,
f => f,
);
}
public async UpdateOIDCAppConfig(projectId: string,
appId: string, oidcConfig: OIDCConfig.AsObject): Promise<OIDCConfig> {
const req = new OIDCConfigUpdate();
req.setProjectId(projectId);
req.setApplicationId(appId);
req.setRedirectUrisList(oidcConfig.redirectUrisList);
req.setResponseTypesList(oidcConfig.responseTypesList);
req.setAuthMethodType(oidcConfig.authMethodType);
req.setPostLogoutRedirectUrisList(oidcConfig.postLogoutRedirectUrisList);
req.setGrantTypesList(oidcConfig.grantTypesList);
req.setApplicationType(oidcConfig.applicationType);
req.setDevMode(oidcConfig.devMode);
return await this.request(
c => c.updateApplicationOIDCConfig,
req,
f => f,
);
}
}
console/src/app/services/toast.service.ts
+2 -2
View File
@@ -6,7 +6,7 @@ import { Observable } from 'rxjs';
import { take } from 'rxjs/operators';
import { WarnDialogComponent } from '../modules/warn-dialog/warn-dialog.component';
import { AuthService } from './auth.service';
import { AuthenticationService } from './authentication.service';
@Injectable({
providedIn: 'root',
@@ -15,7 +15,7 @@ export class ToastService {
constructor(private dialog: MatDialog,
private snackBar: MatSnackBar,
private translate: TranslateService,
private authService: AuthService,
private authService: AuthenticationService,
) { }
public showInfo(message: string, i18nkey: boolean = false): void {