@uiapplib/ngx-ui-web-lib 0.0.1

package/esm2022/lib/services/claims/claims.service.mjs

@@ -0,0 +1,193 @@
+import { Injectable } from '@angular/core';
+import { LibConstants } from '../../models/LibConstants';
+import { BaseService } from '../base-service';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ClaimService extends BaseService {
+    constructor(http) {
+        super(http);
+        this.http = http;
+        this.reasonSeparation = new BehaviorSubject([]);
+        this.filteredReasonSeparation = new BehaviorSubject([]);
+        this.dischargeReasons = new BehaviorSubject([]);
+        this.quitReasons = new BehaviorSubject([]);
+        this.actionsList = new BehaviorSubject([]);
+        this.disastersList = new BehaviorSubject([]);
+        this.countyList = new BehaviorSubject([]);
+        this.countyListIncludingOutOfState = new BehaviorSubject([]);
+    }
+    setServiceContext() {
+        this.serviceContext = LibConstants.claims_service.context;
+    }
+    setServicePort() {
+        this.servicePort = LibConstants.claims_service.port;
+    }
+    setServiceProtocol() {
+        this.protocol = LibConstants.claims_service.protocol;
+    }
+    setServiceHost() {
+        this.host = LibConstants.claims_service.host;
+    }
+    getReasonSeparation() {
+        return this.reasonSeparation;
+    }
+    loadReasonSeparation() {
+        if (this.reasonSeparation.getValue().length < 1)
+            this.get('claims-master/reason-separation')
+                .subscribe(res => this.reasonSeparation.next(res));
+    }
+    clearFilteredReasonSeparation() {
+        this.filteredReasonSeparation.value.length = 0;
+    }
+    getFilteredReasonSeparation() {
+        return this.filteredReasonSeparation;
+    }
+    loadFilteredReasonSeparation(model) {
+        if (this.filteredReasonSeparation.getValue().length < 1)
+            this.post('claims-master/reason-separation/filtered', model)
+                .subscribe(res => this.filteredReasonSeparation.next(res));
+    }
+    getDischargeReasons() {
+        return this.dischargeReasons;
+    }
+    loadDischargeReasons() {
+        if (this.dischargeReasons.getValue().length < 1) {
+            this.get('claims-master/discharge-reasons')
+                .subscribe(res => this.dischargeReasons.next(res));
+        }
+    }
+    getQuitReasons() {
+        return this.quitReasons;
+    }
+    loadQuitReasons() {
+        if (this.quitReasons.getValue().length < 1) {
+            this.get('claims-master/vol-quit-reasons')
+                .subscribe(res => this.quitReasons.next(res));
+        }
+    }
+    loadMasterData() {
+        this.loadReasonSeparation();
+        this.loadDischargeReasons();
+        this.loadQuitReasons();
+    }
+    loadBasePeriodWages(clmEmpRequestModel) {
+        return this.post('claim/app/bpemployers', clmEmpRequestModel);
+    }
+    getAllowSepPreviousIssuesForSSN() {
+        return this.get('claim/csr/allow-sep-prev-issue');
+    }
+    getRequalifyLiftIssuesForSSN() {
+        return this.get('claim/csr/requalify-lift');
+    }
+    getRequalifyCriteriaEnum() {
+        if (this.actionsList.getValue().length < 1) {
+            this.get('claims-master/requalify-criteria')
+                .subscribe(res => this.actionsList.next(res));
+        }
+    }
+    getUI512AResponses() {
+        //let paramsVal = new HttpParams().set("ssn",ssnInput)
+        return this.get('claim/csr/ui512a-response');
+    }
+    fetchSSAStatusForClaimApplication(claimIdentifier) {
+        return this.get(`claim/app/${claimIdentifier}/ssa_status`);
+    }
+    reVerifySSAStatusForClaimApplication(data, claimIdentifier) {
+        return this.post(`claim/app/${claimIdentifier}/ssa_status/re-verify`, data);
+    }
+    getActionsList() {
+        return this.actionsList;
+    }
+    getPhoneNumbersForOtpByUuid(uuid) {
+        return this.get(`ln/phone-email-for-claimant/${uuid}`);
+    }
+    fetchRetroWeeks() {
+        return this.get(`claim/dua-app/retro-weeks`, null);
+    }
+    fetchListOfDisaters() {
+        return this.get('claim-utility/declaration');
+    }
+    getDisastersList() {
+        return this.disastersList;
+    }
+    loadDisastersList() {
+        if (this.disastersList.getValue().length < 1)
+            this.get('claim-utility/declaration')
+                .subscribe(res => this.disastersList.next(res));
+    }
+    getCountyList() {
+        return this.countyList;
+    }
+    getCountyIncludingOutOfStateList() {
+        return this.countyListIncludingOutOfState;
+    }
+    loadCountyList() {
+        if (this.countyList.getValue().length < 1)
+            this.get('claims-master/counties')
+                .subscribe(res => this.countyList.next(res));
+    }
+    loadCountyIncludingOutOfStateList() {
+        if (this.countyListIncludingOutOfState.getValue().length < 1)
+            this.get('claim/county-with-oos')
+                .subscribe(res => this.countyListIncludingOutOfState.next(res));
+    }
+    loadDisasterData() {
+        this.loadDisastersList();
+        this.loadCountyList();
+        this.loadCountyIncludingOutOfStateList();
+    }
+    createAndInitiateDuaRequest(model) {
+        return this.post('claim/dua-request', model);
+    }
+    saveDiasterImpactOnExistingClaimApp(model) {
+        return this.post('claim/new-application/dua-request', model);
+    }
+    getListOfActiveClaim() {
+        return this.get('claim/list-of-active-claims');
+    }
+    fetchBasePeriod() {
+        return this.get('claim-utility/baseperiod/format');
+    }
+    determineNewClaimEligibility() {
+        return this.get('claim/check-eligibility');
+    }
+    determineNewClaimEligibilityForCsr() {
+        return this.get('claim/csr/check-eligibility');
+    }
+    determineInitialClaimEligibilityForCsr() {
+        return this.get('claim/csr/check-initial-eligibility');
+    }
+    /*createAndInitiateClaimApplicationWithBackDateForCSR(model: BackDateRequestModel) {
+        return this.post<BackDateRequestModel[]>('claim/csr/new-application/backdate', model)
+    }
+
+    fetchPreviousFilledBackdateResponse() {
+        return this.get<BackDateRequestModel[]>('claim/csr/backdate-response');
+    }
+
+    fetchMaxMinForCSRBackdating() {
+        return this.get<any>('claim-utility/min-max-csr-backdate')
+    }*/
+    fetchPreviousFilledDuaResponse() {
+        return this.get('claim/dua-response');
+    }
+    saveDisasterRequestPostClaim(model) {
+        return this.post('claim/dua-request-post-claim', model);
+    }
+    createAndInitiateDuaRequestAndCheckEligibility(model) {
+        return this.post('claim/dua-request/check-eligibility', model);
+    }
+    processDuaAppPostClaim(model) {
+        return this.post('claim/apply-dua-post-claim/submit', model);
+    }
+    static { this.ɵfac = function ClaimService_Factory(t) { return new (t || ClaimService)(i0.ɵɵinject(i1.HttpClient)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ClaimService, factory: ClaimService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ClaimService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.HttpClient }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"claims.service.js","sourceRoot":"","sources":["../../../../../../projects/ngx-reusa-app-lib/src/lib/services/claims/claims.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpParams } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { LibConstants } from '../../models/LibConstants';\r\nimport { KeyValueModel } from '../../models/questionnaire/KeyValueModel';\r\nimport { BaseService } from '../base-service';\r\nimport { BehaviorSubject } from 'rxjs';\r\nimport { ChoicesModel } from '../../models/AddressComponentModel';\r\nimport { ClaimAppEmpResponseModel } from '../../models/questionnaire/ClaimAppEmpResponseModel';\r\nimport { ClaimAppEmpRequestModel } from '../../models/questionnaire/ClaimAppEmpRequestModel';\r\nimport { RequalifyLiftPageModel } from '../../models/RequalifyLiftPageModel';\r\nimport { SsaVerificationModel } from '../../models/SsaVerificationModel';\r\nimport { LexisNexisOtpDetailsResponseModel } from '../../models/LexisNexisOtpDetailsResponseModel';\r\nimport { DuaRetroWeeksComponentModel } from '../../models/DuaRetroWeeksComponentModel';\r\nimport { ReasonSeparationRequestModel } from '../../models/ReasonSeparationRequestModel';\r\nimport { CountyModel } from '../../models/CountyModel';\r\nimport { DuaRequestModel } from '../../models/DuaRequestModel';\r\nimport { ActiveClaimModel } from '../../models/ActiveClaimModel'; \r\nimport { StatusModel }  from '../../models/questionnaire/StatusModel';\r\nimport { DuaAppDataModel } from '../../models/DuaAppDataModel';\r\n\r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n  })\r\n  export class ClaimService extends BaseService{\r\n\r\n    private reasonSeparation : BehaviorSubject<ChoicesModel[]> = new BehaviorSubject([]);\r\n    private filteredReasonSeparation : BehaviorSubject<ChoicesModel[]> = new BehaviorSubject([]);\r\n    private dischargeReasons : BehaviorSubject<ChoicesModel[]> = new BehaviorSubject([]);\r\n    private quitReasons : BehaviorSubject<ChoicesModel[]> = new BehaviorSubject([]);\r\n    private actionsList : BehaviorSubject<KeyValueModel[]> = new BehaviorSubject([]);\r\n\r\n    private disastersList : BehaviorSubject<ChoicesModel[]> = new BehaviorSubject([]);\r\n    private countyList : BehaviorSubject<CountyModel[]> = new BehaviorSubject([]);\r\n    private countyListIncludingOutOfState : BehaviorSubject<CountyModel[]> = new BehaviorSubject([]);\r\n\r\n\r\n    constructor(public http : HttpClient) { \r\n      super(http);\r\n    }\r\n  \r\n    setServiceContext() {\r\n      this.serviceContext = LibConstants.claims_service.context\r\n    }\r\n    setServicePort() {\r\n      this.servicePort = LibConstants.claims_service.port;\r\n    }\r\n    setServiceProtocol() {\r\n      this.protocol = LibConstants.claims_service.protocol;\r\n    }\r\n    setServiceHost() {\r\n      this.host = LibConstants.claims_service.host;\r\n    }\r\n\r\n    getReasonSeparation(){\r\n        return this.reasonSeparation;\r\n    } \r\n    \r\n    loadReasonSeparation(){\r\n       if(this.reasonSeparation.getValue().length < 1)\r\n         this.get<ChoicesModel[]>('claims-master/reason-separation')\r\n            .subscribe(res => this.reasonSeparation.next(res));\r\n    }\r\n\r\n    clearFilteredReasonSeparation(){\r\n      this.filteredReasonSeparation.value.length = 0;\r\n    }\r\n\r\n    getFilteredReasonSeparation(){\r\n        return this.filteredReasonSeparation;\r\n    }\r\n\r\n    loadFilteredReasonSeparation(model: ReasonSeparationRequestModel){\r\n      if(this.filteredReasonSeparation.getValue().length < 1)\r\n        this.post<ChoicesModel[]>('claims-master/reason-separation/filtered', model)\r\n           .subscribe(res => this.filteredReasonSeparation.next(res));\r\n   }\r\n\r\n    getDischargeReasons(){\r\n        return this.dischargeReasons;\r\n    }\r\n\r\n    loadDischargeReasons(){\r\n        if(this.dischargeReasons.getValue().length < 1){\r\n            this.get<ChoicesModel[]>('claims-master/discharge-reasons')\r\n                .subscribe(res => this.dischargeReasons.next(res));\r\n        }\r\n    }\r\n\r\n    getQuitReasons(){\r\n        return this.quitReasons;\r\n    }\r\n\r\n    loadQuitReasons(){\r\n        if(this.quitReasons.getValue().length < 1){\r\n            this.get<ChoicesModel[]>('claims-master/vol-quit-reasons')\r\n                .subscribe(res => this.quitReasons.next(res));\r\n        }\r\n    }\r\n\r\n    loadMasterData(){\r\n        this.loadReasonSeparation();\r\n        this.loadDischargeReasons();\r\n        this.loadQuitReasons();\r\n    }\r\n\r\n    loadBasePeriodWages(clmEmpRequestModel: ClaimAppEmpRequestModel){\r\n        return this.post<ClaimAppEmpResponseModel>('claim/app/bpemployers', clmEmpRequestModel);\r\n    }\r\n\r\n    getAllowSepPreviousIssuesForSSN() {\r\n      return this.get<RequalifyLiftPageModel>('claim/csr/allow-sep-prev-issue');\r\n    }\r\n    \r\n    getRequalifyLiftIssuesForSSN(){\r\n        return this.get<RequalifyLiftPageModel>('claim/csr/requalify-lift');\r\n    }\r\n\r\n    getRequalifyCriteriaEnum() {\r\n      if(this.actionsList.getValue().length < 1){\r\n        this.get<ChoicesModel[]>('claims-master/requalify-criteria')\r\n        .subscribe(res => this.actionsList.next(res));\r\n      }\r\n    }\r\n\r\n    getUI512AResponses(){\r\n      //let paramsVal = new HttpParams().set(\"ssn\",ssnInput)\r\n      return this.get<RequalifyLiftPageModel>('claim/csr/ui512a-response');\r\n    }\r\n\r\n    fetchSSAStatusForClaimApplication(claimIdentifier : string){\r\n      return this.get<SsaVerificationModel>(`claim/app/${claimIdentifier}/ssa_status`);\r\n    }\r\n\r\n    reVerifySSAStatusForClaimApplication(data : SsaVerificationModel, claimIdentifier : string){\r\n      return this.post<SsaVerificationModel>(`claim/app/${claimIdentifier}/ssa_status/re-verify`, data);\r\n    }\r\n\r\n    getActionsList(){\r\n      return this.actionsList;\r\n    }\r\n\r\n    getPhoneNumbersForOtpByUuid(uuid: string) {\r\n      return this.get<LexisNexisOtpDetailsResponseModel>(`ln/phone-email-for-claimant/${uuid}`);\r\n    }\r\n\r\n    fetchRetroWeeks(){\r\n      return this.get<DuaRetroWeeksComponentModel>(`claim/dua-app/retro-weeks`, null);\r\n    }\r\n\r\n    fetchListOfDisaters(){\r\n      return this.get<any>('claim-utility/declaration');\r\n   }\r\n\r\n    getDisastersList(){\r\n      return this.disastersList;\r\n    } \r\n  \r\n    loadDisastersList(){\r\n      if(this.disastersList.getValue().length < 1)\r\n        this.get<ChoicesModel[]>('claim-utility/declaration')\r\n            .subscribe(res => this.disastersList.next(res));\r\n    }\r\n\r\n    getCountyList(){\r\n        return this.countyList;\r\n    } \r\n    \r\n    getCountyIncludingOutOfStateList(){\r\n      return this.countyListIncludingOutOfState;\r\n    } \r\n \r\n    loadCountyList(){\r\n      if(this.countyList.getValue().length < 1)\r\n        this.get<CountyModel[]>('claims-master/counties')\r\n            .subscribe(res => this.countyList.next(res));\r\n    }\r\n\r\n    loadCountyIncludingOutOfStateList(){\r\n      if(this.countyListIncludingOutOfState.getValue().length < 1)\r\n        this.get<CountyModel[]>('claim/county-with-oos')\r\n            .subscribe(res => this.countyListIncludingOutOfState.next(res));\r\n    }\r\n\r\n    loadDisasterData(){\r\n        this.loadDisastersList();\r\n        this.loadCountyList();\r\n        this.loadCountyIncludingOutOfStateList();\r\n    }\r\n\r\n    createAndInitiateDuaRequest(model: DuaRequestModel){\r\n      return this.post<DuaRequestModel[]>('claim/dua-request',model);\r\n    }\r\n\r\n    saveDiasterImpactOnExistingClaimApp(model: DuaRequestModel){\r\n      return this.post<DuaRequestModel[]>('claim/new-application/dua-request',model);\r\n    }\r\n\r\n    getListOfActiveClaim(){\r\n      return this.get<ActiveClaimModel[]>('claim/list-of-active-claims')\r\n    }\r\n\r\n    fetchBasePeriod(){\r\n      return this.get<string>('claim-utility/baseperiod/format');\r\n    }\r\n\r\n    determineNewClaimEligibility(){\r\n        return this.get<boolean>('claim/check-eligibility');\r\n    }\r\n\r\n    determineNewClaimEligibilityForCsr() {\r\n      return this.get<any>('claim/csr/check-eligibility');\r\n    }\r\n\r\n    determineInitialClaimEligibilityForCsr() {\r\n        return this.get<any>('claim/csr/check-initial-eligibility');\r\n    }\r\n\r\n    /*createAndInitiateClaimApplicationWithBackDateForCSR(model: BackDateRequestModel) {\r\n        return this.post<BackDateRequestModel[]>('claim/csr/new-application/backdate', model)\r\n    }\r\n\r\n    fetchPreviousFilledBackdateResponse() {\r\n        return this.get<BackDateRequestModel[]>('claim/csr/backdate-response');\r\n    }\r\n\r\n    fetchMaxMinForCSRBackdating() {\r\n        return this.get<any>('claim-utility/min-max-csr-backdate')\r\n    }*/\r\n\r\n    fetchPreviousFilledDuaResponse(){\r\n        return this.get<DuaRequestModel[]>('claim/dua-response')\r\n    }\r\n\r\n    saveDisasterRequestPostClaim(model : DuaRequestModel){\r\n        return this.post<StatusModel>('claim/dua-request-post-claim',model);\r\n    }\r\n\r\n     createAndInitiateDuaRequestAndCheckEligibility(model: DuaRequestModel) {\r\n        return this.post<StatusModel>('claim/dua-request/check-eligibility', model)\r\n    }\r\n\r\n    processDuaAppPostClaim(model : DuaAppDataModel){\r\n        return this.post<StatusModel>('claim/apply-dua-post-claim/submit', model);\r\n    }\r\n}"]}

package/esm2022/lib/services/cmp-service/cmp.service.mjs

@@ -0,0 +1,84 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { LibConstants } from '../../models/LibConstants';
+import { BaseService } from '../base-service';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class CmpService extends BaseService {
+    constructor(http) {
+        super(http);
+        this.http = http;
+        this.messageSource = new BehaviorSubject([]);
+    }
+    setServiceContext() {
+        this.serviceContext = LibConstants.cmp_service.context;
+    }
+    setServicePort() {
+        this.servicePort = LibConstants.cmp_service.port;
+    }
+    setServiceProtocol() {
+        this.protocol = LibConstants.cmp_service.protocol;
+    }
+    setServiceHost() {
+        this.host = LibConstants.cmp_service.host;
+    }
+    getComplaintCategory() {
+        return this.get('cmp/complaint-category');
+    }
+    submitQuery(formData) {
+        let options = {};
+        let headers = new HttpHeaders({
+            'Content-Type': 'multipart/form-data'
+        });
+        options = { headers: headers };
+        return this.postFormData('cmp/inquiry', formData);
+    }
+    submitQueryForCSR(formData) {
+        let options = {};
+        let headers = new HttpHeaders({
+            'Content-Type': 'multipart/form-data'
+        });
+        options = { headers: headers };
+        return this.postFormData('cmp/inquiry/csr', formData);
+    }
+    updateInquiryData(model, caseNumber) {
+        return this.put(`cmp/inquiry/csr/${caseNumber}`, model);
+    }
+    submitEmailTemplate(formData) {
+        return this.postFormData('cmp/email-template', formData);
+    }
+    getEmailTemplates() {
+        return this.get('cmp/email-template');
+    }
+    deleteEmailTemplate(id) {
+        return this.delete(`cmp/email-template/${id}`);
+    }
+    editEmailTemplate(editTeamplate) {
+        return this.put(`cmp/email-template/${editTeamplate.cmpEmailTemplateid}`, editTeamplate);
+    }
+    fetchInquiryDetailsByInquiryId(inquiryId) {
+        return this.get(`cmp/inquiry/${inquiryId}`);
+    }
+    getMsgGeneratedThrough() {
+        return this.get(`cmp/message-sources`);
+    }
+    getMessageSource() {
+        return this.messageSource;
+    }
+    loadMessageSources() {
+        if (this.messageSource.getValue().length < 1) {
+            this.get(`cmp/message-sources`)
+                .subscribe(res => this.messageSource.next(res));
+        }
+    }
+    static { this.ɵfac = function CmpService_Factory(t) { return new (t || CmpService)(i0.ɵɵinject(i1.HttpClient)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CmpService, factory: CmpService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CmpService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.HttpClient }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/dms-service/dms.service.mjs

@@ -0,0 +1,60 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { LibConstants } from '../../models/LibConstants';
+import { BaseService } from '../base-service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class DmsService extends BaseService {
+    constructor(http) {
+        super(http);
+        this.http = http;
+    }
+    setServiceContext() {
+        this.serviceContext = LibConstants.dms_service.context;
+    }
+    setServicePort() {
+        this.servicePort = LibConstants.dms_service.port;
+    }
+    setServiceProtocol() {
+        this.protocol = LibConstants.dms_service.protocol;
+    }
+    setServiceHost() {
+        this.host = LibConstants.dms_service.host;
+    }
+    downloadFile(fileId) {
+        const httpOptions = {
+            //'responseType'  : 'arraybuffer' as 'json'
+            'responseType': 'blob' //This also worked
+        };
+        return this.get(`dms/download/${fileId}`);
+    }
+    uploadFile(formData) {
+        let options = {};
+        let headers = new HttpHeaders({
+            'Content-Type': 'multipart/form-data'
+        });
+        options = { headers: headers };
+        return this.postFormData('file/', formData);
+    }
+    deleteFile(fileId) {
+        return this.delete('file/' + fileId);
+    }
+    getFile(fileId) {
+        return this.get('file/' + fileId);
+    }
+    getAddress(zipCode) {
+        return this.get('address/' + zipCode);
+    }
+    getBankName(routingNo) {
+        return this.get('bank/' + routingNo);
+    }
+    static { this.ɵfac = function DmsService_Factory(t) { return new (t || DmsService)(i0.ɵɵinject(i1.HttpClient)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: DmsService, factory: DmsService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DmsService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.HttpClient }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/employer/employer-service.mjs

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import { BaseService } from '../base-service';
+import { LibConstants } from '../../models/LibConstants';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class EmployerService extends BaseService {
+    constructor(http) {
+        super(http);
+        this.http = http;
+    }
+    setServiceContext() {
+        this.serviceContext = LibConstants.employer_service.context;
+    }
+    setServiceHost() {
+        this.host = LibConstants.employer_service.host;
+    }
+    setServicePort() {
+        this.servicePort = LibConstants.employer_service.port;
+    }
+    setServiceProtocol() {
+        this.protocol = LibConstants.employer_service.protocol;
+    }
+    getEmployerDataById(employerId) {
+        return this.get(`internal/employer/regular/id/${employerId}`);
+    }
+    static { this.ɵfac = function EmployerService_Factory(t) { return new (t || EmployerService)(i0.ɵɵinject(i1.HttpClient)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: EmployerService, factory: EmployerService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EmployerService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.HttpClient }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/event-service/event-service.mjs

@@ -0,0 +1,44 @@
+import { Injectable } from '@angular/core';
+import { BaseService } from '../base-service';
+import { LibConstants } from '../../models/LibConstants';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class EventService extends BaseService {
+    constructor(http) {
+        super(http);
+        this.http = http;
+    }
+    setServiceContext() {
+        this.serviceContext = LibConstants.event_service.context;
+    }
+    setServiceHost() {
+        this.host = LibConstants.event_service.host;
+    }
+    setServicePort() {
+        this.servicePort = LibConstants.event_service.port;
+    }
+    setServiceProtocol() {
+        this.protocol = LibConstants.event_service.protocol;
+    }
+    getAllHintsOfLoggedinUser() {
+        return this.get('event/hint');
+    }
+    getHistoryOfLoggedinUser() {
+        return this.get('event/history');
+    }
+    deactivateHint(transactionId, hintKey) {
+        return this.patch(`event/hint/deactivate/${transactionId}/${hintKey}`, null);
+    }
+    disableHistoryButton(transactionId, historyKey) {
+        return this.patch(`event/history/deactivate/${transactionId}/${historyKey}`, null);
+    }
+    static { this.ɵfac = function EventService_Factory(t) { return new (t || EventService)(i0.ɵɵinject(i1.HttpClient)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: EventService, factory: EventService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EventService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.HttpClient }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/fpjs/fingerprint.service.mjs

@@ -0,0 +1,70 @@
+import { Injectable, Inject } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { LibConstants } from '../../models/LibConstants';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/logger/logger.service";
+export class FingerprintService {
+    constructor(logger, document, rendererFactory) {
+        this.logger = logger;
+        this.document = document;
+        this.SCRIPT_PATH = "https://www.ipqscdn.com/api/localhost.mdes.ms.gov/vyg0g2R32UleOQ5GrEaqHzMfZuXx8SOvdJIHJUbY3b0NavBIGYhjlxCctaNvJmsdXjna4ygJ7jCh5uojWxBMwovssBn2DVOhBIzdqY9LmeCeUtFZPlr4wbOod8ZhQkC7Xdq4Ep72xKW4ZldcFV1QdvAhg1xdSytlbhdm5RPjE4kRd2Rc35AvfsUr0eL3pDaMpJItSpZrUoH5JNn6WW4LNfR0peZdxGkQ20p9VW7pm9MhsLYphXLzQlNAeGfFea0y/learn.js";
+        this.renderer = rendererFactory.createRenderer(null, null);
+        this.initFingerprintJs();
+    }
+    initFingerprintJs() {
+        if (LibConstants.enableFingerprinting == 'true') {
+            const scriptElement = this.loadJsScript(this.renderer, this.SCRIPT_PATH);
+            scriptElement.onload = () => {
+                if (typeof Startup !== "undefined") {
+                    Startup.AfterResult((result) => {
+                        console.log('fraud result', result);
+                        this.browserFingerprint = result.device_id;
+                        this.requestId = result.request_id;
+                        if (result.fraud_chance >= 90) {
+                            window.location.href = "https://www.google.com";
+                        }
+                    });
+                }
+            };
+        }
+        /* if(LibConstants.enableFingerprinting == 'true'){
+           this.logger.info("fpjsToken value --> ", LibConstants.fpjsToken);
+           const fpPromise = FingerprintJS.load({ token: LibConstants.fpjsToken });
+           (async () => {
+             // Get the visitor identifier when you need it.
+             const fp = await fpPromise;
+             const result = await fp.get();
+             // This is the visitor identifier:
+             this.browserFingerprint = result.visitorId;
+             this.logger.info("browserFingerprint value --> ", this.browserFingerprint);
+           })()
+         }else{
+           this.logger.info("Browser fingerprinting not enabled.");
+         }*/
+    }
+    loadJsScript(renderer, src) {
+        const script = renderer.createElement('script');
+        script.type = 'text/javascript';
+        script.src = src;
+        renderer.appendChild(this.document.body, script);
+        return script;
+    }
+    getBrowserFingerprint() {
+        return this.browserFingerprint;
+    }
+    getRequestId() {
+        return this.requestId;
+    }
+    static { this.ɵfac = function FingerprintService_Factory(t) { return new (t || FingerprintService)(i0.ɵɵinject(i1.LoggerService), i0.ɵɵinject(DOCUMENT), i0.ɵɵinject(i0.RendererFactory2)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FingerprintService, factory: FingerprintService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FingerprintService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.LoggerService }, { type: Document, decorators: [{
+                type: Inject,
+                args: [DOCUMENT]
+            }] }, { type: i0.RendererFactory2 }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/google-analytics/google-analytics.service.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class GoogleAnalyticsService {
+    constructor() { }
+    emitEvent(action, eventCategory, eventLabel = null, eventValue = null) {
+        gtag('event', action, {
+            'event_category': eventCategory,
+            'event_label': eventLabel,
+            'value': eventValue
+        });
+    }
+    emitNonInteractiveEvent(action, eventCategory, eventLabel = null, eventValue = null) {
+        gtag('event', action, {
+            'event_category': eventCategory,
+            'event_label': eventLabel,
+            'value': eventValue,
+            'non_interaction': true
+        });
+    }
+    static { this.ɵfac = function GoogleAnalyticsService_Factory(t) { return new (t || GoogleAnalyticsService)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: GoogleAnalyticsService, factory: GoogleAnalyticsService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(GoogleAnalyticsService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [], null); })();
+//# sourceMappingURL=data:application/json;base64,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