verben-authentication-ui 1.0.2 → 1.0.3

package/src/lib/models/UserRequest.ts

@@ -0,0 +1,38 @@
+import { MechanismType } from "./auth-mechanism";
+import { ObjectState } from "./object-state";
+import { RequestStatus } from "./request-status";
+import { Role } from "./Role";
+import { Status } from "./status";
+
+
+
+
+
+export interface Tag {
+  Name: string;
+  IsOptional: boolean;
+}
+
+export interface UserRequestPayload {
+  Code: string;
+  FirstName: string;
+  LastName: string;
+  MailAddress: string;
+  Password: string;
+  PhoneNumber: string;
+  OtherName: string;
+  Role: Role
+  Tags: Tag[];
+  Status: Status;
+  UpdatedAt: Date;
+  CreatedAt: Date;
+  Id: string;
+  DataState: ObjectState;
+  TenantId: string;
+  ServiceName: string;
+  ActionBy: string;
+  SignUpType: MechanismType;
+  RequestStatus: RequestStatus;
+  Comment: string;
+  Token?: string;
+}

package/src/lib/models/auth-mechanism.ts

@@ -0,0 +1,15 @@
+export enum MechanismType {
+  InApp = 'InApp',
+  Google = 'Google',
+  Apple = 'Apple',
+  MicrosoftAD = 'MicrosoftAD',
+}
+
+export interface AuthMechanism {
+  AuthMechanism: string;
+  ClientId: string;
+  ClientSecret: string;
+  RedirectUri: string;
+  Scope: string;
+  TenantId?:string
+}

package/src/lib/models/base.ts

@@ -0,0 +1,13 @@
+import { ObjectState } from './object-state';
+
+export interface BaseModel {
+  id?: string;
+  Id: string;
+  CreatedAt: Date;
+  UpdatedAt: Date;
+  DataState: ObjectState;
+  TenantId: string;
+  ServiceName: string;
+  Code: string;
+  readonly Error?: string;
+}

package/src/lib/models/conditions.ts

@@ -0,0 +1,11 @@
+export enum ConditionOptions {
+    LessThan = "LT",       
+    GreaterThan = "GT",    
+    Equal = "EQ",           
+    NotEqual = "NEQ",      
+    On = "EQ",              
+    Before = "LT",
+    After = "GT",       
+    Yes = "EQ",            
+    No = "NEQ"            
+}

package/src/lib/models/log-in.ts

@@ -0,0 +1,8 @@
+export interface LoginData {
+  MailAddress: string;
+  Password: string;
+  LoginType: string;
+  Tenant: string;
+  Secrete: string;
+  Token?: string;
+}

package/{lib/models/mainUser.d.ts → src/lib/models/mainUser.ts}

@@ -1,5 +1,6 @@
 import { ObjectState } from "./object-state";
-export interface MainUser {
+
+export interface MainUser { 
     Code: string;
     TenantId: string;
     Id: string;
@@ -16,4 +17,4 @@ export interface MainUser {
     CreatedAt: Date;
     UpdatedAt: Date;
     DataState: ObjectState;
-}
+} 

package/src/lib/models/oauth-resp.ts

@@ -0,0 +1,6 @@
+export interface IOauthResp{ 
+    AccessToken:string,
+    Email:string
+    FirstName:string
+    LastName:string
+  }

package/{lib/models/oauth-response.d.ts → src/lib/models/oauth-response.ts}

@@ -3,4 +3,4 @@ export interface OAuthResponse {
     LastName: string;
     Email: string;
     AccessToken: string;
-}
+  }

package/src/lib/models/object-state.ts

@@ -0,0 +1,6 @@
+export enum ObjectState {
+  New = 'New',
+  Changed = 'Changed',
+  Unchanged = 'Unchanged',
+  Removed = 'Removed',
+}

package/{lib/models/otpValue.d.ts → src/lib/models/otpValue.ts}

@@ -1,5 +1,7 @@
 import { MechanismType } from "./auth-mechanism";
 import { MainUser } from "./mainUser";
+
+
 export interface OtpData {
     User: MainUser;
     Token: string;
@@ -7,5 +9,5 @@ export interface OtpData {
     Secret: string;
     OTP?: string;
     Info: string;
-    Provider: MechanismType;
-}
+    Provider:MechanismType
+  }

package/src/lib/models/paged.ts

@@ -0,0 +1,9 @@
+export interface Paged<T> {
+  Skip: number;
+  PageSize: number;
+  IsLoadingResults: boolean;
+  Total: number;
+  PageState?: unknown;
+  Result: T[];
+  LastItem: string[];
+}

