bpm-core 0.0.131 → 0.0.133

package/cli/generate/new/angular-template/src/app/page-components/@@comp-template@@/_html-field.ejs

@@ -0,0 +1,97 @@
+      <% if (item.visibilityCheckCode) { -%>
+        <% importsManager.addImport(getEnumName(item), '../../shared/types/lov.enum') -%>
+        @if(<%= changeCase.camelCase(`is ${item.fieldName || item.headerName} visible`) %>){
+      <% } -%>
+      <% switch(item.componentName){ 
+        case 'input': -%>
+          <app-input
+            <%- getCommonAttributes(item) -%>
+            <% if(item.maxLength){ -%> 
+              maxLength="<%=item.maxLength%>" 
+            <% } -%>
+          >
+          </app-input>
+        <% break; case 'textarea': -%>
+          <app-textarea
+            <%- getCommonAttributes(item) -%>
+            <% if(item.maxLength){ -%> 
+              maxLength="<%=item.maxLength%>" 
+            <% } -%>
+          >
+          </app-textarea>
+        <% break; case 'input-number': -%>
+          <app-input-number
+            <%- getCommonAttributes(item) -%>
+          >
+          </app-input-number>
+        <% break; case 'input-currency': -%>
+          <app-input-currency
+            <%- getCommonAttributes(item) -%>
+          >
+          </app-input-currency>
+        <% break; case 'select': -%>
+          <app-custom-searchable
+            <%- getCommonAttributes(item) -%>
+            [options]="lov?.<%=item.lovName%>?.options"
+            [key]="'value'"
+            [displayedLabel]="'description'"
+          >
+          </app-custom-searchable>
+        <% break; case 'attachment-section': -%>
+          <app-attachment-section
+            class="section-item full"
+            formControlName="<%=item.fieldName%>"
+            <% if(item.label){ %>
+            [label]="'<%=changeCase.camelCase(item.label)%>' | translate"
+            <% } %>
+            [mandatory]="<%=item.required%>"
+            [isReadOnly]="<%=item.readOnly ? 'true' : 'section?.header?.readOnly'%>"
+          >
+          </app-attachment-section>
+        <% break; case 'file-uploader': -%>
+          <app-file-uploader
+            <%- getCommonAttributes(item) -%>
+            <% if(item.maxLength){ -%> 
+              [maxLength]="<%=item.maxLength%>" 
+            <% } -%>
+            <% if(item.multiple){ -%> 
+              [multiple]="true"
+              [displayedFiles]="formGroup.value?.<%=item.fieldName%>"
+            <% } -%>
+          >
+          </app-file-uploader>
+        <% break; case 'datepicker': -%>
+          <app-datepicker
+            <%- getCommonAttributes(item) -%>
+            <% if(item.minDate){ -%> 
+              minDate="<%=item.minDate%>" 
+            <% } -%>
+            <% if(item.maxDate){ -%> 
+              maxDate="<%=item.maxDate%>" 
+            <% } -%>
+            <% if(item.customMinDate){ -%> 
+              customMinDate="<%=item.customMinDate%>" 
+            <% } -%>
+            <% if(item.customMaxDate){ -%> 
+              customMaxDate="<%=item.customMaxDate%>" 
+            <% } -%>
+          >
+          </app-datepicker>
+        <% break; case 'panel-start': -%>
+          <div class="header-line full fs-12 fw-medium mb-2">
+            {{ "<%=changeCase.camelCase(item.headerName)%>" | translate }}
+          </div>
+        <% break; case 'hint': -%>
+          <ds-alert class="mb-3 full" type="<%=item.type%>" icon="<%=item.type === 'danger' ? 'close-circle' : 'info'%>">
+            {{'<%=changeCase.camelCase(item.headerName)%>' | translate}}
+          </ds-alert>
+        <% break; case 'search-employee': -%>
+          <app-search-employee
+            <%- getCommonAttributes(item) -%>
+          >
+          </app-search-employee>
+        <% break; -%>
+      <% } -%>
+      <% if (item.visibilityCheckCode) { -%>
+        }
+      <% } %>

package/cli/generate/new/angular-template/src/app/page-components/@@comp-template@@/_html-table.ejs

