@colijnit/transaction 12.1.58 → 12.1.60

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

@@ -0,0 +1,120 @@
+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._updateMethods = new Map([
+            [RelationKind.Customer, (relation) => this.updateCustomer(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);
+        });
+    }
+    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);
+    }
+    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);
+        }
+    }
+    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\n\r\ntype LockFnHeader = (relationNr: number) => Promise<ValidationResult>;\r\ntype UpdateFnHeader = (relation: Relation) => Promise<Relation>;\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 _updateMethods: Map<RelationKind, UpdateFnHeader> = new Map<RelationKind, UpdateFnHeader>([\r\n    [RelationKind.Customer, (relation: CustomerFullObject) => this.updateCustomer(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 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 updateRelation(relationKind: RelationKind, relation: Relation): Promise<Relation> {\r\n    const updateMethod: UpdateFnHeader = 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 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

@@ -1,9 +1,9 @@
 import { __awaiter } from "tslib";
 import { Injectable } from "@angular/core";
-import { BusinessObjectFactory } from "../factory/business-object-factory";
 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 {
@@ -50,4 +50,4 @@ SharedConnectorService.decorators = [
 SharedConnectorService.ctorParameters = () => [
     { type: OptionsService }
 ];
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,16 +1,19 @@
 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) {
+    constructor(_optionsService, _connector, _transactionEventService) {
         this._optionsService = _optionsService;
         this._connector = _connector;
+        this._transactionEventService = _transactionEventService;
         this._subs = [];
-        this._subs.push(this._optionsService.optionsLoaded.subscribe((loaded) => {
-            if (loaded) {
+        this._subs.push(this._transactionEventService.connectionInitialized.subscribe((initialized) => {
+            if (initialized) {
                 this._connector.connect();
             }
         }));
@@ -25,7 +28,7 @@ export class SharedService {
         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)); }, token: SharedService, providedIn: "root" });
+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"
@@ -33,6 +36,7 @@ SharedService.decorators = [
 ];
 SharedService.ctorParameters = () => [
     { type: OptionsService },
-    { type: SharedConnectorService }
+    { type: SharedConnectorService },
+    { type: TransactionEventService }
 ];
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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