@fluxo-dev/api-client-base 0.0.8

package/src/lib/security/route-rule/route-rule-with-permissions.ts

@@ -0,0 +1,4 @@
+export interface RouteRuleWithPermissions {
+  route: string;
+  permissions: string[];
+}

package/src/lib/security/route-rule/route-rule.service.ts

@@ -0,0 +1,26 @@
+import {RouteRule} from "./route-rule";
+import {BaseCommonService} from "../../infrastructure";
+import {HttpClient} from "../../http-client/http-client";
+import {Permission} from "../permission";
+
+export class RouteRuleService extends BaseCommonService<RouteRule> {
+  constructor() {
+    super('route-rule');
+  }
+
+  public getRouteRulesForScope(scope: string, packageName: string): Promise<RouteRule[]> {
+    return HttpClient.Instance().client.get(`route-rule?scope=${scope}&packageName=${packageName}`);
+  }
+
+  public getPermissions(routeRuleId: string): Promise<Permission[]> {
+    return HttpClient.Instance().client.get(`route-rule/${routeRuleId}/permissions`);
+  }
+
+  public addPermission(routeRuleId: number, permissionId: number): Promise<void> {
+    return HttpClient.Instance().client.post(`route-rule/${routeRuleId}/permissions`, {domainRoleId: routeRuleId, permissionId: permissionId});
+  }
+
+  public removePermission(routeRuleId: number, permissionId: number): Promise<void> {
+    return HttpClient.Instance().client.delete(`route-rule/${routeRuleId}/permissions/${permissionId}`);
+  }
+}

package/src/lib/security/route-rule/route-rule.ts

@@ -0,0 +1,7 @@
+export interface RouteRule {
+  id?: number;
+  scope: string;
+  packageName: string;
+  route: string;
+  permissionsCount?: number;
+}

package/src/lib/security/security-facade.ts

@@ -0,0 +1,42 @@
+import { UserService } from "./user/user-service";
+import {DomainRoleService} from "./domain-role";
+import { ApiKeyService } from "./apikey";
+import {PermissionService} from "./permission/permission.service";
+import {RouteRuleService} from "./route-rule/route-rule.service";
+
+export class SecurityFacade {
+
+  private readonly _userService: UserService;
+  private readonly _apiKeyService: ApiKeyService;
+  private readonly _domainRoleService: DomainRoleService;
+  private readonly _permissionService: PermissionService;
+  private readonly _routeRuleService: RouteRuleService;
+
+  constructor() {
+    this._userService = new UserService();
+    this._apiKeyService = new ApiKeyService();
+    this._domainRoleService = new DomainRoleService();
+    this._permissionService = new PermissionService();
+    this._routeRuleService = new RouteRuleService();
+  }
+
+  get user(): UserService {
+    return this._userService;
+  }
+
+  get permission(): PermissionService {
+    return this._permissionService;
+  }
+
+  get routeRule(): RouteRuleService {
+    return this._routeRuleService;
+  }
+
+  get apiKey(): ApiKeyService {
+    return this._apiKeyService;
+  }
+
+  get domainRole(): DomainRoleService {
+    return this._domainRoleService;
+  }
+}

package/src/lib/security/user/change-password.ts

@@ -0,0 +1,4 @@
+export interface ChangePassword {
+    currentPassword: string;
+    newPassword: string;
+}

package/src/lib/security/user/forgot-password.ts

@@ -0,0 +1,5 @@
+export interface ForgotPassword {
+    token: string;
+    email: string;
+    password: string;
+}

package/src/lib/security/user/identityOperationResult.ts

@@ -0,0 +1,9 @@
+export interface IdentityOperationResult {
+    success: boolean,
+    errors: IdentityOperationResultError[]
+}
+
+export interface IdentityOperationResultError {
+    code: string,
+    description: string
+}

package/src/lib/security/user/index.ts