@@ -0,0 +1,27 @@
+<div class="section-item full mt-2">
+    <% if(field.label){ -%>
+    <div class="header-line full fs-12 fw-medium mb-1">{{ "<%=changeCase.camelCase(field.label)%>" | translate }}</div>
+    <% } -%>
+    <div class="gray-table-wrapper">
+        <table>
+            <thead>
+            <tr>
+                <% field.tableColumns.forEach((column) => { -%>
+                <th>{{'<%=changeCase.camelCase(column.label)%>' | translate}}</th>
+                <% }); -%>
+            </tr>
+            </thead>
+            <tbody formArrayName="<%=field.arrayName%>">
+            @for (item of section.body.details.<%=field.arrayName%>; track $index) {
+                <tr [formGroupName]="$index">
+                <% field.tableColumns.forEach((column) => { -%>
+                    <td>
+                    <%- include('_html-field', {item: column}) %>
+                    </td>
+                <% }); -%>
+                </tr>
+            }
+            </tbody>
+        </table>
+    </div>
+</div>

package/cli/generate/new/angular-template/src/app/page-components/@@comp-template@@/_ts-field.ejs

@@ -0,0 +1,3 @@
+<% if(field.fieldName){ -%>
+    <%= field.fieldName %>: new FormControl<<%- getFieldType(field) %>>(<%- defaultValue || 'null' %><% if(field.required){ -%>, <%- getValidators(field) %><% } %>),
+<% } -%>

package/cli/generate/new/angular-template/src/app/shared/pipes/translate.pipe.ts

@@ -0,0 +1,32 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import * as en from '../../../app/i18n/en';
+import * as ar from '../../../app/i18n/ar';
+
+@Pipe({
+  name: 'translate',
+  standalone:true
+})
+export class TranslatePipe implements PipeTransform {
+  private coreLocales: { [key: string]: { [key: string]: string } };
+  public language: string;
+
+  constructor() {
+    // this.language = "en";
+    this.language = (window as any).wmConfig.language;
+    this.coreLocales = { en: en.default, ar: ar.default };
+  }
+
+  transform(key) {
+    let result = null;
+    try {
+      result = this.coreLocales[this.language][key];
+    } catch (e) {
+      result = null;
+    }
+    return result || key;
+  }
+
+  getLanguage() {
+    return this.language;
+  }
+}

package/cli/generate/new/angular-template/src/app/shared/services/i18n.service.ts

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import * as en from '../../../app/i18n/en';
+import * as ar from '../../../app/i18n/ar';
+
+@Injectable({
+    providedIn: 'any',
+})
+export class I18nService {
+  private readonly locales: {[key: string]: {[key: string]: string}};
+  private readonly language : string;
+
+  constructor() {
+    this.language = (window as any).wmConfig.language;
+    // this.language = "en";
+    this.locales = {en: en.default, ar: ar.default};
+  }
+
+  translate(key) {
+    let result = null;
+    try {
+        result = this.locales[this.language][key];
+    }
+    catch(e) {
+      result = null;
+    }
+    return result || key;
+  }
+
+  getLanguage() {
+    return this.language;
+  }
+}

package/cli/generate/new/angular-template/src/app/shared/services/segment-dynamic-loader.service.ts.ejs

