@thetradeengineorg1/snova-shell-module 0.0.1

package/esm2015/lib/shell-components/services/payment.service.js

@@ -0,0 +1,103 @@
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { LocalStorageProperties } from '../../globaldependencies/constants/localstorage-properties';
+import { ApiUrls } from '../constants/api-urls';
+import { CompanyPaymentUpsertModel } from '../models/company-payment-model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "ngx-cookie-service";
+export class PaymentService {
+    constructor(http, cookieService) {
+        this.http = http;
+        this.cookieService = cookieService;
+    }
+    cancelSubscription() {
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        let APIEndpoint = environment.apiURL;
+        const httpOptions = {
+            headers: new HttpHeaders({ "Content-Type": "application/json" })
+        };
+        const body = JSON.stringify({});
+        return this.http.post(APIEndpoint + ApiUrls.CancelSubscription, body, httpOptions);
+    }
+    getAllInvoices(transaction) {
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        let APIEndpoint = environment.apiURL;
+        const httpOptions = {
+            headers: new HttpHeaders({ "Content-Type": "application/json" })
+        };
+        var companyPaymentDetails = new CompanyPaymentUpsertModel();
+        companyPaymentDetails.TransactionName = transaction;
+        let body = JSON.stringify(companyPaymentDetails);
+        return this.http.post(APIEndpoint + ApiUrls.GetInvoiceDetails, body, httpOptions);
+    }
+    getActiveUsersCount() {
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        let APIEndpoint = environment.apiURL;
+        let paramsObject = new HttpParams();
+        const httpOptions = {
+            headers: new HttpHeaders({ 'Content-Type': 'application/json' }),
+            params: paramsObject
+        };
+        return this.http
+            .get(APIEndpoint + ApiUrls.GetActiveUsersCount, httpOptions)
+            .pipe(map(result => {
+            return result;
+        }));
+    }
+    getPurchasedLicensesCount() {
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        let APIEndpoint = environment.apiURL;
+        let paramsObject = new HttpParams();
+        const httpOptions = {
+            headers: new HttpHeaders({ 'Content-Type': 'application/json' }),
+            params: paramsObject
+        };
+        return this.http
+            .get(APIEndpoint + ApiUrls.GetPurchasedLicensesCount, httpOptions)
+            .pipe(map(result => {
+            return result;
+        }));
+    }
+    upsertCompanyPayments(companyPaymentDetails) {
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        let APIEndpoint = environment.apiURL;
+        const httpOptions = {
+            headers: new HttpHeaders({ 'Content-Type': 'application/json' })
+        };
+        let body = JSON.stringify(companyPaymentDetails);
+        return this.http
+            .post(APIEndpoint + `Payments/PaymentsApi/UpsertCompanyPayment`, body, httpOptions)
+            .pipe(map(result => {
+            return result;
+        }));
+    }
+    getPaymentHistory() {
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        let APIEndpoint = environment.apiURL;
+        const httpOptions = {
+            headers: new HttpHeaders({ "Content-Type": "application/json" })
+        };
+        const body = JSON.stringify({});
+        return this.http.post(APIEndpoint + ApiUrls.GetPaymentHistory, body, httpOptions);
+    }
+    getAllTransactions(transaction) {
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        let APIEndpoint = environment.apiURL;
+        const httpOptions = {
+            headers: new HttpHeaders({ "Content-Type": "application/json" })
+        };
+        var companyPaymentDetails = new CompanyPaymentUpsertModel();
+        companyPaymentDetails.TransactionName = transaction;
+        let body = JSON.stringify(companyPaymentDetails);
+        return this.http.post(APIEndpoint + ApiUrls.GetAllTransactionsDetails, body, httpOptions);
+    }
+}
+PaymentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.1", ngImport: i0, type: PaymentService, deps: [{ token: i1.HttpClient }, { token: i2.CookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+PaymentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.1", ngImport: i0, type: PaymentService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.1", ngImport: i0, type: PaymentService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.CookieService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"payment.service.js","sourceRoot":"","sources":["../../../../../../shell-module-components/shell-components/src/lib/shell-components/services/payment.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { CookieService } from 'ngx-cookie-service';\r\nimport { map } from 'rxjs/operators';\r\nimport { LocalStorageProperties } from '../../globaldependencies/constants/localstorage-properties';\r\nimport { ApiUrls } from '../constants/api-urls';\r\nimport { Observable } from 'rxjs';\r\nimport { CompanyPaymentUpsertModel } from '../models/company-payment-model';\r\n\r\n@Injectable({ providedIn: \"root\" })\r\nexport class PaymentService {\r\n  constructor(private http: HttpClient, private cookieService: CookieService) { }\r\n\r\n  cancelSubscription() {\r\n    let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n    let APIEndpoint = environment.apiURL;\r\n    const httpOptions = {\r\n      headers: new HttpHeaders({ \"Content-Type\": \"application/json\" })\r\n    };\r\n    const body = JSON.stringify({});\r\n    return this.http.post<any>(APIEndpoint + ApiUrls.CancelSubscription, body, httpOptions);\r\n  }\r\n\r\n  getAllInvoices(transaction) {\r\n    let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n    let APIEndpoint = environment.apiURL;\r\n    const httpOptions = {\r\n      headers: new HttpHeaders({ \"Content-Type\": \"application/json\" })\r\n    };\r\n    var companyPaymentDetails = new CompanyPaymentUpsertModel();\r\n    companyPaymentDetails.TransactionName = transaction;\r\n    let body = JSON.stringify(companyPaymentDetails);\r\n    return this.http.post<any>(APIEndpoint + ApiUrls.GetInvoiceDetails, body, httpOptions);\r\n  }\r\n\r\n  getActiveUsersCount() {\r\n    let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n    let APIEndpoint = environment.apiURL;\r\n    let paramsObject = new HttpParams();\r\n    const httpOptions = {\r\n      headers: new HttpHeaders({ 'Content-Type': 'application/json' }),\r\n      params: paramsObject\r\n    };\r\n    return this.http\r\n      .get(APIEndpoint + ApiUrls.GetActiveUsersCount, httpOptions)\r\n      .pipe(\r\n        map(result => {\r\n          return result;\r\n        })\r\n      );\r\n  }\r\n\r\n  getPurchasedLicensesCount() {\r\n    let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n    let APIEndpoint = environment.apiURL;\r\n    let paramsObject = new HttpParams();\r\n    const httpOptions = {\r\n      headers: new HttpHeaders({ 'Content-Type': 'application/json' }),\r\n      params: paramsObject\r\n    };\r\n    return this.http\r\n      .get(APIEndpoint + ApiUrls.GetPurchasedLicensesCount, httpOptions)\r\n      .pipe(\r\n        map(result => {\r\n          return result;\r\n        })\r\n      );\r\n  }\r\n\r\n  upsertCompanyPayments(companyPaymentDetails: CompanyPaymentUpsertModel) {\r\n    let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n    let APIEndpoint = environment.apiURL;\r\n    const httpOptions = {\r\n      headers: new HttpHeaders({ 'Content-Type': 'application/json' })\r\n    };\r\n\r\n    let body = JSON.stringify(companyPaymentDetails);\r\n    return this.http\r\n      .post(APIEndpoint + `Payments/PaymentsApi/UpsertCompanyPayment`, body, httpOptions)\r\n      .pipe(\r\n        map(result => {\r\n          return result;\r\n        })\r\n      );\r\n  }\r\n\r\n  getPaymentHistory() {\r\n    let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n    let APIEndpoint = environment.apiURL;\r\n    const httpOptions = {\r\n        headers: new HttpHeaders({ \"Content-Type\": \"application/json\" })\r\n    };\r\n    const body = JSON.stringify({});\r\n    return this.http.post<any>(APIEndpoint + ApiUrls.GetPaymentHistory, body, httpOptions);\r\n}\r\n\r\ngetAllTransactions(transaction) {\r\n  let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n  let APIEndpoint = environment.apiURL;\r\n  const httpOptions = {\r\n    headers: new HttpHeaders({ \"Content-Type\": \"application/json\" })\r\n  };\r\n  var companyPaymentDetails = new CompanyPaymentUpsertModel();\r\n  companyPaymentDetails.TransactionName = transaction;\r\n  let body = JSON.stringify(companyPaymentDetails);\r\n  return this.http.post<any>(APIEndpoint + ApiUrls.GetAllTransactionsDetails, body, httpOptions);\r\n}\r\n\r\n}"]}