@@ -0,0 +1,2 @@
+export * from './user';
+export * from './user-service';

package/src/lib/security/user/new-account-confirmation.ts

@@ -0,0 +1,4 @@
+export interface NewAccountConfirmation {
+    token: string;
+    email: string;
+}

package/src/lib/security/user/new-user.ts

@@ -0,0 +1,12 @@
+export interface NewUser {
+    user: NewUserUser,
+    assignToRoles: string[];
+    assignToDomainRoles: number[];
+}
+
+export interface NewUserUser {
+    firstName: string,
+    lastName: string,
+    userName: string,
+    email: string
+}

package/src/lib/security/user/user-service.ts

@@ -0,0 +1,83 @@
+import { HttpClient } from "../../http-client/http-client";
+import { ChangePassword } from "./change-password";
+import { ForgotPassword } from "./forgot-password";
+import { IdentityOperationResult } from "./identityOperationResult";
+import { NewAccountConfirmation } from "./new-account-confirmation";
+import { NewUser } from "./new-user";
+import { User } from "./user";
+import {store} from "@fluxo-dev/state";
+
+export class UserService {
+
+  constructor() {
+  }
+
+  public currentUserHasPermissions(requiredPermissions: string[], strategy: 'all' | 'any' = 'all'): boolean {
+    const userPermissions = store.getState().user.userPermissions;
+
+    if (!userPermissions) {
+      return false;
+    }
+
+    if(requiredPermissions.length === 0) {
+      return true;
+    }
+
+    const checkerAll = (arr: any[], target: any[]) => target.every(v => arr.includes(v));
+    const checkerAny = (arr: any[], target: any[]) => target.some(v => arr.includes(v));
+
+    let result: boolean;
+
+    if(strategy === 'all') {
+      result = checkerAll(userPermissions, requiredPermissions);
+    } else {
+      result = checkerAny(userPermissions, requiredPermissions);
+    }
+
+    if(result) {
+      return true;
+    }
+
+    return false;
+  }
+
+  public getAllUsers(): Promise<User[]> {
+    return HttpClient.Instance().client.get(`/identity/user`);
+  }
+
+  public createUser(user: NewUser): Promise<IdentityOperationResult> {
+    return HttpClient.Instance().client.post(`/identity/user`, user);
+  }
+
+  public updateUser(userId: string, user: NewUser): Promise<IdentityOperationResult> {
+    return HttpClient.Instance().client.put(`/identity/user/${userId}`, user);
+  }
+
+  public deleteUser(userId: string): Promise<IdentityOperationResult> {
+    return HttpClient.Instance().client.delete(`/identity/user/${userId}`);
+  }
+
+  public confirmEmail(user: NewAccountConfirmation): Promise<IdentityOperationResult> {
+    return HttpClient.Instance().client.post(`/identity/confirm/email`, user);
+  }
+
+  public changePassword(changePassword: ChangePassword): Promise<IdentityOperationResult> {
+    return HttpClient.Instance().client.post(`/identity/changepassword`, changePassword);
+  }
+
+  public forgotPassword(email: string): Promise<IdentityOperationResult> {
+    return HttpClient.Instance().client.post(`/identity/forgotpassword/require/${encodeURI(email)}`, null);
+  }
+
+  public forgotPasswordConfirm(forgotPassword: ForgotPassword): Promise<IdentityOperationResult> {
+    return HttpClient.Instance().client.post(`/identity/forgotpassword/confirm`, forgotPassword);
+  }
+
+  public disableUserLogin(userId: string): Promise<IdentityOperationResult> {
+    return HttpClient.Instance().client.post(`/disableuser/${userId}`);
+  }
+
+  public enableUserLogin(userId: string): Promise<IdentityOperationResult> {
+    return HttpClient.Instance().client.post(`/enableuser/${userId}`);
+  }
+}

package/src/lib/security/user/user.ts