package/src/lib/models/query-params.ts

@@ -0,0 +1,9 @@
+import { SortDirection } from "./SortDirection";
+
+export interface QueryParams<T> {
+  skip: number;
+  limit: number;
+  sortParam?: keyof T;
+  sortOrder: SortDirection;
+  filterParam?: string;
+}

package/src/lib/models/request-status.ts

@@ -0,0 +1,4 @@
+export enum RequestStatus {
+  Pending='Pending'
+  }
+  

package/src/lib/models/resend-otp-data.ts

@@ -0,0 +1,8 @@
+export interface ResendOtpData {
+  MailAddress: string;
+  Password: string;
+  LoginType: string;
+  Tenant: string;
+  Secrete: string;
+  RedirectUri: string;
+}

package/src/lib/models/resource.ts

@@ -0,0 +1,27 @@
+import { BaseModel } from './base';
+import { ObjectState } from './object-state';
+
+export abstract class ResourceModel<T extends BaseModel> implements BaseModel {
+  public Id: string;
+  public CreatedAt: Date;
+  public UpdatedAt: Date;
+  public State: ObjectState;
+  public TenantId: string;
+  public id: string | number;
+
+  constructor(model?: Partial<T>) {
+    if (model) {
+      Object.assign(this, model);
+    }
+    this.Id = model?.Id || '';
+    this.CreatedAt = model?.CreatedAt ? new Date(model.CreatedAt) : new Date();
+    this.UpdatedAt = model?.UpdatedAt ? new Date(model.UpdatedAt) : new Date();
+    this.State = model?.State ?? ObjectState.New;
+    this.Tenant = model?.Tenant ?? '';
+    this.id = model?.Id ?? Math.random();
+  }
+
+  public toJson(): any {
+    return JSON.parse(JSON.stringify(this));
+  }
+}

package/src/lib/models/sign-up.ts

@@ -0,0 +1,11 @@
+import { BaseModel } from "./base";
+import { User } from "./user";
+
+export interface SignUpData extends BaseModel{ 
+    Firstname:string,
+    Lastname:string,
+    Email:string,
+    Password:string,
+    Confirmpassword?:string,
+    Terms:boolean
+  }

package/src/lib/models/single-sign-on.ts

@@ -0,0 +1,9 @@
+import { BaseModel } from "./base";
+
+
+export interface SingleSignOn extends BaseModel{
+  Name:string
+  Description?: string;
+  Logo: string;
+  Link:string
+}

package/src/lib/models/status.ts

@@ -0,0 +1,5 @@
+export enum Status {
+    InActive = "InActive",
+    Active = "Active",
+  }
+  

package/src/lib/models/user-access-request-status.ts

@@ -0,0 +1,5 @@
+export enum UserAccessRequestStatus {
+  Pending = 'Pending',
+  Approved = 'Approved',
+  Declined = 'Declined',
+}

package/{lib/models/user-access-request.d.ts → src/lib/models/user-access-request.ts}

@@ -1,9 +1,10 @@
 import { OAuthType } from './OAuthType';
 import { User } from './user';
 import { UserAccessRequestStatus } from './user-access-request-status';
+
 export interface UserAccessRequest extends User {
-    RequestStatus: UserAccessRequestStatus;
-    ActionBy?: string;
-    Comment?: string;
-    SignupType: OAuthType;
+  RequestStatus: UserAccessRequestStatus;
+  ActionBy?: string;
+  Comment?: string;
+  SignupType: OAuthType;
 }

package/src/lib/models/user-object-state.ts

@@ -0,0 +1,6 @@
+export enum ObjectState {
+  New = 'New',
+  Active = 'Active',
+  Inactive = 'Inactive',
+  Deleted = 'Deleted',
+}

package/src/lib/models/user.ts

@@ -0,0 +1,19 @@
+import { BaseModel } from './base';
+import { OAuthType } from './OAuthType';
+import { Role } from './Role';
+import { Status } from './status';
+
+export interface User extends BaseModel {
+  Password: string;
+  PhoneNumber?: string;
+  FirstName: string;
+  LastName: string;
+  OtherName?: string;
+  MailAddress: string;
+  IsSeeded: boolean;
+  RoleID?: string;
+  Address?: string;
+  Role?: Role;
+  Status: Status;
+  SignupType: OAuthType;
+}

package/src/lib/pipes/async-label.pipe.spec.ts

