@uiapplib/ngx-ui-web-lib 0.0.1

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

@@ -0,0 +1,257 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { LibConstants } from '../../models/LibConstants';
+import { ScriptConstant } from './script.const';
+import * as i0 from "@angular/core";
+import * as i1 from "../logger/logger.service";
+import * as i2 from "../login/login.service";
+import * as i3 from "../util/util.service";
+export class ChatbotService {
+    constructor(rendererFactory, logger, ls, util) {
+        this.logger = logger;
+        this.ls = ls;
+        this.util = util;
+        this.map = new Map();
+        this.msCustomData = {
+            connectingMessage: "Welcome to ReEmployMS. I am your virtual assistant to help you with MDES related queries.",
+            hoverMessage: "Ask chat bot",
+            botState: "MS",
+            showCollectUserDetailForm: true,
+            showDisclaimerPopUp: true,
+            showChatBubbleAtClosed: false,
+            botAvatarImageName: "AvatarIcon.png",
+            botIconImageName: "AvatarIcon.png",
+            formBannerPath: "",
+            rootFilePath: "UI/",
+            supportedLanguages: ["en"],
+            initialLanguage: "en",
+            // starterTask: {en:"Forgot Password", es:"Forgot Password"},
+            disclaimerPopup: {
+                header: "Important message",
+                message: `MDES' virtual assistant will ask for specific identifying information, such as Social Security Number and Date of Birth, that is needed to answer your question(s).</br></br> MDES follows strict federal security guidelines to protect your sensitive information.</br></br>To further protect your information you should close the chat window and browser when you are finished.</p>`
+            },
+            headerConfig: {
+                showLanguageToggle: false,
+                showMinimizeButton: false,
+                showExpandButton: false,
+                showReloadButton: false,
+            }
+        };
+        this.meCustomData = {
+            connectingMessage: "Welcome to ReEmployME. I am your virtual assistant to help you with ME related queries.",
+            hoverMessage: "Ask Blue",
+            botState: "ME",
+            showCollectUserDetailForm: false,
+            showDisclaimerPopUp: true,
+            showChatBubbleAtClosed: false,
+            botIconImageName: "BlueIcon.svg",
+            botAvatarImageName: "BlueIcon.svg",
+            formBannerPath: "",
+            rootFilePath: "UI/",
+            supportedLanguages: ["en"],
+            initialLanguage: "en",
+            disclaimerPopup: {
+                header: "Important message",
+                message: `MEDOL's virtual assistant may ask you specific identifying information, such as Social Security Number and Date of Birth, that is needed to answer your question(s). ME DOL follows strict federal security guidelines to protect your sensitive information. To further protect your information you should close the chat window and browser when you are finished.`
+            },
+            headerConfig: {
+                showLanguageToggle: false,
+                showMinimizeButton: true,
+                showExpandButton: false,
+                showReloadButton: true,
+            }
+        };
+        this.ctCustomData = {
+            connectingMessage: "Welcome to ReEmployCT. I am your virtual assistant to help you with ME related queries.",
+            hoverMessage: "Ask Blue",
+            botState: "CT",
+            showCollectUserDetailForm: true,
+            showDisclaimerPopUp: true,
+            showChatBubbleAtClosed: false,
+            botIconImageName: "chatboticon.png",
+            botAvatarImageName: "chatboticon.png",
+            formBannerPath: "",
+            rootFilePath: "UI/",
+            supportedLanguages: ["en", "es"],
+            initialLanguage: "en",
+            disclaimerPopup: {
+                header: "Important message",
+                message: `The CTDOL virtual assistant will need to ask for specific identifying information that is needed to answer your question(s) such as date of birth or Social Security number. The agency follows strict federal security guidelines to protect your sensitive information. To further protect your information, if you are on a public computer, please log out and close your browser when you are finished.`
+            },
+            headerConfig: {
+                showLanguageToggle: true,
+                showMinimizeButton: true,
+                showExpandButton: false,
+                showReloadButton: true,
+            }
+        };
+        this.botOptions = {};
+        this.koreBot = {};
+        this.initChatbot = new BehaviorSubject(false);
+        this.showChatbot = (LibConstants.enableChatbot == 'true');
+        this.renderer = rendererFactory.createRenderer(null, null);
+        this.logger.info('ChatbotService initializzed successfully.');
+        this.map.set("ms", this.msCustomData);
+        this.map.set("me", this.meCustomData);
+        this.map.set("ct", this.ctCustomData);
+        this.getChatbotBs().subscribe(val => {
+            if (val) {
+                this.logger.info('Initializing Chatbot.');
+                this.initializeChatbot();
+            }
+        });
+    }
+    getChatbotBs() {
+        return this.initChatbot;
+    }
+    initialize() {
+        this.initChatbot.next(true);
+    }
+    loadScripAndStyle() {
+        if (!LibConstants.production && this.showChatbot) { //set this property to true if you want to test this in local env.
+            this.logger.info('Not Loading Chatbot as current environment is not production. Set "production=true" and "showChatbot=true" if you want to test chatbot in local env.');
+            return;
+            ;
+        }
+        else {
+            this.logger.info('Loading chatbot ...');
+        }
+        ScriptConstant.importUrls.forEach(scriptElement => {
+            // other than js and stylesheet are ignored
+            if (scriptElement.type === ScriptConstant.jsProperty) {
+                const jsScriptNode = document.createElement('script');
+                //// jsScriptNode.src = environment.koreAiWebSdkUrl + scriptElement.url;
+                jsScriptNode.src = LibConstants.koreAiWebSdkUrl + scriptElement.url;
+                jsScriptNode.type = 'text/javascript';
+                if (scriptElement.async == null) {
+                    this.logger.info(jsScriptNode.src + " will be loaded as async because of null async value");
+                    jsScriptNode.async = true;
+                }
+                else if (scriptElement.async == true) {
+                    this.logger.info(scriptElement.url + " will be loaded as async because of null async true");
+                    jsScriptNode.async = true;
+                }
+                else {
+                    this.logger.info(scriptElement.url + " will be loaded as async=false");
+                    jsScriptNode.async = false;
+                }
+                this.renderer.appendChild(document.getElementsByTagName('head')[0], jsScriptNode);
+                document.getElementsByTagName('head')[0].appendChild(jsScriptNode);
+            }
+            else if (scriptElement.type === ScriptConstant.cssProperty) {
+                const styleNode = document.createElement('link');
+                styleNode.rel = 'stylesheet';
+                styleNode.href = LibConstants.koreAiWebSdkUrl + scriptElement.url;
+                this.renderer.appendChild(document.getElementsByTagName('head')[0], styleNode);
+            }
+            else if (scriptElement.type === ScriptConstant.cssPropertyAbsolute) {
+                const styleNode = document.createElement('link');
+                styleNode.rel = 'stylesheet';
+                styleNode.href = scriptElement.url;
+                this.renderer.appendChild(document.getElementsByTagName('head')[0], styleNode);
+            }
+            else {
+                this.logger.error('url ' + scriptElement.url + ' is not going to be loaded because of invalid type ' + scriptElement.type);
+            }
+        }); // for each
+    }
+    initializeChatbot() {
+        this.openbot();
+    }
+    /***
+     *
+     * @description Initialize the chatbot with logged-in user. If user is not logged-in then bot session will be created using unique timestamp.
+     */
+    openbot() {
+        let userId = null;
+        if (this.ls.getUser()) {
+            userId = this.ls.getUser().username + '_' + this.ls.getUser().userType;
+            this.botOptions.accessToken = this.ls.getUser().access_token;
+        }
+        else {
+            userId = Math.floor((Math.random() * 10000000) + 1) + "_" + new Date().getMilliseconds() + "@mdes.ms.gov";
+        }
+        //***CODE_START
+        this.botOptions.logLevel = 'debug';
+        this.botOptions.koreAPIUrl = LibConstants.koreAiChatbotServer;
+        //botOptions.koreSpeechAPIUrl = "https://speech.kore.ai/";
+        //botOptions.bearer = "bearer xyz-------------------";
+        //botOptions.ttsSocketUrl = 'wss://speech.kore.ai/tts/ws';
+        this.botOptions.recorderWorkerPath = './libs/recorderWorker.js';
+        this.botOptions.assertionFn = (options, callback) => this.assertion(options, callback);
+        //botOptions.koreAnonymousFn = koreAnonymousFn;
+        this.botOptions.JWTUrl = LibConstants.koreAiJwtService;
+        this.botOptions.userIdentity = userId; // Provide users email id here
+        this.botOptions.botInfo = {
+            name: LibConstants.koreAiBotName,
+            "_id": LibConstants.koreAiBotId,
+            customData: this.map.get(this.util.getStateLowercase()) ? this.map.get(this.util.getStateLowercase()) : this.map.get('ms'),
+            // customData: { connectingMessage: "Welcome to ReEmployME. I am your virtual assistant to help you with ME related queries.", hoverMessage: "Ask Blue", botState: "ME", showCollectUserDetailForm: false, showDisclaimerPopUp: true, botIconImageName: "chatboticon.png", botAvatarImageName: "chatboticon.png", rootFilePath: "UI/", supportedLanguages: ["en", "es"], initialLanguage: "en", disclaimerPopup: { header: "Important Message", message: `The virtual assistant will need to ask for specific identifying information that is needed to answer you question(s) such as date of birth or Social Security number. The agency follows strict federal security guidelines to protect your sensitive information. To further protect your information, if you are on a public computer, please log out and close your browser when you are finished.`, }, headerConfig: { showLanguageToggle: true, showMinimizeButton: true, showExpandbutton: false, showReloadButton: true, } }
+        }; // bot name is case sensitive
+        this.botOptions.clientId = LibConstants.koreAiClientId;
+        //this.botOptions.clientSecret = LibConstants.koreAiClientSecret;
+        //this.botOptions.reemployUsBearerToken= "";  
+        // will need to pass token to koreAiChatBotServer when authentication needs to be validated for server side api call
+        var chatConfig = {
+            botOptions: this.botOptions,
+            allowIframe: false,
+            isSendButton: true,
+            isTTSEnabled: false,
+            isSpeechEnabled: false,
+            allowGoogleSpeech: false,
+            allowLocation: false,
+            loadHistory: false,
+            messageHistoryLimit: 10,
+            autoEnableSpeechAndTTS: false,
+            graphLib: "d3"
+        };
+        if (Object.keys(this.koreBot).length === 0) {
+            this.koreBot = koreBotChat();
+            this.koreBot.show(chatConfig);
+        }
+        else {
+            this.koreBot.resumeChatWindow();
+        }
+        //***CODE_END
+    }
+    assertion(options, callback) {
+        var jsonData = {
+            "clientId": this.botOptions.clientId,
+            "clientSecret": this.botOptions.clientSecret,
+            "identity": options.userIdentity || this.botOptions.userIdentity,
+            "aud": "",
+            "isAnonymous": (this.ls.getUser() == null),
+            "accessToken": this.botOptions.accessToken
+        };
+        $.ajax({
+            url: this.botOptions.JWTUrl,
+            type: 'post',
+            data: jsonData,
+            dataType: 'json',
+            success: (data) => {
+                options.assertion = data.jwt;
+                options.handleError = this.koreBot.showError;
+                options.chatHistory = this.koreBot.chatHistory;
+                options.botDetails = this.koreBot.botDetails;
+                callback(null, options);
+                setTimeout(function () {
+                    if (this.koreBot && this.koreBot.initToken) {
+                        this.koreBot.initToken(options);
+                    }
+                }, 2000);
+            },
+            error: (err) => {
+                this.koreBot.showError(err.responseText);
+            }
+        });
+    }
+    static { this.ɵfac = function ChatbotService_Factory(t) { return new (t || ChatbotService)(i0.ɵɵinject(i0.RendererFactory2), i0.ɵɵinject(i1.LoggerService), i0.ɵɵinject(i2.LoginService), i0.ɵɵinject(i3.UtilService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ChatbotService, factory: ChatbotService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ChatbotService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i0.RendererFactory2 }, { type: i1.LoggerService }, { type: i2.LoginService }, { type: i3.UtilService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chatbot.service.js","sourceRoot":"","sources":["../../../../../../projects/ngx-reusa-app-lib/src/lib/services/chatbot/chatbot.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Renderer2, RendererFactory2 } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\nimport { LibConstants } from '../../models/LibConstants';\nimport { LoggerService } from '../logger/logger.service';\nimport { ScriptConstant } from './script.const';\nimport { LoginService } from '../login/login.service';\nimport { UtilService } from '../util/util.service';\n\ndeclare const koreBotChat: any;\ndeclare const $: any;\n\ninterface DisclaimerPopup {\n  header: string;\n  message: string\n}\ninterface HeaderConfig {\n  showLanguageToggle: boolean;\n  showMinimizeButton: boolean;\n  showExpandButton: boolean;\n  showReloadButton: boolean;\n}\ninterface CustomData {\n  connectingMessage: string;\n  hoverMessage: string;\n  botState: string;\n  showCollectUserDetailForm: boolean;\n  showDisclaimerPopUp: boolean;\n  showChatBubbleAtClosed: boolean;\n  botAvatarImageName: string;\n  botIconImageName: string;\n  formBannerPath: string,\n  rootFilePath: string;\n  supportedLanguages: string[];\n  initialLanguage: string;\n  disclaimerPopup: DisclaimerPopup;\n  headerConfig: HeaderConfig;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ChatbotService {\n\n  map: Map<string, CustomData> = new Map();\n\n  msCustomData: CustomData = {\n    connectingMessage: \"Welcome to ReEmployMS. I am your virtual assistant to help you with MDES related queries.\",\n    hoverMessage: \"Ask chat bot\",\n    botState: \"MS\",\n    showCollectUserDetailForm: true,\n    showDisclaimerPopUp: true,\n    showChatBubbleAtClosed: false,\n    botAvatarImageName: \"AvatarIcon.png\",\n    botIconImageName: \"AvatarIcon.png\",\n    formBannerPath: \"\",\n    rootFilePath: \"UI/\",\n    supportedLanguages: [\"en\"],\n    initialLanguage: \"en\",\n    // starterTask: {en:\"Forgot Password\", es:\"Forgot Password\"},\n    disclaimerPopup: {\n      header: \"Important message\",\n      message: `MDES' virtual assistant will ask for specific identifying information, such as Social Security Number and Date of Birth, that is needed to answer your question(s).</br></br> MDES follows strict federal security guidelines to protect your sensitive information.</br></br>To further protect your information you should close the chat window and browser when you are finished.</p>`\n    },\n    headerConfig: {\n      showLanguageToggle: false,\n      showMinimizeButton: false,\n      showExpandButton: false,\n      showReloadButton: false,\n    }\n  }\n\n  meCustomData: CustomData = {\n    connectingMessage: \"Welcome to ReEmployME. I am your virtual assistant to help you with ME related queries.\",\n    hoverMessage: \"Ask Blue\",\n    botState: \"ME\",\n    showCollectUserDetailForm: false,\n    showDisclaimerPopUp: true,\n    showChatBubbleAtClosed: false,\n    botIconImageName: \"BlueIcon.svg\",\n    botAvatarImageName: \"BlueIcon.svg\",\n    formBannerPath: \"\",\n    rootFilePath: \"UI/\",\n    supportedLanguages: [\"en\"],\n    initialLanguage: \"en\",\n    disclaimerPopup: {\n      header: \"Important message\",\n      message: `MEDOL's virtual assistant may ask you specific identifying information, such as Social Security Number and Date of Birth, that is needed to answer your question(s). ME DOL follows strict federal security guidelines to protect your sensitive information. To further protect your information you should close the chat window and browser when you are finished.`\n    },\n    headerConfig: {\n      showLanguageToggle: false,\n      showMinimizeButton: true,\n      showExpandButton: false,\n      showReloadButton: true,\n    }\n  }\n  ctCustomData: CustomData = {\n    connectingMessage: \"Welcome to ReEmployCT. I am your virtual assistant to help you with ME related queries.\",\n    hoverMessage: \"Ask Blue\",\n    botState: \"CT\",\n    showCollectUserDetailForm: true,\n    showDisclaimerPopUp: true,\n    showChatBubbleAtClosed: false,\n    botIconImageName: \"chatboticon.png\",\n    botAvatarImageName: \"chatboticon.png\",\n    formBannerPath: \"\",\n    rootFilePath: \"UI/\",\n    supportedLanguages: [\"en\", \"es\"],\n    initialLanguage: \"en\",\n    disclaimerPopup: {\n      header: \"Important message\",\n      message: `The CTDOL virtual assistant will need to ask for specific identifying information that is needed to answer your question(s) such as date of birth or Social Security number. The agency follows strict federal security guidelines to protect your sensitive information. To further protect your information, if you are on a public computer, please log out and close your browser when you are finished.`\n    },\n    headerConfig: {\n      showLanguageToggle: true,\n      showMinimizeButton: true,\n      showExpandButton: false,\n      showReloadButton: true,\n    }\n  }\n  public botOptions: any = {};\n  public koreBot: any = {};\n  initChatbot: BehaviorSubject<Boolean> = new BehaviorSubject(false);\n  private renderer: Renderer2;\n  public showChatbot: boolean = (LibConstants.enableChatbot == 'true');\n  constructor(rendererFactory: RendererFactory2, private logger: LoggerService, private ls: LoginService, private util: UtilService) {\n    this.renderer = rendererFactory.createRenderer(null, null);\n    this.logger.info('ChatbotService initializzed successfully.');\n\n    this.map.set(\"ms\", this.msCustomData);\n    this.map.set(\"me\", this.meCustomData);\n    this.map.set(\"ct\", this.ctCustomData);\n    this.getChatbotBs().subscribe(val => {\n      if (val) {\n        this.logger.info('Initializing Chatbot.');\n        this.initializeChatbot();\n      }\n    });\n  }\n\n  getChatbotBs() {\n    return this.initChatbot;\n  }\n\n  initialize() {\n    this.initChatbot.next(true);\n  }\n\n  loadScripAndStyle() {\n    if (!LibConstants.production && this.showChatbot) { //set this property to true if you want to test this in local env.\n      this.logger.info('Not Loading Chatbot as current environment is not production. Set \"production=true\" and \"showChatbot=true\" if you want to test chatbot in local env.');\n      return;;\n    } else {\n      this.logger.info('Loading chatbot ...');\n    }\n\n    ScriptConstant.importUrls.forEach(scriptElement => {\n      // other than js and stylesheet are ignored\n      if (scriptElement.type === ScriptConstant.jsProperty) {\n        const jsScriptNode = document.createElement('script');\n        //// jsScriptNode.src = environment.koreAiWebSdkUrl + scriptElement.url;\n        jsScriptNode.src = LibConstants.koreAiWebSdkUrl + scriptElement.url;\n\n        jsScriptNode.type = 'text/javascript';\n\n        if (scriptElement.async == null) {\n          this.logger.info(jsScriptNode.src + \" will be loaded as async because of null async value\");\n          jsScriptNode.async = true;\n        } else if (scriptElement.async == true) {\n          this.logger.info(scriptElement.url + \" will be loaded as async because of null async true\");\n\n          jsScriptNode.async = true;\n        }\n        else {\n          this.logger.info(scriptElement.url + \" will be loaded as async=false\");\n\n          jsScriptNode.async = false;\n        }\n        this.renderer.appendChild(document.getElementsByTagName('head')[0], jsScriptNode);\n        document.getElementsByTagName('head')[0].appendChild(jsScriptNode);\n      } else if (scriptElement.type === ScriptConstant.cssProperty) {\n        const styleNode = document.createElement('link');\n        styleNode.rel = 'stylesheet';\n        styleNode.href = LibConstants.koreAiWebSdkUrl + scriptElement.url;\n        this.renderer.appendChild(document.getElementsByTagName('head')[0], styleNode);\n      } else if (scriptElement.type === ScriptConstant.cssPropertyAbsolute) {\n        const styleNode = document.createElement('link');\n        styleNode.rel = 'stylesheet';\n        styleNode.href = scriptElement.url;\n        this.renderer.appendChild(document.getElementsByTagName('head')[0], styleNode);\n      }\n      else {\n        this.logger.error('url ' + scriptElement.url + ' is not going to be loaded because of invalid type ' + scriptElement.type);\n      }\n    }); // for each\n  }\n\n\n\n  public initializeChatbot() {\n    this.openbot();\n  }\n\n  /***\n   * \n   * @description Initialize the chatbot with logged-in user. If user is not logged-in then bot session will be created using unique timestamp.\n   */\n  openbot() {\n    let userId = null;\n    if (this.ls.getUser()) {\n      userId = this.ls.getUser().username + '_' + this.ls.getUser().userType;\n      this.botOptions.accessToken = this.ls.getUser().access_token;\n    } else {\n      userId = Math.floor((Math.random() * 10000000) + 1) + \"_\" + new Date().getMilliseconds() + \"@mdes.ms.gov\";\n    }\n    //***CODE_START\n    this.botOptions.logLevel = 'debug';\n    this.botOptions.koreAPIUrl = LibConstants.koreAiChatbotServer;\n    //botOptions.koreSpeechAPIUrl = \"https://speech.kore.ai/\";\n    //botOptions.bearer = \"bearer xyz-------------------\";\n    //botOptions.ttsSocketUrl = 'wss://speech.kore.ai/tts/ws';\n    this.botOptions.recorderWorkerPath = './libs/recorderWorker.js';\n    this.botOptions.assertionFn = (options, callback) => this.assertion(options, callback);\n    //botOptions.koreAnonymousFn = koreAnonymousFn;\n\n    this.botOptions.JWTUrl = LibConstants.koreAiJwtService;\n    \n    this.botOptions.userIdentity = userId;// Provide users email id here\n    this.botOptions.botInfo = {\n      name: LibConstants.koreAiBotName,\n      \"_id\": LibConstants.koreAiBotId,\n      customData : this.map.get(this.util.getStateLowercase()) ? this.map.get(this.util.getStateLowercase()) : this.map.get('ms'),\n      // customData: { connectingMessage: \"Welcome to ReEmployME. I am your virtual assistant to help you with ME related queries.\", hoverMessage: \"Ask Blue\", botState: \"ME\", showCollectUserDetailForm: false, showDisclaimerPopUp: true, botIconImageName: \"chatboticon.png\", botAvatarImageName: \"chatboticon.png\", rootFilePath: \"UI/\", supportedLanguages: [\"en\", \"es\"], initialLanguage: \"en\", disclaimerPopup: { header: \"Important Message\", message: `The virtual assistant will need to ask for specific identifying information that is needed to answer you question(s) such as date of birth or Social Security number. The agency follows strict federal security guidelines to protect your sensitive information. To further protect your information, if you are on a public computer, please log out and close your browser when you are finished.`, }, headerConfig: { showLanguageToggle: true, showMinimizeButton: true, showExpandbutton: false, showReloadButton: true, } }\n    }; // bot name is case sensitive\n    this.botOptions.clientId = LibConstants.koreAiClientId;\n    //this.botOptions.clientSecret = LibConstants.koreAiClientSecret;\n\n    //this.botOptions.reemployUsBearerToken= \"\";  \n    // will need to pass token to koreAiChatBotServer when authentication needs to be validated for server side api call\n\n    var chatConfig = {\n      botOptions: this.botOptions,\n      allowIframe: false,\n      isSendButton: true,\n      isTTSEnabled: false,\n      isSpeechEnabled: false,\n      allowGoogleSpeech: false,\n      allowLocation: false,\n      loadHistory: false,\n      messageHistoryLimit: 10,\n      autoEnableSpeechAndTTS: false,\n      graphLib: \"d3\"\n    };\n    if (Object.keys(this.koreBot).length === 0) {\n      this.koreBot = koreBotChat();\n      this.koreBot.show(chatConfig);\n    } else {\n      this.koreBot.resumeChatWindow()\n    }\n    //***CODE_END\n\n  }\n\n  assertion(options, callback) {\n    var jsonData = {\n      \"clientId\": this.botOptions.clientId,\n      \"clientSecret\": this.botOptions.clientSecret,\n      \"identity\": options.userIdentity || this.botOptions.userIdentity,\n      \"aud\": \"\",\n      \"isAnonymous\": (this.ls.getUser() == null),\n      \"accessToken\": this.botOptions.accessToken\n    };\n    $.ajax({\n      url: this.botOptions.JWTUrl,\n      type: 'post',\n      data: jsonData,\n      dataType: 'json',\n      success: (data) => {\n        options.assertion = data.jwt;\n        options.handleError = this.koreBot.showError;\n        options.chatHistory = this.koreBot.chatHistory;\n        options.botDetails = this.koreBot.botDetails;\n        callback(null, options);\n        setTimeout(function () {\n          if (this.koreBot && this.koreBot.initToken) {\n            this.koreBot.initToken(options);\n          }\n        }, 2000);\n      },\n      error: (err) => {\n        this.koreBot.showError(err.responseText);\n      }\n    });\n  }\n}\n"]}

package/esm2022/lib/services/chatbot/script.const.mjs

@@ -0,0 +1,42 @@
+export class ScriptConstant {
+    static { this.cssProperty = 'css'; }
+    static { this.cssPropertyAbsolute = 'cssAbsolute'; }
+    static { this.jsProperty = 'js'; }
+    static { this.donotLoad = 'donot-load'; }
+    static { this.importUrls = [
+        { type: ScriptConstant.jsProperty, url: '/UI/libs/kore-no-conflict-start.js', async: false },
+        { type: ScriptConstant.jsProperty, url: '/UI/libs/jquery.js', async: false },
+        { type: ScriptConstant.jsProperty, url: '/UI/libs/jquery.tmpl.min.js', async: false },
+        { type: ScriptConstant.jsProperty, url: '/UI/libs/jquery-ui.min.js', async: false },
+        { type: ScriptConstant.jsProperty, url: '/UI/libs/moment.js' },
+        { type: ScriptConstant.jsProperty, url: '/libs/ie11CustomProperties.js' },
+        { type: ScriptConstant.jsProperty, url: '/libs/lodash.min.js' },
+        { type: ScriptConstant.jsProperty, url: '/libs/d3.v4.min.js' },
+        { type: ScriptConstant.jsProperty, url: '/libs/KoreGraphAdapter.js' },
+        { type: ScriptConstant.jsProperty, url: '/libs/anonymousassertion.js' },
+        { type: ScriptConstant.jsProperty, url: '/kore-bot-sdk-client.js' },
+        { type: ScriptConstant.jsProperty, url: '/UI/chatWindow.js' },
+        { type: ScriptConstant.jsProperty, url: '/UI/libs/jquery.daterangepicker.js' },
+        { type: ScriptConstant.jsProperty, url: '/UI/libs/jquery-clockpicker.js' },
+        { type: ScriptConstant.donotLoad, url: '/libs/kore-pickers.js' },
+        { type: ScriptConstant.jsProperty, url: '/libs/emoji.js' },
+        { type: ScriptConstant.jsProperty, url: '/libs/recorder.js' },
+        { type: ScriptConstant.jsProperty, url: '/libs/recorderWorker.js' },
+        { type: ScriptConstant.jsProperty, url: '/libs/purejscarousel.js' },
+        { type: ScriptConstant.jsProperty, url: '/UI/custom/customTemplate.js' },
+        { type: ScriptConstant.donotLoad, url: '/UI/kore-config.js' },
+        { type: ScriptConstant.donotLoad, url: '/UI/kore-main.js' },
+        { type: ScriptConstant.jsProperty, url: '/UI/libs/kore-no-conflict-end.js', async: false },
+        { type: ScriptConstant.donotLoad, url: '/UI/libs/jquery-ui.min.css' },
+        { type: ScriptConstant.cssProperty, url: '/UI/libs/daterangepicker.css' },
+        { type: ScriptConstant.donotLoad, url: '/UI/libs/jquery-clockpicker.css' },
+        { type: ScriptConstant.cssProperty, url: '/libs/kore-pickers.css' },
+        { type: ScriptConstant.cssProperty, url: '/libs/emojione.sprites.css' },
+        { type: ScriptConstant.cssProperty, url: '/UI/custom/customTemplate.css' },
+        { type: ScriptConstant.cssPropertyAbsolute, url: 'https://netdna.bootstrapcdn.com/font-awesome/3.2.1/css/font-awesome.css' },
+        { type: ScriptConstant.cssPropertyAbsolute, url: 'https://fonts.googleapis.com/icon?family=Material+Icons' },
+        { type: ScriptConstant.cssProperty, url: '/libs/purejscarousel.css' },
+        { type: ScriptConstant.cssProperty, url: '/UI/chatWindow.css' }
+    ]; }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../util/util.service";
+export class ClaimantService {
+    getClaimant() {
+        return this.claimant;
+    }
+    constructor(util) {
+        this.util = util;
+        this.claimant = new BehaviorSubject(null);
+    }
+    search(searchModel) {
+        return this.util.post('claimant/search', searchModel);
+    }
+    getUserDetails(userId) {
+        return this.util.get(`user/${userId}`);
+    }
+    resetClaimantPassword(resetPassword) {
+        return this.util.post('claimant/password/reset', resetPassword);
+    }
+    static { this.ɵfac = function ClaimantService_Factory(t) { return new (t || ClaimantService)(i0.ɵɵinject(i1.UtilService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ClaimantService, factory: ClaimantService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ClaimantService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.UtilService }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/claimant-context/claimant-context.service.mjs

@@ -0,0 +1,48 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/storage-angular";
+export class ClaimantContextService {
+    constructor(storage) {
+        this.storage = storage;
+        this.setupSavedValues();
+    }
+    async setupSavedValues() {
+        await this.storage.create();
+        this.ssn = await this.storage.get('soc');
+        this.claimantId = await this.storage.get('cid');
+    }
+    setClaimantContext(ssn, claimantId) {
+        this.setSsn(ssn);
+        this.setClaimantId(claimantId);
+    }
+    clearContext() {
+        this.setSsn(null);
+        this.setClaimantId(null);
+    }
+    setSsn(social) {
+        this.ssn = social ? btoa(social) : social;
+        this.storage.set('soc', this.ssn);
+    }
+    getSsn() {
+        return this.ssn;
+    }
+    getUnEncodedSsn() {
+        return this.ssn ? atob(this.ssn) : this.ssn;
+    }
+    setClaimantId(claimantId) {
+        this.claimantId = claimantId ? claimantId.toString() : claimantId;
+        this.storage.set('cid', this.claimantId);
+    }
+    getClaimantId() {
+        return this.claimantId;
+    }
+    static { this.ɵfac = function ClaimantContextService_Factory(t) { return new (t || ClaimantContextService)(i0.ɵɵinject(i1.Storage)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ClaimantContextService, factory: ClaimantContextService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ClaimantContextService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.Storage }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,56 @@
+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 ClaimantService extends BaseService {
+    constructor(http) {
+        super(http);
+        this.http = http;
+    }
+    setServiceContext() {
+        this.serviceContext = LibConstants.claimant_service.context;
+    }
+    setServicePort() {
+        this.servicePort = LibConstants.claimant_service.port;
+    }
+    setServiceProtocol() {
+        this.protocol = LibConstants.claimant_service.protocol;
+    }
+    setServiceHost() {
+        this.host = LibConstants.claimant_service.host;
+    }
+    validateEmail(claimIdentifier, uniqueKey) {
+        return this.get(`claimant/verifymail/${claimIdentifier}/${uniqueKey}`);
+    }
+    validateAndUpdateEmail(claimIdentifier, uniqueKey) {
+        return this.get(`claimant/update/${claimIdentifier}/${uniqueKey}`);
+    }
+    resendVerificationEmail(claimIdentifier) {
+        return this.get(`claimant/resendemail/${claimIdentifier}`);
+    }
+    updateEmail(emailId, claimIdentifier) {
+        return this.get(`claimant/updateemail/${emailId}/${claimIdentifier}`);
+    }
+    getJobResults() {
+        return this.get('claimant/v2/jobs');
+    }
+    loadUploadMetaData(uploadType) {
+        return this.get(`claimant/document/${uploadType}`);
+    }
+    clmuploadFile(fileObjectsArray) {
+        return this.post('claimant/document/upload', fileObjectsArray);
+    }
+    validateUpload(uploadTypeId) {
+        return this.get(`claimant/document/validate/${uploadTypeId}`);
+    }
+    static { this.ɵfac = function ClaimantService_Factory(t) { return new (t || ClaimantService)(i0.ɵɵinject(i1.HttpClient)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ClaimantService, factory: ClaimantService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ClaimantService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.HttpClient }], null); })();
+//# sourceMappingURL=data:application/json;base64,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