@@ -0,0 +1,19 @@
+import {DomainRole} from "../domain-role";
+
+export interface User {
+    id: string;
+    email: string;
+    roles: string[];
+    domainRoles: DomainRole[];
+    userData: UserData;
+    emailConfirmed: boolean;
+    phoneNumber: string;
+    phoneNumberConfirmed: boolean;
+    lockoutEnd: string | null;
+    lockoutEnabled: boolean;
+}
+
+export interface UserData {
+    FirstName: string;
+    LastName: string;
+}

package/src/lib/utils/index.ts

@@ -0,0 +1 @@
+export * from './server-filter-helper';

package/src/lib/utils/server-filter-helper.ts

@@ -0,0 +1,34 @@
+export class ServerFilterHelper {
+
+  public static getFilterString(filter: string | undefined,
+                         globalSearchQuery:string | undefined,
+                         globalSearchQueryFields: {fieldName: string, fieldType: 'string' | 'number'}[] | undefined, globalQueryOperator: 'and' | 'or' = 'or') : string {
+
+    let filtersString = filter ? filter : '';
+    const globalSearchFilterArray : string[] = [];
+
+    if (globalSearchQuery && globalSearchQueryFields) {
+      let gFilter = '';
+
+      globalSearchQueryFields.forEach((field) => {
+
+        if(field.fieldType === 'string')
+          gFilter = `(obj.${field.fieldName}.ToLower().Contains("${globalSearchQuery}".ToLower()))`;
+        else
+          gFilter = `(obj.${field.fieldName} == ${globalSearchQuery})`;
+
+        globalSearchFilterArray.push(gFilter);
+      });
+    }
+
+    if (globalSearchFilterArray.length > 0) {
+      if (filtersString !== '')
+        filtersString = filtersString + ` ${globalQueryOperator} ` + globalSearchFilterArray.join(" or ")
+      else
+        filtersString = globalSearchFilterArray.join(" or ")
+    }
+
+    return filtersString;
+  }
+
+}

package/src/lib/workflow/index.ts

@@ -0,0 +1,2 @@
+export * from './models/index';
+export * from './workflow.service';

package/src/lib/workflow/models/action-category-definition.ts

@@ -0,0 +1,7 @@
+import {ActionDefinition} from "./action-definition";
+
+export interface ActionCategoryDefinition {
+  name:    string;
+  actions: ActionDefinition[];
+}
+

package/src/lib/workflow/models/action-definition.ts

@@ -0,0 +1,12 @@
+import {ActionInputDefinition} from "./action-input-definition";
+import {ActionOutputDefinition} from "./action-output-definition";
+
+export interface ActionDefinition {
+  id: string;
+  category: string;
+  name: string;
+  type: string;
+  inputs: ActionInputDefinition[];
+  outputs: ActionOutputDefinition[];
+  outcomes: string[];
+}

package/src/lib/workflow/models/action-input-definition.ts

@@ -0,0 +1,8 @@
+export interface ActionInputDefinition {
+  name: string;
+  type: string;
+  required: boolean;
+  uiHint: string;
+  displayName: null | string;
+  optionsProviderType: null | string;
+}

package/src/lib/workflow/models/action-output-definition.ts

@@ -0,0 +1,4 @@
+export interface ActionOutputDefinition {
+  name: string;
+  type: string;
+}

package/src/lib/workflow/models/index.ts

@@ -0,0 +1,11 @@
+export * from './action-definition';
+export * from './action-input-definition';
+export * from './action-output-definition';
+export * from './action-category-definition';
+export * from './workflow-action';
+export * from './workflow';
+export * from "./workflow-action-input";
+export * from "./workflow-action-input-type";
+export * from './trigger-definition';
+export * from './trigger-category-definition';
+export * from './workflow-trigger';

package/src/lib/workflow/models/trigger-category-definition.ts

@@ -0,0 +1,6 @@
+import { TriggerDefinition } from "./trigger-definition";
+
+export interface TriggerCategoryDefinition {
+  name: string;
+  triggers: TriggerDefinition[];
+}

