@colijnit/sharedcomponents 1.0.57 → 1.0.59

package/esm2015/lib/service/shared.service.js

@@ -1,60 +1,60 @@
-import { __awaiter } from "tslib";
-import { SharedConnectorService } from "./shared-connector.service";
-import { Injectable } from "@angular/core";
-import { OptionsService } from "./options.service";
-import * as i0 from "@angular/core";
-import * as i1 from "./options.service";
-import * as i2 from "./shared-connector.service";
-export class SharedService {
-    constructor(options, connector) {
-        this.options = options;
-        this.connector = connector;
-    }
-    init(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.options.initialize(options);
-            this.connector.connect();
-        });
-    }
-    getAllPrinters() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.connector.getAllPrinters();
-        });
-    }
-    getSendMethods() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.connector.getSendMethods();
-        });
-    }
-    getScreenConfigTree() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.connector.getScreenConfigTree();
-        });
-    }
-    getScreenConfigSubRubric(parentRubricId, configId, fixedKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.connector.getScreenConfigSubRubric(parentRubricId, configId, fixedKey);
-        });
-    }
-    getTagsFullTree(category, includeTags = true) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.connector.getTagsFullTree(category, includeTags);
-        });
-    }
-    getDocumentContent(docId, thumbnail = true) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.connector.getDocumentContent(docId, thumbnail);
-        });
-    }
-}
-SharedService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SharedService_Factory() { return new SharedService(i0.ɵɵinject(i1.OptionsService), i0.ɵɵinject(i2.SharedConnectorService)); }, token: SharedService, providedIn: "root" });
-SharedService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: "root"
-            },] }
-];
-SharedService.ctorParameters = () => [
-    { type: OptionsService },
-    { type: SharedConnectorService }
-];
-//# sourceMappingURL=data:application/json;base64,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
+import { __awaiter } from "tslib";
+import { SharedConnectorService } from "./shared-connector.service";
+import { Injectable } from "@angular/core";
+import { OptionsService } from "./options.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./options.service";
+import * as i2 from "./shared-connector.service";
+export class SharedService {
+    constructor(options, connector) {
+        this.options = options;
+        this.connector = connector;
+    }
+    init(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.options.initialize(options);
+            yield this.connector.connect();
+        });
+    }
+    getAllPrinters() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.connector.getAllPrinters();
+        });
+    }
+    getSendMethods() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.connector.getSendMethods();
+        });
+    }
+    getScreenConfigTree() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.connector.getScreenConfigTree();
+        });
+    }
+    getScreenConfigSubRubric(parentRubricId, configId, fixedKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.connector.getScreenConfigSubRubric(parentRubricId, configId, fixedKey);
+        });
+    }
+    getTagsFullTree(category, includeTags = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.connector.getTagsFullTree(category, includeTags);
+        });
+    }
+    getDocumentContent(docId, thumbnail = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.connector.getDocumentContent(docId, thumbnail);
+        });
+    }
+}
+SharedService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SharedService_Factory() { return new SharedService(i0.ɵɵinject(i1.OptionsService), i0.ɵɵinject(i2.SharedConnectorService)); }, token: SharedService, providedIn: "root" });
+SharedService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+SharedService.ctorParameters = () => [
+    { type: OptionsService },
+    { type: SharedConnectorService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/service/stock.service.js

@@ -1,110 +1,110 @@
-import { __awaiter } from "tslib";
-import { EventEmitter, Injectable } from "@angular/core";
-import { SharedConnectorService } from "./shared-connector.service";
-import * as i0 from "@angular/core";
-import * as i1 from "./shared-connector.service";
-export class StockService {
-    constructor(_sharedService) {
-        this._sharedService = _sharedService;
-        this.warehouseSelected = new EventEmitter();
-    }
-    // public async getPrintStockStickers(data: PrintStockStickers): Promise<void> {
-    //   await this._sharedService.getPrintStockStickers(data);
-    // }
-    // public async getPrintPriceStickers(data: PrintPriceStickers): Promise<void> {
-    //   await this._sharedService.getPrintPriceStickers(data);
-    // }
-    getStockHistory(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._sharedService.getStockHistory(data);
-        });
-    }
-    getStockInformation(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._sharedService.getStockInformation(data);
-        });
-    }
-    // public async getStockStickerPrintLayouts(data: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {
-    //   return await this._connector.getStockStickerPrintLayouts(data);
-    // }
-    getArticleDetails(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._sharedService.getArticleDetails(data);
-        });
-    }
-    updateArticleDetails(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._sharedService.updateArticleDetails(data);
-        });
-    }
-    getStockState() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._sharedService.getStockStatus();
-        });
-    }
-    getArtStockStatus(goodId, branchNo, requestedAmount, warehouseId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._sharedService.getArtStockStatus(goodId, branchNo, requestedAmount, warehouseId);
-        });
-    }
-    // public async getStockStickerTemplates(data: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {
-    //   return await this._sharedService.getStockStickerTemplates(data);
-    // }
-    getStockManagementWarehouses() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._sharedService.getStockManagementWarehouses();
-        });
-    }
-    getStockManagementLocations(warehouseNo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._sharedService.getStockManagementLocations(warehouseNo);
-        });
-    }
-    // public async getOrderConfirmationDefaultSendMethod(relationId: number): Promise<number> {
-    //   return await this._sharedService.getOrderConfirmationDefaultSendMethod(relationId);
-    // }
-    // public async getDefaultEmailAddressListForOrderConfirmation(transactionUUID: string): Promise<string[]> {
-    //   return await this._sharedService.getDefaultEmailAddressListForOrderConfirmation(transactionUUID);
-    // }
-    // public async getPurchaseOrderEmailLayouts(transactionUUID: string): Promise<StockStickersEmailLayouts[]> {
-    //   return await this._sharedService.getPurchaseOrderEmailLayouts(transactionUUID);
-    // }
-    getArticleTransaction(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._sharedService.getArticleTransaction(data);
-        });
-    }
-    stockPrognose(goodId, warehouseNumber) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._sharedService.getStockPrognose(goodId, warehouseNumber);
-        });
-    }
-    lockArticleDetails(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._sharedService.lockArticleDetails(data);
-        });
-    }
-    commit() {
-        return this._sharedService.commit();
-    }
-    getArticleFlat(sku) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._sharedService.getArticleFlat(sku);
-        });
-    }
-    searchArticles(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._sharedService.searchArticles(request);
-        });
-    }
-}
-StockService.ɵprov = i0.ɵɵdefineInjectable({ factory: function StockService_Factory() { return new StockService(i0.ɵɵinject(i1.SharedConnectorService)); }, token: StockService, providedIn: "root" });
-StockService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-StockService.ctorParameters = () => [
-    { type: SharedConnectorService }
-];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stock.service.js","sourceRoot":"","sources":["../../../../../projects/sharedcomponents/src/lib/service/stock.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,YAAY,EAAE,UAAU,EAAC,MAAM,eAAe,CAAC;AAavD,OAAO,EAAC,sBAAsB,EAAC,MAAM,4BAA4B,CAAC;;;AAWlE,MAAM,OAAO,YAAY;IAOvB,YACU,cAAsC;QAAtC,mBAAc,GAAd,cAAc,CAAwB;QAHhC,sBAAiB,GAA4C,IAAI,YAAY,EAA6B,CAAA;IAK1H,CAAC;IAED,gFAAgF;IAChF,2DAA2D;IAC3D,IAAI;IAEJ,gFAAgF;IAChF,2DAA2D;IAC3D,IAAI;IAES,eAAe,CAAC,IAA4B;;YACvD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QACzD,CAAC;KAAA;IAEY,mBAAmB,CAAC,IAAkB;;YACjD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;QAC7D,CAAC;KAAA;IAED,oHAAoH;IACpH,oEAAoE;IACpE,IAAI;IAES,iBAAiB,CAAC,IAA4B;;YACzD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAC3D,CAAC;KAAA;IAEY,oBAAoB,CAAC,IAAsB;;YACtD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;QAC9D,CAAC;KAAA;IAEY,aAAa;;YACxB,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,cAAc,EAAE,CAAC;QACpD,CAAC;KAAA;IAEY,iBAAiB,CAAC,MAAc,EAAE,QAAiB,EAAE,eAAwB,EAAE,WAAoB;;YAC9G,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,MAAM,EAAE,QAAQ,EAAE,eAAe,EAAE,WAAW,CAAC,CAAC;QACrG,CAAC;KAAA;IAED,iHAAiH;IACjH,qEAAqE;IACrE,IAAI;IAES,4BAA4B;;YACvC,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,4BAA4B,EAAE,CAAC;QAClE,CAAC;KAAA;IAEY,2BAA2B,CAAC,WAAmB;;YAC1D,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,2BAA2B,CAAC,WAAW,CAAC,CAAC;QAC5E,CAAC;KAAA;IAED,4FAA4F;IAC5F,wFAAwF;IACxF,IAAI;IAEJ,4GAA4G;IAC5G,sGAAsG;IACtG,IAAI;IAEJ,6GAA6G;IAC7G,oFAAoF;IACpF,IAAI;IAES,qBAAqB,CAAC,IAAwB;;YACzD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC;QAC/D,CAAC;KAAA;IAEY,aAAa,CAAC,MAAc,EAAE,eAAuB;;YAChE,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,gBAAgB,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;QAC7E,CAAC;KAAA;IAEY,kBAAkB,CAAC,IAA4B;;YAC1D,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;QAC5D,CAAC;KAAA;IAEM,MAAM;QACX,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC;IACtC,CAAC;IAEY,cAAc,CAAC,GAAW;;YACrC,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;QACvD,CAAC;KAAA;IAEY,cAAc,CAAC,OAA+B;;YACzD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAC3D,CAAC;KAAA;;;;YAjGF,UAAU,SAAC;gBACV,UAAU,EAAE,MAAM;aACnB;;;YAVO,sBAAsB","sourcesContent":["import {EventEmitter, Injectable} from \"@angular/core\";\r\nimport {PrintStockStickers} from \"@colijnit/sharedapi/build/model/print-stock-stickers\";\r\nimport {GetStockHistoryRequest} from \"@colijnit/articleapi/build/model/get-stock-history-request\";\r\nimport {ArticleStock as ArticleStockBo} from \"@colijnit/articleapi/build/model/article-stock.bo\";\r\nimport {ArticleStock} from \"@colijnit/articleapi/build/model/article-stock\";\r\nimport {StockHistoryBo} from \"@colijnit/articleapi/build/model/stock-history.bo\";\r\nimport {ArticleDetailsBo} from \"@colijnit/articleapi/build/model/article-details.bo\";\r\nimport {ArticleStockManagement} from \"@colijnit/articleapi/build/model/article-stock-management\";\r\nimport {StockStatus} from \"@colijnit/articleapi/build/model/stock-status.bo\";\r\nimport {StockManagementWarehouses} from \"@colijnit/articleapi/build/model/stock-management-warehouses.bo\";\r\nimport {StockLocation} from \"@colijnit/articleapi/build/model/stock-location.bo\";\r\nimport {ArticleTransaction} from \"@colijnit/articleapi/build/model/article-transaction\";\r\nimport {ArticleTransaction as ArticleTransactionBo} from \"@colijnit/articleapi/build/model/article-transaction.bo\";\r\nimport {SharedConnectorService} from \"./shared-connector.service\";\r\nimport {SendMethodParams} from \"../components/send-method-dialog/send-method-params.interface\";\r\nimport {DataServiceResponseData} from '@colijnit/ioneconnector/build/model/data-service-response-data';\r\nimport {StockForecast} from \"@colijnit/articleapi/build/model/stock-forecast.bo\";\r\nimport {ArticleExtendedRequest} from \"@colijnit/articleapi/build/model/article-extended-request\";\r\nimport {ArticleExtended} from \"@colijnit/articleapi/build/model/article-extended.bo\";\r\nimport {ArticleFlat} from \"@colijnit/articleapi/build/model/article-flat.bo\";\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class StockService {\r\n\r\n  public stockStickers: PrintStockStickers;\r\n  public printLayoutParams: SendMethodParams;\r\n\r\n  public readonly warehouseSelected: EventEmitter<StockManagementWarehouses> = new EventEmitter<StockManagementWarehouses>()\r\n\r\n  constructor(\r\n    private _sharedService: SharedConnectorService,\r\n  ) {\r\n  }\r\n\r\n  // public async getPrintStockStickers(data: PrintStockStickers): Promise<void> {\r\n  //   await this._sharedService.getPrintStockStickers(data);\r\n  // }\r\n\r\n  // public async getPrintPriceStickers(data: PrintPriceStickers): Promise<void> {\r\n  //   await this._sharedService.getPrintPriceStickers(data);\r\n  // }\r\n\r\n  public async getStockHistory(data: GetStockHistoryRequest): Promise<StockHistoryBo[]> {\r\n    return await this._sharedService.getStockHistory(data);\r\n  }\r\n\r\n  public async getStockInformation(data: ArticleStock): Promise<ArticleStockBo[]> {\r\n    return await this._sharedService.getStockInformation(data);\r\n  }\r\n\r\n  // public async getStockStickerPrintLayouts(data: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {\r\n  //   return await this._connector.getStockStickerPrintLayouts(data);\r\n  // }\r\n\r\n  public async getArticleDetails(data: ArticleStockManagement): Promise<ArticleDetailsBo[]> {\r\n    return await this._sharedService.getArticleDetails(data);\r\n  }\r\n\r\n  public async updateArticleDetails(data: ArticleDetailsBo): Promise<boolean> {\r\n    return await this._sharedService.updateArticleDetails(data);\r\n  }\r\n\r\n  public async getStockState(): Promise<StockStatus[]> {\r\n    return await this._sharedService.getStockStatus();\r\n  }\r\n\r\n  public async getArtStockStatus(goodId: number, branchNo?: string, requestedAmount?: number, warehouseId?: number): Promise<number> {\r\n    return await this._sharedService.getArtStockStatus(goodId, branchNo, requestedAmount, warehouseId);\r\n  }\r\n\r\n  // public async getStockStickerTemplates(data: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {\r\n  //   return await this._sharedService.getStockStickerTemplates(data);\r\n  // }\r\n\r\n  public async getStockManagementWarehouses(): Promise<StockManagementWarehouses[]> {\r\n    return await this._sharedService.getStockManagementWarehouses();\r\n  }\r\n\r\n  public async getStockManagementLocations(warehouseNo: number): Promise<StockLocation[]> {\r\n    return await this._sharedService.getStockManagementLocations(warehouseNo);\r\n  }\r\n\r\n  // public async getOrderConfirmationDefaultSendMethod(relationId: number): Promise<number> {\r\n  //   return await this._sharedService.getOrderConfirmationDefaultSendMethod(relationId);\r\n  // }\r\n\r\n  // public async getDefaultEmailAddressListForOrderConfirmation(transactionUUID: string): Promise<string[]> {\r\n  //   return await this._sharedService.getDefaultEmailAddressListForOrderConfirmation(transactionUUID);\r\n  // }\r\n\r\n  // public async getPurchaseOrderEmailLayouts(transactionUUID: string): Promise<StockStickersEmailLayouts[]> {\r\n  //   return await this._sharedService.getPurchaseOrderEmailLayouts(transactionUUID);\r\n  // }\r\n\r\n  public async getArticleTransaction(data: ArticleTransaction): Promise<ArticleTransactionBo[]> {\r\n    return await this._sharedService.getArticleTransaction(data);\r\n  }\r\n\r\n  public async stockPrognose(goodId: number, warehouseNumber: number): Promise<StockForecast[]> {\r\n    return await this._sharedService.getStockPrognose(goodId, warehouseNumber);\r\n  }\r\n\r\n  public async lockArticleDetails(data: ArticleStockManagement): Promise<boolean> {\r\n    return await this._sharedService.lockArticleDetails(data);\r\n  }\r\n\r\n  public commit(): Promise<DataServiceResponseData> {\r\n    return this._sharedService.commit();\r\n  }\r\n\r\n  public async getArticleFlat(sku: string): Promise<ArticleFlat> {\r\n    return await this._sharedService.getArticleFlat(sku);\r\n  }\r\n\r\n  public async searchArticles(request: ArticleExtendedRequest): Promise<ArticleExtended[]> {\r\n    return await this._sharedService.searchArticles(request);\r\n  }\r\n\r\n\r\n\r\n\r\n}\r\n"]}
+import { __awaiter } from "tslib";
+import { EventEmitter, Injectable } from "@angular/core";
+import { SharedConnectorService } from "./shared-connector.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./shared-connector.service";
+export class StockService {
+    constructor(_sharedService) {
+        this._sharedService = _sharedService;
+        this.warehouseSelected = new EventEmitter();
+    }
+    // public async getPrintStockStickers(data: PrintStockStickers): Promise<void> {
+    //   await this._sharedService.getPrintStockStickers(data);
+    // }
+    // public async getPrintPriceStickers(data: PrintPriceStickers): Promise<void> {
+    //   await this._sharedService.getPrintPriceStickers(data);
+    // }
+    getStockHistory(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getStockHistory(data);
+        });
+    }
+    getStockInformation(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getStockInformation(data);
+        });
+    }
+    // public async getStockStickerPrintLayouts(data: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {
+    //   return await this._connector.getStockStickerPrintLayouts(data);
+    // }
+    getArticleDetails(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getArticleDetails(data);
+        });
+    }
+    updateArticleDetails(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.updateArticleDetails(data);
+        });
+    }
+    getStockState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getStockStatus();
+        });
+    }
+    getArtStockStatus(goodId, branchNo, requestedAmount, warehouseId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getArtStockStatus(goodId, branchNo, requestedAmount, warehouseId);
+        });
+    }
+    // public async getStockStickerTemplates(data: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {
+    //   return await this._sharedService.getStockStickerTemplates(data);
+    // }
+    getStockManagementWarehouses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getStockManagementWarehouses();
+        });
+    }
+    getStockManagementLocations(warehouseNo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getStockManagementLocations(warehouseNo);
+        });
+    }
+    // public async getOrderConfirmationDefaultSendMethod(relationId: number): Promise<number> {
+    //   return await this._sharedService.getOrderConfirmationDefaultSendMethod(relationId);
+    // }
+    // public async getDefaultEmailAddressListForOrderConfirmation(transactionUUID: string): Promise<string[]> {
+    //   return await this._sharedService.getDefaultEmailAddressListForOrderConfirmation(transactionUUID);
+    // }
+    // public async getPurchaseOrderEmailLayouts(transactionUUID: string): Promise<StockStickersEmailLayouts[]> {
+    //   return await this._sharedService.getPurchaseOrderEmailLayouts(transactionUUID);
+    // }
+    getArticleTransaction(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getArticleTransaction(data);
+        });
+    }
+    stockPrognose(goodId, warehouseNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getStockPrognose(goodId, warehouseNumber);
+        });
+    }
+    lockArticleDetails(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.lockArticleDetails(data);
+        });
+    }
+    commit() {
+        return this._sharedService.commit();
+    }
+    getArticleFlat(sku) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.getArticleFlat(sku);
+        });
+    }
+    searchArticles(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._sharedService.searchArticles(request);
+        });
+    }
+}
+StockService.ɵprov = i0.ɵɵdefineInjectable({ factory: function StockService_Factory() { return new StockService(i0.ɵɵinject(i1.SharedConnectorService)); }, token: StockService, providedIn: "root" });
+StockService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+StockService.ctorParameters = () => [
+    { type: SharedConnectorService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stock.service.js","sourceRoot":"","sources":["../../../../../projects/sharedcomponents/src/lib/service/stock.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,YAAY,EAAE,UAAU,EAAC,MAAM,eAAe,CAAC;AAavD,OAAO,EAAC,sBAAsB,EAAC,MAAM,4BAA4B,CAAC;;;AAWlE,MAAM,OAAO,YAAY;IAOvB,YACU,cAAsC;QAAtC,mBAAc,GAAd,cAAc,CAAwB;QAHhC,sBAAiB,GAA4C,IAAI,YAAY,EAA6B,CAAA;IAK1H,CAAC;IAED,gFAAgF;IAChF,2DAA2D;IAC3D,IAAI;IAEJ,gFAAgF;IAChF,2DAA2D;IAC3D,IAAI;IAES,eAAe,CAAC,IAA4B;;YACvD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QACzD,CAAC;KAAA;IAEY,mBAAmB,CAAC,IAAkB;;YACjD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;QAC7D,CAAC;KAAA;IAED,oHAAoH;IACpH,oEAAoE;IACpE,IAAI;IAES,iBAAiB,CAAC,IAA4B;;YACzD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAC3D,CAAC;KAAA;IAEY,oBAAoB,CAAC,IAAsB;;YACtD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;QAC9D,CAAC;KAAA;IAEY,aAAa;;YACxB,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,cAAc,EAAE,CAAC;QACpD,CAAC;KAAA;IAEY,iBAAiB,CAAC,MAAc,EAAE,QAAiB,EAAE,eAAwB,EAAE,WAAoB;;YAC9G,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,MAAM,EAAE,QAAQ,EAAE,eAAe,EAAE,WAAW,CAAC,CAAC;QACrG,CAAC;KAAA;IAED,iHAAiH;IACjH,qEAAqE;IACrE,IAAI;IAES,4BAA4B;;YACvC,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,4BAA4B,EAAE,CAAC;QAClE,CAAC;KAAA;IAEY,2BAA2B,CAAC,WAAmB;;YAC1D,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,2BAA2B,CAAC,WAAW,CAAC,CAAC;QAC5E,CAAC;KAAA;IAED,4FAA4F;IAC5F,wFAAwF;IACxF,IAAI;IAEJ,4GAA4G;IAC5G,sGAAsG;IACtG,IAAI;IAEJ,6GAA6G;IAC7G,oFAAoF;IACpF,IAAI;IAES,qBAAqB,CAAC,IAAwB;;YACzD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC;QAC/D,CAAC;KAAA;IAEY,aAAa,CAAC,MAAc,EAAE,eAAuB;;YAChE,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,gBAAgB,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;QAC7E,CAAC;KAAA;IAEY,kBAAkB,CAAC,IAA4B;;YAC1D,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;QAC5D,CAAC;KAAA;IAEM,MAAM;QACX,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC;IACtC,CAAC;IAEY,cAAc,CAAC,GAAW;;YACrC,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;QACvD,CAAC;KAAA;IAEY,cAAc,CAAC,OAA+B;;YACzD,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAC3D,CAAC;KAAA;;;;YAjGF,UAAU,SAAC;gBACV,UAAU,EAAE,MAAM;aACnB;;;YAVO,sBAAsB","sourcesContent":["import {EventEmitter, Injectable} from \"@angular/core\";\nimport {PrintStockStickers} from \"@colijnit/sharedapi/build/model/print-stock-stickers\";\nimport {GetStockHistoryRequest} from \"@colijnit/articleapi/build/model/get-stock-history-request\";\nimport {ArticleStock as ArticleStockBo} from \"@colijnit/articleapi/build/model/article-stock.bo\";\nimport {ArticleStock} from \"@colijnit/articleapi/build/model/article-stock\";\nimport {StockHistoryBo} from \"@colijnit/articleapi/build/model/stock-history.bo\";\nimport {ArticleDetailsBo} from \"@colijnit/articleapi/build/model/article-details.bo\";\nimport {ArticleStockManagement} from \"@colijnit/articleapi/build/model/article-stock-management\";\nimport {StockStatus} from \"@colijnit/articleapi/build/model/stock-status.bo\";\nimport {StockManagementWarehouses} from \"@colijnit/articleapi/build/model/stock-management-warehouses.bo\";\nimport {StockLocation} from \"@colijnit/articleapi/build/model/stock-location.bo\";\nimport {ArticleTransaction} from \"@colijnit/articleapi/build/model/article-transaction\";\nimport {ArticleTransaction as ArticleTransactionBo} from \"@colijnit/articleapi/build/model/article-transaction.bo\";\nimport {SharedConnectorService} from \"./shared-connector.service\";\nimport {SendMethodParams} from \"../components/send-method-dialog/send-method-params.interface\";\nimport {DataServiceResponseData} from '@colijnit/ioneconnector/build/model/data-service-response-data';\nimport {StockForecast} from \"@colijnit/articleapi/build/model/stock-forecast.bo\";\nimport {ArticleExtendedRequest} from \"@colijnit/articleapi/build/model/article-extended-request\";\nimport {ArticleExtended} from \"@colijnit/articleapi/build/model/article-extended.bo\";\nimport {ArticleFlat} from \"@colijnit/articleapi/build/model/article-flat.bo\";\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StockService {\n\n  public stockStickers: PrintStockStickers;\n  public printLayoutParams: SendMethodParams;\n\n  public readonly warehouseSelected: EventEmitter<StockManagementWarehouses> = new EventEmitter<StockManagementWarehouses>()\n\n  constructor(\n    private _sharedService: SharedConnectorService,\n  ) {\n  }\n\n  // public async getPrintStockStickers(data: PrintStockStickers): Promise<void> {\n  //   await this._sharedService.getPrintStockStickers(data);\n  // }\n\n  // public async getPrintPriceStickers(data: PrintPriceStickers): Promise<void> {\n  //   await this._sharedService.getPrintPriceStickers(data);\n  // }\n\n  public async getStockHistory(data: GetStockHistoryRequest): Promise<StockHistoryBo[]> {\n    return await this._sharedService.getStockHistory(data);\n  }\n\n  public async getStockInformation(data: ArticleStock): Promise<ArticleStockBo[]> {\n    return await this._sharedService.getStockInformation(data);\n  }\n\n  // public async getStockStickerPrintLayouts(data: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {\n  //   return await this._connector.getStockStickerPrintLayouts(data);\n  // }\n\n  public async getArticleDetails(data: ArticleStockManagement): Promise<ArticleDetailsBo[]> {\n    return await this._sharedService.getArticleDetails(data);\n  }\n\n  public async updateArticleDetails(data: ArticleDetailsBo): Promise<boolean> {\n    return await this._sharedService.updateArticleDetails(data);\n  }\n\n  public async getStockState(): Promise<StockStatus[]> {\n    return await this._sharedService.getStockStatus();\n  }\n\n  public async getArtStockStatus(goodId: number, branchNo?: string, requestedAmount?: number, warehouseId?: number): Promise<number> {\n    return await this._sharedService.getArtStockStatus(goodId, branchNo, requestedAmount, warehouseId);\n  }\n\n  // public async getStockStickerTemplates(data: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {\n  //   return await this._sharedService.getStockStickerTemplates(data);\n  // }\n\n  public async getStockManagementWarehouses(): Promise<StockManagementWarehouses[]> {\n    return await this._sharedService.getStockManagementWarehouses();\n  }\n\n  public async getStockManagementLocations(warehouseNo: number): Promise<StockLocation[]> {\n    return await this._sharedService.getStockManagementLocations(warehouseNo);\n  }\n\n  // public async getOrderConfirmationDefaultSendMethod(relationId: number): Promise<number> {\n  //   return await this._sharedService.getOrderConfirmationDefaultSendMethod(relationId);\n  // }\n\n  // public async getDefaultEmailAddressListForOrderConfirmation(transactionUUID: string): Promise<string[]> {\n  //   return await this._sharedService.getDefaultEmailAddressListForOrderConfirmation(transactionUUID);\n  // }\n\n  // public async getPurchaseOrderEmailLayouts(transactionUUID: string): Promise<StockStickersEmailLayouts[]> {\n  //   return await this._sharedService.getPurchaseOrderEmailLayouts(transactionUUID);\n  // }\n\n  public async getArticleTransaction(data: ArticleTransaction): Promise<ArticleTransactionBo[]> {\n    return await this._sharedService.getArticleTransaction(data);\n  }\n\n  public async stockPrognose(goodId: number, warehouseNumber: number): Promise<StockForecast[]> {\n    return await this._sharedService.getStockPrognose(goodId, warehouseNumber);\n  }\n\n  public async lockArticleDetails(data: ArticleStockManagement): Promise<boolean> {\n    return await this._sharedService.lockArticleDetails(data);\n  }\n\n  public commit(): Promise<DataServiceResponseData> {\n    return this._sharedService.commit();\n  }\n\n  public async getArticleFlat(sku: string): Promise<ArticleFlat> {\n    return await this._sharedService.getArticleFlat(sku);\n  }\n\n  public async searchArticles(request: ArticleExtendedRequest): Promise<ArticleExtended[]> {\n    return await this._sharedService.searchArticles(request);\n  }\n\n\n\n\n}\n"]}