package/esm2015/lib/shell-components/services/recentSearch.service.js

@@ -0,0 +1,90 @@
+import { Injectable } from "@angular/core";
+import { HttpHeaders, HttpParams } from "@angular/common/http";
+import { map } from "rxjs/operators";
+import { LocalStorageProperties } from '../../globaldependencies/constants/localstorage-properties';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+const httpOptions = {
+    headers: new HttpHeaders({ "Content-Type": "application/json" })
+};
+export class RecentSearchService {
+    constructor(http) {
+        this.http = http;
+    }
+    // insertRecentSearch(search: string) {
+    //   let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+    //   let APIEndpoint = environment.apiURL;
+    //   return this.http.post(APIEndpoint + "RecentSearch/RecentSearchApi/InsertRecentSearch" + "?search=" + search, httpOptions);
+    // }
+    getSearchMenuItems(search) {
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        let APIEndpoint = environment.apiURL;
+        let data = new HttpParams();
+        data = data.append('ItemId', search.itemId);
+        data = data.append('SearchText', search.searchText);
+        data = data.append('SearchUniqueId', search.searchUniqueId);
+        const httpOptions = {
+            headers: new HttpHeaders({ "Content-Type": "application/json" }),
+            params: data
+        };
+        return this.http.get(APIEndpoint + "RecentSearch/RecentSearchApi/GetSearchMenuItems", httpOptions)
+            .pipe(map(result => {
+            return result;
+        }));
+    }
+    insertRecentSearch(search) {
+        const httpOptions = {
+            headers: new HttpHeaders({ 'Content-Type': 'application/json' })
+        };
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        let APIEndpoint = environment.apiURL;
+        let body = JSON.stringify(search);
+        // return this._http.post(APIEndpoint + "RecentSearch/RecentSearchApi/InsertRecentSearch" + "?search=" + search.name
+        // + "?searchType=" + search.recentSearchType, httpOptions);
+        return this.http.post(APIEndpoint + "RecentSearch/RecentSearchApi/InsertRecentSearch", body, httpOptions)
+            .pipe(map(result => {
+            return result;
+        }));
+    }
+    getRecentSearch() {
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        let APIEndpoint = environment.apiURL;
+        return this.http.get(APIEndpoint + "RecentSearch/RecentSearchApi/GetRecentSearch", httpOptions)
+            .pipe(map(result => {
+            return result;
+        }));
+    }
+    searchGoalTasks(searchText) {
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        let APIEndpoint = environment.apiURL;
+        const httpOptions = {
+            headers: new HttpHeaders({ "Content-Type": "application/json" }),
+            params: new HttpParams().set('searchText', searchText)
+        };
+        return this.http.get(APIEndpoint + "RecentSearch/RecentSearchApi/SearchGoalTasks", httpOptions)
+            .pipe(map(result => {
+            return result;
+        }));
+    }
+    searchMenuData(retrieveDashboards) {
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        let APIEndpoint = environment.apiURL;
+        const httpOptions = {
+            headers: new HttpHeaders({ "Content-Type": "application/json" }),
+            params: new HttpParams().set('getDashboards', retrieveDashboards.toString())
+        };
+        return this.http.get(APIEndpoint + "RecentSearch/RecentSearchApi/GetSearchMenuData", httpOptions)
+            .pipe(map(result => {
+            return result;
+        }));
+    }
+}
+RecentSearchService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.1", ngImport: i0, type: RecentSearchService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+RecentSearchService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.1", ngImport: i0, type: RecentSearchService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.1", ngImport: i0, type: RecentSearchService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recentSearch.service.js","sourceRoot":"","sources":["../../../../../../shell-module-components/shell-components/src/lib/shell-components/services/recentSearch.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\r\nimport {\r\n  HttpHeaders,\r\n  HttpClient,\r\n  HttpParams\r\n} from \"@angular/common/http\";\r\nimport { Subscription, Observable } from \"rxjs\";\r\nimport { map } from \"rxjs/operators\";\r\nimport { RecentSearchModel, SearchTaskTypeModel } from \"../models/RecentSearchModel\";\r\nimport { LocalStorageProperties } from '../../globaldependencies/constants/localstorage-properties';\r\nimport { RecentSearchApiModel } from '../models/recentSearchApiModel';\r\n\r\nconst httpOptions = {\r\n  headers: new HttpHeaders({ \"Content-Type\": \"application/json\" })\r\n};\r\n\r\n@Injectable({\r\n  providedIn: \"root\"\r\n})\r\n\r\nexport class RecentSearchService {\r\n  constructor(private http: HttpClient) { }\r\n\r\n  // insertRecentSearch(search: string) {\r\n  //   let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n  //   let APIEndpoint = environment.apiURL;\r\n  //   return this.http.post(APIEndpoint + \"RecentSearch/RecentSearchApi/InsertRecentSearch\" + \"?search=\" + search, httpOptions);\r\n  // }\r\n\r\n  getSearchMenuItems(search: any) {\r\n    let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n    let APIEndpoint = environment.apiURL;\r\n    let data = new HttpParams();\r\n    data = data.append('ItemId', search.itemId);\r\n    data = data.append('SearchText', search.searchText);\r\n    data = data.append('SearchUniqueId', search.searchUniqueId);\r\n    const httpOptions = {\r\n      headers: new HttpHeaders({ \"Content-Type\": \"application/json\" }),\r\n      params: data\r\n    };\r\n    return this.http.get<any[]>(APIEndpoint + \"RecentSearch/RecentSearchApi/GetSearchMenuItems\", httpOptions)\r\n      .pipe(map(result => {\r\n        return result;\r\n      }));\r\n  }\r\n\r\n  insertRecentSearch(search: RecentSearchApiModel) {\r\n\t\tconst httpOptions = {\r\n\t\t\theaders: new HttpHeaders({ 'Content-Type': 'application/json' })\r\n\t\t  };\r\n\t\tlet environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n\t\tlet APIEndpoint = environment.apiURL;\r\n\t\tlet body = JSON.stringify(search);\r\n\t\t// return this._http.post(APIEndpoint + \"RecentSearch/RecentSearchApi/InsertRecentSearch\" + \"?search=\" + search.name\r\n\t\t// + \"?searchType=\" + search.recentSearchType, httpOptions);\r\n\t\treturn this.http.post(APIEndpoint + \"RecentSearch/RecentSearchApi/InsertRecentSearch\",body, httpOptions)\r\n\t\t\t.pipe(map(result => {\r\n\t\t\t\treturn result;\r\n\t\t\t}));\r\n\t  }\r\n\r\n  getRecentSearch(): Observable<RecentSearchModel[]> {\r\n    let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n    let APIEndpoint = environment.apiURL;\r\n    return this.http.get<any[]>(APIEndpoint + \"RecentSearch/RecentSearchApi/GetRecentSearch\", httpOptions)\r\n      .pipe(map(result => {\r\n        return result;\r\n      }));\r\n  }\r\n\r\n  searchGoalTasks(searchText: string): Observable<SearchTaskTypeModel[]> {\r\n    let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n    let APIEndpoint = environment.apiURL;\r\n    const httpOptions = {\r\n      headers: new HttpHeaders({ \"Content-Type\": \"application/json\" }),\r\n      params: new HttpParams().set('searchText', searchText)\r\n    };\r\n    return this.http.get<SearchTaskTypeModel[]>(APIEndpoint + \"RecentSearch/RecentSearchApi/SearchGoalTasks\", httpOptions)\r\n      .pipe(map(result => {\r\n        return result;\r\n      }));\r\n  }\r\n\r\n  searchMenuData(retrieveDashboards: boolean) {\r\n    let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n    let APIEndpoint = environment.apiURL;\r\n    const httpOptions = {\r\n      headers: new HttpHeaders({ \"Content-Type\": \"application/json\" }),\r\n      params: new HttpParams().set('getDashboards', retrieveDashboards.toString())\r\n    };\r\n    return this.http.get(APIEndpoint + \"RecentSearch/RecentSearchApi/GetSearchMenuData\", httpOptions)\r\n    .pipe(map(result => {\r\n      return result;\r\n    }));\r\n  }\r\n\r\n}"]}