@@ -0,0 +1,8 @@
+import { AsyncLabelPipe } from './async-label.pipe';
+
+describe('AsyncLabelPipe', () => {
+  it('create an instance', () => {
+    const pipe = new AsyncLabelPipe();
+    expect(pipe).toBeTruthy();
+  });
+});

package/src/lib/pipes/async-label.pipe.ts

@@ -0,0 +1,20 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { from, Observable, of } from 'rxjs';
+import { LabelService } from '../services/label.service';
+
+@Pipe({
+  name: 'asyncLabel',
+  standalone: true
+})
+export class AsyncLabelPipe implements PipeTransform {
+
+  constructor(private labelService: LabelService){
+    
+  }
+
+  transform(code: any, entity: string, labelProp: string, env: string, key: string = 'Code'): Observable<string> {
+    if (!code) return of('');
+    return from(this.labelService.getAsyncLabelWithRequestTracking(code, entity, labelProp, env, key));
+  }
+
+}

package/src/lib/services/authorization.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { AuthorizationService } from './authorization.service';
+
+describe('AuthorizationService', () => {
+  let service: AuthorizationService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(AuthorizationService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/lib/services/authorization.service.ts

@@ -0,0 +1,24 @@
+import { Injectable, InjectionToken, Inject, Optional } from '@angular/core';
+
+export const AUTHORIZATION_CONFIG = new InjectionToken<AuthorizationConfig[]>(
+  'authorization_config'
+);
+
+export interface AuthorizationConfig {
+  Name: string;
+  Actions: string[];
+}
+@Injectable({
+  providedIn: 'root',
+})
+export class AuthorizationService {
+  constructor(
+    @Optional()
+    @Inject(AUTHORIZATION_CONFIG)
+    private auth: AuthorizationConfig[]
+  ) {}
+
+  get authorizationConfig(): AuthorizationConfig[] {
+    return this.auth ? this.auth : [];
+  }
+}

package/src/lib/services/encryption.service.ts

@@ -0,0 +1,57 @@
+import { Injectable } from '@angular/core';
+import CryptoJS from 'crypto-js';
+import {EnvironmentService } from './environment.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class EncryptionService {
+  isProd:boolean
+  private ivString
+  private keyString
+  constructor(
+
+    private envSvc: EnvironmentService,
+
+  ) {
+    this.ivString=this.envSvc.environment.IvString
+    this.keyString=this.envSvc.environment.keyString
+    this.isProd = this.envSvc.environment.production;
+  }
+  encryptData(data: string): string {
+    try {
+      const encrypted = CryptoJS.AES.encrypt(
+        data,
+        CryptoJS.enc.Utf8.parse(this.keyString),
+        {
+          iv: CryptoJS.enc.Utf8.parse(this.ivString),
+        }
+      );
+
+      // Return the encrypted data as a string
+      return encrypted.toString();
+    } catch (error) {
+      console.error('Encryption error:', error);
+      return data; // Return original data if encryption fails
+    }
+  }
+
+  decryptData(data: string): string {
+    try {
+      // Decrypt the data
+      const decrypted = CryptoJS.AES.decrypt(
+        data,
+        CryptoJS.enc.Utf8.parse(this.keyString),
+        {
+          iv: CryptoJS.enc.Utf8.parse(this.ivString),
+        }
+      );
+
+      // Convert the decrypted data to a UTF-8 string
+      return decrypted.toString(CryptoJS.enc.Utf8);
+    } catch (error) {
+      console.error('Decryption error:', error);
+      return data; // Return original data if decryption fails
+    }
+  }
+}

package/src/lib/services/environment.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { EnvironmentService } from './environment.service';
+
+describe('EnvironmentService', () => {
+  let service: EnvironmentService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(EnvironmentService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/lib/services/environment.service.ts

@@ -0,0 +1,30 @@
+// In your library's services/environment.service.ts
+import { Injectable, InjectionToken, Inject } from '@angular/core';
+// import { ENVIRONMENT } from '../models/ENVIRONMENT_TOKEN';
+
+export const ENVIRONMENT = new InjectionToken<Environment>('environment');
+
+export interface Environment {
+  production: boolean;
+  AuthenticationAPI: string;
+  ReportingAPI: string;
+  MessagingAPI: string;
+  WorkflowAPI: string;
+  Tenant: string;
+  APIKey: string;
+  Secret: string;
+ IvString :string;
+  keyString:string;
+
+}
+
+@Injectable({
+  providedIn: 'root',
+})
+export class EnvironmentService {
+  constructor(@Inject(ENVIRONMENT) private env: Environment) {}
+
+  get environment(): Environment {
+    return this.env;
+  }
+}

package/src/lib/services/http-web-request.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { HttpWebRequestService } from './http-web-request.service';
+
+describe('HttpWebRequestService', () => {
+  let service: HttpWebRequestService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(HttpWebRequestService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/lib/services/http-web-request.service.ts

@@ -0,0 +1,114 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ErrorResponse } from '../models/ErrorResponse';
+import { EnvironmentService } from './environment.service';
+import { NotificationService } from 'verben-ng-ui';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class HttpWebRequestService {
+  isProd: boolean;
+
+  constructor(
+    private http: HttpClient,
+    private envSvc: EnvironmentService,
+    private notificationService: NotificationService
+  ) {
+    this.isProd = this.envSvc.environment.production;
+  }
+
+  private buildHeaders() {
+    return {
+      'Content-Type': 'application/json',
+      Authorization:
+        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJNYWlsQWRkcmVzcyI6InZlcmJlbmFAZ21haWwuY29tIiwiQXBwbGljYXRpb24iOiIiLCJOYW1lIjoiVmVyYmVuYSBMb2dpYyBMaW1pdGVkIiwiUm9sZUlEIjoiUk9MLVpYQVhYVCIsIlRlbmFudElkIjoiUERMVEM2IiwiU2VydmljZU5hbWUiOiJXaGl0ZTM2MCIsIkNvbXBhbnkiOiJDT00tNkxJNjNIIiwibmJmIjoxNzQ3MTMxNTk1LCJleHAiOjE3NDczNDc1OTUsImlhdCI6MTc0NzEzMTU5NX0.X-5xj31h2ON268n1sTq6eFhphsiZ1k9JhkJ91R2-PKI',
+    };
+  }
+
+  private buildUrl(url: string, baseUrl: string): string {
+    return `${baseUrl}/${url}`;
+  }
+
+  private handleError(err: any): ErrorResponse {
+    const msg =
+      err?.ErrorMsg ||
+      (err?.errors?.values as string[])?.toString() ||
+      `Error occurred`;
+    this.notificationService.error(msg, { timeout: 10000 });
+    return new ErrorResponse(msg);
+  }
+
+  private request<T>(
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE',
+    url: string,
+    body?: any,
+    baseUrl: string = this.envSvc.environment.AuthenticationAPI
+  ): Promise<T> | Observable<T> {
+    const options = {
+      headers: this.buildHeaders(),
+    };
+
+    const requestUrl = this.buildUrl(url, baseUrl);
+
+    switch (method) {
+      case 'GET':
+        return new Promise((resolve) =>
+          this.http.get<T>(requestUrl, options).subscribe({
+            next: resolve,
+            error: (err) => resolve(this.handleError(err) as T),
+          })
+        );
+      case 'POST':
+        return new Promise((resolve) =>
+          this.http.post<T>(requestUrl, body, options).subscribe({
+            next: resolve,
+            error: (err) => resolve(this.handleError(err) as T),
+          })
+        );
+      case 'PUT':
+        return this.http.put<T>(requestUrl, body, options);
+      case 'DELETE':
+        return this.http.delete<T>(requestUrl, options);
+    }
+  }
+
+  get<T>(url: string, baseUrl?: string): Promise<T> {
+    return this.request('GET', url, undefined, baseUrl) as Promise<T>;
+  }
+
+  post<T>(url: string, body: any, baseUrl?: string): Promise<T> {
+    return this.request(
+      'POST',
+      url,
+      JSON.stringify(body),
+      baseUrl
+    ) as Promise<T>;
+  }
+
+  postFile<T>(url: string, formData: FormData, baseUrl?: string): Promise<T> {
+    return new Promise((resolve) =>
+      this.http
+        .post<T>(
+          this.buildUrl(
+            url,
+            baseUrl || this.envSvc.environment.AuthenticationAPI
+          ),
+          formData
+        )
+        .subscribe({
+          next: resolve,
+          error: (err) => resolve(this.handleError(err) as T),
+        })
+    );
+  }
+
+  put<T>(url: string, body: any, baseUrl?: string): Observable<T> {
+    return this.request('PUT', url, body, baseUrl) as Observable<T>;
+  }
+
+  delete<T>(url: string, baseUrl?: string): Observable<T> {
+    return this.request('DELETE', url, undefined, baseUrl) as Observable<T>;
+  }
+}

package/src/lib/services/label.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { LabelService } from './label.service';
+
+describe('LabelService', () => {
+  let service: LabelService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(LabelService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});