@colijnit/sharedcomponents 1.0.23 → 1.0.25

package/projects/sharedcomponents/src/lib/service/dictionary.service.ts

@@ -0,0 +1,86 @@
+import {Injectable} from "@angular/core";
+import {LanguageCode} from "../enum/language-code.enum";
+import {StringUtils} from "../utils/string-utils";
+import {Dictionary} from "../assets/dictionary/text.properties";
+
+// The localization service, providing peers with text translation functionality.
+@Injectable({
+  providedIn: "root"
+})
+export class DictionaryService {
+  private readonly dictionaryUrl: string = "js/browser/res/dictionary/";
+
+  public get language(): string {
+    return this._language;
+  }
+
+  public set rootUrl(value: string) {
+    this._rootUrl = value;
+    this._dictBasePath = this._rootUrl + "/" + this.dictionaryUrl;
+  }
+
+  // public dictionaryLoaded: Subject<void> = new Subject();
+
+  private _dictBasePath: string;
+  private _rootUrl: string;
+  // private _dictionaryPromise: Map<LanguageCode, Promise<{ [key: string]: string }>> = new Map<LanguageCode, Promise<{ [key: string]: string }>>();
+  private _dictionaries: Map<string, { [key: string]: string }> = new Map<string, { [key: string]: string }>();
+  private _language: string;
+
+  // Some dictionary values have one or more '|~' texts in them, meant to be replaced with client-side given texts.
+  private readonly _placeholder: string = "|~";
+
+  constructor(
+  ) {
+  }
+
+  // Loads the dictionary for given language in memory.
+  public async setDictionary(language: string): Promise<void> {
+    this._language = language || LanguageCode.Dutch;
+    this._loadDictionary();
+  }
+
+  private _loadDictionary() {
+    if (!this._dictionaries.has(this._language)) {
+      const dictionary: Dictionary = new Dictionary();
+      // eslint-disable-next-line no-magic-numbers
+      if (dictionary.strings[this._language.substr(0, 2).toLowerCase()] !== undefined) {
+        // eslint-disable-next-line no-magic-numbers
+        this._dictionaries.set(this._language, dictionary.strings[this._language.substr(0, 2).toLowerCase()]);
+      }
+    }
+  }
+
+  /**
+   * Returns the localized text for the given dictionary key.
+   * @param {string} key
+   * @param {boolean} [upperCaseFirst = true] False for first letter lowercase, true for first letter uppercase for returned dict val
+   * @param {string[]} replacementTexts Rest params for replacement of '|~' in returned dict value
+   * @returns {string} The translated text for given dictionary key
+   */
+  public get(key: string, upperCaseFirst: boolean = true, ...replacementTexts: string[]): string {
+    if (!StringUtils.IsStringWithLength(key)) {
+      return key || "";
+    }
+
+    if (this.language === undefined) {
+      this._language = LanguageCode.Dutch;
+      this._loadDictionary();
+    }
+
+    let text: string = this._dictionaries.get(this.language)[key];
+    text = StringUtils.IsStringWithLength(text) ? text : key;
+
+    if (upperCaseFirst) {
+      text = text.charAt(0).toUpperCase() + text.slice(1);
+    } else {
+      text = text.charAt(0).toLowerCase() + text.slice(1);
+    }
+
+    if (replacementTexts.length > 0) {
+      text = StringUtils.ReplaceOccurrencesIn(text, this._placeholder, ...replacementTexts);
+    }
+
+    return text;
+  }
+}

package/projects/sharedcomponents/src/lib/service/icon-cache.service.ts

