@colijnit/sharedcomponents 1.0.54 → 1.0.56

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

@@ -0,0 +1,401 @@
+import {Articles} from '@colijnit/articleapi/build/articles';
+import {Sharedapi} from '@colijnit/sharedapi/build/sharedapi';
+import {Injectable} from '@angular/core';
+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 {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 {MainApi} from '@colijnit/mainapi';
+import {Printer} from '@colijnit/mainapi/build/model/printer.bo';
+import {DataServiceResponseData} from '@colijnit/ioneconnector/build/model/data-service-response-data';
+import {SendMethod} from '@colijnit/mainapi/build/model/send-method.bo';
+import {StockForecast} from "@colijnit/articleapi/build/model/stock-forecast.bo";
+import {BusinessObjectFactory} from '@colijnit/ioneconnector/build/service/business-object-factory';
+import {TagCategory} from "@colijnit/mainapi/build/enum/tab-category.enum";
+import {TagTreeItem} from "@colijnit/mainapi/build/model/tag-tree-item.bo";
+import {ArticleExtended} from "@colijnit/articleapi/build/model/article-extended.bo";
+import {ArticleExtendedRequest} from "@colijnit/articleapi/build/model/article-extended-request";
+import {ArticleFlat} from "@colijnit/articleapi/build/model/article-flat.bo";
+
+@Injectable({
+  providedIn: "root"
+})
+export class SharedConnectorService {
+  public articleConnector: Articles;
+  public sharedConnector: Sharedapi;
+  public mainConnector: MainApi;
+
+  private _boFactory: BusinessObjectFactory = new BusinessObjectFactory();
+
+
+  constructor(
+    private _optionsService: OptionsService,
+  ) {
+  }
+
+  public async connect(): Promise<void> {
+    this.sharedConnector = new Sharedapi(this._optionsService.options);
+    await this.sharedConnector.connect();
+    this.articleConnector = new Articles(this._optionsService.options);
+    this.mainConnector = new MainApi(this._optionsService.options);
+  }
+
+  public async getAllPrinters(): Promise<Printer[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.listAllPrinters().then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObject) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(Printer, result.resultObject));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getSendMethods(): Promise<SendMethod[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.getSendMethods().then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObject && result.resultObject.result) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(SendMethod, result.resultObject.result));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getScreenConfigTree(): Promise<any> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.sharedConnector.getConfigTreeObject('T', 'JS').then((result: any) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObjects) {
+            resolve(result.resultObjects);
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getScreenConfigSubRubric(parentRubricId: number, configId: number, fixedKey: string): Promise<any> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.sharedConnector.getConfigSubRubric(parentRubricId, configId, fixedKey).then((result: any) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObjects) {
+            resolve(result.resultObjects);
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getTagsFullTree(category: TagCategory, includeTags: boolean): Promise<TagTreeItem[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.getTagsFullTree(category, includeTags).then((result: any) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObjects) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(TagTreeItem, result.resultObjects));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getDocumentContent(id: number, thumbnail: boolean = true): Promise<string> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.getDocumentContent(id, thumbnail).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          resolve(result.resultObject.documentContent);
+        } 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: DataServiceResponseData) => {
+  //       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: DataServiceResponseData) => {
+  //       if (result.validationResult && result.validationResult.success) {
+  //         if (result.resultObject) {
+  //           resolve(this._boFactory.makeWithRawBackendData(PrintPriceStickers, 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 getArtStockStatus(goodId: number, branchNo?: string, requestedAmount?: number, warehouseId?: number): Promise<number> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.articleConnector.getArtStockStatus(goodId, branchNo, requestedAmount, warehouseId).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObject) {
+            resolve(result.resultObject);
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getArticleFlat(sku: string): Promise<ArticleFlat> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.articleConnector.getArticleFlat(sku).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObject) {
+            resolve(result.resultObject);
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async searchArticles(request: ArticleExtendedRequest): Promise<ArticleExtended[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.articleConnector.searchArticles(request, false).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 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 getOrderConfirmationDefaultSendMethod(relationId: number): Promise<number> {
+  //   return new Promise((resolve: Function, reject: Function) => {
+  //     return this.sharedConnector.getOrderConfirmationDefaultSendMethod(relationId).then((result: DataServiceResponseData) => {
+  //       if (result.validationResult && result.validationResult.success) {
+  //         if (result.resultObject) {
+  //           resolve (result.resultObject);
+  //         }
+  //       } else {
+  //         reject(result.validationMessagesAsString);
+  //       }
+  //     });
+  //   });
+  // }
+
+  // public async getDefaultEmailAddressListForOrderConfirmation(transactionUUID: string): Promise<string[]> {
+  //   return new Promise((resolve: Function, reject: Function) => {
+  //     return this.sharedConnector.getDefaultEmailAddressListForOrderConfirmation(transactionUUID).then((result: DataServiceResponseData) => {
+  //       if (result.validationResult && result.validationResult.success) {
+  //         if (result.resultObject) {
+  //           resolve (result.resultObject);
+  //         }
+  //       } else {
+  //         reject(result.validationMessagesAsString);
+  //       }
+  //     });
+  //   });
+  // }
+
+  // public async getPurchaseOrderEmailLayouts(transactionUUID: string): Promise<StockStickersEmailLayouts[]> {
+  //   return new Promise((resolve: Function, reject: Function) => {
+  //     return this.sharedConnector.getPurchaseOrderEmailLayouts(transactionUUID).then((result: DataServiceResponseData) => {
+  //       if (result.validationResult && result.validationResult.success) {
+  //         if (result.resultObject) {
+  //           resolve (result.resultObject);
+  //         }
+  //       } 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.mainConnector.getStockStickerPrintLayouts(data).then((result: DataServiceResponseData) => {
+  //       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 async getStockPrognose(goodId: number, warehouseNumber: number): Promise<StockForecast[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.articleConnector.getStockForecast(goodId, warehouseNumber).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObjects) {
+            resolve(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://localhost:8080/ione",
+      schema: "815",
+      version: "253",
+      useLoginEncryption: true,
+      username: "stefan",
+      password: "stefan",
+      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,49 @@
+import {SharedConnectorService} from "./shared-connector.service";
+import {Injectable} from "@angular/core";
+import {OptionsService} from "./options.service";
+import {Printer} from '@colijnit/mainapi/build/model/printer.bo';
+import {SendMethod} from '@colijnit/mainapi/build/model/send-method.bo';
+import {TagCategory} from "@colijnit/mainapi/build/enum/tab-category.enum";
+import {TagTreeItem} from "@colijnit/mainapi/build/model/tag-tree-item.bo";
+
+@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();
+  }
+
+  public async getAllPrinters(): Promise<Printer[]> {
+    return await this.connector.getAllPrinters();
+  }
+
+  public async getSendMethods(): Promise<SendMethod[]> {
+    return await this.connector.getSendMethods();
+  }
+
+  public async getScreenConfigTree(): Promise<any> {
+    return await this.connector.getScreenConfigTree();
+  }
+
+  public async getScreenConfigSubRubric(parentRubricId: number, configId: number, fixedKey: string): Promise<any> {
+    return await this.connector.getScreenConfigSubRubric(parentRubricId, configId, fixedKey);
+  }
+
+  public async getTagsFullTree(category: TagCategory, includeTags: boolean = true): Promise<TagTreeItem[]> {
+    return await this.connector.getTagsFullTree(category, includeTags);
+  }
+
+  public async getDocumentContent(docId: number, thumbnail: boolean = true): Promise<string> {
+    return await this.connector.getDocumentContent(docId, thumbnail);
+  }
+}

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

@@ -0,0 +1,124 @@
+import {EventEmitter, Injectable} from "@angular/core";
+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 {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 {ArticleTransaction} from "@colijnit/articleapi/build/model/article-transaction";
+import {ArticleTransaction as ArticleTransactionBo} from "@colijnit/articleapi/build/model/article-transaction.bo";
+import {SharedConnectorService} from "./shared-connector.service";
+import {SendMethodParams} from "../components/send-method-dialog/send-method-params.interface";
+import {DataServiceResponseData} from '@colijnit/ioneconnector/build/model/data-service-response-data';
+import {StockForecast} from "@colijnit/articleapi/build/model/stock-forecast.bo";
+import {ArticleExtendedRequest} from "@colijnit/articleapi/build/model/article-extended-request";
+import {ArticleExtended} from "@colijnit/articleapi/build/model/article-extended.bo";
+import {ArticleFlat} from "@colijnit/articleapi/build/model/article-flat.bo";
+
+@Injectable({
+  providedIn: 'root',
+})
+export class StockService {
+
+  public stockStickers: PrintStockStickers;
+  public printLayoutParams: SendMethodParams;
+
+  public readonly warehouseSelected: EventEmitter<StockManagementWarehouses> = new EventEmitter<StockManagementWarehouses>()
+
+  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 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 getArtStockStatus(goodId: number, branchNo?: string, requestedAmount?: number, warehouseId?: number): Promise<number> {
+    return await this._sharedService.getArtStockStatus(goodId, branchNo, requestedAmount, warehouseId);
+  }
+
+  // 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 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);
+  // }
+
+  public async getArticleTransaction(data: ArticleTransaction): Promise<ArticleTransactionBo[]> {
+    return await this._sharedService.getArticleTransaction(data);
+  }
+
+  public async stockPrognose(goodId: number, warehouseNumber: number): Promise<StockForecast[]> {
+    return await this._sharedService.getStockPrognose(goodId, warehouseNumber);
+  }
+
+  public async lockArticleDetails(data: ArticleStockManagement): Promise<boolean> {
+    return await this._sharedService.lockArticleDetails(data);
+  }
+
+  public commit(): Promise<DataServiceResponseData> {
+    return this._sharedService.commit();
+  }
+
+  public async getArticleFlat(sku: string): Promise<ArticleFlat> {
+    return await this._sharedService.getArticleFlat(sku);
+  }
+
+  public async searchArticles(request: ArticleExtendedRequest): Promise<ArticleExtended[]> {
+    return await this._sharedService.searchArticles(request);
+  }
+
+
+
+
+}