bpm-core 0.0.2 → 0.0.3

package/esm2022/lib/services/core.service.ts.mjs

@@ -0,0 +1,346 @@
+import { HttpHeaders } from "@angular/common/http";
+import { Inject, Injectable } from "@angular/core";
+import { Form, Header, Messages, MY_LIB_CONFIG_TOKEN, ProfileInfoDrop, Section, SectionHeader } from "../../public-api";
+import * as constants from '../constants';
+import { catchError, throwError } from "rxjs";
+import { map } from "rxjs/operators";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class CoreService {
+    http;
+    config;
+    apiUrl = '';
+    authToken;
+    refreshToken;
+    projectConfig;
+    userData;
+    localUser;
+    loggedInUserData;
+    constructor(http, config) {
+        this.http = http;
+        this.config = config;
+        const language = window?.wmConfig?.language ? window.wmConfig.language : 'en';
+        this.apiUrl = this.config.proxyServiceBaseUrl + language + this.config.proxyFullAddress + this.config.proxyServiceExecute;
+        console.log('Config: ', this.config); // for testing purposes only
+        this.localUser = {
+            "formPrefix": "CEP",
+            "formId": "CEP5595432",
+            "inboxUri": "\/group\/hub\/inbox",
+            "baseUrl": "\/group\/i-gate\/wm-bpm\/forms\/-\/proxy",
+            "showPrint": true,
+            "language": "en",
+            "isMobile": true,
+            "outlook": false,
+            "loggedInUserEmail": "ibrahimmaa.c@stc.com.sa"
+        };
+        this.projectConfig = (this.config.production) ? window['wmConfig'] : btoa(JSON.stringify(this.localUser));
+        this.userData = JSON.parse(atob(this.projectConfig));
+    }
+    getLoggedInUserData() {
+        let loggedInEmail = this.loggedInUserId();
+        this.employeeProfile(loggedInEmail).subscribe((response) => {
+            this.loggedInUserData = response?.["Users"]?.[0];
+            console.log('getLoggedInUserData', response);
+        });
+    }
+    loadForm() {
+        const authUrl = this.buildAuthUrl();
+        return this.http.get(authUrl, { observe: 'response' }).toPromise()
+            .then((res) => {
+            const tokenInformation = res.body;
+            this.authToken = tokenInformation.token;
+            this.getLoggedInUserData();
+            this.refreshToken = tokenInformation.refreshToken;
+            const body = this.buildBody();
+            const options = this.getRequestOptions();
+            return this.callPost(body, options);
+        })
+            .catch((httpError) => {
+            return throwError(httpError);
+        });
+    }
+    buildAuthUrl() {
+        const baseUrl = this.config.proxyServiceBaseUrl;
+        const language = window?.wmConfig?.language ? window.wmConfig.language : 'en';
+        const fullAddress = this.config.proxyFullAddress;
+        const authPart = this.config.proxyServiceAuthorization;
+        return `${baseUrl}${language}${fullAddress}${authPart}?ts=${(new Date()).valueOf()}`;
+    }
+    buildBody() {
+        const baseBody = {
+            method: constants.HTTP_METHOD_GET,
+            destination: constants.TARGET_SERVER_WM,
+            serviceName: constants.SERVICE_NAME_WM_FORM,
+            formName: this.config.formName,
+            formId: "",
+            queryParameters: null
+        };
+        if (!this.config.formId) {
+            delete baseBody.formId;
+        }
+        else {
+            baseBody.formId = this.config.formId;
+        }
+        return baseBody;
+    }
+    employeeProfile(employeeEmail) {
+        let body = {
+            method: "GET",
+            formName: "AAI",
+            destination: "DP",
+            serviceName: "igate.users.search.v3",
+            parameters: {
+                q: employeeEmail
+            }
+        };
+        return this.http.post(this.apiUrl, body, {
+            headers: new HttpHeaders({
+                authToken: this.authToken,
+                "Content-Type": "application/x-www-form-urlencoded"
+            }),
+            observe: "body"
+        }).pipe(map((response) => {
+            return response;
+        }), catchError((err) => {
+            return throwError(err);
+        }));
+    }
+    getRequestOptions() {
+        return {
+            headers: new HttpHeaders({
+                authToken: this.authToken,
+                'Content-Type': constants.HEADER_CONTENT_TYPE_FORM
+            }),
+            observe: 'body'
+        };
+    }
+    callPost(body, options) {
+        const language = window?.wmConfig?.language ? window.wmConfig.language : "en";
+        let apiUrl = this.config.proxyServiceBaseUrl + language + this.config.proxyFullAddress + this.config.proxyServiceExecute;
+        return this.http.post(apiUrl, encodeURIComponent(JSON.stringify(body)), options).toPromise()
+            .then((responseObject) => {
+            // let payload = responseObject.body;
+            return this.successWm(responseObject);
+        }).catch((httpError) => {
+            return throwError(httpError);
+        });
+    }
+    successWm(...args) {
+        let [payload] = args;
+        // let wasSendBack = false;
+        /* Convert into Form Object */
+        let result = new Form(constants.NO_VALUE, constants.NO_VALUE, constants.NO_VALUE, constants.NO_VALUE, constants.NO_VALUE, constants.NO_VALUE, constants.NO_VALUE);
+        /* Generate Header Object */
+        let payloadFormDetails = payload.data.form;
+        let isReadOnly = (payloadFormDetails.readOnly.toUpperCase() === constants.TRUE_STRING ? constants.TRUE_BOOL : (payloadFormDetails.readOnly.toUpperCase() === constants.FALSE_STRING ? constants.FALSE_BOOL : constants.NO_VALUE));
+        result.header = new Header(payload.data['requester'].fullName, constants.IGATE_STATIC_ASSET_PROFILE_PHOTO_URL + payload.data['requester'].employeeEmail, (payloadFormDetails.formId ? payloadFormDetails.formId : constants.DONT_SHOW), (payloadFormDetails.creationDate ? payloadFormDetails.creationDate : constants.DONT_SHOW), payloadFormDetails['formStatus'], payloadFormDetails.details);
+        /* Generate Profile Information Object */
+        let payloadProfileInfo = payload.data['requester'];
+        result.profileInfoDrop = new ProfileInfoDrop((payloadProfileInfo.onBehalfAuthorized ? JSON.parse(payloadProfileInfo.onBehalfAuthorized) : null), payloadProfileInfo['employeeId'], payloadProfileInfo.employeeEmail, payloadProfileInfo.fullName, payloadProfileInfo.generalDepartmentName, payloadProfileInfo.jobPosition, payloadProfileInfo.sectorName, payloadProfileInfo.departmentName, payloadProfileInfo.generalDepartmentCode, payloadProfileInfo['humanResourceLocation'], payloadProfileInfo.nationality, payloadProfileInfo.businessPhone, payloadProfileInfo.directManagerName, payloadProfileInfo.seniorSectorName);
+        /* Generate Sections Object */
+        result.sections = [];
+        /* Push as first object the section for the request details */
+        let requestDetailsHasComment = false;
+        if (payload.data.request.details.comment) {
+            requestDetailsHasComment = true;
+        }
+        result.sections.push(new Section(constants.SECTION_ID_REQUEST_DETAILS, new SectionHeader(constants.DONT_SHOW, constants.DONT_SHOW, constants.DONT_SHOW, constants.DONT_SHOW, constants.DONT_SHOW, constants.DONT_SHOW, constants.DONT_SHOW, requestDetailsHasComment, (payload.data['workflowSteps'] ? constants.READ_ONLY : isReadOnly)), payload.data.request));
+        /*   if (result.header.formId) {
+             result.commentsDrop = (!result.commentsDrop ? [] : result.commentsDrop);
+             this.dispatch(constants.STATE_MACHINE_ACTION_LOAD_HISTORY, result.header.formId).then((responseObject: any) => {
+               if (responseObject) {
+                 responseObject.items.forEach((item: any) => {
+                   if (item.sequenceNumber !== '0' && item.processedBy) {
+                     const name = item.processedBy.firstName + ' ' + item.processedBy.secondMiddleName + ' ' + item.processedBy.familyName;
+                     result.commentsDrop.push(new CommentsDrop(
+                       constants.IGATE_STATIC_ASSET_PROFILE_PHOTO_URL + item.processedBy.email,
+                       name,
+                       item.comments,
+                       item.modifiedDate,
+                       item.attachments,
+                       item.processedBy.job
+                     ));
+                   }
+                 });
+               }
+             });
+           }
+           if (result.header.formId && /^DYL/.test(result.header.formId)) {
+             this.state = constants.STATE_MACHINE_STATUS_IDLE;
+             result.confidentialComments = [];
+             this.dispatch('loadConfidentialComments', result.header.formId).then((responseObject: any) => {
+               if (responseObject && responseObject.items && responseObject.items.length > 0) {
+                 responseObject.items.forEach((item: any) => {
+                   result.confidentialComments.push(new CommentsDrop(
+                     constants.IGATE_STATIC_ASSET_PROFILE_PHOTO_URL + item.email,
+                     item.name,
+                     item.comment,
+                     item.modifiedDate,
+                     item.attachment,
+                     item.position
+                   ));
+                 })
+               }
+             });
+           }
+    
+           const inboxType = this.getInboxType(result);
+           if (result.header.formId && (!this.isOpenOnInbox())) {
+             this.state = constants.STATE_MACHINE_STATUS_IDLE;
+             this.dispatch(constants.STATE_MACHINE_ACTION_GET_INBOX_ITEM, result.header.formId, inboxType).then((responseObject) => {
+               if (responseObject) {
+                 const item = responseObject.item;
+                 result.inboxItem = new InboxItem(
+                   item.flagging.flagPriority,
+                   item.flagging.isFlagged,
+                   item.feedback.canRequestFeedback,
+                   item.feedback.hasFeedback,
+                   item.feedback.isPending,
+                   item.feedback.isRequested,
+                   item.feedback.isResponded
+                 );
+               }
+             });
+           }
+    
+           let payloadWorkflowSteps = payload.data.workflowSteps;
+           if (payloadWorkflowSteps && payloadWorkflowSteps.constructor === Array && payloadWorkflowSteps.length > 0) {
+             payloadWorkflowSteps.forEach((step, index) => {
+               let currentIsRequesterSendBack = JSON.stringify(step.details) === JSON.stringify({});
+               let hasComments = (!currentIsRequesterSendBack && (step.details.comment || step.comment) ? constants.HAS_COMMENTS : constants.NO_COMMENTS);
+               let currentActor = (step.actor.email === step.actor.recipient.email ? step.actor.recipient : (step.actor.delegate ? step.actor.delegate : null))
+               if (hasComments) {
+                 result.commentsDrop = (!result.commentsDrop ? [] : result.commentsDrop);
+                 if (step.details.attachment && step.details.attachment.attachmentId && this.config.production) {
+                   this.state = constants.STATE_MACHINE_STATUS_IDLE;
+                   this.dispatch(constants.STATE_MACHINE_ACTION_LOAD_FILE, step.details.attachment.attachmentId).then((responseObject) => {
+                     let fileInformation = responseObject.body;
+                     if (currentActor) {
+                       /!*this.dispatch(constants.STATE_MACHINE_ACTION_EMPLOYEE_PROFILE, currentActor.email).then((profile) => {
+                         result.commentsDrop.push(new CommentsDrop(
+                           constants.IGATE_STATIC_ASSET_PROFILE_PHOTO_URL + currentActor.email,
+                           currentActor.name,
+                           (step.details.comment ? step.details.comment : (step.comment ? step.comment : null)),
+                           step.date,
+                           fileInformation.fileName + "|data:" + fileInformation.mimeType + ";base64," + fileInformation.fileContents,
+                           profile.job.name
+                         ))
+                       })*!/
+                     }
+                   });
+                   this.state = constants.STATE_MACHINE_STATUS_FETCHING;
+                 } else if (step.details.attachmentId) {
+                   this.state = constants.STATE_MACHINE_STATUS_IDLE;
+                   this.dispatch(constants.STATE_MACHINE_ACTION_LOAD_FILE, step.details.attchmentId).then((responseObject) => {
+                     let fileInformation = responseObject.body;
+                     if (currentActor) {
+                       /!*this.dispatch(constants.STATE_MACHINE_ACTION_EMPLOYEE_PROFILE, currentActor.email).then((profile) => {
+                         result.commentsDrop.push(new CommentsDrop(
+                           constants.IGATE_STATIC_ASSET_PROFILE_PHOTO_URL + currentActor.email,
+                           currentActor.name,
+                           (step.details.comment ? step.details.comment : (step.comment ? step.comment : null)),
+                           step.date,
+                           fileInformation.fileName + "|data:" + fileInformation.mimeType + ";base64," + fileInformation.fileContents,
+                           profile.job.name
+                         ))
+                       })*!/
+                     }
+                   });
+                   this.state = constants.STATE_MACHINE_STATUS_FETCHING;
+                 } else {
+                   if (currentActor) {
+                     this.state = constants.STATE_MACHINE_STATUS_IDLE;
+                     /!*this.dispatch(constants.STATE_MACHINE_ACTION_EMPLOYEE_PROFILE, currentActor.email).then((profile) => {
+                       result.commentsDrop.push(new CommentsDrop(
+                         constants.IGATE_STATIC_ASSET_PROFILE_PHOTO_URL + currentActor.email,
+                         currentActor.name,
+                         (step.details.comment ? step.details.comment : (step.comment ? step.comment : null)),
+                         step.date,
+                         null,
+                         profile.job.name
+                       ))
+                     })*!/
+                   }
+                   this.state = constants.STATE_MACHINE_STATUS_FETCHING;
+                 }
+               }
+    
+               if (wasSendBack && step.actor.recipient.role === 'REQUESTER') {
+                 console.log("wasSendBack && REQUESTER")
+                 result.sections = [new Section(
+                   constants.SECTION_ID_REQUEST_DETAILS,
+                   new SectionHeader(
+                     constants.DONT_SHOW,
+                     constants.DONT_SHOW,
+                     constants.DONT_SHOW,
+                     constants.DONT_SHOW,
+                     constants.DONT_SHOW,
+                     constants.DONT_SHOW,
+                     constants.DONT_SHOW,
+                     requestDetailsHasComment,
+                     (payload.data.workflowSteps ? constants.READ_ONLY : isReadOnly)
+                   ),
+                   payload.data.request
+                 )]
+               } else if (wasSendBack) {
+                 console.log("Pop")
+                 if (result.sections.length > 1) {
+                   result.sections.pop();
+                 }
+                 wasSendBack = false;
+               }
+               if (step.details.decision && step.details.decision.key === constants.FORM_STATUS_SEND_BACK) {
+                 wasSendBack = true;
+               } else if (JSON.stringify(step.details) !== JSON.stringify({})) {
+                 result.sections.push(
+                   new Section(
+                     step.actor.recipient.role.toLowerCase() + constants.SECTION_ID_APPROVAL_PARTIAL_NAME,
+                     new SectionHeader(
+                       (currentActor ? this.getShortName(currentActor.name) : null),
+                       step.date,
+                       this.getShortName(step.actor.recipient.name),
+                       constants.IGATE_STATIC_ASSET_PROFILE_PHOTO_URL + step.actor.recipient.email,
+                       (step.actor.delegate && step.actor.delegate.name ? this.getShortName(step.actor.delegate.name) : null),
+                       (step.actor.delegate && step.actor.delegate.email ? constants.IGATE_STATIC_ASSET_PROFILE_PHOTO_URL + step.actor.delegate.email : null),
+                       step.actor.status,
+                       hasComments,
+                       (index < payloadWorkflowSteps.length - 1 ? constants.READ_ONLY : isReadOnly)
+                     ),
+                     {details: step.details, processingDate: step.date}
+                   )
+                 );
+                 this.currentSubmitter = {actor: step.actor, recipient: step.recipient, delegate: step.actor.delegate};
+               }
+             });
+           }
+       */
+        /* Create Lov Sections */
+        result.lovs = (payload.meta && payload.meta.lovs ? payload.meta.lovs : null);
+        if (payload.meta && payload.meta.messages) {
+            result.messages = new Messages({}, [], [], []);
+            payload.meta.messages.forEach((message) => {
+                result.messages.originalMsgs.push(message);
+                result.messages[message.type].push(message.message);
+            });
+        }
+        // result.messages = (payload.meta && payload.meta.messages ? payload.meta.messages : null);
+        /* Fix last section to be the RO/WM from the variable */
+        result.sections[result.sections.length - 1].header.readOnly = isReadOnly;
+        return result;
+    }
+    loggedInUserId() {
+        return this.userData['loggedInUserEmail'];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CoreService, deps: [{ token: i1.HttpClient }, { token: MY_LIB_CONFIG_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CoreService, providedIn: "any" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CoreService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "any"
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MY_LIB_CONFIG_TOKEN]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core.service.ts.js","sourceRoot":"","sources":["../../../../../projects/bpm-core/src/lib/services/core.service.ts.ts"],"names":[],"mappings":"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","sourcesContent":["import {HttpClient, HttpHeaders} from \"@angular/common/http\";\r\nimport {Inject, Injectable} from \"@angular/core\";\r\nimport type {MyLibConfig} from \"../interfaces/shared.interface\";\r\nimport {Form, Header, Messages, MY_LIB_CONFIG_TOKEN, ProfileInfoDrop, Section, SectionHeader} from \"../../public-api\";\r\nimport * as constants from '../constants'\r\nimport {catchError, throwError} from \"rxjs\";\r\nimport {map} from \"rxjs/operators\";\r\n\r\n@Injectable({\r\n  providedIn: \"any\"\r\n})\r\nexport class CoreService {\r\n  apiUrl: string = ''\r\n  private authToken: string;\r\n  private refreshToken: string;\r\n  private readonly projectConfig: string;\r\n  public userData: string;\r\n  private readonly localUser: {};\r\n  public loggedInUserData: {  };\r\n\r\n\r\n  constructor(private http: HttpClient,\r\n              @Inject(MY_LIB_CONFIG_TOKEN) private config: MyLibConfig) {\r\n    const language = (window as any)?.wmConfig?.language ? (window as any).wmConfig.language : 'en';\r\n    this.apiUrl = this.config.proxyServiceBaseUrl + language + this.config.proxyFullAddress + this.config.proxyServiceExecute;\r\n    console.log('Config: ', this.config); // for testing purposes only\r\n    this.localUser = {\r\n      \"formPrefix\": \"CEP\",\r\n      \"formId\": \"CEP5595432\",\r\n      \"inboxUri\": \"\\/group\\/hub\\/inbox\",\r\n      \"baseUrl\": \"\\/group\\/i-gate\\/wm-bpm\\/forms\\/-\\/proxy\",\r\n      \"showPrint\": true,\r\n      \"language\": \"en\",\r\n      \"isMobile\": true,\r\n      \"outlook\": false,\r\n      \"loggedInUserEmail\": \"ibrahimmaa.c@stc.com.sa\"\r\n    }\r\n    this.projectConfig = (this.config.production) ? (window as any)['wmConfig'] : btoa(JSON.stringify(this.localUser));\r\n    this.userData = JSON.parse(atob(this.projectConfig));\r\n  }\r\n\r\n  getLoggedInUserData() {\r\n    let loggedInEmail = this.loggedInUserId()\r\n    this.employeeProfile(loggedInEmail).subscribe((response: any) => {\r\n      this.loggedInUserData = response?.[\"Users\"]?.[0]\r\n      console.log('getLoggedInUserData', response)\r\n    })\r\n  }\r\n\r\n  loadForm() {\r\n    const authUrl = this.buildAuthUrl();\r\n    return this.http.get(authUrl, {observe: 'response'}).toPromise()\r\n      .then((res: any) => {\r\n        const tokenInformation = res.body;\r\n        this.authToken = tokenInformation.token;\r\n        this.getLoggedInUserData()\r\n        this.refreshToken = tokenInformation.refreshToken;\r\n        const body = this.buildBody();\r\n        const options = this.getRequestOptions();\r\n        return this.callPost(body, options);\r\n      })\r\n      .catch((httpError: any) => {\r\n        return throwError(httpError);\r\n      });\r\n  }\r\n\r\n  private buildAuthUrl(): string {\r\n    const baseUrl = this.config.proxyServiceBaseUrl;\r\n    const language = (window as any)?.wmConfig?.language ? (window as any).wmConfig.language : 'en';\r\n    const fullAddress = this.config.proxyFullAddress;\r\n    const authPart = this.config.proxyServiceAuthorization;\r\n    return `${baseUrl}${language}${fullAddress}${authPart}?ts=${(new Date()).valueOf()}`;\r\n  }\r\n\r\n  private buildBody(): object {\r\n    const baseBody = {\r\n      method: constants.HTTP_METHOD_GET,\r\n      destination: constants.TARGET_SERVER_WM,\r\n      serviceName: constants.SERVICE_NAME_WM_FORM,\r\n      formName: this.config.formName,\r\n      formId: \"\",\r\n      queryParameters: null\r\n    };\r\n    if (!this.config.formId) {\r\n      delete baseBody.formId;\r\n    } else {\r\n      baseBody.formId = this.config.formId;\r\n    }\r\n    return baseBody;\r\n  }\r\n\r\n  employeeProfile(employeeEmail: any) {\r\n    let body = {\r\n      method: \"GET\",\r\n      formName: \"AAI\",\r\n      destination: \"DP\",\r\n      serviceName: \"igate.users.search.v3\",\r\n      parameters: {\r\n        q: employeeEmail\r\n      }\r\n    };\r\n    return this.http.post(this.apiUrl, body, {\r\n      headers: new HttpHeaders({\r\n        authToken: this.authToken,\r\n        \"Content-Type\": \"application/x-www-form-urlencoded\"\r\n      }),\r\n      observe: \"body\"\r\n    }).pipe(\r\n      map((response: any) => {\r\n        return response\r\n      })\r\n      , catchError((err: any) => {\r\n        return throwError(err)\r\n      }));\r\n  }\r\n\r\n  private getRequestOptions() {\r\n    return {\r\n      headers: new HttpHeaders({\r\n        authToken: this.authToken,\r\n        'Content-Type': constants.HEADER_CONTENT_TYPE_FORM\r\n      }),\r\n      observe: 'body'\r\n    }\r\n  }\r\n\r\n  private callPost(body, options) {\r\n    const language = (window as any)?.wmConfig?.language ? (window as any).wmConfig.language : \"en\";\r\n    let apiUrl = this.config.proxyServiceBaseUrl + language + this.config.proxyFullAddress + this.config.proxyServiceExecute;\r\n    return this.http.post(apiUrl, encodeURIComponent(JSON.stringify(body)), options).toPromise()\r\n      .then(\r\n        (responseObject: any) => {\r\n          // let payload = responseObject.body;\r\n          return this.successWm(responseObject)\r\n        },\r\n      ).catch(\r\n        (httpError: any) => {\r\n          return throwError(httpError)\r\n        }\r\n      );\r\n  }\r\n\r\n  successWm(...args) {\r\n    let [payload] = args;\r\n    // let wasSendBack = false;\r\n    /* Convert into Form Object */\r\n    let result = new Form(\r\n      constants.NO_VALUE,\r\n      constants.NO_VALUE,\r\n      constants.NO_VALUE,\r\n      constants.NO_VALUE,\r\n      constants.NO_VALUE,\r\n      constants.NO_VALUE,\r\n      constants.NO_VALUE\r\n    );\r\n    /* Generate Header Object */\r\n    let payloadFormDetails = payload.data.form;\r\n    let isReadOnly = (payloadFormDetails.readOnly.toUpperCase() === constants.TRUE_STRING ? constants.TRUE_BOOL : (payloadFormDetails.readOnly.toUpperCase() === constants.FALSE_STRING ? constants.FALSE_BOOL : constants.NO_VALUE))\r\n    result.header = new Header(\r\n      payload.data['requester'].fullName,\r\n      constants.IGATE_STATIC_ASSET_PROFILE_PHOTO_URL + payload.data['requester'].employeeEmail,\r\n      (payloadFormDetails.formId ? payloadFormDetails.formId : constants.DONT_SHOW),\r\n      (payloadFormDetails.creationDate ? payloadFormDetails.creationDate : constants.DONT_SHOW),\r\n      payloadFormDetails['formStatus'],\r\n      payloadFormDetails.details\r\n    );\r\n    /* Generate Profile Information Object */\r\n    let payloadProfileInfo = payload.data['requester'];\r\n    result.profileInfoDrop = new ProfileInfoDrop(\r\n      (payloadProfileInfo.onBehalfAuthorized ? JSON.parse(payloadProfileInfo.onBehalfAuthorized) : null),\r\n      payloadProfileInfo['employeeId'],\r\n      payloadProfileInfo.employeeEmail,\r\n      payloadProfileInfo.fullName,\r\n      payloadProfileInfo.generalDepartmentName,\r\n      payloadProfileInfo.jobPosition,\r\n      payloadProfileInfo.sectorName,\r\n      payloadProfileInfo.departmentName,\r\n      payloadProfileInfo.generalDepartmentCode,\r\n      payloadProfileInfo['humanResourceLocation'],\r\n      payloadProfileInfo.nationality,\r\n      payloadProfileInfo.businessPhone,\r\n      payloadProfileInfo.directManagerName,\r\n      payloadProfileInfo.seniorSectorName\r\n    );\r\n    /* Generate Sections Object */\r\n    result.sections = [];\r\n    /* Push as first object the section for the request details */\r\n    let requestDetailsHasComment = false;\r\n    if (payload.data.request.details.comment) {\r\n      requestDetailsHasComment = true;\r\n    }\r\n    result.sections.push(\r\n      new Section(\r\n        constants.SECTION_ID_REQUEST_DETAILS,\r\n        new SectionHeader(\r\n          constants.DONT_SHOW,\r\n          constants.DONT_SHOW,\r\n          constants.DONT_SHOW,\r\n          constants.DONT_SHOW,\r\n          constants.DONT_SHOW,\r\n          constants.DONT_SHOW,\r\n          constants.DONT_SHOW,\r\n          requestDetailsHasComment,\r\n          (payload.data['workflowSteps'] ? constants.READ_ONLY : isReadOnly)\r\n        ),\r\n        payload.data.request\r\n      )\r\n    );\r\n\r\n    /*   if (result.header.formId) {\r\n         result.commentsDrop = (!result.commentsDrop ? [] : result.commentsDrop);\r\n         this.dispatch(constants.STATE_MACHINE_ACTION_LOAD_HISTORY, result.header.formId).then((responseObject: any) => {\r\n           if (responseObject) {\r\n             responseObject.items.forEach((item: any) => {\r\n               if (item.sequenceNumber !== '0' && item.processedBy) {\r\n                 const name = item.processedBy.firstName + ' ' + item.processedBy.secondMiddleName + ' ' + item.processedBy.familyName;\r\n                 result.commentsDrop.push(new CommentsDrop(\r\n                   constants.IGATE_STATIC_ASSET_PROFILE_PHOTO_URL + item.processedBy.email,\r\n                   name,\r\n                   item.comments,\r\n                   item.modifiedDate,\r\n                   item.attachments,\r\n                   item.processedBy.job\r\n                 ));\r\n               }\r\n             });\r\n           }\r\n         });\r\n       }\r\n       if (result.header.formId && /^DYL/.test(result.header.formId)) {\r\n         this.state = constants.STATE_MACHINE_STATUS_IDLE;\r\n         result.confidentialComments = [];\r\n         this.dispatch('loadConfidentialComments', result.header.formId).then((responseObject: any) => {\r\n           if (responseObject && responseObject.items && responseObject.items.length > 0) {\r\n             responseObject.items.forEach((item: any) => {\r\n               result.confidentialComments.push(new CommentsDrop(\r\n                 constants.IGATE_STATIC_ASSET_PROFILE_PHOTO_URL + item.email,\r\n                 item.name,\r\n                 item.comment,\r\n                 item.modifiedDate,\r\n                 item.attachment,\r\n                 item.position\r\n               ));\r\n             })\r\n           }\r\n         });\r\n       }\r\n\r\n       const inboxType = this.getInboxType(result);\r\n       if (result.header.formId && (!this.isOpenOnInbox())) {\r\n         this.state = constants.STATE_MACHINE_STATUS_IDLE;\r\n         this.dispatch(constants.STATE_MACHINE_ACTION_GET_INBOX_ITEM, result.header.formId, inboxType).then((responseObject) => {\r\n           if (responseObject) {\r\n             const item = responseObject.item;\r\n             result.inboxItem = new InboxItem(\r\n               item.flagging.flagPriority,\r\n               item.flagging.isFlagged,\r\n               item.feedback.canRequestFeedback,\r\n               item.feedback.hasFeedback,\r\n               item.feedback.isPending,\r\n               item.feedback.isRequested,\r\n               item.feedback.isResponded\r\n             );\r\n           }\r\n         });\r\n       }\r\n\r\n       let payloadWorkflowSteps = payload.data.workflowSteps;\r\n       if (payloadWorkflowSteps && payloadWorkflowSteps.constructor === Array && payloadWorkflowSteps.length > 0) {\r\n         payloadWorkflowSteps.forEach((step, index) => {\r\n           let currentIsRequesterSendBack = JSON.stringify(step.details) === JSON.stringify({});\r\n           let hasComments = (!currentIsRequesterSendBack && (step.details.comment || step.comment) ? constants.HAS_COMMENTS : constants.NO_COMMENTS);\r\n           let currentActor = (step.actor.email === step.actor.recipient.email ? step.actor.recipient : (step.actor.delegate ? step.actor.delegate : null))\r\n           if (hasComments) {\r\n             result.commentsDrop = (!result.commentsDrop ? [] : result.commentsDrop);\r\n             if (step.details.attachment && step.details.attachment.attachmentId && this.config.production) {\r\n               this.state = constants.STATE_MACHINE_STATUS_IDLE;\r\n               this.dispatch(constants.STATE_MACHINE_ACTION_LOAD_FILE, step.details.attachment.attachmentId).then((responseObject) => {\r\n                 let fileInformation = responseObject.body;\r\n                 if (currentActor) {\r\n                   /!*this.dispatch(constants.STATE_MACHINE_ACTION_EMPLOYEE_PROFILE, currentActor.email).then((profile) => {\r\n                     result.commentsDrop.push(new CommentsDrop(\r\n                       constants.IGATE_STATIC_ASSET_PROFILE_PHOTO_URL + currentActor.email,\r\n                       currentActor.name,\r\n                       (step.details.comment ? step.details.comment : (step.comment ? step.comment : null)),\r\n                       step.date,\r\n                       fileInformation.fileName + \"|data:\" + fileInformation.mimeType + \";base64,\" + fileInformation.fileContents,\r\n                       profile.job.name\r\n                     ))\r\n                   })*!/\r\n                 }\r\n               });\r\n               this.state = constants.STATE_MACHINE_STATUS_FETCHING;\r\n             } else if (step.details.attachmentId) {\r\n               this.state = constants.STATE_MACHINE_STATUS_IDLE;\r\n               this.dispatch(constants.STATE_MACHINE_ACTION_LOAD_FILE, step.details.attchmentId).then((responseObject) => {\r\n                 let fileInformation = responseObject.body;\r\n                 if (currentActor) {\r\n                   /!*this.dispatch(constants.STATE_MACHINE_ACTION_EMPLOYEE_PROFILE, currentActor.email).then((profile) => {\r\n                     result.commentsDrop.push(new CommentsDrop(\r\n                       constants.IGATE_STATIC_ASSET_PROFILE_PHOTO_URL + currentActor.email,\r\n                       currentActor.name,\r\n                       (step.details.comment ? step.details.comment : (step.comment ? step.comment : null)),\r\n                       step.date,\r\n                       fileInformation.fileName + \"|data:\" + fileInformation.mimeType + \";base64,\" + fileInformation.fileContents,\r\n                       profile.job.name\r\n                     ))\r\n                   })*!/\r\n                 }\r\n               });\r\n               this.state = constants.STATE_MACHINE_STATUS_FETCHING;\r\n             } else {\r\n               if (currentActor) {\r\n                 this.state = constants.STATE_MACHINE_STATUS_IDLE;\r\n                 /!*this.dispatch(constants.STATE_MACHINE_ACTION_EMPLOYEE_PROFILE, currentActor.email).then((profile) => {\r\n                   result.commentsDrop.push(new CommentsDrop(\r\n                     constants.IGATE_STATIC_ASSET_PROFILE_PHOTO_URL + currentActor.email,\r\n                     currentActor.name,\r\n                     (step.details.comment ? step.details.comment : (step.comment ? step.comment : null)),\r\n                     step.date,\r\n                     null,\r\n                     profile.job.name\r\n                   ))\r\n                 })*!/\r\n               }\r\n               this.state = constants.STATE_MACHINE_STATUS_FETCHING;\r\n             }\r\n           }\r\n\r\n           if (wasSendBack && step.actor.recipient.role === 'REQUESTER') {\r\n             console.log(\"wasSendBack && REQUESTER\")\r\n             result.sections = [new Section(\r\n               constants.SECTION_ID_REQUEST_DETAILS,\r\n               new SectionHeader(\r\n                 constants.DONT_SHOW,\r\n                 constants.DONT_SHOW,\r\n                 constants.DONT_SHOW,\r\n                 constants.DONT_SHOW,\r\n                 constants.DONT_SHOW,\r\n                 constants.DONT_SHOW,\r\n                 constants.DONT_SHOW,\r\n                 requestDetailsHasComment,\r\n                 (payload.data.workflowSteps ? constants.READ_ONLY : isReadOnly)\r\n               ),\r\n               payload.data.request\r\n             )]\r\n           } else if (wasSendBack) {\r\n             console.log(\"Pop\")\r\n             if (result.sections.length > 1) {\r\n               result.sections.pop();\r\n             }\r\n             wasSendBack = false;\r\n           }\r\n           if (step.details.decision && step.details.decision.key === constants.FORM_STATUS_SEND_BACK) {\r\n             wasSendBack = true;\r\n           } else if (JSON.stringify(step.details) !== JSON.stringify({})) {\r\n             result.sections.push(\r\n               new Section(\r\n                 step.actor.recipient.role.toLowerCase() + constants.SECTION_ID_APPROVAL_PARTIAL_NAME,\r\n                 new SectionHeader(\r\n                   (currentActor ? this.getShortName(currentActor.name) : null),\r\n                   step.date,\r\n                   this.getShortName(step.actor.recipient.name),\r\n                   constants.IGATE_STATIC_ASSET_PROFILE_PHOTO_URL + step.actor.recipient.email,\r\n                   (step.actor.delegate && step.actor.delegate.name ? this.getShortName(step.actor.delegate.name) : null),\r\n                   (step.actor.delegate && step.actor.delegate.email ? constants.IGATE_STATIC_ASSET_PROFILE_PHOTO_URL + step.actor.delegate.email : null),\r\n                   step.actor.status,\r\n                   hasComments,\r\n                   (index < payloadWorkflowSteps.length - 1 ? constants.READ_ONLY : isReadOnly)\r\n                 ),\r\n                 {details: step.details, processingDate: step.date}\r\n               )\r\n             );\r\n             this.currentSubmitter = {actor: step.actor, recipient: step.recipient, delegate: step.actor.delegate};\r\n           }\r\n         });\r\n       }\r\n   */\r\n    /* Create Lov Sections */\r\n    result.lovs = (payload.meta && payload.meta.lovs ? payload.meta.lovs : null);\r\n\r\n    if (payload.meta && payload.meta.messages) {\r\n      result.messages = new Messages(\r\n        {},\r\n        [],\r\n        [],\r\n        []\r\n      );\r\n      payload.meta.messages.forEach((message) => {\r\n        result.messages.originalMsgs.push(message);\r\n        result.messages[message.type].push(message.message);\r\n      });\r\n    }\r\n\r\n    // result.messages = (payload.meta && payload.meta.messages ? payload.meta.messages : null);\r\n    /* Fix last section to be the RO/WM from the variable */\r\n    result.sections[result.sections.length - 1].header.readOnly = isReadOnly;\r\n    return result;\r\n  }\r\n\r\n  public loggedInUserId() {\r\n    return this.userData['loggedInUserEmail'];\r\n  }\r\n\r\n}\r\n"]}

package/esm2022/public-api.mjs

@@ -2,6 +2,7 @@
  * Public API Surface of bpm-core
  */
 import { InjectionToken } from '@angular/core';
+export * from './lib/app/app.component';
 export * from './lib/components/shared-components';
 export * from './lib/components/app-component-sections';
 export * from './lib/pipes';
@@ -13,4 +14,4 @@ export * from './lib/hooks';
 export * from './lib/functions';
 export * from './lib/validators';
 export const MY_LIB_CONFIG_TOKEN = new InjectionToken('MyLibConfig');
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2JwbS1jb3JlL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUkvQyxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxrQkFBa0IsQ0FBQztBQUdqQyxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxJQUFJLGNBQWMsQ0FBYyxhQUFhLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXHJcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBicG0tY29yZVxyXG4gKi9cclxuaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHtNeUxpYkNvbmZpZ30gZnJvbSBcIi4vbGliL2ludGVyZmFjZXMvc2hhcmVkLmludGVyZmFjZVwiO1xyXG5cclxuXHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvc2hhcmVkLWNvbXBvbmVudHMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2FwcC1jb21wb25lbnQtc2VjdGlvbnMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9waXBlcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2kxOG4nO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb25zdGFudHMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9pbnRlcmZhY2VzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvY2xhc3Nlcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2hvb2tzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvZnVuY3Rpb25zJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvdmFsaWRhdG9ycyc7XHJcblxyXG5cclxuZXhwb3J0IGNvbnN0IE1ZX0xJQl9DT05GSUdfVE9LRU4gPSBuZXcgSW5qZWN0aW9uVG9rZW48TXlMaWJDb25maWc+KCdNeUxpYkNvbmZpZycpO1xyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2JwbS1jb3JlL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUkvQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGtCQUFrQixDQUFDO0FBR2pDLE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFHLElBQUksY0FBYyxDQUFjLGFBQWEsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcclxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGJwbS1jb3JlXHJcbiAqL1xyXG5pbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQge015TGliQ29uZmlnfSBmcm9tIFwiLi9saWIvaW50ZXJmYWNlcy9zaGFyZWQuaW50ZXJmYWNlXCI7XHJcblxyXG5cclxuZXhwb3J0ICogZnJvbSAnLi9saWIvYXBwL2FwcC5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL3NoYXJlZC1jb21wb25lbnRzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9hcHAtY29tcG9uZW50LXNlY3Rpb25zJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvcGlwZXMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9pMThuJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29uc3RhbnRzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvaW50ZXJmYWNlcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NsYXNzZXMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9ob29rcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2Z1bmN0aW9ucyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3ZhbGlkYXRvcnMnO1xyXG5cclxuXHJcbmV4cG9ydCBjb25zdCBNWV9MSUJfQ09ORklHX1RPS0VOID0gbmV3IEluamVjdGlvblRva2VuPE15TGliQ29uZmlnPignTXlMaWJDb25maWcnKTtcclxuIl19