@uiapplib/ngx-ui-web-lib 0.0.1

package/esm2022/lib/services/weekly-cert/review.service.mjs

@@ -0,0 +1,101 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/storage-angular";
+import * as i2 from "@ionic/angular";
+//import { environment } from 'src/environments/environment';
+export class ReviewService {
+    constructor(storage, alertCtrl, platform) {
+        this.storage = storage;
+        this.alertCtrl = alertCtrl;
+        this.platform = platform;
+        this.REVIEW_KEY = 'SHOULD_DISPLAY_APP_REVIEW_DIALOG';
+        this.SHOULD_DISPLAY_APP_REVIEW_DIALOG = "NO";
+    }
+    getShouldReviewApp() {
+        return this.SHOULD_DISPLAY_APP_REVIEW_DIALOG == 'YES' ? true : false;
+    }
+    async setReviewApp(value) {
+        this.SHOULD_DISPLAY_APP_REVIEW_DIALOG = (value ? "YES" : "NO");
+    }
+    /* private showReviewDialog(){
+      var buttons = [
+                      {
+                        text : 'Rate it',
+                        handler : () => this.openAppStore()
+                          },
+                          {
+                        text : "Later",
+                        handler : () => this.defaultOK()
+                          },
+                          {
+                        text : "No Thanks",
+                        handler : () => this.saveUserPreferenceForAppReview("NO")
+                      }
+                            ];
+      this.showDialog("Like 2FileUI?", "Take a moment to to rate 2FileUI.", buttons);
+    } */
+    /* private openAppStore(){
+      if(this.platform.is('android')){
+        this.openExternamUrl(environment.appStoreUrls.googlePlayStoreURL);
+      }else if(this.platform.is('ios')){
+        this.openExternamUrl(environment.appStoreUrls.appleAppStoreURL);
+      }
+      this.saveUserPreferenceForAppReview("NO");
+    } */
+    async saveUserPreferenceForAppReview(value) {
+        await this.storage.set(this.REVIEW_KEY, value);
+    }
+    openExternamUrl(url) {
+        window.open(url, "_system", "location=yes,hidden=no,closebuttoncaption=Close");
+    }
+    async showDialog(title, text, buttons) {
+        if (title == null || title == undefined) {
+            title = "Alert";
+        }
+        if (buttons == null || buttons == undefined) {
+            buttons = [
+                {
+                    text: "Ok",
+                    handler: this.defaultOK
+                }
+            ];
+        }
+        let alert = await this.alertCtrl.create({
+            header: title,
+            subHeader: text,
+            buttons: buttons,
+            cssClass: 'alertCustomCss'
+        });
+        alert.present();
+    }
+    defaultOK() { }
+    async doesUserPrefrenceAllowAppReview() {
+        let secureValue = await this.storage.get(this.REVIEW_KEY);
+        console.log("Value from Storage :: " + secureValue);
+        let value;
+        if (secureValue == null || secureValue == undefined) {
+            console.log("value not found, setting value to YES");
+            await this.storage.set(this.REVIEW_KEY, "YES");
+            value = await this.storage.get(this.REVIEW_KEY);
+        }
+        else {
+            console.log("value found, getting value");
+            value = await this.storage.get(this.REVIEW_KEY);
+        }
+        return await (value == "YES" ? true : false);
+    }
+    async showAppReviewDialog() {
+        if (this.getShouldReviewApp() && await this.doesUserPrefrenceAllowAppReview() && this.platform.is('capacitor')) {
+            //this.showReviewDialog();
+        }
+    }
+    static { this.ɵfac = function ReviewService_Factory(t) { return new (t || ReviewService)(i0.ɵɵinject(i1.Storage), i0.ɵɵinject(i2.AlertController), i0.ɵɵinject(i2.Platform)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ReviewService, factory: ReviewService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ReviewService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.Storage }, { type: i2.AlertController }, { type: i2.Platform }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/weekly-cert/weekly-cert-v2.service.mjs

@@ -0,0 +1,214 @@
+import { Injectable } from '@angular/core';
+import { BaseService } from '../../services/base-service';
+import { LibConstants } from '../../models/LibConstants';
+import { EmployerInfoModel } from '../../models/weekly-cert/employer-info-v2-model';
+import { WeeklyCertEligibilityModelV2 } from '../../models/weekly-cert/weekly-cert-eligibility-v2-model';
+import { WeeklyCertificationModel } from '../../models/weekly-cert/weekly-certification-v2-model';
+import { WorkSearchJournalModel } from '../../models/weekly-cert/work-search-record-v2-model';
+import { AdminLeaveDetailsModel } from '../../models/weekly-cert/admin-leave-details-model';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/util/util.service";
+import * as i2 from "@angular/common/http";
+export class WeeklyCertServiceV2 extends BaseService {
+    setServiceContext() {
+        this.serviceContext = LibConstants.weeklycert_service.context;
+    }
+    setServicePort() {
+        this.servicePort = LibConstants.weeklycert_service.port;
+    }
+    setServiceProtocol() {
+        this.protocol = LibConstants.weeklycert_service.protocol;
+    }
+    setServiceHost() {
+        this.host = LibConstants.weeklycert_service.host;
+    }
+    constructor(util, http) {
+        super(http);
+        this.util = util;
+        this.http = http;
+        this.weeklyCertData = new WeeklyCertificationModel();
+        this.weeklyCertServerData = new WeeklyCertEligibilityModelV2();
+        this.workSearchJournal = new WorkSearchJournalModel();
+        this.adminLeaveDetailsModel = new AdminLeaveDetailsModel();
+        this.employerData = new EmployerInfoModel();
+    }
+    checkWeeklyEligibility() {
+        return this.get('weeklycert/v2/check-eligibility');
+    }
+    submitWeeklyCertification(last4OfSsn) {
+        this.weeklyCertData.signature = last4OfSsn;
+        return this.post('weeklycert/process', this.weeklyCertData);
+    }
+    getClaimantWorkSearchJournalRecords(weekToCertify) {
+        return this.get(`weeklycert/existing-work-search/${weekToCertify.replace('/', '-').replace('/', '-')}`);
+    }
+    determineQuestionniareToOpen() {
+        return this.post('weeklycert/file-weeklies/determine-qe', this.weeklyCertData);
+    }
+    getSundayDateAsString() {
+        return this.weeklyCertServerData.sundayOfWeekToCertifyString;
+    }
+    getSaturdayDateAsString() {
+        return this.weeklyCertServerData.weekToCertifyString;
+    }
+    getSaturdayDate() {
+        return this.weeklyCertServerData.weekToCertify;
+    }
+    getSundayDate() {
+        return this.weeklyCertServerData.sundayOfWeekToCertify;
+    }
+    getDisplayWorkSearchScreen() {
+        return this.weeklyCertServerData.showWorkSearchScreen && !this.weeklyCertServerData.isWorkSearchWaived;
+    }
+    getEmployerRecords() {
+        return this.weeklyCertData.employerDetailsList;
+    }
+    getWorkSearchData() {
+        return this.weeklyCertData.workSearchData;
+    }
+    setWorkSearchData(workSearchData) {
+        this.weeklyCertData.workSearchData = workSearchData;
+    }
+    setAdminLeaveDetails(adminLeaveDetails) {
+        this.weeklyCertData.adminLeaveDetails = adminLeaveDetails;
+    }
+    getClaimTypeFlag() {
+        let claimTypeFlag = this.weeklyCertData['tra_claim_flag'];
+        return claimTypeFlag;
+    }
+    getWorkSearchRecordsCount() {
+        if (this.weeklyCertData.workSearchRecords != null) {
+            return this.weeklyCertData.workSearchRecords.length;
+        }
+        else {
+            return 0;
+        }
+    }
+    getWorkSearchRecords() {
+        return this.weeklyCertData.workSearchRecords;
+    }
+    removeWorkSearchRecord(index) {
+        this.weeklyCertData.workSearchRecords.splice(index, 1);
+    }
+    removeEmployerRecord(index) {
+        this.weeklyCertData.employerDetailsList.splice(index, 1);
+    }
+    getEmployerRecordsCount() {
+        if (this.weeklyCertData.employerDetailsList != null) {
+            return this.weeklyCertData.employerDetailsList.length;
+        }
+        else {
+            return 0;
+        }
+    }
+    getTotalEarningAmount() {
+        let totalAmount = 0.0;
+        if (this.getEmployerRecordsCount() > 0) {
+            this.weeklyCertData.employerDetailsList.forEach(element => {
+                totalAmount = totalAmount + Number.parseFloat(element.grossEarning.toString());
+            });
+        }
+        return totalAmount;
+    }
+    resetWeeklyCertData() {
+        this.weeklyCertData = new WeeklyCertificationModel();
+    }
+    getWorkSearchRecordsCountWithNotHiredStatus() {
+        let workSearchRecords = this.getWorkSearchRecords();
+        if (workSearchRecords == null || workSearchRecords.length == 0) {
+            return 0;
+        }
+        else {
+            var count = 0;
+            for (var index = 0; index < workSearchRecords.length; index++) {
+                if (workSearchRecords[index].searchResult == 'NOHI') {
+                    count++;
+                }
+            }
+            return count;
+        }
+    }
+    getWorkSearchRecordsCountWithHiredStatus() {
+        let workSearchRecords = this.getWorkSearchRecords();
+        if (workSearchRecords == null || workSearchRecords.length == 0) {
+            return 0;
+        }
+        else {
+            var count = 0;
+            for (var index = 0; index < workSearchRecords.length; index++) {
+                if (workSearchRecords[index].searchResult == 'HIRE') {
+                    count++;
+                }
+            }
+            return count;
+        }
+    }
+    checkIfInadequateWorkSearchQuestionnaireShouldBeOpened() {
+        if (this.weeklyCertData.workSearchData.isWorkSearchPerformedFlag == "1") {
+            if (this.getWorkSearchRecordsCount() < 1) {
+                return false;
+            }
+            if (this.getWorkSearchRecordsCountWithHiredStatus() > 0) {
+                return false;
+            }
+            else if (this.getWorkSearchRecordsCount() < 3) {
+                return true;
+            }
+            else if (this.getWorkSearchRecordsCountWithNotHiredStatus() < 1) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    hasReferralRecords() {
+        let hasReferralPresent = false;
+        if (this.weeklyCertData.workSearchRecords != null && this.weeklyCertData.workSearchRecords.length > 0) {
+            this.weeklyCertData.workSearchRecords.forEach((wrkSrchModel) => {
+                if (wrkSrchModel.searchResult == 'MDES') {
+                    hasReferralPresent = true;
+                }
+            });
+        }
+        return hasReferralPresent;
+    }
+    convertNumberToBoolean(value) {
+        if (value == 1) {
+            return true;
+        }
+        else if (value == 0) {
+            return false;
+        }
+        else {
+            return null;
+        }
+    }
+    setNullIfEmpty(value) {
+        if (value == null || value == undefined || value == '') {
+            return null;
+        }
+        return value;
+    }
+    getWorkSearchWaived() {
+        return this.weeklyCertServerData.isWorkSearchWaived;
+    }
+    getWaitingWeekServed() {
+        return this.weeklyCertServerData.isWaitingWeekServed;
+    }
+    getHidIsSeapParticipant() {
+        return this.weeklyCertServerData.hidIsSeapParticipant;
+    }
+    static { this.ɵfac = function WeeklyCertServiceV2_Factory(t) { return new (t || WeeklyCertServiceV2)(i0.ɵɵinject(i1.UtilService), i0.ɵɵinject(i2.HttpClient)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: WeeklyCertServiceV2, factory: WeeklyCertServiceV2.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WeeklyCertServiceV2, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.UtilService }, { type: i2.HttpClient }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"weekly-cert-v2.service.js","sourceRoot":"","sources":["../../../../../../projects/ngx-reusa-app-lib/src/lib/services/weekly-cert/weekly-cert-v2.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { BaseService } from '../../services/base-service';\r\nimport { UtilService } from '../../services/util/util.service';\r\nimport { LibConstants } from '../../models/LibConstants';\r\nimport { ComboOption } from '../../models/combo-model';\r\nimport { EmployerInfoModel } from '../../models/weekly-cert/employer-info-v2-model';\r\nimport { WeeklyCertEligibilityModelV2 } from '../../models/weekly-cert/weekly-cert-eligibility-v2-model';\r\nimport { WeeklyCertData, WeeklyCertificationModel } from '../../models/weekly-cert/weekly-certification-v2-model';\r\nimport { WorkSearchModel } from '../../models/weekly-cert/work-search-v2-model';\r\nimport { WorkSearchJournalModel, WorkSearchRecordModel } from '../../models/weekly-cert/work-search-record-v2-model';\r\nimport { StatusModel } from '../../models/questionnaire/StatusModel';\r\nimport { AdminLeaveDetailsModel } from '../../models/weekly-cert/admin-leave-details-model';\r\nimport { DependentModel } from '../../models/dependent.model';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class WeeklyCertServiceV2 extends BaseService {\r\n\r\n  setServiceContext() {\r\n    this.serviceContext = LibConstants.weeklycert_service.context;\r\n  }\r\n  setServicePort() {\r\n    this.servicePort = LibConstants.weeklycert_service.port;\r\n  }\r\n  setServiceProtocol() {\r\n    this.protocol = LibConstants.weeklycert_service.protocol;\r\n  }\r\n  setServiceHost() {\r\n    this.host = LibConstants.weeklycert_service.host;\r\n  }\r\n\r\n  public weeklyCertData: WeeklyCertificationModel = new WeeklyCertificationModel();\r\n\r\n  public weeklyCertServerData: WeeklyCertEligibilityModelV2 = new WeeklyCertEligibilityModelV2();\r\n\r\n  public workSearchJournal: WorkSearchJournalModel = new WorkSearchJournalModel();\r\n\r\n  public adminLeaveDetailsModel: AdminLeaveDetailsModel = new AdminLeaveDetailsModel();\r\n\r\n  public employerData: EmployerInfoModel = new EmployerInfoModel();\r\n\r\n  public qeStatusModel: StatusModel;\r\n\r\n  constructor(public util: UtilService, public http: HttpClient) {\r\n    super(http);\r\n  }\r\n\r\n  checkWeeklyEligibility() {\r\n    return this.get<WeeklyCertEligibilityModelV2>('weeklycert/v2/check-eligibility');\r\n  }\r\n\r\n  submitWeeklyCertification(last4OfSsn: string) {\r\n     this.weeklyCertData.signature = last4OfSsn;\r\n     return this.post<any>('weeklycert/process', this.weeklyCertData);\r\n  }\r\n\r\n  getClaimantWorkSearchJournalRecords(weekToCertify: string){\r\n   return this.get<WorkSearchJournalModel>(`weeklycert/existing-work-search/${weekToCertify.replace('/','-').replace('/','-')}`);\r\n  }\r\n\r\n  determineQuestionniareToOpen(){\r\n    return this.post<any>('weeklycert/file-weeklies/determine-qe', this.weeklyCertData);\r\n  }\r\n\r\n  getSundayDateAsString(): string {\r\n    return this.weeklyCertServerData.sundayOfWeekToCertifyString;\r\n  }\r\n\r\n  getSaturdayDateAsString(): string {\r\n    return this.weeklyCertServerData.weekToCertifyString;\r\n  }\r\n\r\n  getSaturdayDate() {\r\n    return this.weeklyCertServerData.weekToCertify;\r\n  }\r\n\r\n  getSundayDate() {\r\n    return this.weeklyCertServerData.sundayOfWeekToCertify;\r\n  }\r\n\r\n  getDisplayWorkSearchScreen() {\r\n    return this.weeklyCertServerData.showWorkSearchScreen && !this.weeklyCertServerData.isWorkSearchWaived;\r\n  }\r\n\r\n  getEmployerRecords(): EmployerInfoModel[] {\r\n    return this.weeklyCertData.employerDetailsList;\r\n  }\r\n\r\n  getWorkSearchData(): WorkSearchModel {\r\n    return this.weeklyCertData.workSearchData;\r\n  }\r\n\r\n  setWorkSearchData(workSearchData: WorkSearchModel) {\r\n    this.weeklyCertData.workSearchData = workSearchData;\r\n  }\r\n\r\n  setAdminLeaveDetails(adminLeaveDetails: AdminLeaveDetailsModel){\r\n    this.weeklyCertData.adminLeaveDetails = adminLeaveDetails;\r\n  }\r\n\r\n  getClaimTypeFlag() {\r\n    let claimTypeFlag = this.weeklyCertData['tra_claim_flag'];\r\n    return claimTypeFlag;\r\n  }\r\n\r\n  getWorkSearchRecordsCount(): number {\r\n    if (this.weeklyCertData.workSearchRecords != null) {\r\n      return this.weeklyCertData.workSearchRecords.length;\r\n    }else {    \r\n      return 0;\r\n    }\r\n  }\r\n\r\n  getWorkSearchRecords(): WorkSearchRecordModel[] {\r\n    return this.weeklyCertData.workSearchRecords;\r\n  }\r\n\r\n  removeWorkSearchRecord(index: number) {\r\n    this.weeklyCertData.workSearchRecords.splice(index, 1);\r\n  }\r\n\r\n  removeEmployerRecord(index: number) {\r\n    this.weeklyCertData.employerDetailsList.splice(index, 1);\r\n  }\r\n\r\n  getEmployerRecordsCount(): number {\r\n    if (this.weeklyCertData.employerDetailsList != null) {\r\n      return this.weeklyCertData.employerDetailsList.length;\r\n    } else {\r\n      return 0;\r\n    }\r\n  }\r\n\r\n  getTotalEarningAmount(): number {\r\n    let totalAmount: number = 0.0;\r\n    if (this.getEmployerRecordsCount() > 0) {\r\n      this.weeklyCertData.employerDetailsList.forEach(element => {\r\n        totalAmount = totalAmount + Number.parseFloat(element.grossEarning.toString());\r\n      });\r\n    }\r\n    return totalAmount;\r\n  }\r\n\r\n  resetWeeklyCertData() {\r\n    this.weeklyCertData = new WeeklyCertificationModel();\r\n  }\r\n\r\n  getWorkSearchRecordsCountWithNotHiredStatus() {\r\n    let workSearchRecords: WorkSearchRecordModel[] = this.getWorkSearchRecords();\r\n    if (workSearchRecords == null || workSearchRecords.length == 0) {\r\n      return 0;\r\n    } else {\r\n      var count = 0;\r\n      for (var index = 0; index < workSearchRecords.length; index++) {\r\n        if (workSearchRecords[index].searchResult == 'NOHI') {\r\n          count++;\r\n        }\r\n      }\r\n      return count;\r\n    }\r\n  }\r\n\r\n  getWorkSearchRecordsCountWithHiredStatus(): number {\r\n    let workSearchRecords: WorkSearchRecordModel[] = this.getWorkSearchRecords();\r\n    if (workSearchRecords == null || workSearchRecords.length == 0) {\r\n      return 0;\r\n    } else {\r\n      var count = 0;\r\n      for (var index = 0; index < workSearchRecords.length; index++) {\r\n        if (workSearchRecords[index].searchResult == 'HIRE') {\r\n          count++;\r\n        }\r\n      }\r\n      return count;\r\n    }\r\n  }\r\n\r\n  checkIfInadequateWorkSearchQuestionnaireShouldBeOpened(): boolean {\r\n    if(this.weeklyCertData.workSearchData.isWorkSearchPerformedFlag == \"1\"){\r\n      if ( this.getWorkSearchRecordsCount() < 1) {\r\n        return false;\r\n      }\r\n      if (this.getWorkSearchRecordsCountWithHiredStatus() > 0) {\r\n        return false;\r\n      } else if (this.getWorkSearchRecordsCount() < 3) {\r\n        return true;\r\n      } else if (this.getWorkSearchRecordsCountWithNotHiredStatus() < 1) {\r\n        return true;\r\n      } else {\r\n        return false;\r\n      }\r\n    }\r\n    else{\r\n      return false;\r\n    }\r\n    \r\n  }\r\n\r\n  hasReferralRecords(): boolean {\r\n    let hasReferralPresent: boolean = false;\r\n    if (this.weeklyCertData.workSearchRecords != null && this.weeklyCertData.workSearchRecords.length > 0) {\r\n      this.weeklyCertData.workSearchRecords.forEach(\r\n        (wrkSrchModel) => {\r\n          if (wrkSrchModel.searchResult == 'MDES') {\r\n            hasReferralPresent = true;\r\n          }\r\n        }\r\n      );\r\n    }\r\n    return hasReferralPresent;\r\n  }\r\n\r\n  convertNumberToBoolean(value) {\r\n    if (value == 1) {\r\n      return true;\r\n    } else if (value == 0) {\r\n      return false;\r\n    } else {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  setNullIfEmpty(value){\r\n    if(value == null || value == undefined || value == ''){\r\n      return null;\r\n    }\r\n    return value;\r\n  }\r\n\r\n  getWorkSearchWaived() {\r\n    return this.weeklyCertServerData.isWorkSearchWaived;\r\n  }\r\n\r\n  getWaitingWeekServed() {\r\n    return this.weeklyCertServerData.isWaitingWeekServed;\r\n  }\r\n\r\n  getHidIsSeapParticipant() {\r\n    return this.weeklyCertServerData.hidIsSeapParticipant;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/services/weekly-cert/weekly-cert.service.mjs

@@ -0,0 +1,37 @@
+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 "../util/util.service";
+import * as i2 from "@angular/common/http";
+export class WeeklyCertService extends BaseService {
+    setServiceContext() {
+        this.serviceContext = LibConstants.weeklycert_service.context;
+    }
+    setServicePort() {
+        this.servicePort = LibConstants.weeklycert_service.port;
+    }
+    setServiceProtocol() {
+        this.protocol = LibConstants.weeklycert_service.protocol;
+    }
+    setServiceHost() {
+        this.host = LibConstants.weeklycert_service.host;
+    }
+    constructor(util, http) {
+        super(http);
+        this.util = util;
+        this.http = http;
+    }
+    fetchWeeklyEmployerDetails(claimantId, claimWeekEndDate) {
+        return this.post(`weeklycert/fetchEmployerDetails?claimantId=${claimantId}&claimWeekEndDate=${claimWeekEndDate}`, null);
+    }
+    static { this.ɵfac = function WeeklyCertService_Factory(t) { return new (t || WeeklyCertService)(i0.ɵɵinject(i1.UtilService), i0.ɵɵinject(i2.HttpClient)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: WeeklyCertService, factory: WeeklyCertService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WeeklyCertService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.UtilService }, { type: i2.HttpClient }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/weekly-cert/work-search.service.mjs

@@ -0,0 +1,58 @@
+import { Injectable } from '@angular/core';
+import { BaseService } from '../../services/base-service';
+import { LibConstants } from '../../models/LibConstants';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/util/util.service";
+import * as i2 from "@angular/common/http";
+export class WorkSearchService extends BaseService {
+    setServiceContext() {
+        this.serviceContext = LibConstants.weeklycert_service.context;
+    }
+    setServicePort() {
+        this.servicePort = LibConstants.weeklycert_service.port;
+    }
+    setServiceProtocol() {
+        this.protocol = LibConstants.weeklycert_service.protocol;
+    }
+    setServiceHost() {
+        this.host = LibConstants.weeklycert_service.host;
+    }
+    constructor(util, http) {
+        super(http);
+        this.util = util;
+        this.http = http;
+    }
+    getSundayDateAsString() {
+        return this.workSearchJournal.minWorkSearchDateString;
+    }
+    getSaturdayDateAsString() {
+        return this.workSearchJournal.maxWorkSearchDateString;
+    }
+    getSaturdayDate() {
+        return this.util.getEnteredDate(this.workSearchJournal.minWorkSearchDate);
+    }
+    getSundayDate() {
+        return this.util.getEnteredDate(this.workSearchJournal.maxWorkSearchDate);
+    }
+    fetchWorkSearchJournals() {
+        return this.get('weeklycert/v2/work-search-journals');
+    }
+    saveWorkSearchJournal(journal) {
+        return this.post('weeklycert/v2/work-search-journals', journal);
+    }
+    deleteWorkSearchJournal(journalId) {
+        return this.delete(`weeklycert/work-search-journals/${journalId}`);
+    }
+    getWaitingWeekServed() {
+        return this.workSearchJournal.isWaitingWeekServed;
+    }
+    static { this.ɵfac = function WorkSearchService_Factory(t) { return new (t || WorkSearchService)(i0.ɵɵinject(i1.UtilService), i0.ɵɵinject(i2.HttpClient)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: WorkSearchService, factory: WorkSearchService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WorkSearchService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.UtilService }, { type: i2.HttpClient }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/validations/AppRegex.mjs

@@ -0,0 +1,49 @@
+/***
+ *
+ * @description Class Contains all regular expressions used in the project.
+ * @author Prerak Tiwari
+ */
+// @dynamic
+export class AppRegex {
+    /**
+     * @description Regular Expression to validate username
+    */
+    static { this.USERNAME_REGEX = /^[a-zA-Z]{1}[\w\@\.]*$/; }
+    /**
+     * @description Regular Expression to validate First Name, Last Name
+    */
+    static { this.NAME_REGEX = /^[A-Za-z%][A-Za-z\s'-]*$/; }
+    /**
+     * @description Regular Expression to validate if at least 1 of the following character is present or not : '_' '@' '*' '$' '!' '#' '.'
+    */
+    static { this.CLAIMANT_SYMBOL_REGEX = /.*[_@*$!#.]+.*/; }
+    /**
+     * @description Regular Expression to validate if at least 2 of the following character is present or not : '_' '@' '*' '$' '!' '#' '.'
+    */
+    static { this.AGENCY_SYMBOL_REGEX = /.*[_@*$!#.]+.*[_@*$!#.]+.*/; }
+    /**
+     * @description Regular Expression to validate if small case letter is present or not
+    */
+    static { this.LOWER_CASE_REGEX = /.*[a-z]+.*/; }
+    /**
+     * @description Regular Expression to validate if upper case letter is present or not
+    */
+    static { this.UPPER_CASE_REGEX = /.*[A-Z]+.*/; }
+    /**
+     * @description Regular Expression to validate if numbber is present or not
+    */
+    static { this.NUMBER_REGEX = /.*[0-9]+.*/; }
+    /**
+     * @description Regular Expression to validate if accountnumber has only numbers present or not
+    */
+    static { this.ACCOUNT_NUMBER_REGEX = /^\d+$/; }
+    /**
+     * @description Regular Expression to validate email format
+    */
+    static { this.EMAIL_REGEX = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/; }
+    /**
+     * @description Regular Expression to station no. format
+     */
+    static { this.STATION_NO_REGEX = /^[A-Za-z0-9]{4}$/; }
+}
+//# sourceMappingURL=data:application/json;base64,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