@@ -0,0 +1,51 @@
+import {Injectable} from "@angular/core";
+import {DomSanitizer, SafeHtml} from "@angular/platform-browser";
+import {Icon} from "../enum/icon.enum";
+import {IconSvg} from "../model/icon-svg";
+
+@Injectable({
+  providedIn: "root"
+})
+export class IconCacheService {
+  /**
+   * All the icons as a large JSON object, from the all-icons.json file.
+   * The object has property keys that are the icon names, and property values with the data string of the actual svg icon.
+   */
+  public get iconCache(): { [iconName: string]: SafeHtml } {
+    return this._iconCache;
+  }
+
+  private _iconCache: { [iconName: string]: SafeHtml } = {};
+
+  constructor(
+    private _sanitizer: DomSanitizer
+  ) {
+    this.setIconCache();
+  }
+
+  public getIcon(iconName: Icon): SafeHtml {
+    if (iconName) {
+      return this._iconCache[iconName.toLowerCase()];
+    }
+  }
+
+  public getIconAsBase64(iconName: Icon): SafeHtml {
+    const icon: string = IconSvg[iconName];
+    const base64Data: string = window.btoa(icon);
+    return this._sanitizer.bypassSecurityTrustUrl(`data:image/svg+xml;base64,${base64Data}`);
+  }
+
+  public getRawIcon(iconName: Icon): string {
+    if (iconName) {
+      return IconSvg[iconName.toLowerCase()];
+    }
+  }
+
+  public setIconCache(): void {
+    for (const key in IconSvg) {
+      if (IconSvg.hasOwnProperty(key) && typeof IconSvg[key] !== "function") {
+        this._iconCache[key.toLowerCase()] = this._sanitizer.bypassSecurityTrustHtml(IconSvg[key]);
+      }
+    }
+  }
+}

package/projects/sharedcomponents/src/lib/service/options.service.ts

@@ -0,0 +1,66 @@
+import {Injectable} from "@angular/core";
+import {BehaviorSubject} from "rxjs";
+import {DictionaryService} from "./dictionary.service";
+
+@Injectable({
+  providedIn: "root"
+})
+export class OptionsService {
+
+  public optionsInitialized: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
+
+  public set options(value: any) {
+    this._options = value;
+  }
+
+  public get options(): any {
+    return this._options;
+  }
+
+  public optionsLoaded: BehaviorSubject<boolean> = new BehaviorSubject(false);
+
+  private _options: any;
+
+  constructor(private _dictionary: DictionaryService) {
+  }
+
+  public async createSettingsFromObject(obj: any): Promise<void> {
+    this.options = new Object();
+    if (obj.hasOwnProperty("url")) {
+      this.options.url = obj["url"];
+    }
+    if (obj.hasOwnProperty("schema")) {
+      this.options.schema = obj["schema"];
+    }
+    if (obj.hasOwnProperty("version")) {
+      this.options.version = obj["version"];
+    }
+    if (obj.hasOwnProperty("languageCode")) {
+      this.options.languageCode = obj["languageCode"];
+    } else {
+      this.options.languageCode = "NL";
+    }
+    if (obj.hasOwnProperty("username")) {
+      this.options.username = obj["username"];
+    }
+    if (obj.hasOwnProperty("password")) {
+      this.options.password = obj["password"];
+    }
+    if (obj.hasOwnProperty("session")) {
+      this.options.session = obj["session"];
+    }
+    if (obj.hasOwnProperty("useLoginEncryption")) {
+      this.options.useLoginEncryption = obj["useLoginEncryption"];
+    }
+
+    this.optionsLoaded.next(true);
+  }
+
+  public async initialize(options: any): Promise<void> {
+    if (options) {
+      await this.createSettingsFromObject(options);
+      await this._dictionary.setDictionary(this.options.languageCode);
+      this.optionsInitialized.next(true);
+    }
+  }
+}

package/projects/sharedcomponents/src/lib/service/shared-connector.service.ts