@@ -0,0 +1,49 @@
+import { Injectable } from '@angular/core';
+import {RequestDetailsSectionComponent} from '../../page-components/request-details-section/request-details-section.component';
+import segmentDynamicLoaderConfiguration from '../../config/segment-dynamic-loader.config';
+import * as Constants from 'bpm-core';
+import { I18nService } from './i18n.service';
+
+@Injectable({
+  providedIn: 'any'
+})
+export class SegmentDynamicLoaderService {
+  requestDetailsSection = RequestDetailsSectionComponent;
+  roleToApprovalSectionMapping = segmentDynamicLoaderConfiguration.roleToApprovalSectionMapping;
+
+  constructor(private i18n: I18nService) {
+
+  }
+
+  getComponent(componentId: string) {
+    if (componentId.toLowerCase() === Constants.SECTION_ID_REQUEST_DETAILS.toLowerCase()) {
+      return this.requestDetailsSection;
+    }
+    let role = componentId.toLowerCase().split(Constants.SECTION_ID_APPROVAL_PARTIAL_NAME.toLowerCase())[0].toLowerCase();
+    return this.roleToApprovalSectionMapping[role];
+  }
+
+  getSectionName(componentId: string): string {
+    if(componentId.toLowerCase() === Constants.SECTION_ID_REQUEST_DETAILS.toLowerCase()) {
+      return this.i18n.translate('requestDetailsTitle');
+    }
+    else if(componentId.toLowerCase() === 'hrRequestDetails'.toLowerCase()) {
+      return this.i18n.translate('hrRequestDetailsTitle');
+    }
+    let role = componentId.toLowerCase().split(Constants.SECTION_ID_APPROVAL_PARTIAL_NAME.toLowerCase())[0].toLowerCase();
+    return this.i18n.translate(`${role.toLowerCase()}Role`);
+  }
+
+  getPrintPartialName (componentName: string) {
+    if (componentName === Constants.SECTION_ID_REQUEST_DETAILS) {
+      return 'sectionRequestDetails';
+    }
+    <% getRoleStages().forEach(stageInfo => { -%>
+    else if (componentName === "<%= stageInfo.role.toLowerCase()%>Approval") {
+      return "<%=stageInfo.printPartialName%>";
+    } 
+    <% }); -%>
+    else { return 'sectionGeneralApproval' }
+
+  }
+}

package/cli/generate/new/angular-template/src/app/shared/services/state-machine.service.ts

@@ -0,0 +1,119 @@
+import {Injectable} from '@angular/core';
+import {HttpClient} from '@angular/common/http';
+import * as constants from "bpm-core";
+import {CoreService, Messages} from "bpm-core";
+import {environment} from "../../../environments/environment";
+
+@Injectable({
+    providedIn: 'any',
+})
+export class StateMachineService {
+  private readonly transitions: { [key: string]: { [key: string]: Function } };
+  private state: string;
+
+  constructor(private http: HttpClient, private coreStateMachineService: CoreService) {
+    this.state = constants.STATE_MACHINE_STATUS_IDLE;
+    this.transitions = {
+      idle: {
+        generalApi: function (serviceName: string, ...args) {
+          let body = {
+            method: constants.HTTP_METHOD_GET, //GET - PUT - POST
+            destination: constants.TARGET_SERVER_WM,
+            serviceName: serviceName, //,
+            formName: environment.formName,
+            queryParameters: {
+
+            }
+          }
+          let options = this.coreStateMachineService.getRequestOptions();
+          let succ = 'serviceResponce';
+          return this.callPost(body, succ, options);
+        }
+      },
+      fetching: {
+        serviceResponce: function (...args: any) {
+          let [payload] = args;
+          let result = payload;
+          this.state = constants.STATE_MACHINE_STATUS_IDLE;
+          return result;
+        },
+        failure: function (...args) {
+          let [errors] = args;
+          this.state = constants.STATE_MACHINE_STATUS_ERROR;
+          return this.dispatch(constants.STATE_MACHINE_ACTION_HANDLE_ERROR, errors);
+        }
+      },
+      error: {
+        handleError: function (...args) {
+          let [errors] = args;
+          let result = new Messages(
+            {},
+            [],
+            [],
+            []
+          );
+          if (errors?.meta?.messages) {
+            errors.meta.messages.forEach((message) => {
+              result[message.type].push(message.message);
+              if (message.payloadReference) {
+                let payloadReferenceTokens = message.payloadReference.split('/');
+                payloadReferenceTokens.slice(1, payloadReferenceTokens.length - 1);
+                let element = result.errorFields;
+                payloadReferenceTokens.forEach((token) => {
+                  element[token] = {};
+                  element = element[token];
+                })
+                element = true;
+              }
+            });
+          } else if (errors?.errors) {
+            errors.errors.forEach((message) => {
+              result['error'].push(message.message);
+            });
+          }
+          this.state = constants.STATE_MACHINE_STATUS_IDLE;
+          return result;
+        }
+      },
+      sending: {
+        failure: function (...args) {
+          let [errors] = args;
+          this.state = constants.STATE_MACHINE_STATUS_ERROR;
+          return this.dispatch(constants.STATE_MACHINE_ACTION_HANDLE_ERROR, errors);
+        }
+      }
+    }
+  }
+
+  public dispatch(actionName, ...args) {
+    const actions = this.transitions[this.state];
+    const action = actions[actionName];
+
+    if (action) {
+      return action.apply(this, args);
+    }
+  }
+
+  public callPost(body, succ, options) {
+    let apiUrl = environment.proxyServiceBaseUrl + (window as any).wmConfig.language + environment.proxyFullAddress + environment.proxyServiceExecute;
+    return this.http.post(apiUrl, encodeURIComponent(JSON.stringify(body)), options).toPromise()
+      .then(
+        (responseObject: any) => {
+          let payload = responseObject;
+          this.state = constants.STATE_MACHINE_STATUS_FETCHING;
+          return this.dispatch(succ, payload);
+        },
+      ).catch(
+        (httpError: any) => {
+          let responseError = httpError.error;
+          if (responseError) {
+            this.state = constants.STATE_MACHINE_STATUS_FETCHING;
+            return this.dispatch(constants.STATE_MACHINE_ACTION_FAILURE, responseError);
+          } else {
+            this.state = constants.STATE_MACHINE_STATUS_IDLE;
+            throw httpError;
+          }
+        }
+      );
+  }
+}

