@deeksha2309/sunbird-collection-editor 8.0.7

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

@@ -0,0 +1,192 @@
+import { of as observableOf, throwError as observableThrowError } from 'rxjs';
+import { mergeMap } from 'rxjs/operators';
+import { Injectable } from '@angular/core';
+import { v4 as uuidv4 } from 'uuid';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * Service to provide base CRUD methods to make api request.
+ *
+ */
+export class DataService {
+    /**
+     * Constructor
+     * @param HttpClient http HttpClient reference
+     */
+    constructor(http) {
+        /**
+         * Contains base Url for api end points
+         */
+        this.baseUrl = 'api/';
+        this.http = http;
+        this._document = document;
+        const url = this._document.defaultView.questionEditorBaseUrl;
+        this.baseUrl = url ? `${url}/api/` : this.baseUrl;
+    }
+    /**
+     * for making get api calls which needs headers in response
+     *  headers are fetched to get server time using Date attribute in header
+     * @param requestParam interface
+     */
+    getWithHeaders(requestParam) {
+        const httpOptions = {
+            headers: requestParam.header ? requestParam.header : this.getHeader(),
+            params: requestParam.param,
+            observe: 'response'
+        };
+        return this.http.get(this.baseUrl + requestParam.url, httpOptions).pipe(mergeMap(({ body, headers }) => {
+            // replace ts time with header date , this value is used in telemetry
+            body.ts = this.getDateDiff((headers.get('Date')));
+            if (body.responseCode !== 'OK') {
+                return observableThrowError(body);
+            }
+            return observableOf(body);
+        }));
+    }
+    /**
+     * for making get api calls
+     *
+     * @param requestParam interface
+     */
+    get(requestParam) {
+        const httpOptions = {
+            headers: requestParam.header ? requestParam.header : this.getHeader(),
+            params: requestParam.param
+        };
+        return this.http.get(this.baseUrl + requestParam.url, httpOptions).pipe(mergeMap((data) => {
+            if (data.responseCode !== 'OK') {
+                return observableThrowError(data);
+            }
+            return observableOf(data);
+        }));
+    }
+    /**
+     * for making post api calls with headers in response object
+     *
+     * @param RequestParam requestParam interface
+     *
+     */
+    postWithHeaders(requestParam) {
+        const httpOptions = {
+            headers: requestParam.header ? this.getHeader(requestParam.header) : this.getHeader(),
+            params: requestParam.param,
+            observe: 'response'
+        };
+        return this.http.post(this.baseUrl + requestParam.url, requestParam.data, httpOptions).pipe(mergeMap(({ body, headers }) => {
+            // replace ts time with header date , this value is used in telemetry
+            body.ts = this.getDateDiff((headers.get('Date')));
+            if (body.responseCode !== 'OK') {
+                return observableThrowError(body);
+            }
+            return observableOf(body);
+        }));
+    }
+    /**
+     * for making post api calls
+     * @param RequestParam requestParam interface
+     */
+    post(requestParam) {
+        const httpOptions = {
+            headers: requestParam.header ? this.getHeader(requestParam.header) : this.getHeader(),
+            params: requestParam.param
+        };
+        return this.http.post(this.baseUrl + requestParam.url, requestParam.data, httpOptions).pipe(mergeMap((data) => {
+            if (data.responseCode !== 'OK') {
+                return observableThrowError(data);
+            }
+            return observableOf(data);
+        }));
+    }
+    /**
+     * for making patch api calls
+     *
+     * @param RequestParam requestParam interface
+     *
+     */
+    patch(requestParam) {
+        const httpOptions = {
+            headers: requestParam.header ? requestParam.header : this.getHeader(),
+            params: requestParam.param
+        };
+        return this.http.patch(this.baseUrl + requestParam.url, requestParam.data, httpOptions).pipe(mergeMap((data) => {
+            if (data.responseCode !== 'OK') {
+                return observableThrowError(data);
+            }
+            return observableOf(data);
+        }));
+    }
+    /**
+     * for making delete api calls
+     * @param RequestParam requestParam interface
+     */
+    delete(requestParam) {
+        const httpOptions = {
+            headers: requestParam.header ? requestParam.header : this.getHeader(),
+            params: requestParam.param,
+            body: requestParam.data
+        };
+        return this.http.delete(this.baseUrl + requestParam.url, httpOptions).pipe(mergeMap((data) => {
+            if (data.responseCode !== 'OK') {
+                return observableThrowError(data);
+            }
+            return observableOf(data);
+        }));
+    }
+    /**
+     * for preparing headers
+     */
+    getHeader(headers) {
+        // tslint:disable-next-line:variable-name
+        const default_headers = {
+            Accept: 'application/json',
+            // 'X-Consumer-ID': 'X-Consumer-ID',
+            'X-Source': 'web',
+            ts: '2020-12-31T16:23:27+05:30',
+            'X-msgid': uuidv4(),
+            // tslint:disable-next-line:max-line-length
+            Authorization: ''
+        };
+        try {
+            this.deviceId = document.getElementById('deviceId').value || '9d1588c3cbc765c334ccc565e53d81a8';
+            this.appId = document.getElementById('appId').value || 'dev.dock.portal';
+        }
+        catch (err) { }
+        if (this.deviceId) {
+            default_headers['X-Device-ID'] = this.deviceId;
+        }
+        if (this.rootOrgId) {
+            default_headers['X-Org-code'] = this.rootOrgId;
+        }
+        if (this.channelId) {
+            default_headers['X-Channel-Id'] = this.channelId;
+        }
+        if (this.appId) {
+            default_headers['X-App-Id'] = this.appId;
+        }
+        if (headers) {
+            return { ...default_headers, ...headers };
+        }
+        else {
+            return { ...default_headers };
+        }
+    }
+    getDateDiff(serverdate) {
+        const currentdate = new Date();
+        const serverDate = new Date(serverdate);
+        if (serverdate) {
+            return (serverDate - currentdate) / 1000;
+        }
+        else {
+            return 0;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DataService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DataService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DataService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data.service.js","sourceRoot":"","sources":["../../../../../../projects/collection-editor-library/src/lib/services/data/data.service.ts"],"names":[],"mappings":"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","sourcesContent":["\nimport { of as observableOf, throwError as observableThrowError, Observable } from 'rxjs';\nimport { mergeMap } from 'rxjs/operators';\nimport { HttpClient } from '@angular/common/http';\nimport { Inject, Injectable } from '@angular/core';\nimport { v4 as uuidv4 } from 'uuid';\n// import * as moment from 'moment';\nimport * as _ from 'lodash-es';\nimport { ServerResponse } from '../../interfaces/serverResponse';\nimport { RequestParam } from '../../interfaces/requestParam';\nimport { HttpOptions } from '../../interfaces/httpOptions';\nimport { DOCUMENT } from '@angular/common';\n\n/**\n * Service to provide base CRUD methods to make api request.\n *\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class DataService {\n  /**\n   * Contains rootOrg Id\n   */\n  rootOrgId: string;\n  /**\n   * Contains channel Id\n   */\n  channelId: string;\n   /**\n    * Contains appId\n    */\n  appId: string;\n  /**\n   * Contains devoce Id\n   */\n  deviceId: string;\n  /**\n   * Contains base Url for api end points\n   */\n  baseUrl = 'api/';\n  /**\n   * angular HttpClient\n   */\n  http: HttpClient;\n\n  _document: Document\n  /**\n   * Constructor\n   * @param HttpClient http HttpClient reference\n   */\n  constructor(http: HttpClient) {\n    this.http = http;\n    this._document = document as Document\n    const url = (this._document.defaultView as any).questionEditorBaseUrl;\n    this.baseUrl = url ? `${url}/api/`: this.baseUrl\n  }\n\n  /**\n   * for making get api calls which needs headers in response\n   *  headers are fetched to get server time using Date attribute in header\n   * @param requestParam interface\n   */\n  getWithHeaders(requestParam: RequestParam): Observable<ServerResponse> {\n    const httpOptions: HttpOptions = {\n      headers: requestParam.header ? requestParam.header : this.getHeader(),\n      params: requestParam.param,\n      observe: 'response'\n    };\n\n    return this.http.get(this.baseUrl + requestParam.url, httpOptions).pipe(\n      mergeMap(({body, headers}: any) => {\n        // replace ts time with header date , this value is used in telemetry\n        body.ts =  this.getDateDiff((headers.get('Date')));\n        if (body.responseCode !== 'OK') {\n          return observableThrowError(body);\n        }\n        return observableOf(body);\n      }));\n  }\n\n  /**\n   * for making get api calls\n   *\n   * @param requestParam interface\n   */\n  get(requestParam: RequestParam): Observable<ServerResponse> {\n    const httpOptions: HttpOptions = {\n      headers: requestParam.header ? requestParam.header : this.getHeader(),\n      params: requestParam.param\n    };\n\n    return this.http.get(this.baseUrl + requestParam.url, httpOptions).pipe(\n      mergeMap((data: ServerResponse) => {\n        if (data.responseCode !== 'OK') {\n          return observableThrowError(data);\n        }\n        return observableOf(data);\n      }));\n\n  }\n\n  /**\n   * for making post api calls with headers in response object\n   *\n   * @param RequestParam requestParam interface\n   *\n   */\n  postWithHeaders(requestParam: RequestParam): Observable<any> {\n    const httpOptions: HttpOptions = {\n      headers: requestParam.header ? this.getHeader(requestParam.header) : this.getHeader(),\n      params: requestParam.param,\n      observe: 'response'\n    };\n\n    return this.http.post(this.baseUrl + requestParam.url, requestParam.data, httpOptions).pipe(\n      mergeMap(({body, headers}: any) => {\n        // replace ts time with header date , this value is used in telemetry\n        body.ts =  this.getDateDiff((headers.get('Date')));\n        if (body.responseCode !== 'OK') {\n          return observableThrowError(body);\n        }\n        return observableOf(body);\n      }));\n  }\n\n  /**\n   * for making post api calls\n   * @param RequestParam requestParam interface\n   */\n  post(requestParam: RequestParam): Observable<ServerResponse> {\n    const httpOptions: HttpOptions = {\n      headers: requestParam.header ? this.getHeader(requestParam.header) : this.getHeader(),\n      params: requestParam.param\n    };\n\n    return this.http.post(this.baseUrl + requestParam.url, requestParam.data, httpOptions).pipe(\n      mergeMap((data: ServerResponse) => {\n        if (data.responseCode !== 'OK') {\n          return observableThrowError(data);\n        }\n        return observableOf(data);\n      }));\n  }\n\n  /**\n   * for making patch api calls\n   *\n   * @param RequestParam requestParam interface\n   *\n   */\n  patch(requestParam: RequestParam): Observable<ServerResponse> {\n    const httpOptions: HttpOptions = {\n      headers: requestParam.header ? requestParam.header : this.getHeader(),\n      params: requestParam.param\n    };\n\n    return this.http.patch(this.baseUrl + requestParam.url, requestParam.data, httpOptions).pipe(\n      mergeMap((data: ServerResponse) => {\n        if (data.responseCode !== 'OK') {\n          return observableThrowError(data);\n        }\n        return observableOf(data);\n      }));\n  }\n\n  /**\n   * for making delete api calls\n   * @param RequestParam requestParam interface\n   */\n  delete(requestParam: RequestParam): Observable<ServerResponse> {\n    const httpOptions: HttpOptions = {\n      headers: requestParam.header ? requestParam.header : this.getHeader(),\n      params: requestParam.param,\n      body: requestParam.data\n    };\n    return this.http.delete(this.baseUrl + requestParam.url, httpOptions).pipe(\n      mergeMap((data: ServerResponse) => {\n        if (data.responseCode !== 'OK') {\n          return observableThrowError(data);\n        }\n        return observableOf(data);\n      }));\n  }\n\n  /**\n   * for preparing headers\n   */\n  private getHeader(headers?: HttpOptions['headers']): HttpOptions['headers'] {\n    // tslint:disable-next-line:variable-name\n    const default_headers = {\n      Accept: 'application/json',\n      // 'X-Consumer-ID': 'X-Consumer-ID',\n      'X-Source': 'web',\n      ts: '2020-12-31T16:23:27+05:30', // moment().format(), //TODO::\n      'X-msgid': uuidv4(),\n      // tslint:disable-next-line:max-line-length\n      Authorization: ''\n    };\n\n    try {\n      this.deviceId = (document.getElementById('deviceId') as HTMLInputElement).value || '9d1588c3cbc765c334ccc565e53d81a8';\n      this.appId = (document.getElementById('appId') as HTMLInputElement).value || 'dev.dock.portal';\n    } catch (err) { }\n    if (this.deviceId) {\n      default_headers['X-Device-ID'] = this.deviceId;\n    }\n    if (this.rootOrgId) {\n      default_headers['X-Org-code'] = this.rootOrgId;\n    }\n    if (this.channelId) {\n      default_headers['X-Channel-Id'] = this.channelId;\n    }\n    if (this.appId) {\n      default_headers['X-App-Id'] = this.appId;\n    }\n    if (headers) {\n      return { ...default_headers, ...headers };\n    } else {\n      return { ...default_headers };\n    }\n  }\n\n  private getDateDiff(serverdate): number {\n    const currentdate: any = new Date();\n    const serverDate: any = new Date(serverdate);\n    if (serverdate) {\n      return ( serverDate - currentdate ) / 1000;\n    } else {\n      return 0;\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,309 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import * as _ from 'lodash-es';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../config/config.service";
+import * as i2 from "../public-data/public-data.service";
+import * as i3 from "../../services/tree/tree.service";
+import * as i4 from "../../services/toaster/toaster.service";
+export class DialcodeService {
+    constructor(configService, publicDataService, treeService, toasterService) {
+        this.configService = configService;
+        this.publicDataService = publicDataService;
+        this.treeService = treeService;
+        this.toasterService = toasterService;
+        this.invaliddialCodeMap = {};
+        this.dialCodeMap = {};
+        this.dialcodeList = [];
+        this.maxChar = 6;
+    }
+    reserveDialCode(indetifier, requestCount) {
+        const req = {
+            url: this.configService.urlConFig.URLS.DIALCODE.RESERVE + indetifier,
+            data: {
+                request: {
+                    dialcodes: {
+                        count: requestCount,
+                        qrCodeSpec: {
+                            errorCorrectionLevel: 'H'
+                        }
+                    }
+                }
+            }
+        };
+        return this.publicDataService.post(req);
+    }
+    linkDialcode(indetifier, dialcodes) {
+        const req = {
+            url: this.configService.urlConFig.URLS.DIALCODE.LINK + indetifier,
+            data: {
+                request: {
+                    content: dialcodes
+                }
+            }
+        };
+        return this.publicDataService.post(req);
+    }
+    downloadQRCode(processId) {
+        const req = {
+            url: this.configService.urlConFig.URLS.DIALCODE.PROCESS + processId,
+        };
+        return this.publicDataService.get(req);
+    }
+    searchDialCode(dialcode) {
+        const req = {
+            url: this.configService.urlConFig.URLS.DIALCODE.SEARCH,
+            data: {
+                request: {
+                    search: {
+                        identifier: dialcode,
+                    }
+                }
+            }
+        };
+        return this.publicDataService.post(req);
+    }
+    updateDialCode(dialcode) {
+        if (!_.isEmpty(dialcode)) {
+            dialcode = _.isArray(dialcode) ? dialcode[0] : dialcode;
+            const editFlag = (dialcode && (dialcode.length === this.maxChar)) ? true : false;
+            if (_.indexOf(this.dialcodeList, dialcode) !== -1) {
+                return of({ isEditable: editFlag, isValid: true });
+            }
+            else {
+                return this.searchDialCode(dialcode).pipe(map(response => {
+                    if (response.result.count) {
+                        _.uniq(this.dialcodeList.push(response.result.dialcodes[0].identifier));
+                        return { isEditable: editFlag, isValid: true };
+                    }
+                    else {
+                        return { isEditable: editFlag, isValid: false };
+                    }
+                }));
+            }
+        }
+        else {
+            return of({ isEditable: false });
+        }
+    }
+    clearDialCode() {
+        const currentNode = this.treeService.getActiveNode().data;
+        if (_.has(this.invaliddialCodeMap, currentNode.id)) {
+            _.unset(this.invaliddialCodeMap, currentNode.id);
+        }
+        if (_.has(this.dialCodeMap, currentNode.id)) {
+            _.unset(this.dialCodeMap, currentNode.id);
+        }
+        if (currentNode.metadata && currentNode.metadata.dialcodes === null) {
+            if (this.treeService.treeCache.nodesModified && this.treeService.treeCache.nodesModified[currentNode.id]) {
+                this.treeService.treeCache.nodesModified[currentNode.id].metadata.dialcodes = [];
+            }
+            this.dialCodeMap[currentNode.id] = '';
+            currentNode.metadata.dialcodes = null;
+        }
+        this.treeService.nextTreeStatus('modified');
+    }
+    changeDialCode(dialcode) {
+        const currentNode = this.treeService.getActiveNode().data;
+        if (_.isEmpty(dialcode)) {
+            if (_.has(this.invaliddialCodeMap, currentNode.id)) {
+                _.unset(this.invaliddialCodeMap, currentNode.id);
+            }
+            if (_.has(this.dialCodeMap, currentNode.id)) {
+                _.unset(this.dialCodeMap, currentNode.id);
+            }
+            if (currentNode.metadata && currentNode.metadata.dialcodes && currentNode.metadata.dialcodes.length) {
+                if (this.treeService.treeCache.nodesModified && this.treeService.treeCache.nodesModified[currentNode.id]) {
+                    this.treeService.treeCache.nodesModified[currentNode.id].metadata.dialcodes = [];
+                }
+                this.dialCodeMap[currentNode.id] = '';
+                currentNode.metadata.dialcodes = null;
+            }
+            this.treeService.nextTreeStatus('modified');
+        }
+    }
+    validateDialCode(dialcode) {
+        if (this.checkDuplicateDialCode(dialcode)) {
+            return of({ isEditable: true, isValid: false, statusMsg: 'Duplicate QR code' });
+        }
+        else if (String(dialcode).match(/^[A-Z0-9]{2,}$/)) {
+            const node = this.treeService.getActiveNode();
+            if (this.treeService.treeCache.nodesModified && this.treeService.treeCache.nodesModified[node.data.id]) {
+                this.treeService.treeCache.nodesModified[node.data.id].metadata.dialcodes = _.castArray(dialcode);
+            }
+            if (_.indexOf(this.dialcodeList, dialcode) !== -1) {
+                if (_.has(this.invaliddialCodeMap, node.data.id)) {
+                    _.unset(this.invaliddialCodeMap, node.data.id);
+                }
+                this.dialCodeMap[node.data.id] = dialcode;
+                node.data.metadata.dialcodes = dialcode;
+                this.treeService.nextTreeStatus('modified');
+                return of({ isEditable: true, isValid: true });
+            }
+            else {
+                return this.searchDialCode(dialcode).pipe(map(response => {
+                    if (response.result.count) {
+                        _.uniq(this.dialcodeList.push(dialcode));
+                        if (_.has(this.invaliddialCodeMap, node.data.id)) {
+                            _.unset(this.invaliddialCodeMap, node.data.id);
+                        }
+                        this.dialCodeMap[node.data.id] = dialcode;
+                        node.data.metadata.dialcodes = dialcode;
+                        this.treeService.nextTreeStatus('modified');
+                        return { isEditable: true, isValid: true };
+                    }
+                    else {
+                        if (_.has(this.dialCodeMap, node.data.id)) {
+                            _.unset(this.dialCodeMap, node.data.id);
+                        }
+                        this.invaliddialCodeMap[node.data.id] = dialcode;
+                        node.data.metadata.dialcodes = dialcode;
+                        this.treeService.nextTreeStatus('modified');
+                        return { isEditable: true, isValid: false };
+                    }
+                }));
+            }
+        }
+        else {
+            return of({ isEditable: false });
+        }
+    }
+    checkDuplicateDialCode(activeQRCode) {
+        const getAllNodes = this.treeService.getTreeObject();
+        const findValuesDeepByKey = (obj, key, res = []) => (
+        // tslint:disable-next-line:no-unused-expression
+        _.cloneDeepWith(obj, (v, k) => { k === key && res.push(v); }) && res);
+        const dialcodeArray = _.flattenDeep(findValuesDeepByKey(getAllNodes, 'dialcodes'));
+        if (_.includes(dialcodeArray, activeQRCode)) {
+            return true;
+        }
+        return false;
+    }
+    validateUnitsDialcodes() {
+        let dialCodeMisssing = false;
+        const rootNode = this.treeService.getTreeObject();
+        let dialcodes;
+        rootNode.visit((node) => {
+            dialcodes = node.data.metadata.dialcodes;
+            const unitDialCode = _.isArray(dialcodes) ? dialcodes[0] : dialcodes;
+            if (node.data.metadata.visibility === 'Parent' || node.data.root) {
+                if (node.data.metadata.dialcodeRequired === 'Yes' && !_.includes(this.dialcodeList, unitDialCode)) {
+                    dialCodeMisssing = true;
+                    this.treeService.highlightNode(node.data.id, 'add');
+                }
+                else if (node.data.metadata.dialcodeRequired === 'Yes' && _.isEmpty(dialcodes)) {
+                    dialCodeMisssing = true;
+                    this.treeService.highlightNode(node.data.id, 'add');
+                }
+                // else if (node.data.metadata.dialcodeRequired === 'No' && !_.isEmpty(dialcodes)) {
+                //   dialCodeMisssing = true;
+                //   this.treeService.highlightNode(node.data.id, 'add');
+                // }
+            }
+        });
+        if (dialCodeMisssing) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    highlightNodeForInvalidDialCode(res, nodesModified, indetifier) {
+        const mapArr = [];
+        _.forEach(this.invaliddialCodeMap, (value, key) => {
+            if (_.has(res.identifiers, key)) {
+                delete this.invaliddialCodeMap[key];
+                this.invaliddialCodeMap[res.identifiers[key]] = value;
+                this.treeService.highlightNode(res.identifiers[key], 'add');
+                this.storeDialCodes(res.identifiers[key], value);
+            }
+            else {
+                this.storeDialCodes(key, value);
+                this.treeService.highlightNode(key, 'add');
+            }
+        });
+        _.forEach(this.dialCodeMap, (value, key) => {
+            if (_.has(res.identifiers, key)) {
+                delete this.dialCodeMap[key];
+                this.dialCodeMap[res.identifiers[key]] = value;
+                mapArr.push({ identifier: res.identifiers[key], dialcode: value });
+                this.treeService.highlightNode(res.identifiers[key], 'remove');
+                this.storeDialCodes(res.identifiers[key], value);
+            }
+            else {
+                mapArr.push({ identifier: key, dialcode: value });
+                this.storeDialCodes(key, value);
+                this.treeService.highlightNode(key, 'remove');
+            }
+        });
+        let dialcodesUpdated = false;
+        _.forIn(nodesModified, (node) => {
+            if ((node.metadata.dialcodes || node.metadata.dialcodes === null) && !dialcodesUpdated) {
+                dialcodesUpdated = true;
+            }
+            else {
+                const dialObj = _.find(mapArr, (Obj) => {
+                    return Obj.identifier === res.content_id;
+                });
+                if (!_.isUndefined(dialObj)) {
+                    dialcodesUpdated = true;
+                }
+            }
+        });
+        if (dialcodesUpdated) {
+            this.dialcodeLink(mapArr, indetifier);
+        }
+    }
+    storeDialCodes(nodeId, dialCode) {
+        const node = this.treeService.getNodeById(nodeId);
+        if (node && node.data) {
+            node.data.metadata.dialcodes = dialCode;
+        }
+    }
+    dialcodeLink(dialcodeMap, indetifier) {
+        if (!_.isEmpty(dialcodeMap)) {
+            this.linkDialcode(indetifier, dialcodeMap).subscribe((res) => {
+                if (!_.isEmpty(this.dialCodeMap) && !_.isEmpty(this.invaliddialCodeMap)) {
+                    this.toasterService.warning(_.get(this.configService, 'labelConfig.messages.warning.002'));
+                }
+                else {
+                    this.toasterService.success(_.get(this.configService, 'labelConfig.messages.success.009'));
+                }
+                this.clearDialCodeMaps();
+            }, (err) => {
+                if (err && err.error && err.error.params && err.error.params.err === 'ERR_DIALCODE_LINK') {
+                    this.toasterService.error(err.error.params.errmsg);
+                }
+                else {
+                    this.toasterService.error(_.get(this.configService, 'labelConfig.messages.error.012'));
+                }
+            });
+        }
+        else if (!_.isEmpty(this.invaliddialCodeMap)) {
+            this.toasterService.warning(_.get(this.configService, 'labelConfig.messages.warning.002'));
+        }
+    }
+    clearDialCodeMaps() {
+        this.dialCodeMap = {};
+        this.invaliddialCodeMap = {};
+    }
+    readExistingQrCode() {
+        const rootNode = this.treeService.getTreeObject();
+        this.dialcodeList = [];
+        rootNode.visit((node) => {
+            if (!_.isEmpty(node.data.metadata.dialcodes)) {
+                this.dialcodeList.push(node.data.metadata.dialcodes[0]);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DialcodeService, deps: [{ token: i1.ConfigService }, { token: i2.PublicDataService }, { token: i3.TreeService }, { token: i4.ToasterService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DialcodeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DialcodeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ConfigService }, { type: i2.PublicDataService }, { type: i3.TreeService }, { type: i4.ToasterService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialcode.service.js","sourceRoot":"","sources":["../../../../../../projects/collection-editor-library/src/lib/services/dialcode/dialcode.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable, of } from 'rxjs';\nimport * as _ from 'lodash-es';\nimport { DialcodeCursor } from '@project-sunbird/common-form-elements-full';\nimport { ConfigService } from '../config/config.service';\nimport { PublicDataService } from '../public-data/public-data.service';\nimport { TreeService } from '../../services/tree/tree.service';\nimport { ToasterService } from '../../services/toaster/toaster.service';\nimport { map } from 'rxjs/operators';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DialcodeService implements DialcodeCursor {\n\n  public invaliddialCodeMap = {};\n  public dialCodeMap = {};\n  public dialcodeList = [];\n  private maxChar = 6;\n  constructor(public configService: ConfigService, private publicDataService: PublicDataService,\n              private treeService: TreeService, private toasterService: ToasterService) { }\n\n  reserveDialCode(indetifier, requestCount): Observable<any> {\n    const req = {\n      url: this.configService.urlConFig.URLS.DIALCODE.RESERVE + indetifier,\n      data: {\n        request: {\n          dialcodes: {\n            count: requestCount,\n            qrCodeSpec: {\n              errorCorrectionLevel: 'H'\n            }\n          }\n        }\n      }\n    };\n    return this.publicDataService.post(req);\n  }\n\n  linkDialcode(indetifier, dialcodes): Observable<any> {\n    const req = {\n      url: this.configService.urlConFig.URLS.DIALCODE.LINK + indetifier,\n      data: {\n        request: {\n          content: dialcodes\n        }\n      }\n    };\n    return this.publicDataService.post(req);\n  }\n\n  downloadQRCode(processId): Observable<any> {\n    const req = {\n      url: this.configService.urlConFig.URLS.DIALCODE.PROCESS + processId,\n    };\n    return this.publicDataService.get(req);\n  }\n\n  searchDialCode(dialcode): Observable<any> {\n    const req = {\n      url: this.configService.urlConFig.URLS.DIALCODE.SEARCH,\n      data: {\n        request: {\n          search: {\n            identifier: dialcode,\n          }\n        }\n      }\n    };\n    return this.publicDataService.post(req);\n  }\n\n  updateDialCode(dialcode): Observable<any> {\n    if (!_.isEmpty(dialcode)) {\n      dialcode = _.isArray(dialcode) ? dialcode[0] : dialcode;\n      const editFlag = (dialcode && (dialcode.length === this.maxChar)) ? true : false;\n      if (_.indexOf(this.dialcodeList, dialcode) !== -1) {\n        return of({ isEditable: editFlag, isValid: true });\n      } else {\n        return this.searchDialCode(dialcode).pipe(map(response => {\n          if (response.result.count) {\n            _.uniq(this.dialcodeList.push(response.result.dialcodes[0].identifier));\n            return { isEditable: editFlag, isValid: true };\n          } else {\n            return { isEditable: editFlag, isValid: false };\n          }\n        }));\n      }\n    } else {\n      return of({ isEditable: false });\n    }\n  }\n\n  clearDialCode() {\n    const currentNode = this.treeService.getActiveNode().data;\n    if (_.has(this.invaliddialCodeMap, currentNode.id)) { _.unset(this.invaliddialCodeMap, currentNode.id); }\n    if (_.has(this.dialCodeMap, currentNode.id)) { _.unset(this.dialCodeMap, currentNode.id); }\n    if (currentNode.metadata && currentNode.metadata.dialcodes === null) {\n      if (this.treeService.treeCache.nodesModified && this.treeService.treeCache.nodesModified[currentNode.id]) {\n        this.treeService.treeCache.nodesModified[currentNode.id].metadata.dialcodes = [];\n      }\n      this.dialCodeMap[currentNode.id] = '';\n      currentNode.metadata.dialcodes = null;\n    }\n    this.treeService.nextTreeStatus('modified');\n  }\n\n  changeDialCode(dialcode) {\n    const currentNode = this.treeService.getActiveNode().data;\n    if (_.isEmpty(dialcode)) {\n      if (_.has(this.invaliddialCodeMap, currentNode.id)) { _.unset(this.invaliddialCodeMap, currentNode.id); }\n      if (_.has(this.dialCodeMap, currentNode.id)) { _.unset(this.dialCodeMap, currentNode.id); }\n      if (currentNode.metadata && currentNode.metadata.dialcodes && currentNode.metadata.dialcodes.length) {\n        if (this.treeService.treeCache.nodesModified && this.treeService.treeCache.nodesModified[currentNode.id]) {\n          this.treeService.treeCache.nodesModified[currentNode.id].metadata.dialcodes = [];\n        }\n        this.dialCodeMap[currentNode.id] = '';\n        currentNode.metadata.dialcodes = null;\n      }\n      this.treeService.nextTreeStatus('modified');\n    }\n  }\n\n  validateDialCode(dialcode): Observable<any> {\n    if (this.checkDuplicateDialCode(dialcode)) {\n      return of({ isEditable: true, isValid: false, statusMsg: 'Duplicate QR code' });\n    } else if (String(dialcode).match(/^[A-Z0-9]{2,}$/)) {\n      const node = this.treeService.getActiveNode();\n      if (this.treeService.treeCache.nodesModified && this.treeService.treeCache.nodesModified[node.data.id]) {\n        this.treeService.treeCache.nodesModified[node.data.id].metadata.dialcodes = _.castArray(dialcode);\n      }\n      if (_.indexOf(this.dialcodeList, dialcode) !== -1) {\n        if (_.has(this.invaliddialCodeMap, node.data.id)) { _.unset(this.invaliddialCodeMap, node.data.id); }\n        this.dialCodeMap[node.data.id] = dialcode;\n        node.data.metadata.dialcodes = dialcode;\n        this.treeService.nextTreeStatus('modified');\n        return of({ isEditable: true, isValid: true });\n      } else {\n        return this.searchDialCode(dialcode).pipe(map(response => {\n          if (response.result.count) {\n            _.uniq(this.dialcodeList.push(dialcode));\n            if (_.has(this.invaliddialCodeMap, node.data.id)) { _.unset(this.invaliddialCodeMap, node.data.id); }\n            this.dialCodeMap[node.data.id] = dialcode;\n            node.data.metadata.dialcodes = dialcode;\n            this.treeService.nextTreeStatus('modified');\n            return { isEditable: true, isValid: true };\n          } else {\n            if (_.has(this.dialCodeMap, node.data.id)) { _.unset(this.dialCodeMap, node.data.id); }\n            this.invaliddialCodeMap[node.data.id] = dialcode;\n            node.data.metadata.dialcodes = dialcode;\n            this.treeService.nextTreeStatus('modified');\n            return { isEditable: true, isValid: false };\n          }\n        }));\n      }\n    } else {\n      return of({ isEditable: false });\n    }\n  }\n\n  checkDuplicateDialCode(activeQRCode) {\n    const getAllNodes = this.treeService.getTreeObject();\n    const findValuesDeepByKey = (obj, key, res = []) => (\n      // tslint:disable-next-line:no-unused-expression\n      _.cloneDeepWith(obj, (v, k) => { k === key && res.push(v); }) && res\n    );\n    const dialcodeArray = _.flattenDeep(findValuesDeepByKey(getAllNodes, 'dialcodes'));\n    if (_.includes(dialcodeArray, activeQRCode)) {\n      return true;\n    }\n    return false;\n  }\n\n  validateUnitsDialcodes() {\n    let dialCodeMisssing = false;\n    const rootNode = this.treeService.getTreeObject();\n    let dialcodes;\n    rootNode.visit((node) => {\n      dialcodes = node.data.metadata.dialcodes;\n      const unitDialCode = _.isArray(dialcodes) ? dialcodes[0] : dialcodes;\n      if (node.data.metadata.visibility === 'Parent' || node.data.root) {\n        if (node.data.metadata.dialcodeRequired === 'Yes' && !_.includes(this.dialcodeList, unitDialCode)) {\n          dialCodeMisssing = true;\n          this.treeService.highlightNode(node.data.id, 'add');\n        } else if (node.data.metadata.dialcodeRequired === 'Yes' && _.isEmpty(dialcodes)) {\n          dialCodeMisssing = true;\n          this.treeService.highlightNode(node.data.id, 'add');\n        } \n        // else if (node.data.metadata.dialcodeRequired === 'No' && !_.isEmpty(dialcodes)) {\n        //   dialCodeMisssing = true;\n        //   this.treeService.highlightNode(node.data.id, 'add');\n        // }\n      }\n    });\n    if (dialCodeMisssing) {\n      return false;\n    } else {\n      return true;\n    }\n  }\n\n  highlightNodeForInvalidDialCode(res, nodesModified, indetifier) {\n    const mapArr = [];\n    _.forEach(this.invaliddialCodeMap, (value, key) => {\n      if (_.has(res.identifiers, key)) {\n        delete this.invaliddialCodeMap[key];\n        this.invaliddialCodeMap[res.identifiers[key]] = value;\n        this.treeService.highlightNode(res.identifiers[key], 'add');\n        this.storeDialCodes(res.identifiers[key], value);\n      } else {\n        this.storeDialCodes(key, value);\n        this.treeService.highlightNode(key, 'add');\n      }\n    });\n    _.forEach(this.dialCodeMap, (value, key) => {\n      if (_.has(res.identifiers, key)) {\n        delete this.dialCodeMap[key];\n        this.dialCodeMap[res.identifiers[key]] = value;\n        mapArr.push({ identifier: res.identifiers[key], dialcode: value });\n        this.treeService.highlightNode(res.identifiers[key], 'remove');\n        this.storeDialCodes(res.identifiers[key], value);\n      } else {\n        mapArr.push({ identifier: key, dialcode: value });\n        this.storeDialCodes(key, value);\n        this.treeService.highlightNode(key, 'remove');\n      }\n    });\n    let dialcodesUpdated = false;\n    _.forIn(nodesModified, (node) => {\n      if ((node.metadata.dialcodes || node.metadata.dialcodes === null) && !dialcodesUpdated) {\n        dialcodesUpdated = true;\n      } else {\n        const dialObj = _.find(mapArr, (Obj) => {  // check this: not required\n          return Obj.identifier === res.content_id;\n        });\n        if (!_.isUndefined(dialObj)) {\n          dialcodesUpdated = true;\n        }\n      }\n    });\n    if (dialcodesUpdated) {\n      this.dialcodeLink(mapArr, indetifier);\n    }\n  }\n\n  storeDialCodes(nodeId, dialCode) {\n    const node = this.treeService.getNodeById(nodeId);\n    if (node && node.data) {\n      node.data.metadata.dialcodes = dialCode;\n    }\n  }\n\n  dialcodeLink(dialcodeMap, indetifier) {\n    if (!_.isEmpty(dialcodeMap)) {\n      this.linkDialcode(indetifier, dialcodeMap).subscribe((res) => {\n        if ( !_.isEmpty(this.dialCodeMap) && !_.isEmpty(this.invaliddialCodeMap)) {\n          this.toasterService.warning(_.get(this.configService, 'labelConfig.messages.warning.002'));\n        } else {\n          this.toasterService.success(_.get(this.configService, 'labelConfig.messages.success.009'));\n        }\n        this.clearDialCodeMaps();\n        }, (err) => {\n          if (err && err.error && err.error.params && err.error.params.err === 'ERR_DIALCODE_LINK') {\n            this.toasterService.error(err.error.params.errmsg);\n        } else {\n            this.toasterService.error(_.get(this.configService, 'labelConfig.messages.error.012'));\n        }\n      });\n    } else if (!_.isEmpty(this.invaliddialCodeMap)) {\n      this.toasterService.warning(_.get(this.configService, 'labelConfig.messages.warning.002'));\n    }\n  }\n\n  clearDialCodeMaps() {\n    this.dialCodeMap = {};\n    this.invaliddialCodeMap = {};\n  }\n\n  readExistingQrCode() {\n    const rootNode = this.treeService.getTreeObject();\n    this.dialcodeList = [] ;\n    rootNode.visit(( node ) => {\n        if (!_.isEmpty(node.data.metadata.dialcodes)) {\n            this.dialcodeList.push(node.data.metadata.dialcodes[0]);\n        }\n    });\n  }\n\n}\n"]}