@@ -0,0 +1,258 @@
+import {Articles} from "@colijnit/articleapi/build/articles";
+import {Sharedapi} from "@colijnit/sharedapi/build/sharedapi";
+import {Printer} from "@colijnit/sharedapi/build/model/report/printer.bo";
+import {Injectable} from "@angular/core";
+import {ArticleExtended} from "@colijnit/articleapi/build/model/article-extended.bo";
+import {DataServiceResponseData} from "@colijnit/articleapi/build/model/data-service-response-data";
+import {DataServiceResponseData as DataServiceResponse} from "@colijnit/sharedapi/build/model/data-service-response-data";
+import {BusinessObjectFactory} from "../factory/business-object-factory";
+import {PrintStockStickers} from "@colijnit/sharedapi/build/model/print-stock-stickers";
+import {GetStockHistoryRequest} from "@colijnit/articleapi/build/model/get-stock-history-request";
+import {ArticleStock as ArticleStockBo} from "@colijnit/articleapi/build/model/article-stock.bo";
+import {ArticleStock} from "@colijnit/articleapi/build/model/article-stock";
+import {StockHistoryBo} from "@colijnit/articleapi/build/model/stock-history.bo";
+import {StockStickersPrintLayouts} from "@colijnit/sharedapi/build/model/report/stock-stickers-print-layouts.bo";
+import {ArticleStockManagement} from "@colijnit/articleapi/build/model/article-stock-management";
+import {ArticleDetailsBo} from "@colijnit/articleapi/build/model/article-details.bo";
+import {StockStatus} from "@colijnit/articleapi/build/model/stock-status.bo";
+import {StockManagementWarehouses} from "@colijnit/articleapi/build/model/stock-management-warehouses.bo";
+import {StockLocation} from "@colijnit/articleapi/build/model/stock-location.bo";
+import {ArticleTransaction} from "@colijnit/articleapi/build/model/article-transaction";
+import {ArticleTransaction as ArticleTransactionBo} from "@colijnit/articleapi/build/model/article-transaction.bo";
+import {OptionsService} from "./options.service";
+import {PrintPriceStickers} from "@colijnit/sharedapi/build/model/print-price-stickers.bo";
+
+
+@Injectable({
+  providedIn: "root"
+})
+export class SharedConnectorService {
+  public articleConnector: Articles;
+  public sharedConnector: Sharedapi;
+
+  private _boFactory: BusinessObjectFactory = new BusinessObjectFactory();
+
+
+  constructor(
+    private _optionsService: OptionsService,
+  ) {
+  }
+
+  public async connect(): Promise<void> {
+    this.articleConnector = new Articles(this._optionsService.options);
+    this.sharedConnector = new Sharedapi(this._optionsService.options);
+  }
+
+  public async getAllPrinters(showAll: boolean = true): Promise<Printer[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.sharedConnector.listAllPrinters(showAll).then((result: DataServiceResponse) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObject) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(Printer, result.resultObject));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getPrintStockStickers(request: PrintStockStickers): Promise<PrintStockStickers> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.sharedConnector.getPrintStockStickers(request).then((result: DataServiceResponse) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObject) {
+            resolve(this._boFactory.makeWithRawBackendData(PrintStockStickers, result.resultObject));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      })
+    })
+  }
+
+  public async getPrintPriceStickers(request: PrintPriceStickers): Promise<PrintPriceStickers> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.sharedConnector.printPriceStickers(request).then((result: DataServiceResponse) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObject) {
+            resolve(this._boFactory.makeWithRawBackendData(PrintPriceStickers, result.resultObject));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      })
+    })
+  }
+
+  // public async getStockStickerPrintLayouts(stockStickersPrintLayouts: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {
+  //   return new Promise((resolve: Function, reject: Function) => {
+  //     return this.sharedConnector.getStockStickerPrintLayouts(stockStickersPrintLayouts).then((result: DataServiceResponse) => {
+  //       if (result.validationResult && result.validationResult.success) {
+  //         if (result.resultObject) {
+  //           resolve(this._boFactory.makeWithRawBackendData(stockStickersPrintLayouts, result.resultObject));
+  //         }
+  //       } else {
+  //         reject(result.validationMessagesAsString);
+  //       }
+  //     })
+  //   })
+  // }
+
+  public async getArticleFullObject(goodId: number): Promise<ArticleExtended> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.articleConnector.getArticleFullObject(goodId).then((result: DataServiceResponseData) => {
+        // if (result.validationResult && result.validationResult.success) {
+        //   if (result.resultObject) {
+        //     resolve(this._boFactory.makeWithRawBackendData(ArticleExtended, result.resultObject));
+        //   }
+        // } else {
+        //   reject(result.validationMessagesAsString);
+        // }
+      });
+    });
+  }
+
+  public async getStockHistory(request: GetStockHistoryRequest): Promise<StockHistoryBo[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.articleConnector.getStockHistory(request).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObject && result.resultObject.hasOwnProperty("stockHistory")) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(StockHistoryBo, result.resultObject.stockHistory));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      })
+    })
+  }
+
+  public async getStockInformation(data: ArticleStock): Promise<ArticleStockBo[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.articleConnector.getStockInformation(data).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObjects) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(ArticleStockBo, result.resultObjects));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getStockManagementWarehouses(): Promise<StockManagementWarehouses[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.articleConnector.getStockManagementWarehouses().then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObjects) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(StockManagementWarehouses, result.resultObjects));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getStockManagementLocations(warehouseNo: number): Promise<StockLocation[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.articleConnector.getStockManagementLocations(warehouseNo).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObjects) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(StockLocation, result.resultObjects));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getArticleDetails(data: ArticleStockManagement): Promise<ArticleDetailsBo[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.articleConnector.getArticleDetails(data).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObjects) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(ArticleDetailsBo, result.resultObjects));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async updateArticleDetails(data: ArticleDetailsBo): Promise<boolean> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.articleConnector.updateArticleDetails(data).then(async (result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          await this.commit();
+          resolve(true);
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+  public async lockArticleDetails(data: ArticleStockManagement): Promise<boolean> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.articleConnector.lockArticleDetails(data).then(async (result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          await this.commit();
+          resolve(true);
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+
+  public async getStockStatus(): Promise<StockStatus[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.articleConnector.getStockState().then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObjects) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(StockStatus, result.resultObjects));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getStockStickerTemplates(data: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.sharedConnector.getStockStickerPrintLayouts(data).then((result: DataServiceResponse) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObject) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(StockStickersPrintLayouts, result.resultObject));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getArticleTransaction(data: ArticleTransaction): Promise<ArticleTransactionBo[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.articleConnector.getArticleTransaction(data).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObjects) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(ArticleTransactionBo, result.resultObjects));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public commit(): Promise<DataServiceResponseData> {
+    return this.articleConnector.commit();
+  }
+
+}

package/projects/sharedcomponents/src/lib/service/shared-initializer.service.ts

@@ -0,0 +1,29 @@
+import {Inject, Injectable, Injector} from "@angular/core";
+import {SharedService} from "./shared.service";
+
+@Injectable()
+export class SharedInitializerService {
+
+  constructor(
+    @Inject(Injector) private readonly injector: Injector
+  ) {
+  }
+
+  public async initializeApp(): Promise<void> {
+    const options = {
+      url: "http://130.62.7.55:8888/ione/",
+      schema: "815",
+      version: "252",
+      useLoginEncryption: true,
+      username: "patrick",
+      password: "patrick",
+      languageCode: "NL",
+    };
+
+    const sharedService = this.injector.get(SharedService);
+    if (sharedService) {
+      await sharedService.init(options);
+    }
+  }
+
+}

package/projects/sharedcomponents/src/lib/service/shared.service.ts

@@ -0,0 +1,21 @@
+import {SharedConnectorService} from "./shared-connector.service";
+import {Injectable} from "@angular/core";
+import {OptionsService} from "./options.service";
+
+@Injectable({
+  providedIn: "root"
+})
+
+export class SharedService {
+
+  constructor(
+    protected options: OptionsService,
+    protected connector: SharedConnectorService,
+  ) {
+  }
+
+  public async init(options: any): Promise<void> {
+    await this.options.initialize(options);
+    this.connector.connect();
+  }
+}

package/projects/sharedcomponents/src/lib/service/stock.service.ts

@@ -0,0 +1,95 @@
+import {Injectable} from "@angular/core";
+import {PrintStockStickers} from "@colijnit/sharedapi/build/model/print-stock-stickers";
+import {Printer} from "@colijnit/sharedapi/build/model/report/printer.bo";
+import {GetStockHistoryRequest} from "@colijnit/articleapi/build/model/get-stock-history-request";
+import {ArticleStock as ArticleStockBo} from "@colijnit/articleapi/build/model/article-stock.bo";
+import {ArticleStock} from "@colijnit/articleapi/build/model/article-stock";
+import {StockHistoryBo} from "@colijnit/articleapi/build/model/stock-history.bo";
+import {StockStickersPrintLayouts} from "@colijnit/sharedapi/build/model/report/stock-stickers-print-layouts.bo";
+import {ArticleDetailsBo} from "@colijnit/articleapi/build/model/article-details.bo";
+import {ArticleStockManagement} from "@colijnit/articleapi/build/model/article-stock-management";
+import {StockStatus} from "@colijnit/articleapi/build/model/stock-status.bo";
+import {StockManagementWarehouses} from "@colijnit/articleapi/build/model/stock-management-warehouses.bo";
+import {StockLocation} from "@colijnit/articleapi/build/model/stock-location.bo";
+import {DataServiceResponseData} from "@colijnit/articleapi/build/model/data-service-response-data";
+import {ArticleTransaction} from "@colijnit/articleapi/build/model/article-transaction";
+import {ArticleTransaction as ArticleTransactionBo} from "@colijnit/articleapi/build/model/article-transaction.bo";
+import {SharedService} from "./shared.service";
+import {PrintPriceStickers} from "@colijnit/sharedapi/build/model/print-price-stickers.bo";
+import {SharedConnectorService} from "./shared-connector.service";
+
+@Injectable({
+  providedIn: 'root',
+})
+export class StockService {
+
+  public stockStickers: PrintStockStickers;
+  public printSticker: PrintStockStickers = new PrintStockStickers();
+  public printPriceSticker: PrintPriceStickers = new PrintPriceStickers();
+
+  constructor(
+    private _sharedService: SharedConnectorService,
+  ) {
+  }
+
+  public async getPrintStockStickers(data: PrintStockStickers): Promise<void> {
+    await this._sharedService.getPrintStockStickers(data);
+  }
+
+  public async getPrintPriceStickers(data: PrintPriceStickers): Promise<void> {
+    await this._sharedService.getPrintPriceStickers(data);
+  }
+
+  public async getAllPrinters(showAll: boolean = true): Promise<Printer[]> {
+    return await this._sharedService.getAllPrinters(showAll);
+  }
+
+  public async getStockHistory(data: GetStockHistoryRequest): Promise<StockHistoryBo[]> {
+    return await this._sharedService.getStockHistory(data);
+  }
+
+  public async getStockInformation(data: ArticleStock): Promise<ArticleStockBo[]> {
+    return await this._sharedService.getStockInformation(data);
+  }
+
+  // public async getStockStickerPrintLayouts(data: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {
+  //   return await this._connector.getStockStickerPrintLayouts(data);
+  // }
+
+  public async getArticleDetails(data: ArticleStockManagement): Promise<ArticleDetailsBo[]> {
+    return await this._sharedService.getArticleDetails(data);
+  }
+
+  public async updateArticleDetails(data: ArticleDetailsBo): Promise<boolean> {
+    return await this._sharedService.updateArticleDetails(data);
+  }
+
+  public async getStockState(): Promise<StockStatus[]> {
+    return await this._sharedService.getStockStatus();
+  }
+
+  public async getStockStickerTemplates(data: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {
+    return await this._sharedService.getStockStickerTemplates(data);
+  }
+
+  public async getStockManagementWarehouses(): Promise<StockManagementWarehouses[]> {
+    return await this._sharedService.getStockManagementWarehouses();
+  }
+
+  public async getStockManagementLocations(warehouseNo: number): Promise<StockLocation[]> {
+    return await this._sharedService.getStockManagementLocations(warehouseNo);
+  }
+
+  public async getArticleTransaction(data: ArticleTransaction): Promise<ArticleTransactionBo[]> {
+    return await this._sharedService.getArticleTransaction(data);
+  }
+
+  public async lockArticleDetails(data: ArticleStockManagement): Promise<boolean> {
+    return await this._sharedService.lockArticleDetails(data);
+  }
+
+  public commit(): Promise<DataServiceResponseData> {
+    return this._sharedService.commit();
+  }
+
+}