package/cli/generate/new/angular-template/src/app/shared/types/lov.enum.ts.ejs

@@ -0,0 +1,7 @@
+<% if(visibilityCodeLOVEnums) { -%>
+    <% Object.entries(visibilityCodeLOVEnums).forEach(([enumName, enumKeys]) => { %>
+        export enum <%= enumName %> {
+            <%- [...enumKeys].join(',\n')  %>
+        }
+    <% }); %>
+<% } -%>

package/cli/generate/new/angular-template/src/app/templates/print-section/print-section.component.html

@@ -0,0 +1,5 @@
+<ds-button
+  square icon size="small"
+  (click)="print()" class="has-comments">
+  <ds-icon icon="print" class="fc-coral fs-20 fs-md-17"></ds-icon>
+</ds-button>

package/cli/generate/new/angular-template/src/app/templates/print-section/print-section.component.ts.ejs

@@ -0,0 +1,156 @@
+import {Component, CUSTOM_ELEMENTS_SCHEMA, Input, NO_ERRORS_SCHEMA} from '@angular/core';
+import printTemplate from '../print';
+import * as Constants from 'bpm-core';
+import moment from 'moment';
+import {Form} from 'bpm-core';
+import {SegmentDynamicLoaderService} from '../../shared/services/segment-dynamic-loader.service';
+import * as Handlebars from 'handlebars';
+import {I18nService} from '../../shared/services/i18n.service';
+import { DecimalPipe } from "@angular/common";
+
+@Component({
+  selector: 'app-print-section',
+  templateUrl: './print-section.component.html',
+  styleUrls: ['./print-section.component.scss'],
+  standalone: true,
+  schemas: [CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA],
+})
+export class PrintSectionComponent {
+
+  @Input() form: Form;
+
+  constructor(
+    public i18n: I18nService,
+    public segmentDynamicLoader: SegmentDynamicLoaderService,
+  ) { }
+
+  print() {
+    let compiledTemplate = null;
+    let popupWin: any;
+    popupWin = window.open('', '_blank', 'top=0,left=0,height=auto,width=auto');
+    let printObject = {
+      form: this.form,
+      i18n: this.i18n,
+      segmentDynamicLoader: this.segmentDynamicLoader,
+      lovs: this.form.lovs,
+      formId: this.form.header.formId
+    };
+
+    Handlebars.registerHelper('i18nTranslate', this.translateHelper);
+    Handlebars.registerHelper('dateFormat', this.dateFormatHelper);
+    Handlebars.registerHelper('dateFormatHelper3', this.dateFormatHelper3);
+    Handlebars.registerHelper('dateFormat2', this.dateFormatHelper2);
+    Handlebars.registerHelper('getPartialName', this.sectionIdHelper);
+    Handlebars.registerHelper('getSectionTitle', this.sectionTitleHelper);
+    Handlebars.registerHelper('consoleLog', this.consoleLog);
+    Handlebars.registerHelper('eq', this.eq);
+    Handlebars.registerHelper('getFormId', this.getFormId.bind(this));
+    Handlebars.registerHelper('getDirection', this.getDirection.bind(this));
+    Handlebars.registerHelper('and', this.and);
+    Handlebars.registerHelper('or', this.or);
+    Handlebars.registerHelper('not', this.not);
+    Handlebars.registerHelper('statusClass', this.statusClass);
+    Handlebars.registerHelper("currencyFormat", this.currencyFormat);
+
+    <% getPrintPartials().forEach(printPartial => { -%>
+      Handlebars.registerPartial(
+        "<%= printPartial.printPartialName %>",
+        printTemplate.<%= printPartial.printPartialName %>
+      );
+    <% }); -%>
+
+    compiledTemplate = Handlebars.compile(printTemplate.printTemplate);
+    popupWin.document.open();
+    popupWin.document.write(compiledTemplate(printObject));
+    popupWin.document.close();
+  }
+
+  public getCurrentLang() {
+    return this.i18n.getLanguage();
+  }
+
+  private sectionIdHelper(context: any, id: any) {
+    return context.segmentDynamicLoader.getPrintPartialName(id);
+  }
+
+  private translateHelper(key: any) {
+    return this.i18n.translate(key);
+  }
+
+  private dateFormatHelper(key: any) {
+    return moment(key).locale('en-US').format(Constants.DATE_TIME);
+  }
+
+  private dateFormatHelper2(key: any) {
+    return moment(key).locale('en-US').format(Constants.DATE_DASH);
+  }
+
+  private dateFormatHelper3(key: any) {
+    return moment(key).locale('en-US').format(Constants.DATE_SLASH);
+  }
+
+  private consoleLog(type: any) {
+    // <label>{{consolelog 'test'}}</label>
+    console.log('------------', type, '-----------------', this);
+  }
+
+  private getFormId() {
+    return this.form.header.formId;
+  }
+
+  private sectionTitleHelper(componentId: any, segmentDynamicLoader: any) {
+    return segmentDynamicLoader.getSectionName(componentId);
+  }
+
+  private eq(valueA: any, valueB: any) {
+    // {{#if (eq action.key 'MOVE')}}
+    let result = valueA === valueB;
+    return result;
+  }
+
+  private and(valueA: any, valueB: any) {
+    // {{#if (and (eq body.details.workRelation.key 'SUBCONTRACTOR')  (eq body.details.workRelation.key 'CONTRACTOR'))}}
+    let result = valueA && valueB;
+    return result;
+  }
+
+  private or(valueA: any, valueB: any) {
+    // {{#if (or (eq body.details.workRelation.key 'SUBCONTRACTOR')  (eq body.details.workRelation.key 'CONTRACTOR'))}}
+    let result = valueA || valueB;
+    return result;
+  }
+
+  private not(valueA: any, valueB: any) {
+    // {{#if (not action.key 'MOVE')}}
+    let result = valueA != valueB;
+    return result;
+  }
+
+
+  private statusClass(status: string) {
+    if (
+      status === Constants.FORM_STATUS_REJECTED || status === Constants.FORM_STATUS_CANCELLED
+      || status.toLowerCase() === 'reject' || status.toLowerCase() === 'unsatisfied' || status.toLowerCase() === 'cancel'
+    ) {
+      return 'danger';
+    } else if (status === Constants.FORM_STATUS_PENDING || status.toLowerCase() === 'pending') {
+      return 'warning';
+    } else {
+      return 'success';
+    }
+  }
+
+  private getDirection() {
+    if (this.i18n.getLanguage() === Constants.LANGUAGE_CODE_AR) {
+      return 'rtl';
+    } else {
+      return 'ltr';
+    }
+  }
+
+  private currencyFormat(value: number | string): string {
+    const decimalPipe = new DecimalPipe('en-US');
+    return decimalPipe.transform(value, '1.2-2');
+  }
+
+}