@colijnit/sharedcomponents 261.1.0 → 261.1.2

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

@@ -0,0 +1,863 @@
+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";
+import {ObjectConfiguration} from "@colijnit/ioneconnector/build/model/object-configuration";
+import {RelationApi} from "@colijnit/relationapi";
+import {RelationListObject} from "@colijnit/relationapi/build/model/relation-list-object.bo";
+import {RelationRequest} from "@colijnit/relationapi/build/model/relation-request";
+import {TaskCategory} from "@colijnit/mainapi/build/model/task-category.bo";
+import {TableName} from "@colijnit/mainapi/build/enum/table-name.enum";
+import {WorkflowProcess} from "@colijnit/mainapi/build/model/workflow-process";
+import {DomainName} from "@colijnit/mainapi/build/enum/domain-name.enum";
+import {CoDomainValue} from "@colijnit/mainapi/build/model/co-domain-value.bo";
+import {RoleEmailaddress} from "@colijnit/mainapi/build/model/role-email-address";
+import {Activity} from "@colijnit/mainapi/build/model/activity.bo";
+import {ValidationResult} from "@colijnit/ioneconnector/build/model/validation-result";
+import {WorkflowProcessInfoPerStatus} from "@colijnit/mainapi/build/model/workflow-process-info-per-status";
+import {RelationSmallObject} from "@colijnit/mainapi/build/model/relation-small-object.bo";
+import {ReportParamType} from "@colijnit/mainapi/build/enum/report-param-type.enum";
+import {SelectReportTemplatesRequest} from "@colijnit/mainapi/build/model/select-report-templates-request";
+import {Report} from "@colijnit/mainapi/build/model/report.bo";
+import {EmailJob} from "@colijnit/mainapi/build/model/email-job";
+import {Work} from "@colijnit/mainapi/build/model/work.bo";
+import {Remark} from "@colijnit/mainapi/build/model/remark.bo";
+import {Task} from "@colijnit/mainapi/build/model/task.bo";
+import {ActivityEmailHistory} from "@colijnit/mainapi/build/model/activity-email-history.bo";
+import {ActivityWorkflow} from "@colijnit/mainapi/build/model/activity-workflow";
+import {EmailActivityRequest} from "@colijnit/mainapi/build/model/email-activity-request";
+import {Form} from '@colijnit/mainapi/build/model/form.bo';
+import {FormResponse} from '@colijnit/mainapi/build/model/form-response.bo';
+
+@Injectable({
+  providedIn: "root"
+})
+export class SharedConnectorService {
+  public articleConnector: Articles;
+  public sharedConnector: Sharedapi;
+  public mainConnector: MainApi;
+  public relationConnector: RelationApi;
+
+  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);
+    this.relationConnector = new RelationApi(this._optionsService.options);
+  }
+
+  public async getConfiguration(module: string, params: string[]): Promise<ObjectConfiguration[]> {
+    const response: DataServiceResponseData = await this.mainConnector.getObjectConfigurations(module, params);
+    if (response && response.validationResult && response.validationResult.success) {
+      return this._boFactory.makeBOArrayFromRawBackendDataArray(ObjectConfiguration, response.resultObjects) as ObjectConfiguration[];
+    }
+  }
+
+  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 getDefaultPrinter(reportId: number, layoutCode: string): Promise<string> {
+    const response: DataServiceResponseData = await this.mainConnector.getStandardPrinter(reportId, layoutCode);
+    if (response && response.validationResult && response.validationResult.success) {
+      if(response.resultObject && response.resultObject?.length > 0) {
+        return response.resultObject;
+      }
+    } else {
+      return null;
+    }
+  }
+
+  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 getComponentActivitiesWithoutRelationFiltering(table: TableName, key: string): Promise<Activity[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.getComponentActivitiesWithoutRelationFiltering(table, key).then((result: any) => {
+        if (result && result.validationResult && result.validationResult.success) {
+          resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(Activity, result.resultObject) as unknown as Activity[]);
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getRelationSmallObject(relationId: number): Promise<RelationSmallObject> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.relationConnector.getRelationSmallObject(relationId).then((result: any) => {
+        if (result && result.validationResult && result.validationResult.success) {
+          resolve(this._boFactory.makeWithRawBackendData(RelationSmallObject, result.resultObject));
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getWorkflowStatusForActivity(table: TableName, key: string, component: string ): Promise<ActivityWorkflow> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.getWorkflowStatusForActivity(table, key, component).then(async (result: DataServiceResponseData) => {
+        if (result && result.validationResult && result.validationResult.success) {
+          resolve(this._boFactory.makeWithRawBackendData(ActivityWorkflow, result.resultObject));
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async insertActivity(activity: Activity): Promise<boolean> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.insertActivity(activity).then(async (result: DataServiceResponseData) => {
+        resolve(result.validationResult);
+      });
+    });
+  }
+
+  public async insertWork(activity: Activity): Promise<Work> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.insertActivity(activity).then(async (result: DataServiceResponseData) => {
+        if (result && result.validationResult && result.validationResult.success) {
+          resolve(this._boFactory.makeWithRawBackendData(Work, result.resultObject));
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async insertRemark(activity: Activity): Promise<Remark> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.insertActivity(activity).then(async (result: DataServiceResponseData) => {
+        if (result && result.validationResult && result.validationResult.success) {
+          resolve(this._boFactory.makeWithRawBackendData(Remark, result.resultObject));
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async insertTask(activity: Activity): Promise<Task> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.insertActivity(activity).then(async (result: DataServiceResponseData) => {
+        if (result && result.validationResult && result.validationResult.success) {
+          resolve(this._boFactory.makeWithRawBackendData(Task, result.resultObject));
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async updateActivity(activity: Activity): Promise<boolean> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.updateActivity(activity).then(async (result: DataServiceResponseData) => {
+        resolve(result.validationResult);
+      });
+    });
+  }
+
+  public async deleteActivity(activity: Activity): Promise<boolean> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.deleteActivity(activity).then(async (result: DataServiceResponseData) => {
+        resolve(result.validationResult);
+      });
+    });
+  }
+
+  public async lockTask(id: number): Promise<boolean> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.lockTask(id).then(async (result: DataServiceResponseData) => {
+        resolve(result.validationResult);
+      });
+    });
+  }
+
+  public async fireTrigger(workFlowProcessId: number, sequence: number, triggerId: number): Promise<ValidationResult> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.fireTrigger(workFlowProcessId, sequence, triggerId).then(async (result: DataServiceResponseData) => {
+        resolve(result.validationResult);
+      });
+    });
+  }
+
+  public async fireGenericTrigger(workFlowProcessId: number, genericTransitionId: number, relationId: number): Promise<ValidationResult> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.fireGenericTrigger(workFlowProcessId, genericTransitionId, relationId).then(async (result: DataServiceResponseData) => {
+        resolve(result.validationResult);
+      });
+    });
+  }
+
+  public async getJoinedTags(table: string, key: string): Promise<TagTreeItem[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.getJoinedTags(table, key).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 async getRelationListObjects(request: RelationRequest): Promise<RelationListObject[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return  this.relationConnector.getRelationListObjects(request, false ).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObjects) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(RelationListObject, result.resultObjects));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getTaskCategories(): Promise<TaskCategory[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.getTaskCategories().then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObjects) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(TaskCategory, result.resultObjects));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getActiveProcessesByTableAndKey(table: TableName, key: string): Promise<WorkflowProcess[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.getActiveProcessesByTableAndKey(table, key).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObjects) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(WorkflowProcess, result.resultObjects));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getDomainCollection(languageCode: string, domain: DomainName): Promise<CoDomainValue[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.getDomainCollection(languageCode, domain).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObjects) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(CoDomainValue, result.resultObjects));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getRoleEmailAddressesByWorkflowCategoryAndKey(workflowCategory: string, key: string): Promise<RoleEmailaddress[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.getRoleEmailAddressesByWorkflowCategoryAndKey(workflowCategory, key).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObject) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(RoleEmailaddress, result.resultObject));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getEmailSenderByWorkflowCategoryAndKey(worlflowCategory: string, key: string): Promise<string> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.getEmailSenderByWorkflowCategoryAndKey(worlflowCategory, key).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          resolve(result.resultObject);
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getReportTemplates(reportTemplatesRequest: SelectReportTemplatesRequest): Promise<Report[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.getReportTemplates(reportTemplatesRequest).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObjects) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(Report, result.resultObjects));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async emailReport(emailJob: EmailJob): Promise<boolean> {
+      const result: DataServiceResponseData = await this.mainConnector.emailReport(emailJob);
+      if (result && result.validationResult && result.validationResult.success) {
+        return Promise.resolve(true);
+      } else {
+        return Promise.resolve(false);
+      }
+  }
+
+  public async emailActivity(request: EmailActivityRequest): Promise<boolean> {
+    const result: DataServiceResponseData = await this.mainConnector.emailActivity(request);
+    if (result && result.validationResult && result.validationResult.success) {
+      return Promise.resolve(true);
+    } else {
+      return Promise.resolve(false);
+    }
+  }
+
+  public async insertEmailHistoryForRemark(history: ActivityEmailHistory): Promise<boolean> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.insertEmailHistoryForRemark(history).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          resolve(result.resultObject);
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async insertEmailHistoryForWork(history: ActivityEmailHistory): Promise<boolean> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.insertEmailHistoryForWork(history).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          resolve(result.resultObject);
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async insertEmailHistoryForTask(history: ActivityEmailHistory): Promise<boolean> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.insertEmailHistoryForTask(history).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          resolve(result.resultObject);
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+
+  public async getWorkflowProcessInfoPerStatus(worlflowCategory: string): Promise<WorkflowProcessInfoPerStatus[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.getWorkflowProcessInfoPerStatus(worlflowCategory).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObject) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(WorkflowProcessInfoPerStatus, result.resultObject));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getHistoricActivities(table: TableName, key: string): Promise<Activity[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.getHistoricActivities(table, key).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObject) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(Activity, result.resultObject));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getComponentActivities(table: TableName, key: string): Promise<Activity[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.getComponentActivities(table, key).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObject) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(Activity, result.resultObject));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getFormById(formId: number): Promise<Form> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.getFormById(formId).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObject) {
+            resolve(this._boFactory.makeWithRawBackendData(Form, result.resultObject));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async getAllFormResponsesForTableAndKey(table: TableName, key: string): Promise<FormResponse[]> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.getAllFormResponsesForTableAndKey(table, key).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObjects) {
+            resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(FormResponse, result.resultObjects));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async insertFormResponse(formResponse: FormResponse): Promise<FormResponse> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.insertFormResponse(formResponse).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObject) {
+            resolve(this._boFactory.makeWithRawBackendData(FormResponse, result.resultObject));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+
+
+  public async updateFormResponse(formResponse: FormResponse): Promise<FormResponse> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.updateFormResponse(formResponse).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          if (result.resultObject) {
+            resolve(this._boFactory.makeWithRawBackendData(FormResponse, result.resultObject));
+          }
+        } else {
+          reject(result.validationMessagesAsString);
+        }
+      });
+    });
+  }
+
+  public async lockFormResponse(formResponseId: number): Promise<boolean> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.lockFormResponse(formResponseId).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          resolve(true);
+        } else {
+          reject(result.validationResult.messages[0].message);
+        }
+      });
+    });
+  }
+
+  public async unlockFormResponse(formResponseId: number): Promise<boolean> {
+    return new Promise((resolve: Function, reject: Function) => {
+      return this.mainConnector.unlockFormResponse(formResponseId).then((result: DataServiceResponseData) => {
+        if (result.validationResult && result.validationResult.success) {
+          resolve(true)
+        } else {
+          reject(result.validationResult.messages[0].message);
+        }
+      });
+    });
+  }
+
+
+
+
+
+
+
+
+  public commit(): Promise<DataServiceResponseData> {
+    return this.articleConnector.commit();
+  }
+
+}