package/esm2015/lib/utils/array-utils.js

@@ -0,0 +1,202 @@
+import { ObjectUtils } from "./object-utils";
+import { NumberUtils } from "./number-utils";
+import { isNill } from "./is-nill.function";
+import { notNill } from "./function/not-nill.function";
+export class ArrayUtils {
+    /**
+     * Returns whether at least one element in given array could be found by given finder function.
+     *
+     * @param {T[]} array
+     * @param {(element: T) => boolean} finder A finder function that takes an element of the array and returns a boolean that represents
+     * the 'found status' for that element; whether it should have been found or not.
+     */
+    static ContainsAnElementFoundBy(array, finder) {
+        if (!array || !finder) {
+            return false;
+        }
+        return notNill(this.Find(array, finder));
+    }
+    /**
+     * Cross-browser Array.find() function. Returns the first item in given array for which the foundBy function returns true. Returns
+     * undefined when none was found.
+     *
+     * Example usage:
+     * const foundItem: BusinessObject = ArrayUtils.Find<BusinessObject>(modelArray, (modelItem: BusinessObject) => <br>
+     *     (return modelItem.getId() === '1')
+     *   * });
+     *
+     * @param array The array with items to search in.
+     * @param foundBy The finder function applied on each items of the array, when that returns true, the item is considered found.
+     */
+    static Find(array, foundBy) {
+        if (!array || !foundBy) {
+            return undefined;
+        }
+        for (let i = 0, len = array.length; i < len; i++) {
+            const itemCur = array[i];
+            if (foundBy(itemCur)) {
+                return itemCur;
+            }
+        }
+        return undefined;
+    }
+    // @returns empty array when nothing found, otherwise array with found items
+    static FindAll(array, foundBy) {
+        const answer = [];
+        if (!array || !foundBy) {
+            return answer;
+        }
+        for (let i = 0, len = array.length; i < len; i++) {
+            const itemCur = array[i];
+            if (foundBy(itemCur)) {
+                answer.push(itemCur);
+            }
+        }
+        return answer;
+    }
+    // returns a simple clone of given array, using array.slice(0)
+    static CloneArray(array) {
+        let answer = [];
+        if (array) {
+            answer = array.slice(0);
+        }
+        return answer;
+    }
+    /**
+     * Returns a 'semi deep clone' of given array. Its first-level members are object-shallow-cloned (optionally with a strongly typed constructor),
+     * or just as plain object (see param arrayItemsClass).
+     * @param array
+     * @param arrayItemsClass If provided, the cloned array's first-level items will be strongly typed to / constructed as this class. Otherwise
+     * it'll be a plain object.
+     * @param deepClone Set to true if array items contain FUNCTIONS that need to be cloned..
+     * @returns {Array} semi-deep clone of given array
+     */
+    static CloneArrayAndItsItems(array, arrayItemsClass, deepClone = false) {
+        const cloneArray = [];
+        if (array) {
+            for (let i = 0, len = array.length; i < len; i++) {
+                if (deepClone) {
+                    cloneArray.push(ObjectUtils.GetDeepClone(array[i]));
+                }
+                else {
+                    cloneArray.push(ObjectUtils.GetShallowClone(array[i], arrayItemsClass));
+                }
+            }
+        }
+        else {
+            return [];
+        }
+        return cloneArray;
+    }
+    /**
+     * Removes element at given index from given array. Doesn't just set it to null like JavaScripts standard 'delete' does, but really
+     * removes the element using splice().
+     *
+     * @param {number} index
+     * @param {any[]} array in-out
+     * @returns {boolean} True if and only if the element on given index is succesfully removed from given array.
+     */
+    static RemoveElementAtIndex(index, array) {
+        if (NumberUtils.IsNaN(index) || index < 0 || !Array.isArray(array) || array.length === 0) {
+            return false;
+        }
+        if (index in array) {
+            array.splice(index, 1);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * Removes given element from given array. Doesn't just set it to null like JavaScripts standard 'delete' does, but really removes the
+     * element using splice(). Also works on associative arrays.
+     *
+     * @param {T} element The element to remove.
+     * @param {T[]} array The array to remove the element from.
+     * @returns {boolean} True iff given element was truly successfully removed from given array.
+     */
+    static RemoveElement(element, array) {
+        if (!Array.isArray(array)) {
+            return false;
+        }
+        const index = array.indexOf(element);
+        return ArrayUtils.RemoveElementAtIndex(index, array);
+    }
+    // Checks if given array is defined, and is an array, and has length > 0, and, optionally checks that the first element is of type given clazz.
+    static IsArrayWithElements(arrayToCheck, classItemsMustBeInstanceOf) {
+        if (isNill(arrayToCheck)) {
+            return false;
+        }
+        if (Array.isArray(arrayToCheck) && arrayToCheck.length > 0) {
+            if (classItemsMustBeInstanceOf) {
+                return arrayToCheck[0] instanceof classItemsMustBeInstanceOf;
+            }
+            else {
+                return true;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    // Removes all elements from given array for which given filter function holds true. Returns true if at least one removed, else false.
+    static RemoveElementsByFilter(array, filterFunction) {
+        if (!ArrayUtils.IsArrayWithElements(array) || !filterFunction) {
+            return false;
+        }
+        let atLeastOneRemoved = false;
+        const len = array.length;
+        for (let i = len - 1; i >= 0; i--) {
+            const item = array[i];
+            if (filterFunction.call(this, item) === true) {
+                array.splice(i, 1);
+                atLeastOneRemoved = true;
+            }
+        }
+        return atLeastOneRemoved;
+    }
+    static MoveElement(element, toIndex, array) {
+        if (!Array.isArray(array) || isNill(toIndex)) {
+            return false;
+        }
+        const fromIndex = array.indexOf(element);
+        const toIndexCorrected = NumberUtils.GetNearestNumberWithinBounds(toIndex, 0, array.length - 1);
+        if (fromIndex === -1 || array[toIndexCorrected] === element) {
+            // element did not exist in given array, or already existed on given toIndex
+            return false;
+        }
+        array.splice(toIndexCorrected, 0, array.splice(fromIndex, 1)[0]);
+        return true;
+    }
+    // PRE: elements exists in given array. POST: given elementToPlace has a lower index than given afterThisElement. Array is in-out manipulated.
+    static PlaceElementAfterOther(array, elementToPlace, afterThisElement) {
+        if (array) {
+            const afterThisElIdx = array.indexOf(afterThisElement);
+            const elToPlaceIdx = array.indexOf(elementToPlace);
+            if (afterThisElIdx >= elToPlaceIdx) {
+                ArrayUtils.MoveElement(elementToPlace, afterThisElIdx + 1, array);
+            }
+        }
+    }
+    /**
+     * Returns max value from all resulting values from applying given itemValueFunction to all items of given array.
+     * @param array
+     * @param itemValueFunction The function applied to each array item that gives it a numerical value. The max num val found is returned.
+     */
+    static GetMaxCalculatedValue(array, itemValueFunction) {
+        if (!array || !itemValueFunction) {
+            return NaN;
+        }
+        let max = undefined;
+        const len = array.length;
+        for (let i = 0; i < len; i++) {
+            const valueCur = itemValueFunction.call(this);
+            if (valueCur > max) {
+                max = valueCur;
+            }
+        }
+        return max;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"array-utils.js","sourceRoot":"","sources":["../../../../../projects/sharedcomponents/src/lib/utils/array-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {ObjectUtils} from \"./object-utils\";\nimport {NumberUtils} from \"./number-utils\";\nimport {isNill} from \"./is-nill.function\";\nimport {notNill} from \"./function/not-nill.function\";\n\nexport class ArrayUtils {\n    /**\n     * Returns whether at least one element in given array could be found by given finder function.\n     *\n     * @param {T[]} array\n     * @param {(element: T) => boolean} finder A finder function that takes an element of the array and returns a boolean that represents\n     * the 'found status' for that element; whether it should have been found or not.\n     */\n    public static ContainsAnElementFoundBy<T>(array: T[], finder: (element: T) => boolean): boolean {\n        if (!array || !finder) {\n            return false;\n        }\n\n        return notNill(this.Find<T>(array, finder));\n    }\n\n    /**\n     * Cross-browser Array.find() function. Returns the first item in given array for which the foundBy function returns true. Returns\n     * undefined when none was found.\n     *\n     * Example usage:\n     * const foundItem: BusinessObject = ArrayUtils.Find<BusinessObject>(modelArray, (modelItem: BusinessObject) => <br>\n     *     (return modelItem.getId() === '1')\n     *   * });\n     *\n     * @param array The array with items to search in.\n     * @param foundBy The finder function applied on each items of the array, when that returns true, the item is considered found.\n     */\n    public static Find<T>(array: T[], foundBy: (item: T) => boolean): T {\n        if (!array || !foundBy) {\n            return undefined;\n        }\n\n        for (let i: number = 0, len: number = array.length; i < len; i++) {\n            const itemCur: T = array[i];\n            if (foundBy(itemCur) ) {\n                return itemCur;\n            }\n        }\n        return undefined;\n    }\n\n    // @returns empty array when nothing found, otherwise array with found items\n    public static FindAll<T>(array: T[], foundBy: (item: T) => boolean): T[] {\n        const answer: T[] = [];\n        if (!array || !foundBy) {\n            return answer;\n        }\n\n        for (let i: number = 0, len: number = array.length; i < len; i++) {\n            const itemCur: T = array[i];\n            if (foundBy(itemCur)) {\n                answer.push(itemCur);\n            }\n        }\n        return answer;\n    }\n\n    // returns a simple clone of given array, using array.slice(0)\n    public static CloneArray<T>(array: T[]): T[] {\n        let answer: T[] = [];\n\n        if (array) {\n            answer = array.slice(0);\n        }\n\n        return answer;\n    }\n\n    /**\n     * Returns a 'semi deep clone' of given array. Its first-level members are object-shallow-cloned (optionally with a strongly typed constructor),\n     * or just as plain object (see param arrayItemsClass).\n     * @param array\n     * @param arrayItemsClass If provided, the cloned array's first-level items will be strongly typed to / constructed as this class. Otherwise\n     * it'll be a plain object.\n     * @param deepClone Set to true if array items contain FUNCTIONS that need to be cloned..\n     * @returns {Array} semi-deep clone of given array\n     */\n    public static CloneArrayAndItsItems<T>(array: T[], arrayItemsClass?: any, deepClone: boolean = false): T[] {\n        const cloneArray: T[] = [];\n\n        if (array) {\n            for (let i: number = 0, len: number = array.length; i < len; i++) {\n                if (deepClone) {\n                    cloneArray.push(ObjectUtils.GetDeepClone(array[i]));\n                } else {\n                    cloneArray.push(ObjectUtils.GetShallowClone(array[i], arrayItemsClass));\n                }\n            }\n        } else {\n            return [];\n        }\n\n        return cloneArray;\n    }\n\n    /**\n     * Removes element at given index from given array. Doesn't just set it to null like JavaScripts standard 'delete' does, but really\n     * removes the element using splice().\n     *\n     * @param {number} index\n     * @param {any[]} array in-out\n     * @returns {boolean} True if and only if the element on given index is succesfully removed from given array.\n     */\n    public static RemoveElementAtIndex(index: number, array: any[]): boolean {\n        if (NumberUtils.IsNaN(index) || index < 0 || !Array.isArray(array) || array.length === 0) {\n            return false;\n        }\n\n        if (index in array) {\n            array.splice(index, 1);\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * Removes given element from given array. Doesn't just set it to null like JavaScripts standard 'delete' does, but really removes the\n     * element using splice(). Also works on associative arrays.\n     *\n     * @param {T} element The element to remove.\n     * @param {T[]} array The array to remove the element from.\n     * @returns {boolean} True iff given element was truly successfully removed from given array.\n     */\n    public static RemoveElement<T>(element: T, array: T[]): boolean {\n        if (!Array.isArray(array)) {\n            return false;\n        }\n\n        const index: number = array.indexOf(element);\n        return ArrayUtils.RemoveElementAtIndex(index, array);\n    }\n\n    // Checks if given array is defined, and is an array, and has length > 0, and, optionally checks that the first element is of type given clazz.\n    public static IsArrayWithElements<T>(arrayToCheck: T[], classItemsMustBeInstanceOf?: any): boolean {\n        if (isNill(arrayToCheck)) {\n            return false;\n        }\n\n        if (Array.isArray(arrayToCheck) && arrayToCheck.length > 0) {\n            if (classItemsMustBeInstanceOf) {\n                return arrayToCheck[0] instanceof classItemsMustBeInstanceOf;\n            } else {\n                return true;\n            }\n        } else {\n            return false;\n        }\n    }\n\n    // Removes all elements from given array for which given filter function holds true. Returns true if at least one removed, else false.\n    public static RemoveElementsByFilter(array: any[], filterFunction: (item: any) => boolean): boolean {\n        if (!ArrayUtils.IsArrayWithElements(array) || !filterFunction) {\n            return false;\n        }\n\n        let atLeastOneRemoved: boolean = false;\n\n        const len: number = array.length;\n        for (let i: number = len - 1; i >= 0; i--) {\n            const item: any = array[i];\n            if (filterFunction.call(this, item) === true) {\n                array.splice(i, 1);\n                atLeastOneRemoved = true;\n            }\n        }\n\n        return atLeastOneRemoved;\n    }\n\n    public static MoveElement<T>(element: T, toIndex: number, array: T[]): boolean {\n        if (!Array.isArray(array) || isNill(toIndex)) {\n            return false;\n        }\n\n        const fromIndex: number = array.indexOf(element);\n        const toIndexCorrected: number = NumberUtils.GetNearestNumberWithinBounds(toIndex, 0, array.length - 1);\n        if (fromIndex === -1 || array[toIndexCorrected] === element) {\n            // element did not exist in given array, or already existed on given toIndex\n            return false;\n        }\n        array.splice(toIndexCorrected, 0, array.splice(fromIndex, 1)[0]);\n        return true;\n    }\n\n    // PRE: elements exists in given array. POST: given elementToPlace has a lower index than given afterThisElement. Array is in-out manipulated.\n    public static PlaceElementAfterOther(array: any[], elementToPlace: any, afterThisElement: any): void {\n        if (array) {\n            const afterThisElIdx: number = array.indexOf(afterThisElement);\n            const elToPlaceIdx: number = array.indexOf(elementToPlace);\n            if (afterThisElIdx >= elToPlaceIdx) {\n                ArrayUtils.MoveElement(elementToPlace, afterThisElIdx + 1, array);\n            }\n        }\n    }\n\n  /**\n   * Returns max value from all resulting values from applying given itemValueFunction to all items of given array.\n   * @param array\n   * @param itemValueFunction The function applied to each array item that gives it a numerical value. The max num val found is returned.\n   */\n  public static GetMaxCalculatedValue<T>(array: T[], itemValueFunction: (item: T) => number): number {\n    if (!array || !itemValueFunction) {\n      return NaN;\n    }\n\n    let max: number = undefined;\n\n    const len: number = array.length;\n    for (let i: number = 0; i < len; i++) {\n      const valueCur: number = itemValueFunction.call(this);\n      if (valueCur > max) {\n        max = valueCur;\n      }\n    }\n\n    return max;\n  }\n}\n"]}