package/src/lib/workflow/models/trigger-definition.ts

@@ -0,0 +1,11 @@
+import {ActionInputDefinition} from "./action-input-definition";
+import {ActionOutputDefinition} from "./action-output-definition";
+
+export interface TriggerDefinition {
+  id: string;
+  category: string;
+  name: string;
+  type: string;
+  inputs: ActionInputDefinition[];
+  outputs: ActionOutputDefinition[];
+}

package/src/lib/workflow/models/workflow-action-input-type.ts

@@ -0,0 +1,6 @@
+export enum WorkflowActionInputType {
+  none,
+  manual,
+  dynamic,
+  expression
+}

package/src/lib/workflow/models/workflow-action-input.ts

@@ -0,0 +1,6 @@
+import {WorkflowActionInputType} from "./workflow-action-input-type";
+
+export interface WorkflowActionInput {
+  type: WorkflowActionInputType;
+  value: string | undefined;
+}

package/src/lib/workflow/models/workflow-action.ts

@@ -0,0 +1,14 @@
+import {WorkflowActionInput} from "./workflow-action-input";
+
+export interface WorkflowAction {
+  id: string;
+  name: string;
+  color: string;
+  description: string;
+  type: string;
+  outcomes: string[];
+  nextActions: { [outcome: string]: WorkflowAction };
+  parallelActions: WorkflowAction[];
+  inputs: { [property: string]: WorkflowActionInput };
+}
+

package/src/lib/workflow/models/workflow-trigger.ts

@@ -0,0 +1,11 @@
+import {WorkflowActionInput} from "./workflow-action-input";
+
+export interface WorkflowTrigger {
+  id: string;
+  name: string;
+  color: string;
+  description: string;
+  type: string;
+  inputs: { [property: string]: WorkflowActionInput };
+}
+

package/src/lib/workflow/models/workflow.ts

@@ -0,0 +1,10 @@
+import {WorkflowAction} from "./workflow-action";
+import {WorkflowTrigger} from "./workflow-trigger";
+
+export interface Workflow {
+  id: string;
+  description: string;
+  version: number;
+  trigger?: WorkflowTrigger;
+  firstAction?: WorkflowAction;
+}

package/src/lib/workflow/workflow.service.ts

@@ -0,0 +1,17 @@
+import {HttpClient} from "../http-client/http-client";
+import {ActionCategoryDefinition, TriggerCategoryDefinition, Workflow} from "./models";
+
+export class WorkflowService {
+
+  getActionsDefinition(): Promise<ActionCategoryDefinition[]> {
+    return HttpClient.Instance().client.get('workflow/designer/actions');
+  }
+
+  getTriggersDefinition(): Promise<TriggerCategoryDefinition[]> {
+    return HttpClient.Instance().client.get('workflow/designer/triggers');
+  }
+
+  test(workflow: Workflow): Promise<void> {
+    return HttpClient.Instance().client.post('workflow/convert', workflow);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "allowJs": false,
+    "esModuleInterop": false,
+    "allowSyntheticDefaultImports": true,
+    "strict": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ],
+  "extends": "../../../tsconfig.base.json"
+}

package/tsconfig.lib.json

@@ -0,0 +1,24 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "types": [
+      "node",
+
+      "@nx/react/typings/cssmodule.d.ts",
+      "@nx/react/typings/image.d.ts"
+    ]
+  },
+  "exclude": [
+    "jest.config.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.js",
+    "src/**/*.test.js",
+    "src/**/*.spec.jsx",
+    "src/**/*.test.jsx"
+  ],
+  "include": ["src/**/*.js", "src/**/*.jsx", "src/**/*.ts", "src/**/*.tsx"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,20 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["jest", "node"]
+  },
+  "include": [
+    "jest.config.ts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/**/*.d.ts"
+  ]
+}