package/esm2015/lib/shell-components/services/shell.modules.service.js

@@ -0,0 +1,24 @@
+import { Injectable, Optional } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../models/shellModulesInfo";
+export class ShellModulesService {
+    constructor(config) {
+        if (config) {
+            this._allModules = config;
+        }
+    }
+    get allModules() {
+        return this._allModules;
+    }
+}
+ShellModulesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.1", ngImport: i0, type: ShellModulesService, deps: [{ token: i1.shellModulesInfo, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+ShellModulesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.1", ngImport: i0, type: ShellModulesService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.1", ngImport: i0, type: ShellModulesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.shellModulesInfo, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hlbGwubW9kdWxlcy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc2hlbGwtbW9kdWxlLWNvbXBvbmVudHMvc2hlbGwtY29tcG9uZW50cy9zcmMvbGliL3NoZWxsLWNvbXBvbmVudHMvc2VydmljZXMvc2hlbGwubW9kdWxlcy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7QUFNckQsTUFBTSxPQUFPLG1CQUFtQjtJQUc5QixZQUF3QixNQUF3QjtRQUM5QyxJQUFJLE1BQU0sRUFBRTtZQUFFLElBQUksQ0FBQyxXQUFXLEdBQUcsTUFBTSxDQUFDO1NBQUU7SUFDNUMsQ0FBQztJQUVELElBQUksVUFBVTtRQUNaLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQztJQUMxQixDQUFDOztnSEFUVSxtQkFBbUI7b0hBQW5CLG1CQUFtQixjQUZsQixNQUFNOzJGQUVQLG1CQUFtQjtrQkFIL0IsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkI7OzBCQUljLFFBQVEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlLCBPcHRpb25hbCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBzaGVsbE1vZHVsZXNJbmZvIH0gZnJvbSAnLi4vbW9kZWxzL3NoZWxsTW9kdWxlc0luZm8nO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgU2hlbGxNb2R1bGVzU2VydmljZSB7XHJcbiAgcHJpdmF0ZSBfYWxsTW9kdWxlcyA6IHNoZWxsTW9kdWxlc0luZm87XHJcblxyXG4gIGNvbnN0cnVjdG9yKEBPcHRpb25hbCgpIGNvbmZpZzogc2hlbGxNb2R1bGVzSW5mbykge1xyXG4gICAgaWYgKGNvbmZpZykgeyB0aGlzLl9hbGxNb2R1bGVzID0gY29uZmlnOyB9XHJcbiAgfVxyXG5cclxuICBnZXQgYWxsTW9kdWxlcygpIHtcclxuICAgIHJldHVybiB0aGlzLl9hbGxNb2R1bGVzO1xyXG4gIH1cclxufSJdfQ==

