@colijnit/transaction 12.1.78 → 12.1.80

package/esm2015/lib/service/relation-connector.service.js

@@ -0,0 +1,222 @@
+import { __awaiter } from "tslib";
+import { Injectable } from "@angular/core";
+import { OptionsService } from "./options.service";
+import { BusinessObjectFactory } from "@colijnit/ioneconnector/build/factory/business-object-factory";
+import { RelationApi } from "@colijnit/relationapi";
+import { CustomerFullObject } from "@colijnit/relationapi/build/model/customer-full-object.bo";
+import { SupplierFullObject } from "@colijnit/relationapi/build/model/supplier-full-object.bo";
+import { ErrorService } from "./error.service";
+import { RelationListObject } from "@colijnit/relationapi/build/model/relation-list-object.bo";
+import { BranchLov } from "@colijnit/relationapi/build/model/branch-lov.bo";
+import { TransactionEventService } from "./transaction-event.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./options.service";
+import * as i2 from "./error.service";
+import * as i3 from "./transaction-event.service";
+export class RelationConnectorService {
+    constructor(_optionsService, _errorService, _transactionEventService) {
+        this._optionsService = _optionsService;
+        this._errorService = _errorService;
+        this._transactionEventService = _transactionEventService;
+        this._boFactory = new BusinessObjectFactory();
+        this._transactionEventService.connectionInitialized.subscribe((initialized) => {
+            if (initialized) {
+                this.connect();
+            }
+        });
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.connector = new RelationApi(this._optionsService.options);
+        });
+    }
+    getCustomerFullObject(relationNo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.connector.getCustomerFullObject(relationNo);
+            if (result.validationResult && result.validationResult.success) {
+                return this._boFactory.makeWithRawBackendData(CustomerFullObject, result.resultObject);
+            }
+            else {
+                this._handleExceptionFromResponse(result);
+                return null;
+            }
+        });
+    }
+    getSupplierFullObject(relationNo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.connector.getSupplierFullObject(relationNo);
+            if (result.validationResult && result.validationResult.success) {
+                return this._boFactory.makeWithRawBackendData(SupplierFullObject, result.resultObject);
+            }
+            else {
+                this._handleExceptionFromResponse(result);
+                return null;
+            }
+        });
+    }
+    getRelationListObjects(relationRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.connector.getRelationListObjects(relationRequest);
+            if (result.validationResult && result.validationResult.success) {
+                return this._boFactory.makeBOArrayFromRawBackendDataArray(RelationListObject, result.resultObjects);
+            }
+            else {
+                this._handleExceptionFromResponse(result);
+                return [];
+            }
+        });
+    }
+    getRelationNumber(relationId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.connector.getRelationNumber(relationId);
+            if (result.validationResult && result.validationResult.success) {
+                return result.resultObject;
+            }
+            else {
+                this._handleExceptionFromResponse(result);
+                return "";
+            }
+        });
+    }
+    getBranches(branchNr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.connector.getBranches(branchNr);
+            if (result.validationResult && result.validationResult.success) {
+                return this._boFactory.makeBOArrayFromRawBackendDataArray(BranchLov, result.resultObjects);
+            }
+            else {
+                this._handleExceptionFromResponse(result);
+                return [];
+            }
+        });
+    }
+    commit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.connector.commit();
+            if (result) {
+                return true;
+            }
+            else {
+                this._handleExceptionFromResponse(result);
+                return false;
+            }
+        });
+    }
+    lockCustomerFullObject(relationNr) {
+        return new Promise((resolve, reject) => {
+            return this.connector.lockCustomerById(relationNr).then((result) => __awaiter(this, void 0, void 0, function* () {
+                resolve(result.validationResult);
+            }));
+        });
+    }
+    lockSupplierFullObject(relationNr) {
+        return new Promise((resolve, reject) => {
+            return this.connector.lockSupplierById(relationNr).then((result) => __awaiter(this, void 0, void 0, function* () {
+                resolve(result.validationResult);
+            }));
+        });
+    }
+    lockEmployeeFullObject(relationNr) {
+        return new Promise((resolve, reject) => {
+            return this.connector.lockEmployeeById(relationNr).then((result) => __awaiter(this, void 0, void 0, function* () {
+                resolve(result.validationResult);
+            }));
+        });
+    }
+    lockBranchFullObject(relationNr) {
+        return new Promise((resolve, reject) => {
+            return this.connector.lockBranchById(relationNr).then((result) => __awaiter(this, void 0, void 0, function* () {
+                resolve(result.validationResult);
+            }));
+        });
+    }
+    lockCompanyFullObject(relationNr) {
+        return new Promise((resolve, reject) => {
+            return this.connector.lockCompanyById(relationNr).then((result) => __awaiter(this, void 0, void 0, function* () {
+                resolve(result.validationResult);
+            }));
+        });
+    }
+    lockContactPerson(relationNr) {
+        return new Promise((resolve, reject) => {
+            return this.connector.lockContactPersonById(relationNr).then((result) => __awaiter(this, void 0, void 0, function* () {
+                resolve(result.validationResult);
+            }));
+        });
+    }
+    insertCustomer(relation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                return this.connector.insertCustomer(relation).then((result) => {
+                    if (result.validationResult && result.validationResult.success) {
+                        resolve(this._boFactory.makeWithRawBackendData(CustomerFullObject, result.resultObject));
+                    }
+                    else {
+                        this._handleExceptionFromResponse(result);
+                        reject(null);
+                    }
+                });
+            });
+        });
+    }
+    updateCustomer(relation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                return this.connector.updateCustomer(relation).then((result) => {
+                    if (result.validationResult && result.validationResult.success) {
+                        resolve(this._boFactory.makeWithRawBackendData(CustomerFullObject, result.resultObject));
+                    }
+                    else {
+                        this._handleExceptionFromResponse(result);
+                        reject(null);
+                    }
+                });
+            });
+        });
+    }
+    insertSupplier(relation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                return this.connector.insertSupplier(relation).then((result) => {
+                    if (result.validationResult && result.validationResult.success) {
+                        resolve(this._boFactory.makeWithRawBackendData(SupplierFullObject, result.resultObject));
+                    }
+                    else {
+                        this._handleExceptionFromResponse(result);
+                        reject(null);
+                    }
+                });
+            });
+        });
+    }
+    updateSupplier(relation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                return this.connector.updateSupplier(relation).then((result) => {
+                    if (result.validationResult && result.validationResult.success) {
+                        resolve(this._boFactory.makeWithRawBackendData(SupplierFullObject, result.resultObject));
+                    }
+                    else {
+                        this._handleExceptionFromResponse(result);
+                        reject(null);
+                    }
+                });
+            });
+        });
+    }
+    _handleExceptionFromResponse(result) {
+        this._errorService.showValidationError(result);
+    }
+}
+RelationConnectorService.ɵprov = i0.ɵɵdefineInjectable({ factory: function RelationConnectorService_Factory() { return new RelationConnectorService(i0.ɵɵinject(i1.OptionsService), i0.ɵɵinject(i2.ErrorService), i0.ɵɵinject(i3.TransactionEventService)); }, token: RelationConnectorService, providedIn: "root" });
+RelationConnectorService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+RelationConnectorService.ctorParameters = () => [
+    { type: OptionsService },
+    { type: ErrorService },
+    { type: TransactionEventService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"relation-connector.service.js","sourceRoot":"","sources":["../../../../../projects/transaction/src/lib/service/relation-connector.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from \"@angular/core\";\r\nimport {OptionsService} from \"./options.service\";\r\nimport {BusinessObjectFactory} from \"@colijnit/ioneconnector/build/factory/business-object-factory\";\r\nimport {RelationApi} from \"@colijnit/relationapi\";\r\nimport {CustomerFullObject} from \"@colijnit/relationapi/build/model/customer-full-object.bo\";\r\nimport {SupplierFullObject} from \"@colijnit/relationapi/build/model/supplier-full-object.bo\";\r\nimport {ErrorService} from \"./error.service\";\r\nimport {DataServiceResponseData} from \"@colijnit/ioneconnector/build/model/data-service-response-data\";\r\nimport {RelationRequest} from \"@colijnit/relationapi/build/model/relation-request\";\r\nimport {RelationListObject} from \"@colijnit/relationapi/build/model/relation-list-object.bo\";\r\nimport {BranchLov} from \"@colijnit/relationapi/build/model/branch-lov.bo\";\r\nimport {ValidationResult} from \"@colijnit/ioneconnector/build/model/validation-result\";\r\nimport {TransactionEventService} from \"./transaction-event.service\";\r\n\r\n@Injectable({\r\n  providedIn: \"root\"\r\n})\r\nexport class RelationConnectorService {\r\n  public connector: RelationApi;\r\n\r\n  private _boFactory: BusinessObjectFactory = new BusinessObjectFactory();\r\n\r\n  constructor(\r\n    private _optionsService: OptionsService,\r\n    private _errorService: ErrorService,\r\n    private _transactionEventService: TransactionEventService\r\n  ) {\r\n    this._transactionEventService.connectionInitialized.subscribe((initialized: boolean) => {\r\n      if (initialized) {\r\n        this.connect();\r\n      }\r\n    })\r\n  }\r\n\r\n  public async connect(): Promise<void> {\r\n    this.connector = new RelationApi(this._optionsService.options);\r\n  }\r\n\r\n  public async getCustomerFullObject(relationNo: number): Promise<CustomerFullObject> {\r\n    const result: DataServiceResponseData = await this.connector.getCustomerFullObject(relationNo);\r\n    if (result.validationResult && result.validationResult.success) {\r\n      return this._boFactory.makeWithRawBackendData(CustomerFullObject, result.resultObject) as unknown as CustomerFullObject;\r\n    } else {\r\n      this._handleExceptionFromResponse(result);\r\n      return null;\r\n    }\r\n  }\r\n\r\n  public async getSupplierFullObject(relationNo: number): Promise<SupplierFullObject> {\r\n    const result: DataServiceResponseData = await this.connector.getSupplierFullObject(relationNo);\r\n    if (result.validationResult && result.validationResult.success) {\r\n      return this._boFactory.makeWithRawBackendData(SupplierFullObject, result.resultObject) as unknown as SupplierFullObject;\r\n    } else {\r\n      this._handleExceptionFromResponse(result);\r\n      return null;\r\n    }\r\n  }\r\n\r\n  public async getRelationListObjects(relationRequest: RelationRequest): Promise<RelationListObject[]> {\r\n    const result: DataServiceResponseData = await this.connector.getRelationListObjects(relationRequest);\r\n    if (result.validationResult && result.validationResult.success) {\r\n      return this._boFactory.makeBOArrayFromRawBackendDataArray(RelationListObject, result.resultObjects) as unknown as RelationListObject[];\r\n    } else {\r\n      this._handleExceptionFromResponse(result);\r\n      return [];\r\n    }\r\n  }\r\n\r\n  public async getRelationNumber(relationId: number): Promise<string> {\r\n    const result: DataServiceResponseData = await this.connector.getRelationNumber(relationId);\r\n    if (result.validationResult && result.validationResult.success) {\r\n      return result.resultObject;\r\n    } else {\r\n      this._handleExceptionFromResponse(result);\r\n      return \"\";\r\n    }\r\n  }\r\n\r\n  public async getBranches(branchNr?: string): Promise<BranchLov[]> {\r\n    const result: DataServiceResponseData = await this.connector.getBranches(branchNr);\r\n    if (result.validationResult && result.validationResult.success) {\r\n      return this._boFactory.makeBOArrayFromRawBackendDataArray(BranchLov, result.resultObjects) as unknown as BranchLov[];\r\n    } else {\r\n      this._handleExceptionFromResponse(result);\r\n      return [];\r\n    }\r\n  }\r\n\r\n  public async commit(): Promise<boolean> {\r\n    const result: DataServiceResponseData = await this.connector.commit();\r\n    if (result) {\r\n      return true;\r\n    } else {\r\n      this._handleExceptionFromResponse(result);\r\n      return false;\r\n    }\r\n  }\r\n\r\n  public lockCustomerFullObject(relationNr: number): Promise<ValidationResult> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.lockCustomerById(relationNr).then(async (result: DataServiceResponseData) => {\r\n        resolve(result.validationResult);\r\n      });\r\n    });\r\n  }\r\n\r\n  public lockSupplierFullObject(relationNr: number): Promise<ValidationResult> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.lockSupplierById(relationNr).then(async (result: DataServiceResponseData) => {\r\n        resolve(result.validationResult);\r\n      });\r\n    });\r\n  }\r\n\r\n  public lockEmployeeFullObject(relationNr: number): Promise<ValidationResult> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.lockEmployeeById(relationNr).then(async (result: DataServiceResponseData) => {\r\n        resolve(result.validationResult);\r\n      });\r\n    });\r\n  }\r\n\r\n  public lockBranchFullObject(relationNr: number): Promise<ValidationResult> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.lockBranchById(relationNr).then(async (result: DataServiceResponseData) => {\r\n        resolve(result.validationResult);\r\n      });\r\n    });\r\n  }\r\n\r\n  public lockCompanyFullObject(relationNr: number): Promise<ValidationResult> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.lockCompanyById(relationNr).then(async (result: DataServiceResponseData) => {\r\n        resolve(result.validationResult);\r\n      });\r\n    });\r\n  }\r\n\r\n  public lockContactPerson(relationNr: number): Promise<ValidationResult> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.lockContactPersonById(relationNr).then(async (result: DataServiceResponseData) => {\r\n        resolve(result.validationResult);\r\n      });\r\n    });\r\n  }\r\n\r\n  public async insertCustomer(relation: CustomerFullObject): Promise<CustomerFullObject> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.insertCustomer(relation).then((result: DataServiceResponseData) => {\r\n        if (result.validationResult && result.validationResult.success) {\r\n          resolve(this._boFactory.makeWithRawBackendData(CustomerFullObject, result.resultObject));\r\n        } else {\r\n          this._handleExceptionFromResponse(result);\r\n          reject(null);\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  public async updateCustomer(relation: CustomerFullObject): Promise<CustomerFullObject> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.updateCustomer(relation).then((result: DataServiceResponseData) => {\r\n        if (result.validationResult && result.validationResult.success) {\r\n          resolve(this._boFactory.makeWithRawBackendData(CustomerFullObject, result.resultObject));\r\n        } else {\r\n          this._handleExceptionFromResponse(result);\r\n          reject(null);\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  public async insertSupplier(relation: SupplierFullObject): Promise<SupplierFullObject> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.insertSupplier(relation).then((result: DataServiceResponseData) => {\r\n        if (result.validationResult && result.validationResult.success) {\r\n          resolve(this._boFactory.makeWithRawBackendData(SupplierFullObject, result.resultObject));\r\n        } else {\r\n          this._handleExceptionFromResponse(result);\r\n          reject(null);\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  public async updateSupplier(relation: SupplierFullObject): Promise<SupplierFullObject> {\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      return this.connector.updateSupplier(relation).then((result: DataServiceResponseData) => {\r\n        if (result.validationResult && result.validationResult.success) {\r\n          resolve(this._boFactory.makeWithRawBackendData(SupplierFullObject, result.resultObject));\r\n        } else {\r\n          this._handleExceptionFromResponse(result);\r\n          reject(null);\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  private _handleExceptionFromResponse(result: DataServiceResponseData): void {\r\n    this._errorService.showValidationError(result);\r\n  }\r\n}\r\n"]}

package/esm2015/lib/service/relation.service.js

@@ -0,0 +1,158 @@
+import { __awaiter } from "tslib";
+import { Injectable } from "@angular/core";
+import { SelectMultipleCacheService } from "../cache/service/select-multiple-cache.service";
+import { RelationConnectorService } from "./relation-connector.service";
+import { RelationKind } from "@colijnit/articleapi/build/enum/relation-kind.enum";
+import { ValidationResult } from "@colijnit/ioneconnector/build/model/validation-result";
+import { CustomerFullObject } from "@colijnit/relationapi/build/model/customer-full-object.bo";
+import { BranchLov } from "@colijnit/relationapi/build/model/branch-lov.bo";
+import { SupplierFullObject } from "@colijnit/relationapi/build/model/supplier-full-object.bo";
+import { SelectSingleCacheService } from "../cache/service/select-single-cache.service";
+import { SelectMultipleParameterizedCacheService } from "../cache/service/select-multiple-parameterized-cache.service";
+import { Relation } from "@colijnit/relationapi/build/model/relation.bo";
+import * as i0 from "@angular/core";
+import * as i1 from "./relation-connector.service";
+import * as i2 from "../cache/service/select-multiple-cache.service";
+import * as i3 from "../cache/service/select-single-cache.service";
+import * as i4 from "../cache/service/select-multiple-parameterized-cache.service";
+export class RelationService {
+    constructor(_adapterService, _selectMultipleCacheService, _selectSingleCacheService, _selectMultipleParameterizedCacheService) {
+        this._adapterService = _adapterService;
+        this._selectMultipleCacheService = _selectMultipleCacheService;
+        this._selectSingleCacheService = _selectSingleCacheService;
+        this._selectMultipleParameterizedCacheService = _selectMultipleParameterizedCacheService;
+        this._lockMethods = new Map([
+            [RelationKind.Customer, (relationNr) => this._lockCustomerFullObject(relationNr)],
+            [RelationKind.Supplier, (relationNr) => this._lockSupplierFullObject(relationNr)],
+            [RelationKind.Personnel, (relationNr) => this._lockEmployeeFullObject(relationNr)],
+            [RelationKind.Branch, (relationNr) => this._lockBranchFullObject(relationNr)],
+            [RelationKind.Company, (relationNr) => this._lockCompanyFullObject(relationNr)],
+            [RelationKind.ContactPerson, (relationNr) => this._lockContactPerson(relationNr)],
+        ]);
+        this._getMethods = new Map([
+            [RelationKind.Customer, (relationNr) => this.getCustomerFullObject(relationNr)],
+            [RelationKind.Supplier, (relationNr) => this.getSupplierFullObject(relationNr)]
+        ]);
+        this._updateMethods = new Map([
+            [RelationKind.Customer, (relation) => this.updateCustomer(relation)],
+            [RelationKind.Supplier, (relation) => this.updateSupplier(relation)]
+        ]);
+        this._insertMethods = new Map([
+            [RelationKind.Customer, (relation) => this.insertCustomer(relation)],
+            [RelationKind.Supplier, (relation) => this.insertSupplier(relation)]
+        ]);
+    }
+    getCustomerFullObject(relationNo) {
+        return this._selectSingleCacheService.requestCache(CustomerFullObject, relationNo, () => {
+            return this._adapterService.getCustomerFullObject(relationNo);
+        }).getValue();
+    }
+    getSupplierFullObject(relationNo) {
+        return this._selectSingleCacheService.requestCache(SupplierFullObject, relationNo, () => {
+            return this._adapterService.getSupplierFullObject(relationNo);
+        }).getValue();
+    }
+    insertCustomer(relation) {
+        return this._adapterService.insertCustomer(relation);
+    }
+    updateCustomer(relation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._adapterService.updateCustomer(relation);
+        });
+    }
+    insertSupplier(relation) {
+        return this._adapterService.insertSupplier(relation);
+    }
+    updateSupplier(relation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._adapterService.updateSupplier(relation);
+        });
+    }
+    getRelationListObjects(relationRequest) {
+        return this._adapterService.getRelationListObjects(relationRequest);
+    }
+    getRelationNumber(relationId) {
+        return this._adapterService.getRelationNumber(relationId);
+    }
+    getBranches(branchNr) {
+        return this._selectMultipleParameterizedCacheService.requestCache(BranchLov, (branchNr) => {
+            return this._adapterService.getBranches(branchNr);
+        }).getValue(branchNr);
+    }
+    insertRelation(relationKind, relation) {
+        const insertMethod = this._insertMethods.get(relationKind);
+        if (insertMethod) {
+            return insertMethod.call(this, relation);
+        }
+        else {
+            const result = new Relation();
+            return Promise.resolve(result);
+        }
+    }
+    updateRelation(relationKind, relation) {
+        const updateMethod = this._updateMethods.get(relationKind);
+        if (updateMethod) {
+            return updateMethod.call(this, relation);
+        }
+        else {
+            const result = new Relation();
+            return Promise.resolve(result);
+        }
+    }
+    lockRelation(relationKind, relationNr) {
+        const lockMethod = this._lockMethods.get(relationKind);
+        if (lockMethod) {
+            return lockMethod.call(this, relationNr);
+        }
+        else {
+            const result = new ValidationResult();
+            result.success = false;
+            return Promise.resolve(result);
+        }
+    }
+    getRelation(relationKind, relationNr) {
+        const getMethod = this._getMethods.get(relationKind);
+        if (getMethod) {
+            return getMethod.call(this, relationNr);
+        }
+        else {
+            const result = new ValidationResult();
+            result.success = false;
+            return Promise.resolve(null);
+        }
+    }
+    commit() {
+        return this._adapterService.commit();
+    }
+    _lockCustomerFullObject(relationNr) {
+        return this._adapterService.lockCustomerFullObject(relationNr);
+    }
+    _lockSupplierFullObject(relationNr) {
+        return this._adapterService.lockSupplierFullObject(relationNr);
+    }
+    _lockEmployeeFullObject(relationNr) {
+        return this._adapterService.lockEmployeeFullObject(relationNr);
+    }
+    _lockBranchFullObject(relationNr) {
+        return this._adapterService.lockBranchFullObject(relationNr);
+    }
+    _lockCompanyFullObject(relationNr) {
+        return this._adapterService.lockCompanyFullObject(relationNr);
+    }
+    _lockContactPerson(relationNr) {
+        return this._adapterService.lockContactPerson(relationNr);
+    }
+}
+RelationService.ɵprov = i0.ɵɵdefineInjectable({ factory: function RelationService_Factory() { return new RelationService(i0.ɵɵinject(i1.RelationConnectorService), i0.ɵɵinject(i2.SelectMultipleCacheService), i0.ɵɵinject(i3.SelectSingleCacheService), i0.ɵɵinject(i4.SelectMultipleParameterizedCacheService)); }, token: RelationService, providedIn: "root" });
+RelationService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+RelationService.ctorParameters = () => [
+    { type: RelationConnectorService },
+    { type: SelectMultipleCacheService },
+    { type: SelectSingleCacheService },
+    { type: SelectMultipleParameterizedCacheService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"relation.service.js","sourceRoot":"","sources":["../../../../../projects/transaction/src/lib/service/relation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from \"@angular/core\";\r\nimport {SelectMultipleCacheService} from \"../cache/service/select-multiple-cache.service\";\r\nimport {RelationConnectorService} from \"./relation-connector.service\";\r\nimport {RelationKind} from \"@colijnit/articleapi/build/enum/relation-kind.enum\";\r\nimport {ValidationResult} from \"@colijnit/ioneconnector/build/model/validation-result\";\r\nimport {CustomerFullObject} from \"@colijnit/relationapi/build/model/customer-full-object.bo\";\r\nimport {RelationRequest} from \"@colijnit/relationapi/build/model/relation-request\";\r\nimport {RelationListObject} from \"@colijnit/relationapi/build/model/relation-list-object.bo\";\r\nimport {BranchLov} from \"@colijnit/relationapi/build/model/branch-lov.bo\";\r\nimport {SupplierFullObject} from \"@colijnit/relationapi/build/model/supplier-full-object.bo\";\r\nimport {SelectSingleCacheService} from \"../cache/service/select-single-cache.service\";\r\nimport {SelectMultipleParameterizedCacheService} from \"../cache/service/select-multiple-parameterized-cache.service\";\r\nimport {Relation} from \"@colijnit/relationapi/build/model/relation.bo\";\r\nimport {RelationAnyType} from \"@colijnit/relationapi/build/model/relation-any-type\";\r\n\r\ntype LockFnHeader = (relationNr: number) => Promise<ValidationResult>;\r\ntype GetRelationFnHeader = (relationNr: number) => Promise<RelationAnyType>;\r\ntype InsertRelationFn = (relation: RelationAnyType) => Promise<RelationAnyType>;\r\ntype UpdateRelationFn = (relation: RelationAnyType) => Promise<RelationAnyType>;\r\n\r\n\r\n@Injectable({\r\n  providedIn: \"root\"\r\n})\r\nexport class RelationService {\r\n  private readonly _lockMethods: Map<RelationKind, LockFnHeader> = new Map<RelationKind, LockFnHeader>([\r\n    [RelationKind.Customer, (relationNr: number) => this._lockCustomerFullObject(relationNr)],\r\n    [RelationKind.Supplier, (relationNr: number) => this._lockSupplierFullObject(relationNr)],\r\n    [RelationKind.Personnel, (relationNr: number) => this._lockEmployeeFullObject(relationNr)],\r\n    [RelationKind.Branch, (relationNr: number) => this._lockBranchFullObject(relationNr)],\r\n    [RelationKind.Company, (relationNr: number) => this._lockCompanyFullObject(relationNr)],\r\n    [RelationKind.ContactPerson, (relationNr: number) => this._lockContactPerson(relationNr)],\r\n  ]);\r\n\r\n  private readonly _getMethods: Map<RelationKind, GetRelationFnHeader> = new Map<RelationKind, GetRelationFnHeader>([\r\n    [RelationKind.Customer, (relationNr: number) => this.getCustomerFullObject(relationNr)],\r\n    [RelationKind.Supplier, (relationNr: number) => this.getSupplierFullObject(relationNr)]\r\n  ]);\r\n\r\n  private readonly _updateMethods: Map<RelationKind, UpdateRelationFn> = new Map<RelationKind, UpdateRelationFn>([\r\n    [RelationKind.Customer, (relation: CustomerFullObject) => this.updateCustomer(relation)],\r\n    [RelationKind.Supplier, (relation: SupplierFullObject) => this.updateSupplier(relation)]\r\n  ]);\r\n\r\n  private readonly _insertMethods: Map<RelationKind, InsertRelationFn> = new Map<RelationKind, InsertRelationFn>([\r\n    [RelationKind.Customer, (relation: CustomerFullObject) => this.insertCustomer(relation)],\r\n    [RelationKind.Supplier, (relation: SupplierFullObject) => this.insertSupplier(relation)]\r\n  ])\r\n\r\n  constructor(\r\n    private _adapterService: RelationConnectorService,\r\n    private _selectMultipleCacheService: SelectMultipleCacheService,\r\n    private _selectSingleCacheService: SelectSingleCacheService,\r\n    private _selectMultipleParameterizedCacheService: SelectMultipleParameterizedCacheService\r\n  ) {}\r\n\r\n  public getCustomerFullObject(relationNo: number): Promise<CustomerFullObject> {\r\n    return this._selectSingleCacheService.requestCache<CustomerFullObject>(CustomerFullObject, relationNo, () => {\r\n      return this._adapterService.getCustomerFullObject(relationNo)\r\n    }).getValue();\r\n  }\r\n\r\n  public getSupplierFullObject(relationNo: number): Promise<SupplierFullObject> {\r\n    return this._selectSingleCacheService.requestCache<SupplierFullObject>(SupplierFullObject, relationNo, () => {\r\n      return this._adapterService.getSupplierFullObject(relationNo)\r\n    }).getValue();\r\n  }\r\n\r\n  public insertCustomer(relation: CustomerFullObject): Promise<CustomerFullObject> {\r\n    return this._adapterService.insertCustomer(relation);\r\n  }\r\n\r\n  public async updateCustomer(relation: CustomerFullObject): Promise<CustomerFullObject> {\r\n    return this._adapterService.updateCustomer(relation);\r\n  }\r\n\r\n  public insertSupplier(relation: SupplierFullObject): Promise<SupplierFullObject> {\r\n    return this._adapterService.insertSupplier(relation);\r\n  }\r\n\r\n  public async updateSupplier(relation: SupplierFullObject): Promise<SupplierFullObject> {\r\n    return this._adapterService.updateSupplier(relation);\r\n  }\r\n\r\n  public getRelationListObjects(relationRequest: RelationRequest): Promise<RelationListObject[]> {\r\n    return this._adapterService.getRelationListObjects(relationRequest);\r\n  }\r\n\r\n  public getRelationNumber(relationId: number): Promise<string> {\r\n    return this._adapterService.getRelationNumber(relationId);\r\n  }\r\n\r\n  public getBranches(branchNr?: string): Promise<BranchLov[]> {\r\n    return this._selectMultipleParameterizedCacheService.requestCache<BranchLov>(BranchLov, (branchNr?: string) => {\r\n      return this._adapterService.getBranches(branchNr)\r\n    }).getValue(branchNr);\r\n  }\r\n\r\n  public insertRelation(relationKind: RelationKind, relation: Relation): Promise<Relation> {\r\n    const insertMethod: InsertRelationFn = this._insertMethods.get(relationKind);\r\n    if (insertMethod) {\r\n      return insertMethod.call(this, relation);\r\n    } else {\r\n      const result: Relation = new Relation();\r\n      return Promise.resolve(result);\r\n    }\r\n  }\r\n\r\n  public updateRelation(relationKind: RelationKind, relation: Relation): Promise<Relation> {\r\n    const updateMethod: UpdateRelationFn = this._updateMethods.get(relationKind);\r\n    if (updateMethod) {\r\n      return updateMethod.call(this, relation);\r\n    } else {\r\n      const result: Relation = new Relation();\r\n      return Promise.resolve(result);\r\n    }\r\n  }\r\n\r\n  public lockRelation(relationKind: RelationKind, relationNr: number): Promise<ValidationResult> {\r\n    const lockMethod: LockFnHeader = this._lockMethods.get(relationKind);\r\n    if (lockMethod) {\r\n      return lockMethod.call(this, relationNr);\r\n    } else {\r\n      const result: ValidationResult = new ValidationResult();\r\n      result.success = false;\r\n      return Promise.resolve(result);\r\n    }\r\n  }\r\n\r\n  public getRelation(relationKind: RelationKind, relationNr: number): Promise<RelationAnyType> {\r\n    const getMethod: GetRelationFnHeader = this._getMethods.get(relationKind);\r\n    if (getMethod) {\r\n      return getMethod.call(this, relationNr);\r\n    } else {\r\n      const result: ValidationResult = new ValidationResult();\r\n      result.success = false;\r\n      return Promise.resolve(null);\r\n    }\r\n  }\r\n\r\n  public commit(): Promise<boolean> {\r\n    return this._adapterService.commit();\r\n  }\r\n\r\n  private _lockCustomerFullObject(relationNr: number): Promise<ValidationResult> {\r\n    return this._adapterService.lockCustomerFullObject(relationNr);\r\n  }\r\n\r\n  private _lockSupplierFullObject(relationNr: number): Promise<ValidationResult> {\r\n    return this._adapterService.lockSupplierFullObject(relationNr);\r\n  }\r\n\r\n  private _lockEmployeeFullObject(relationNr: number): Promise<ValidationResult> {\r\n    return this._adapterService.lockEmployeeFullObject(relationNr);\r\n  }\r\n\r\n  private _lockBranchFullObject(relationNr: number): Promise<ValidationResult> {\r\n    return this._adapterService.lockBranchFullObject(relationNr);\r\n  }\r\n\r\n  private _lockCompanyFullObject(relationNr: number): Promise<ValidationResult> {\r\n    return this._adapterService.lockCompanyFullObject(relationNr);\r\n  }\r\n\r\n  private _lockContactPerson(relationNr: number): Promise<ValidationResult> {\r\n    return this._adapterService.lockContactPerson(relationNr);\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,53 @@
+import { __awaiter } from "tslib";
+import { Injectable } from "@angular/core";
+import { OptionsService } from "./options.service";
+import { Sharedapi } from "@colijnit/sharedapi/build/sharedapi";
+import { CoDocument } from "@colijnit/sharedapi/build/model/co-document.bo";
+import { BusinessObjectFactory } from "@colijnit/ioneconnector/build/factory/business-object-factory";
+import * as i0 from "@angular/core";
+import * as i1 from "./options.service";
+export class SharedConnectorService {
+    constructor(_optionsService) {
+        this._optionsService = _optionsService;
+        this._boFactory = new BusinessObjectFactory();
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.connector = new Sharedapi(this._optionsService.options);
+        });
+    }
+    selectDocsByTableKey(table, key) {
+        return new Promise((resolve, reject) => {
+            return this.connector.selectDocsByTableKey(table, key).then((result) => {
+                if (result.validationResult && result.validationResult.success) {
+                    resolve(this._boFactory.makeBOArrayFromRawBackendDataArray(CoDocument, result.resultObjects));
+                }
+                else {
+                    reject(result.validationMessagesAsString);
+                }
+            });
+        });
+    }
+    getDocumentContent(id, thumbnail = true) {
+        return new Promise((resolve, reject) => {
+            return this.connector.getDocumentContent(id, thumbnail).then((result) => {
+                if (result.validationResult && result.validationResult.success) {
+                    resolve(result.resultObject.documentContent);
+                }
+                else {
+                    reject(result.validationMessagesAsString);
+                }
+            });
+        });
+    }
+}
+SharedConnectorService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SharedConnectorService_Factory() { return new SharedConnectorService(i0.ɵɵinject(i1.OptionsService)); }, token: SharedConnectorService, providedIn: "root" });
+SharedConnectorService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+SharedConnectorService.ctorParameters = () => [
+    { type: OptionsService }
+];
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,42 @@
+import { Injectable } from "@angular/core";
+import { OptionsService } from "./options.service";
+import { SharedConnectorService } from "./shared-connector.service";
+import { TransactionEventService } from "./transaction-event.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./options.service";
+import * as i2 from "./shared-connector.service";
+import * as i3 from "./transaction-event.service";
+export class SharedService {
+    constructor(_optionsService, _connector, _transactionEventService) {
+        this._optionsService = _optionsService;
+        this._connector = _connector;
+        this._transactionEventService = _transactionEventService;
+        this._subs = [];
+        this._subs.push(this._transactionEventService.connectionInitialized.subscribe((initialized) => {
+            if (initialized) {
+                this._connector.connect();
+            }
+        }));
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+    }
+    selectDocsByTableKey(table, key) {
+        return this._connector.selectDocsByTableKey(table, key);
+    }
+    getDocumentContent(docId, thumbnail = true) {
+        return this._connector.getDocumentContent(docId, thumbnail);
+    }
+}
+SharedService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SharedService_Factory() { return new SharedService(i0.ɵɵinject(i1.OptionsService), i0.ɵɵinject(i2.SharedConnectorService), i0.ɵɵinject(i3.TransactionEventService)); }, token: SharedService, providedIn: "root" });
+SharedService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+SharedService.ctorParameters = () => [
+    { type: OptionsService },
+    { type: SharedConnectorService },
+    { type: TransactionEventService }
+];
+//# sourceMappingURL=data:application/json;base64,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