package/esm2015/lib/shell-components/services/signalr.service.js

@@ -0,0 +1,113 @@
+import { Injectable } from '@angular/core';
+import * as signalR from "@microsoft/signalr";
+import { LocalStorageProperties } from '../../globaldependencies/constants/localstorage-properties';
+import { BehaviorSubject } from 'rxjs';
+import { HttpHeaders } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-cookie-service";
+import * as i2 from "@angular/common/http";
+export class SignalrService {
+    constructor(cookieService, http) {
+        this.cookieService = cookieService;
+        this.http = http;
+        this.notifications$ = new BehaviorSubject([]);
+        this.notifications = [];
+    }
+    initializeSignalRConnection() {
+        //     this.connection = $.hubConnection(`${environment.apiURL}signalr`, { useDefaultPath: false });
+        // // Please note that by default '/signalr' URL will be used to connect to your SignalR service. Providing 'useDefaultPath' allows you to customize it
+        //     this.proxy = this.connection.createHubProxy('LookupSyncNotification');
+        //     this.proxy.on('LookupSyncSuccess', (serverMessage) => this.onMessageReceived(serverMessage));
+        //     this.connection.start().done((data: any) => {
+        //       console.log('Connected to Connection Hub');
+        //       this.sendMessage();
+        //     }).catch((error: any) => {
+        //       console.log('Connection Hub error:' + error);
+        //     });
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        let APIEndpoint = environment.notificationUrl;
+        let connection = new signalR.HubConnectionBuilder()
+            .withUrl(APIEndpoint, {
+            skipNegotiation: true,
+            transport: signalR.HttpTransportType.WebSockets,
+            accessTokenFactory: () => "Bearer " + this.cookieService.get(LocalStorageProperties.CurrentUser)
+        })
+            .withAutomaticReconnect()
+            .build();
+        connection.start().then(function () {
+            console.log("connected signalr hub");
+            connection.invoke('GetConnectionId', sessionStorage.getItem('conectionId'))
+                .then((res) => { sessionStorage.setItem('conectionId', res); })
+                .catch((error) => {
+                console.log(error);
+            });
+        }).catch(function (er) {
+            console.log("hub con error: " + er);
+        });
+        connection.on('BroadCastNotification', (serverMessage) => this.addToNotificationItem(serverMessage));
+    }
+    //   public sendMessage(): void {
+    //     connection.invoke('ClientMessage', 'My message')
+    //       .catch((error: any) => {
+    //         console.log('sending message error -> ' + error);
+    //       });
+    //   }
+    onMessageReceived(serverMessage) {
+        console.log('New message received from Server: ' + serverMessage);
+    }
+    getNotifications() {
+        this.notifications$.next(this.notifications);
+    }
+    addToNotificationItem(item) {
+        this.notifications.push(item);
+        this.getNotifications();
+    }
+    addToNotificationList(item) {
+        this.notifications.push(...item);
+        this.getNotifications();
+    }
+    removeItemFromNotifications(id) {
+        this.notifications = this.notifications.filter(item => item.id != id);
+        this.getNotifications();
+    }
+    removeAllNotifications() {
+        this.notifications = [];
+        this.getNotifications();
+    }
+    upsertReadNewNotifications(notifications) {
+        const httpOptions = {
+            headers: new HttpHeaders({ 'Content-Type': 'application/json' })
+        };
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        let APIEndpoint = environment.apiURL;
+        let body = JSON.stringify(notifications);
+        return this.http.post(APIEndpoint + "Notification/NotificationApi/UpsertReadNewNotifications", body, httpOptions)
+            .pipe(map(result => {
+            return result;
+        }));
+    }
+    getNotificationsFromApi() {
+        const httpOptions = {
+            headers: new HttpHeaders({ 'Content-Type': 'application/json' })
+        };
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        let APIEndpoint = environment.apiURL;
+        return this.http.post(APIEndpoint + "Notification/NotificationApi/GetNotifications", null, httpOptions)
+            .pipe(map((result) => {
+            if (result.success && result.data && result.data.length > 0) {
+                this.notifications = result.data;
+                this.getNotifications();
+            }
+        }));
+    }
+}
+SignalrService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.1", ngImport: i0, type: SignalrService, deps: [{ token: i1.CookieService }, { token: i2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+SignalrService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.1", ngImport: i0, type: SignalrService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.1", ngImport: i0, type: SignalrService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CookieService }, { type: i2.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signalr.service.js","sourceRoot":"","sources":["../../../../../../shell-module-components/shell-components/src/lib/shell-components/services/signalr.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HubConnection, HubConnectionBuilder, LogLevel } from '@microsoft/signalr'\r\nimport * as signalR from \"@microsoft/signalr\";\r\nimport { CookieService } from 'ngx-cookie-service';\r\nimport { LocalStorageProperties } from '../../globaldependencies/constants/localstorage-properties';\r\nimport { BehaviorSubject, Observable } from 'rxjs';\r\nimport { NotificationModel } from '../models/NotificationsOutPutModel';\r\nimport { HttpClient, HttpHeaders } from '@angular/common/http';\r\nimport { map } from 'rxjs/operators';\r\n// import { MessagePackHubProtocol } from '@microsoft/signalr-protocol-msgpack'\r\n\r\ndeclare var $: any;\r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class SignalrService {\r\n\r\n    private connection: any;\r\n    private proxy: any;\r\n    public notifications$: any = new BehaviorSubject([]);\r\n    notifications: any = [];\r\n    constructor(private cookieService: CookieService, private http: HttpClient) { }\r\n\r\n    public initializeSignalRConnection(): void {\r\n        //     this.connection = $.hubConnection(`${environment.apiURL}signalr`, { useDefaultPath: false });\r\n        // // Please note that by default '/signalr' URL will be used to connect to your SignalR service. Providing 'useDefaultPath' allows you to customize it\r\n        //     this.proxy = this.connection.createHubProxy('LookupSyncNotification');\r\n\r\n        //     this.proxy.on('LookupSyncSuccess', (serverMessage) => this.onMessageReceived(serverMessage));\r\n\r\n        //     this.connection.start().done((data: any) => {\r\n        //       console.log('Connected to Connection Hub');\r\n        //       this.sendMessage();\r\n        //     }).catch((error: any) => {\r\n        //       console.log('Connection Hub error:' + error);\r\n        //     });\r\n        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n\t\tlet APIEndpoint = environment.notificationUrl;\r\n        let connection = new signalR.HubConnectionBuilder()\r\n            .withUrl(APIEndpoint, {\r\n                skipNegotiation: true,\r\n                transport: signalR.HttpTransportType.WebSockets,\r\n                accessTokenFactory: () => \"Bearer \" + this.cookieService.get(LocalStorageProperties.CurrentUser)\r\n            })\r\n            .withAutomaticReconnect()\r\n            .build();\r\n        connection.start().then(\r\n            function () {\r\n                console.log(\"connected signalr hub\");\r\n                connection.invoke('GetConnectionId', sessionStorage.getItem('conectionId'))\r\n                    .then((res) =>  {sessionStorage.setItem('conectionId', res)})\r\n                    .catch((error: any) => {\r\n                        console.log(error);\r\n                    });\r\n            }\r\n        ).catch(\r\n                function (er) {\r\n                    console.log(\"hub con error: \" + er);\r\n                }\r\n            );\r\n        connection.on('BroadCastNotification', (serverMessage) => this.addToNotificationItem(serverMessage));\r\n    }\r\n\r\n    //   public sendMessage(): void {\r\n    //     connection.invoke('ClientMessage', 'My message')\r\n    //       .catch((error: any) => {\r\n    //         console.log('sending message error -> ' + error);\r\n    //       });\r\n    //   }\r\n\r\n    private onMessageReceived(serverMessage: any) {\r\n        console.log('New message received from Server: ' + serverMessage);\r\n    }\r\n\r\n    getNotifications() {\r\n        this.notifications$.next(this.notifications);\r\n    }\r\n\r\n    addToNotificationItem(item) {\r\n        this.notifications.push(item);\r\n        this.getNotifications();\r\n    }\r\n\r\n    addToNotificationList(item) {\r\n        this.notifications.push(...item);\r\n        this.getNotifications();\r\n    }\r\n\r\n    removeItemFromNotifications(id) {\r\n        this.notifications = this.notifications.filter(item => item.id != id);\r\n        this.getNotifications();\r\n    }\r\n\r\n    removeAllNotifications() {\r\n        this.notifications = [];\r\n        this.getNotifications();\r\n    }\r\n\r\n    upsertReadNewNotifications(notifications: NotificationModel[]) {\r\n        const httpOptions = {\r\n\t\t\theaders: new HttpHeaders({ 'Content-Type': 'application/json' })\r\n\t\t  };\r\n\t\tlet environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n\t\tlet APIEndpoint = environment.apiURL;\r\n\t\tlet body = JSON.stringify(notifications);\r\n\t\treturn this.http.post(APIEndpoint + \"Notification/NotificationApi/UpsertReadNewNotifications\",body, httpOptions)\r\n\t\t\t.pipe(map(result => {\r\n\t\t\t\treturn result;\r\n\t\t\t}));\r\n    }\r\n\r\n    getNotificationsFromApi() {\r\n        const httpOptions = {\r\n\t\t\theaders: new HttpHeaders({ 'Content-Type': 'application/json' })\r\n\t\t  };\r\n\t\tlet environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n\t\tlet APIEndpoint = environment.apiURL;\r\n\t\treturn this.http.post(APIEndpoint + \"Notification/NotificationApi/GetNotifications\", null, httpOptions)\r\n\t\t\t.pipe(map((result: any) => {\r\n\t\t\t\tif(result.success && result.data && result.data.length > 0) {\r\n                    this.notifications = result.data;\r\n                    this.getNotifications();\r\n                }\r\n\t\t\t}));   \r\n    }\r\n\r\n}"]}

package/esm2015/lib/shell-components/services/theme.service.js

@@ -0,0 +1,161 @@
+import { Injectable } from "@angular/core";
+import * as domHelper from "../../globaldependencies/helpers/dom.helper";
+import * as i0 from "@angular/core";
+export class ThemeService {
+    constructor() {
+        this.egretThemes = [{
+                name: 'egret-blue',
+                baseColor: '#247ba0',
+                isActive: false,
+                companyThemeId: 'FD2ABC0F-F8D7-47C4-A7BD-BAA637E14BD5'
+            },
+            {
+                name: "egret-btrak",
+                baseColor: "#3da8b5",
+                isActive: true,
+                companyThemeId: '752471EB-94F4-4A33-8C3B-6E0A8D42F0D1'
+            },
+            {
+                name: "egret-default",
+                baseColor: "#009999",
+                isActive: true,
+                companyThemeId: 'B299BB1E-F6AE-4944-8DC0-50C7D01C8D72'
+            },
+            {
+                name: 'egret-lime-green',
+                baseColor: '#3ca956',
+                isActive: false,
+                companyThemeId: 'B5769B53-4718-4DFD-9201-E03C4D3A665E'
+            },
+            {
+                name: 'egret-indigo',
+                baseColor: '#3f51b5',
+                isActive: false,
+                companyThemeId: '9BC13630-98FE-4498-8557-465E4C64F444'
+            },
+            {
+                name: 'egret-dark-blue',
+                baseColor: '#0074A6',
+                isActive: false,
+                companyThemeId: 'A0C5B5F6-E9EA-442B-AFFB-77B9F631421E'
+            },
+            {
+                name: 'egret-very-dark-magenta',
+                baseColor: '#561f55',
+                isActive: false,
+                companyThemeId: 'DE636C82-4CB6-4F84-8730-CF2B9D9C39D4'
+            },
+            {
+                name: "egret-grayish-cyan",
+                baseColor: "#9fa8a3",
+                isActive: false,
+                companyThemeId: '0929D35A-3573-4B06-93FB-C7D46AAFA918'
+            },
+            {
+                name: "egret-desaturated-pink",
+                baseColor: "#59323c",
+                isActive: false,
+                companyThemeId: '576E2F5C-22DE-4D90-A21E-1ACA1364DC72'
+            },
+            {
+                name: 'egret-desaturated-dark-cyan',
+                baseColor: '#4e7b68 ',
+                isActive: false,
+                companyThemeId: 'C00FFAB9-6451-4820-A53B-CC4FFB6E07F0'
+            },
+            {
+                name: 'egret-desaturated-orange',
+                baseColor: '#a68572',
+                isActive: false,
+                companyThemeId: 'F3F05E52-6310-4C26-BE8C-690BA6380739'
+            },
+            {
+                name: 'egret-soft-red',
+                baseColor: '#eb6f7b',
+                isActive: false,
+                companyThemeId: '81CC4F29-5561-4FC8-AE72-A4F6C84B134E'
+            },
+            {
+                name: 'egret-dark-yellow',
+                baseColor: '#a89344',
+                isActive: false,
+                companyThemeId: '3F1FEFA0-977C-4DFA-B989-8CCD7E8D9047'
+            },
+            {
+                name: 'egret-strong-blue',
+                baseColor: '#06acc1',
+                isActive: false,
+                companyThemeId: 'A30D4C15-F90E-461D-A46B-17DBAEFEF70E'
+            },
+            {
+                name: 'egret-dark-grayish-green',
+                baseColor: '#9dab86',
+                isActive: false,
+                companyThemeId: '41692008-E752-40C2-B603-CF5570B32743'
+            },
+            {
+                name: 'egret-moderate-orange',
+                baseColor: '#d5763f',
+                isActive: false,
+                companyThemeId: 'EE551928-63C1-449A-97FB-B06361F82466'
+            },
+            {
+                name: 'egret-bright-red',
+                baseColor: '#fa4252',
+                isActive: false,
+                companyThemeId: '4C7E967D-27C0-4FF8-A73B-C654D3BFC2A8'
+            },
+            {
+                name: 'egret-dark-moderate-violet',
+                baseColor: '#52297B',
+                isActive: false,
+                companyThemeId: '10A47983-A043-44DF-9242-3BD5FF282208'
+            },
+            {
+                name: 'egret-grayish-blue',
+                baseColor: '#4b4e52',
+                isActive: false,
+                companyThemeId: '32BE8C7C-94AA-4F6D-B28E-D4DCF8B20609'
+            },
+            {
+                name: 'egret-rebecca-purple',
+                baseColor: '#662E8F',
+                isActive: false,
+                companyThemeId: '3E8A43CD-57D2-48FA-AD6B-4089845DC656'
+            },
+            {
+                name: 'egret-bright-blue',
+                baseColor: '#002060',
+                isActive: false,
+                companyThemeId: 'F6006F47-700C-4FC1-AE03-2242A212C836'
+            }
+        ];
+    }
+    changeTheme(theme) {
+        const themeColors = this.egretThemes;
+        const filteredThemes = themeColors.filter((color) => {
+            return color.companyThemeId.toLowerCase() === theme.companyThemeId.toLowerCase();
+        });
+        var currentTheme = filteredThemes[0] != undefined || filteredThemes[0] != null ? filteredThemes[0] : {
+            name: 'egret-blue',
+            baseColor: '#247ba0',
+            isActive: false,
+            companyThemeId: 'FD2ABC0F-F8D7-47C4-A7BD-BAA637E14BD5'
+        };
+        localStorage.setItem('themeColor', currentTheme.baseColor);
+        domHelper.changeTheme(this.egretThemes, currentTheme.name);
+        this.egretThemes.forEach((t) => {
+            t.isActive = false;
+            if (t.name === currentTheme.name) {
+                t.isActive = true;
+                this.activatedThemeName = currentTheme.name;
+            }
+        });
+    }
+}
+ThemeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.1", ngImport: i0, type: ThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ThemeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.1", ngImport: i0, type: ThemeService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.1", ngImport: i0, type: ThemeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"theme.service.js","sourceRoot":"","sources":["../../../../../../shell-module-components/shell-components/src/lib/shell-components/services/theme.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\r\nimport * as domHelper from \"../../globaldependencies/helpers/dom.helper\";\r\n\r\ninterface ITheme {\r\n  name: string,\r\n  baseColor?: string,\r\n  isActive?: boolean\r\n}\r\n\r\n@Injectable()\r\nexport class ThemeService {\r\n  egretThemes = [{\r\n    name: 'egret-blue',\r\n    baseColor: '#247ba0',\r\n    isActive: false,\r\n    companyThemeId: 'FD2ABC0F-F8D7-47C4-A7BD-BAA637E14BD5'\r\n  },\r\n  {\r\n    name: \"egret-btrak\",\r\n    baseColor: \"#3da8b5\",\r\n    isActive: true,\r\n    companyThemeId: '752471EB-94F4-4A33-8C3B-6E0A8D42F0D1'\r\n  },\r\n  {\r\n    name: \"egret-default\",\r\n    baseColor: \"#009999\",\r\n    isActive: true,\r\n    companyThemeId: 'B299BB1E-F6AE-4944-8DC0-50C7D01C8D72'\r\n  },\r\n  {\r\n    name: 'egret-lime-green',\r\n    baseColor: '#3ca956',\r\n    isActive: false,\r\n    companyThemeId: 'B5769B53-4718-4DFD-9201-E03C4D3A665E'\r\n  },\r\n  {\r\n    name: 'egret-indigo',\r\n    baseColor: '#3f51b5',\r\n    isActive: false,\r\n    companyThemeId: '9BC13630-98FE-4498-8557-465E4C64F444'\r\n  },\r\n  {\r\n    name: 'egret-dark-blue',\r\n    baseColor: '#0074A6',\r\n    isActive: false,\r\n    companyThemeId: 'A0C5B5F6-E9EA-442B-AFFB-77B9F631421E'\r\n  },\r\n  {\r\n    name: 'egret-very-dark-magenta',\r\n    baseColor: '#561f55',\r\n    isActive: false,\r\n    companyThemeId: 'DE636C82-4CB6-4F84-8730-CF2B9D9C39D4'\r\n  },\r\n  {\r\n    name: \"egret-grayish-cyan\",\r\n    baseColor: \"#9fa8a3\",\r\n    isActive: false,\r\n    companyThemeId: '0929D35A-3573-4B06-93FB-C7D46AAFA918'\r\n  },\r\n  {\r\n    name: \"egret-desaturated-pink\",\r\n    baseColor: \"#59323c\",\r\n    isActive: false,\r\n    companyThemeId: '576E2F5C-22DE-4D90-A21E-1ACA1364DC72'\r\n  },\r\n  {\r\n    name: 'egret-desaturated-dark-cyan',\r\n    baseColor: '#4e7b68 ',\r\n    isActive: false,\r\n    companyThemeId: 'C00FFAB9-6451-4820-A53B-CC4FFB6E07F0'\r\n  },\r\n  {\r\n    name: 'egret-desaturated-orange',\r\n    baseColor: '#a68572',\r\n    isActive: false,\r\n    companyThemeId: 'F3F05E52-6310-4C26-BE8C-690BA6380739'\r\n  },\r\n  {\r\n    name: 'egret-soft-red',\r\n    baseColor: '#eb6f7b',\r\n    isActive: false,\r\n    companyThemeId: '81CC4F29-5561-4FC8-AE72-A4F6C84B134E'\r\n  },\r\n  {\r\n    name: 'egret-dark-yellow',\r\n    baseColor: '#a89344',\r\n    isActive: false,\r\n    companyThemeId: '3F1FEFA0-977C-4DFA-B989-8CCD7E8D9047'\r\n  },\r\n  {\r\n    name: 'egret-strong-blue',\r\n    baseColor: '#06acc1',\r\n    isActive: false,\r\n    companyThemeId: 'A30D4C15-F90E-461D-A46B-17DBAEFEF70E'\r\n  },\r\n  {\r\n    name: 'egret-dark-grayish-green',\r\n    baseColor: '#9dab86',\r\n    isActive: false,\r\n    companyThemeId: '41692008-E752-40C2-B603-CF5570B32743'\r\n  },\r\n  {\r\n    name: 'egret-moderate-orange',\r\n    baseColor: '#d5763f',\r\n    isActive: false,\r\n    companyThemeId: 'EE551928-63C1-449A-97FB-B06361F82466'\r\n  },\r\n  {\r\n    name: 'egret-bright-red',\r\n    baseColor: '#fa4252',\r\n    isActive: false,\r\n    companyThemeId: '4C7E967D-27C0-4FF8-A73B-C654D3BFC2A8'\r\n  },\r\n  {\r\n    name: 'egret-dark-moderate-violet',\r\n    baseColor: '#52297B',\r\n    isActive: false,\r\n    companyThemeId: '10A47983-A043-44DF-9242-3BD5FF282208'\r\n  },\r\n  {\r\n    name: 'egret-grayish-blue',\r\n    baseColor: '#4b4e52',\r\n    isActive: false,\r\n    companyThemeId: '32BE8C7C-94AA-4F6D-B28E-D4DCF8B20609'\r\n  },\r\n  {\r\n    name: 'egret-rebecca-purple',\r\n    baseColor: '#662E8F',\r\n    isActive: false,\r\n    companyThemeId: '3E8A43CD-57D2-48FA-AD6B-4089845DC656'\r\n  },\r\n  {\r\n    name: 'egret-bright-blue',\r\n    baseColor: '#002060',\r\n    isActive: false,\r\n    companyThemeId: 'F6006F47-700C-4FC1-AE03-2242A212C836'\r\n  }\r\n  ];\r\n  activatedThemeName: String;\r\n  constructor() {\r\n  }\r\n  changeTheme(theme) {\r\n\r\n    const themeColors = this.egretThemes;\r\n    const filteredThemes = themeColors.filter((color) => {\r\n      return color.companyThemeId.toLowerCase() === theme.companyThemeId.toLowerCase()\r\n    })\r\n    var currentTheme = filteredThemes[0] != undefined || filteredThemes[0] != null ? filteredThemes[0] : {\r\n      name: 'egret-blue',\r\n      baseColor: '#247ba0',\r\n      isActive: false,\r\n      companyThemeId: 'FD2ABC0F-F8D7-47C4-A7BD-BAA637E14BD5'};\r\n    localStorage.setItem('themeColor', currentTheme.baseColor)\r\n    domHelper.changeTheme(this.egretThemes, currentTheme.name);\r\n    this.egretThemes.forEach((t) => {\r\n      t.isActive = false;\r\n      if (t.name === currentTheme.name) {\r\n        t.isActive = true;\r\n        this.activatedThemeName = currentTheme.name;\r\n      }\r\n    });\r\n  }\r\n}\r\n"]}