taxtank-core 0.32.89 → 0.33.2

package/esm2022/src/lib/models/user-event/user-event-type-category.mjs

@@ -0,0 +1,4 @@
+import { UserEventTypeCategory as UserEventTypeCategoryBase } from '../../db/Models/user/user-event-type-category';
+export class UserEventTypeCategory extends UserEventTypeCategoryBase {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci1ldmVudC10eXBlLWNhdGVnb3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL21vZGVscy91c2VyLWV2ZW50L3VzZXItZXZlbnQtdHlwZS1jYXRlZ29yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUscUJBQXFCLElBQUkseUJBQXlCLEVBQUUsTUFBTSwrQ0FBK0MsQ0FBQztBQUVuSCxNQUFNLE9BQU8scUJBQXNCLFNBQVEseUJBQXlCO0NBQ25FIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVXNlckV2ZW50VHlwZUNhdGVnb3J5IGFzIFVzZXJFdmVudFR5cGVDYXRlZ29yeUJhc2UgfSBmcm9tICcuLi8uLi9kYi9Nb2RlbHMvdXNlci91c2VyLWV2ZW50LXR5cGUtY2F0ZWdvcnknO1xuXG5leHBvcnQgY2xhc3MgVXNlckV2ZW50VHlwZUNhdGVnb3J5IGV4dGVuZHMgVXNlckV2ZW50VHlwZUNhdGVnb3J5QmFzZSB7XG59XG4iXX0=

package/esm2022/src/lib/models/user-event/user-event-type.mjs

@@ -0,0 +1,23 @@
+import { __decorate } from "tslib";
+import { UserEventType as UserEventTypeBase } from '../../db/Models/user/user-event-type';
+import { UserEventTypeCategory } from './user-event-type-category';
+import { UserEventSetting } from './user-event-setting';
+import { Type, plainToClass } from 'class-transformer';
+import { UserEventTypeFrequencyEnum } from '../../db/Enums/user-event-type-frequency.enum';
+export class UserEventType extends UserEventTypeBase {
+    toSetting() {
+        return plainToClass(UserEventSetting, {
+            byEmail: this.byEmail,
+            byNotification: this.byNotification,
+            frequency: this.frequency,
+            type: this,
+        });
+    }
+    get frequencyLabel() {
+        return this.frequency ? UserEventTypeFrequencyEnum[UserEventTypeFrequencyEnum[this.frequency]] : null;
+    }
+}
+__decorate([
+    Type(() => UserEventTypeCategory)
+], UserEventType.prototype, "category", void 0);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/models/vehicle/index.mjs

@@ -0,0 +1,5 @@
+export * from './vehicle';
+export * from './vehicle-claim';
+export * from './vehicle-claim-details';
+export * from './vehicle-logbook';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvbW9kZWxzL3ZlaGljbGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3ZlaGljbGUnO1xuZXhwb3J0ICogZnJvbSAnLi92ZWhpY2xlLWNsYWltJztcbmV4cG9ydCAqIGZyb20gJy4vdmVoaWNsZS1jbGFpbS1kZXRhaWxzJztcbmV4cG9ydCAqIGZyb20gJy4vdmVoaWNsZS1sb2dib29rJztcbiJdfQ==

package/esm2022/src/lib/models/vehicle/vehicle-claim-details.mjs

@@ -0,0 +1,27 @@
+import { __decorate } from "tslib";
+import { VehicleClaimDetails as VehicleClaimDetailsBase } from '../../db/Models/vehicle/vehicle-claim-details';
+import { Type } from 'class-transformer';
+import { User } from '../user/user';
+import { VehicleClaimDetailsMethodEnum } from '../../db/Enums/vehicle-claim-details-method.enum';
+import { FinancialYear } from '../financial-year/financial-year';
+export class VehicleClaimDetails extends VehicleClaimDetailsBase {
+    constructor() {
+        super(...arguments);
+        /**
+         * Init default values for the new instances
+         */
+        this.isManual = true;
+        this.method = VehicleClaimDetailsMethodEnum.KMS;
+        this.financialYear = new FinancialYear().year;
+    }
+    isLogbookMethod() {
+        return this.method === VehicleClaimDetailsMethodEnum.LOGBOOK;
+    }
+    isKmsMethod() {
+        return this.method === VehicleClaimDetailsMethodEnum.KMS;
+    }
+}
+__decorate([
+    Type(() => User)
+], VehicleClaimDetails.prototype, "user", void 0);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/models/vehicle/vehicle-claim.mjs

@@ -0,0 +1,60 @@
+import { __decorate } from "tslib";
+import { VehicleClaim as VehicleClaimBase } from '../../db/Models/vehicle/vehicle-claim';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+import { Type } from 'class-transformer';
+import { VehicleClaimDetails } from './vehicle-claim-details';
+import { SoleBusiness } from '../sole';
+import { FinancialYear } from '../financial-year';
+import round from 'lodash/round';
+export class VehicleClaim extends VehicleClaimBase {
+    constructor() {
+        super(...arguments);
+        this.kilometers = 0;
+        this.workUsage = 0;
+    }
+    /**
+     * limit for kms claim method
+     */
+    static { this.totalKmsLimit = 5000; }
+    /**
+     * limit for work usage claim method
+     */
+    static { this.totalWorkUsagePercent = 100; }
+    isWorkTank() {
+        return !this.business;
+    }
+    isSoleTank() {
+        return !!this.business;
+    }
+    get tankType() {
+        return this.isSoleTank() ? TankTypeEnum.SOLE : TankTypeEnum.WORK;
+    }
+    /**
+     * Claim amount for KMs method. Exists only for KMs method.
+     */
+    getKMSClaimAmount(vehicleClaimRate) {
+        return round(this.kilometers * vehicleClaimRate, 2);
+    }
+    /**
+     * Get logbook claim amount. Exists only for logbook method.
+     * ClaimAmount = WorkUsage * transaction/depreciation amount
+     */
+    getLogbookClaimAmount(transactions) {
+        const transactionsAmount = transactions
+            .getByVehicleClaim(this)
+            .getLogbookTransactions()
+            .sumBy('amount');
+        // Math.abs because amount will be negative (because we sum expenses), but we don't want negative percent value
+        return Math.abs(transactionsAmount) * this.workUsage / 100;
+    }
+    getAverageWeeklyKMS() {
+        return this.kilometers / FinancialYear.weeksInYear;
+    }
+}
+__decorate([
+    Type(() => VehicleClaimDetails)
+], VehicleClaim.prototype, "details", void 0);
+__decorate([
+    Type(() => SoleBusiness)
+], VehicleClaim.prototype, "business", void 0);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/models/vehicle/vehicle-logbook.mjs

@@ -0,0 +1,27 @@
+import { __decorate } from "tslib";
+import { VehicleLogbook as VehicleLogbookBase } from '../../db/Models/vehicle/vehicle-logbook';
+import { Type } from 'class-transformer';
+import { SoleBusiness } from '../sole';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+export class VehicleLogbook extends VehicleLogbookBase {
+    get kilometers() {
+        return this.odometerEnd - this.odometerStart;
+    }
+    get tankType() {
+        switch (true) {
+            case !!this.business:
+                return TankTypeEnum.SOLE;
+            case this.isPersonal:
+                return TankTypeEnum.PERSONAL;
+            default:
+                return TankTypeEnum.WORK;
+        }
+    }
+}
+__decorate([
+    Type(() => Date)
+], VehicleLogbook.prototype, "date", void 0);
+__decorate([
+    Type(() => SoleBusiness)
+], VehicleLogbook.prototype, "business", void 0);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/models/vehicle/vehicle.mjs

@@ -0,0 +1,10 @@
+import { __decorate } from "tslib";
+import { Vehicle as VehicleBase } from '../../db/Models/vehicle/vehicle';
+import { VehicleLogbook } from './vehicle-logbook';
+import { Type } from 'class-transformer';
+export class Vehicle extends VehicleBase {
+}
+__decorate([
+    Type(() => VehicleLogbook)
+], Vehicle.prototype, "logbook", void 0);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVoaWNsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9tb2RlbHMvdmVoaWNsZS92ZWhpY2xlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsT0FBTyxJQUFJLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ3pFLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFekMsTUFBTSxPQUFPLE9BQVEsU0FBUSxXQUFXO0NBR3ZDO0FBREc7SUFERCxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsY0FBYyxDQUFDO3dDQUNDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVmVoaWNsZSBhcyBWZWhpY2xlQmFzZSB9IGZyb20gJy4uLy4uL2RiL01vZGVscy92ZWhpY2xlL3ZlaGljbGUnO1xuaW1wb3J0IHsgVmVoaWNsZUxvZ2Jvb2sgfSBmcm9tICcuL3ZlaGljbGUtbG9nYm9vayc7XG5pbXBvcnQgeyBUeXBlIH0gZnJvbSAnY2xhc3MtdHJhbnNmb3JtZXInO1xuXG5leHBvcnQgY2xhc3MgVmVoaWNsZSBleHRlbmRzIFZlaGljbGVCYXNlIHtcbiAgQFR5cGUoKCkgPT4gVmVoaWNsZUxvZ2Jvb2spXG4gICAgbG9nYm9vazogVmVoaWNsZUxvZ2Jvb2tbXTtcbn1cbiJdfQ==

package/esm2022/src/lib/pipes/app-currency.pipe.mjs

@@ -0,0 +1,23 @@
+import { Pipe } from '@angular/core';
+import { CurrencyPipe } from '@angular/common';
+import * as i0 from "@angular/core";
+/**
+ * extended version of currency pipe
+ */
+export class AppCurrencyPipe extends CurrencyPipe {
+    transform(value, currencyCode, display, digitsInfo, locale) {
+        // 2 non-zero decimals by default (43.43344 => 43.43, 0.0000114201553151 => $0.000011)
+        digitsInfo = digitsInfo ?? '1.0-' + (value.toString().match(/[1-9]/)?.index || 2);
+        return super.transform(value, currencyCode, display, digitsInfo, locale);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: AppCurrencyPipe, deps: null, target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.8", ngImport: i0, type: AppCurrencyPipe, isStandalone: true, name: "appCurrency" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: AppCurrencyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'appCurrency',
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLWN1cnJlbmN5LnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvcGlwZXMvYXBwLWN1cnJlbmN5LnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7QUFDcEQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDOztBQUUvQzs7R0FFRztBQUtILE1BQU0sT0FBTyxlQUFnQixTQUFRLFlBQVk7SUFDL0MsU0FBUyxDQUFDLEtBQThCLEVBQUUsWUFBcUIsRUFBRSxPQUFnRSxFQUFFLFVBQW1CLEVBQUUsTUFBZTtRQUNySyxzRkFBc0Y7UUFDdEYsVUFBVSxHQUFHLFVBQVUsSUFBSSxNQUFNLEdBQUcsQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxFQUFFLEtBQUssSUFBSSxDQUFDLENBQUMsQ0FBQztRQUVsRixPQUFPLEtBQUssQ0FBQyxTQUFTLENBQUMsS0FBSyxFQUFFLFlBQVksRUFBRSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQzNFLENBQUM7OEdBTlUsZUFBZTs0R0FBZixlQUFlOzsyRkFBZixlQUFlO2tCQUozQixJQUFJO21CQUFDO29CQUNKLElBQUksRUFBRSxhQUFhO29CQUNuQixVQUFVLEVBQUUsSUFBSTtpQkFDakIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDdXJyZW5jeVBpcGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuXG4vKipcbiAqIGV4dGVuZGVkIHZlcnNpb24gb2YgY3VycmVuY3kgcGlwZVxuICovXG5AUGlwZSh7XG4gIG5hbWU6ICdhcHBDdXJyZW5jeScsXG4gIHN0YW5kYWxvbmU6IHRydWUsXG59KVxuZXhwb3J0IGNsYXNzIEFwcEN1cnJlbmN5UGlwZSBleHRlbmRzIEN1cnJlbmN5UGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICB0cmFuc2Zvcm0odmFsdWU/OiBudW1iZXIgfCBzdHJpbmcgfCBudWxsLCBjdXJyZW5jeUNvZGU/OiBzdHJpbmcsIGRpc3BsYXk/OiAnY29kZScgfCAnc3ltYm9sJyB8ICdzeW1ib2wtbmFycm93JyB8IHN0cmluZyB8IGJvb2xlYW4sIGRpZ2l0c0luZm8/OiBzdHJpbmcsIGxvY2FsZT86IHN0cmluZyk6IGFueSB7XG4gICAgLy8gMiBub24temVybyBkZWNpbWFscyBieSBkZWZhdWx0ICg0My40MzM0NCA9PiA0My40MywgMC4wMDAwMTE0MjAxNTUzMTUxID0+ICQwLjAwMDAxMSlcbiAgICBkaWdpdHNJbmZvID0gZGlnaXRzSW5mbyA/PyAnMS4wLScgKyAodmFsdWUudG9TdHJpbmcoKS5tYXRjaCgvWzEtOV0vKT8uaW5kZXggfHwgMik7XG5cbiAgICByZXR1cm4gc3VwZXIudHJhbnNmb3JtKHZhbHVlLCBjdXJyZW5jeUNvZGUsIGRpc3BsYXksIGRpZ2l0c0luZm8sIGxvY2FsZSk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/src/lib/pipes/index.mjs

@@ -0,0 +1,3 @@
+export * from './app-currency.pipe';
+export * from './safe-url.pipe';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvcGlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGlCQUFpQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hcHAtY3VycmVuY3kucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3NhZmUtdXJsLnBpcGUnO1xuIl19

package/esm2022/src/lib/pipes/safe-url.pipe.mjs

@@ -0,0 +1,21 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+export class SafeUrlPipe {
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+    }
+    transform(url) {
+        return this.sanitizer.bypassSecurityTrustResourceUrl(url);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SafeUrlPipe, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.8", ngImport: i0, type: SafeUrlPipe, isStandalone: true, name: "safeUrl" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: SafeUrlPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'safeUrl',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.DomSanitizer }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FmZS11cmwucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9waXBlcy9zYWZlLXVybC5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDOzs7QUFPcEQsTUFBTSxPQUFPLFdBQVc7SUFDdEIsWUFBb0IsU0FBdUI7UUFBdkIsY0FBUyxHQUFULFNBQVMsQ0FBYztJQUFHLENBQUM7SUFFL0MsU0FBUyxDQUFDLEdBQVc7UUFDbkIsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLDhCQUE4QixDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQzVELENBQUM7OEdBTFUsV0FBVzs0R0FBWCxXQUFXOzsyRkFBWCxXQUFXO2tCQUp2QixJQUFJO21CQUFDO29CQUNKLElBQUksRUFBRSxTQUFTO29CQUNmLFVBQVUsRUFBRSxJQUFJO2lCQUNqQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IERvbVNhbml0aXplciwgU2FmZVJlc291cmNlVXJsIH0gZnJvbSAnQGFuZ3VsYXIvcGxhdGZvcm0tYnJvd3Nlcic7XG5cbkBQaXBlKHtcbiAgbmFtZTogJ3NhZmVVcmwnLFxuICBzdGFuZGFsb25lOiB0cnVlLFxufSlcbmV4cG9ydCBjbGFzcyBTYWZlVXJsUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHNhbml0aXplcjogRG9tU2FuaXRpemVyKSB7fVxuXG4gIHRyYW5zZm9ybSh1cmw6IHN0cmluZyk6IFNhZmVSZXNvdXJjZVVybCB7XG4gICAgcmV0dXJuIHRoaXMuc2FuaXRpemVyLmJ5cGFzc1NlY3VyaXR5VHJ1c3RSZXNvdXJjZVVybCh1cmwpO1xuICB9XG59XG4iXX0=

package/esm2022/src/lib/services/account-setup/account-setup.service.mjs

@@ -0,0 +1,168 @@
+import { Injectable } from '@angular/core';
+import { AccountSetupItemCollection, IncomeSourceCollection, TransactionCollection } from '../../collections';
+import { combineLatest, of } from 'rxjs';
+import { map, mergeMap } from 'rxjs/operators';
+import intersection from 'lodash/intersection';
+import { UserRolesEnum } from 'taxtank-core/common';
+import { SetupItemTypeEnum } from '../../db/Enums/setup-item-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../http/setup-item/setup-item.service";
+import * as i2 from "../http";
+/**
+ * Service handling user's account setup process.
+ * Checks required steps and their completion
+ */
+export class AccountSetupService {
+    constructor(setupItemService, propertyService, incomeSourceService, bankAccountsService, transactionAllocationService, vehicleClaimService, transactionService, soleBusinessService, holdingService, userService, clientMovementService, clientInviteService, employeeService, employeeInviteService, firmService) {
+        this.setupItemService = setupItemService;
+        this.propertyService = propertyService;
+        this.incomeSourceService = incomeSourceService;
+        this.bankAccountsService = bankAccountsService;
+        this.transactionAllocationService = transactionAllocationService;
+        this.vehicleClaimService = vehicleClaimService;
+        this.transactionService = transactionService;
+        this.soleBusinessService = soleBusinessService;
+        this.holdingService = holdingService;
+        this.userService = userService;
+        this.clientMovementService = clientMovementService;
+        this.clientInviteService = clientInviteService;
+        this.employeeService = employeeService;
+        this.employeeInviteService = employeeInviteService;
+        this.firmService = firmService;
+    }
+    /**
+     * Get list of account setup items for current user/firm
+     */
+    get(type) {
+        return combineLatest([
+            this.setupItemService.get(),
+            this.userService.getFirst()
+        ])
+            .pipe(mergeMap(([items, user]) => {
+            this.items = items;
+            this.user = user;
+            return type === SetupItemTypeEnum.CLIENT ? this.getClientItems$() : this.getFirmItems$();
+        }));
+    }
+    getClientItems$() {
+        const batch = [];
+        if (this.user.hasRoles(UserRolesEnum.WORK_TANK)) {
+            batch.push(
+            // Salary item is completed when user added salary income source
+            this.setItemStatus(this.items.findBy('isSalary', true), this.getIncomeSources(true)), 
+            // Other income is a part of work tank, completed when user added at least one other income source
+            this.setItemStatus(this.items.findBy('isOtherIncome', true), this.getIncomeSources()));
+        }
+        // Rental income item is completed when user added at least one property
+        if (this.user.hasRoles(UserRolesEnum.PROPERTY_TANK)) {
+            batch.push(this.setItemStatus(this.items.findBy('isProperty', true), this.propertyService.getArray()));
+        }
+        // Sole business item is completed when user added at least one business
+        if (this.user.hasRoles(UserRolesEnum.SOLE_TANK)) {
+            batch.push(this.setItemStatus(this.items.findBy('isSoleBusiness', true), this.soleBusinessService.get()));
+        }
+        // holdings item is completed when user added at least one holding
+        if (this.user.hasRoles(UserRolesEnum.HOLDING_TANK)) {
+            batch.push(this.setItemStatus(this.items.findBy('isHoldings', true), this.holdingService.getArray()));
+        }
+        if (this.user.hasRoles([UserRolesEnum.WORK_TANK, UserRolesEnum.PROPERTY_TANK, UserRolesEnum.SOLE_TANK, UserRolesEnum.HOLDING_TANK])) {
+            // Bank feeds item is completed when user added at least one bank account (basiq or manual)
+            batch.push(this.getBankFeedsItem());
+            // Logbook item is completed when user has at least one vehicle claim with any method (kms or logbook)
+            batch.push(this.getLogbookItem());
+            // Allocation item is completed when user added at least one transaction allocation
+            batch.push(this.setItemStatus(this.items.findBy('isTransactionAllocate', true), this.transactionAllocationService.get()));
+        }
+        return combineLatest(batch).pipe(map((items) => new AccountSetupItemCollection(items)));
+    }
+    getFirmItems$() {
+        const batch = [];
+        batch.push(
+        // Firm Details item is completed when user filled some general information
+        this.firmService.get().pipe(map((firm) => {
+            const item = this.items.findBy('isFirmDetails', true);
+            if (firm.address || firm.phone || firm.file || firm.shortName) {
+                item.isCompleted = true;
+            }
+            return item;
+        })));
+        batch.push(
+        // Invite team item is completed when firm has employees except firm owner or firm has invited employees.
+        this.setItemStatus(this.items.findBy('isInviteTeam', true), combineLatest([
+            this.employeeService.getArray(),
+            this.employeeInviteService.getArray()
+        ]).pipe(map(([employees, invites]) => {
+            // we always have at least 1 employee (firm owner), so we should check other employees except firm owner
+            if (employees.length) {
+                employees.splice(0, 1);
+            }
+            return [...employees, ...invites];
+        }))));
+        batch.push(
+        // Invite clients item is completed when firm has clients or firm has invited clients.
+        this.setItemStatus(this.items.findBy('isInviteClients', true), combineLatest([this.clientMovementService.getActive(), this.clientInviteService.getFirmInvites()])
+            .pipe(map(([movements, invites]) => [...movements.toArray(), ...invites.toArray()]))));
+        return combineLatest(batch).pipe(map((items) => new AccountSetupItemCollection(items)));
+    }
+    /**
+     * Check and update isCompleted flag for passed item
+     */
+    setItemStatus(item, request) {
+        return request.pipe(map((result) => {
+            const isSkipped = !!this.user.blacklistSetupItems.find((skippedItem) => skippedItem.id === item.id);
+            if (result.length || isSkipped) {
+                item.isCompleted = true;
+            }
+            else {
+                item.isCompleted = false;
+            }
+            return item;
+        }));
+    }
+    /**
+     * @TODO Alex: work with collection when services refactored
+     * @TODO Vik: waiting for income sources refactoring
+     */
+    getIncomeSources(isSalary = false) {
+        return this.incomeSourceService.get().pipe(map((incomeSources) => {
+            const collection = new IncomeSourceCollection(incomeSources);
+            if (isSalary) {
+                return collection.getSalary();
+            }
+            return collection.items.filter((incomeSource) => incomeSource.isOtherIncome());
+        }));
+    }
+    /**
+     * Show logbook item when user has at least 1 vehicle transaction
+     */
+    getLogbookItem() {
+        return this.transactionService.get()
+            .pipe(
+        // @TODO Alex: remove map when services start work with collections
+        map((transactions) => new TransactionCollection(transactions)), mergeMap((transactions) => {
+            if (transactions.getVehicleTransactions().length) {
+                return this.setItemStatus(this.items.findBy('isWorkLogbook', true), this.vehicleClaimService.get());
+            }
+            return of(null);
+        }));
+    }
+    /**
+     * Hide bank feeds item when user has only holding tank
+     */
+    getBankFeedsItem() {
+        const bankFeedsRoles = [UserRolesEnum.PROPERTY_TANK, UserRolesEnum.WORK_TANK, UserRolesEnum.SOLE_TANK];
+        if (!intersection(bankFeedsRoles, this.user.roles).length) {
+            return of(null);
+        }
+        return this.setItemStatus(this.items.findBy('isBankFeeds', true), this.bankAccountsService.getArray());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: AccountSetupService, deps: [{ token: i1.SetupItemService }, { token: i2.PropertyService }, { token: i2.IncomeSourceService }, { token: i2.BankAccountService }, { token: i2.TransactionAllocationService }, { token: i2.VehicleClaimService }, { token: i2.TransactionService }, { token: i2.SoleBusinessService }, { token: i2.HoldingService }, { token: i2.UserService }, { token: i2.ClientMovementService }, { token: i2.ClientInviteService }, { token: i2.EmployeeService }, { token: i2.EmployeeInviteService }, { token: i2.FirmService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: AccountSetupService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: AccountSetupService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.SetupItemService }, { type: i2.PropertyService }, { type: i2.IncomeSourceService }, { type: i2.BankAccountService }, { type: i2.TransactionAllocationService }, { type: i2.VehicleClaimService }, { type: i2.TransactionService }, { type: i2.SoleBusinessService }, { type: i2.HoldingService }, { type: i2.UserService }, { type: i2.ClientMovementService }, { type: i2.ClientInviteService }, { type: i2.EmployeeService }, { type: i2.EmployeeInviteService }, { type: i2.FirmService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"account-setup.service.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/services/account-setup/account-setup.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { AccountSetupItem } from '../../models/account-setup/account-setup-item';\nimport {\n  BankAccountService,\n  ClientInviteService,\n  ClientMovementService,\n  EmployeeInviteService,\n  EmployeeService,\n  FirmService,\n  HoldingService,\n  IncomeSourceService,\n  PropertyService,\n  SoleBusinessService,\n  TransactionAllocationService,\n  TransactionService,\n  UserService,\n  VehicleClaimService\n} from '../http';\nimport { IncomeSource, Transaction, User } from '../../models';\nimport {\n  AccountSetupItemCollection,\n  ClientInviteCollection,\n  ClientMovementCollection,\n  Collection,\n  IncomeSourceCollection,\n  TransactionCollection\n} from '../../collections';\nimport { Observable, combineLatest, of } from 'rxjs';\nimport { map, mergeMap } from 'rxjs/operators';\nimport intersection from 'lodash/intersection';\nimport { UserRolesEnum } from 'taxtank-core/common';\nimport { SetupItemTypeEnum } from '../../db/Enums/setup-item-type.enum';\nimport { EmployeeInvite } from '../../db/Models';\nimport { Firm } from '../../models/firm/firm';\nimport { SetupItemService } from '../http/setup-item/setup-item.service';\n\n/**\n * Service handling user's account setup process.\n * Checks required steps and their completion\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class AccountSetupService {\n  items: AccountSetupItemCollection;\n  user: User;\n\n  constructor(\n    private setupItemService: SetupItemService,\n    private propertyService: PropertyService,\n    private incomeSourceService: IncomeSourceService,\n    private bankAccountsService: BankAccountService,\n    private transactionAllocationService: TransactionAllocationService,\n    private vehicleClaimService: VehicleClaimService,\n    private transactionService: TransactionService,\n    private soleBusinessService: SoleBusinessService,\n    private holdingService: HoldingService,\n    private userService: UserService,\n    private clientMovementService: ClientMovementService,\n    private clientInviteService: ClientInviteService,\n    private employeeService: EmployeeService,\n    private employeeInviteService: EmployeeInviteService,\n    private firmService: FirmService\n  ) {\n  }\n\n  /**\n   * Get list of account setup items for current user/firm\n   */\n  get(type: SetupItemTypeEnum): Observable<AccountSetupItemCollection> {\n    return combineLatest([\n      this.setupItemService.get(),\n      this.userService.getFirst()\n    ])\n      .pipe(\n        mergeMap(([items, user]: [AccountSetupItemCollection, User]) => {\n          this.items = items;\n          this.user = user;\n\n          return type === SetupItemTypeEnum.CLIENT ? this.getClientItems$() : this.getFirmItems$();\n        })\n      );\n  }\n\n  getClientItems$(): Observable<AccountSetupItemCollection> {\n    const batch: Observable<AccountSetupItem>[] = [];\n\n    if (this.user.hasRoles(UserRolesEnum.WORK_TANK)) {\n      batch.push(\n        // Salary item is completed when user added salary income source\n        this.setItemStatus(\n          this.items.findBy('isSalary', true),\n          this.getIncomeSources(true)\n        ),\n        // Other income is a part of work tank, completed when user added at least one other income source\n        this.setItemStatus(\n          this.items.findBy('isOtherIncome', true),\n          this.getIncomeSources()\n        )\n      );\n    }\n\n    // Rental income item is completed when user added at least one property\n    if (this.user.hasRoles(UserRolesEnum.PROPERTY_TANK)) {\n      batch.push(\n        this.setItemStatus(\n          this.items.findBy('isProperty', true),\n          this.propertyService.getArray()\n        )\n      );\n    }\n\n    // Sole business item is completed when user added at least one business\n    if (this.user.hasRoles(UserRolesEnum.SOLE_TANK)) {\n      batch.push(\n        this.setItemStatus(\n          this.items.findBy('isSoleBusiness', true),\n          this.soleBusinessService.get()\n        )\n      );\n    }\n\n    // holdings item is completed when user added at least one holding\n    if (this.user.hasRoles(UserRolesEnum.HOLDING_TANK)) {\n      batch.push(\n        this.setItemStatus(\n          this.items.findBy('isHoldings', true),\n          this.holdingService.getArray()\n        )\n      );\n    }\n\n    if (this.user.hasRoles([UserRolesEnum.WORK_TANK, UserRolesEnum.PROPERTY_TANK, UserRolesEnum.SOLE_TANK, UserRolesEnum.HOLDING_TANK])) {\n      // Bank feeds item is completed when user added at least one bank account (basiq or manual)\n      batch.push(this.getBankFeedsItem());\n\n      // Logbook item is completed when user has at least one vehicle claim with any method (kms or logbook)\n      batch.push(this.getLogbookItem());\n\n      // Allocation item is completed when user added at least one transaction allocation\n      batch.push(\n        this.setItemStatus(\n          this.items.findBy('isTransactionAllocate', true),\n          this.transactionAllocationService.get()\n        )\n      );\n    }\n\n    return combineLatest(batch).pipe(map((items: AccountSetupItem[]) => new AccountSetupItemCollection(items)));\n  }\n\n  getFirmItems$(): Observable<AccountSetupItemCollection> {\n    const batch: Observable<AccountSetupItem>[] = [];\n\n    batch.push(\n      // Firm Details item is completed when user filled some general information\n      this.firmService.get().pipe(map((firm: Firm) => {\n        const item = this.items.findBy('isFirmDetails', true);\n        if (firm.address || firm.phone || firm.file || firm.shortName) {\n          item.isCompleted = true;\n        }\n\n        return item;\n      }))\n    );\n\n    batch.push(\n      // Invite team item is completed when firm has employees except firm owner or firm has invited employees.\n      this.setItemStatus(\n        this.items.findBy('isInviteTeam', true),\n        combineLatest([\n          this.employeeService.getArray(),\n          this.employeeInviteService.getArray()\n        ]).pipe(map(([employees, invites]: [User[], EmployeeInvite[]]) => {\n          // we always have at least 1 employee (firm owner), so we should check other employees except firm owner\n          if (employees.length) {\n            employees.splice(0, 1);\n          }\n\n          return [...employees, ...invites];\n        }))\n      )\n    )\n\n    batch.push(\n      // Invite clients item is completed when firm has clients or firm has invited clients.\n      this.setItemStatus(\n        this.items.findBy('isInviteClients', true),\n        combineLatest([this.clientMovementService.getActive(), this.clientInviteService.getFirmInvites()])\n          .pipe(\n            map(([movements, invites]: [ClientMovementCollection, ClientInviteCollection]) => [...movements.toArray(), ...invites.toArray()])\n          )\n      )\n    )\n\n    return combineLatest(batch).pipe(map((items: AccountSetupItem[]) => new AccountSetupItemCollection(items)));\n  }\n\n  /**\n   * Check and update isCompleted flag for passed item\n   */\n  private setItemStatus(item: AccountSetupItem, request: Observable<object[]>): Observable<AccountSetupItem> {\n    return request.pipe(\n      map((result: object[]): AccountSetupItem => {\n        const isSkipped = !!this.user.blacklistSetupItems.find((skippedItem: AccountSetupItem) => skippedItem.id === item.id);\n\n        if (result.length || isSkipped) {\n          item.isCompleted = true;\n        } else {\n          item.isCompleted = false;\n        }\n\n        return item;\n      })\n    );\n  }\n\n  /**\n   * @TODO Alex: work with collection when services refactored\n   * @TODO Vik: waiting for income sources refactoring\n   */\n  private getIncomeSources(isSalary = false): Observable<IncomeSource[]> {\n    return this.incomeSourceService.get().pipe(\n      map((incomeSources: IncomeSource[]): IncomeSource[] => {\n        const collection: IncomeSourceCollection = new IncomeSourceCollection(incomeSources);\n        if (isSalary) {\n          return collection.getSalary();\n        }\n\n        return collection.items.filter((incomeSource: IncomeSource) => incomeSource.isOtherIncome());\n      })\n    )\n  }\n\n  /**\n   * Show logbook item when user has at least 1 vehicle transaction\n   */\n  private getLogbookItem(): Observable<AccountSetupItem> {\n    return this.transactionService.get()\n      .pipe(\n        // @TODO Alex: remove map when services start work with collections\n        map((transactions: Transaction[]) => new TransactionCollection(transactions)),\n        mergeMap((transactions: TransactionCollection) => {\n          if (transactions.getVehicleTransactions().length) {\n            return this.setItemStatus(\n              this.items.findBy('isWorkLogbook', true),\n              this.vehicleClaimService.get()\n            );\n          }\n\n          return of(null);\n        })\n      );\n  }\n\n  /**\n   * Hide bank feeds item when user has only holding tank\n   */\n  private getBankFeedsItem(): Observable<AccountSetupItem> {\n    const bankFeedsRoles = [UserRolesEnum.PROPERTY_TANK, UserRolesEnum.WORK_TANK, UserRolesEnum.SOLE_TANK];\n\n    if (!intersection(bankFeedsRoles, this.user.roles).length) {\n      return of(null);\n    }\n\n    return this.setItemStatus(\n      this.items.findBy('isBankFeeds', true),\n      this.bankAccountsService.getArray()\n    );\n  }\n}\n"]}

package/esm2022/src/lib/services/account-setup/index.mjs

@@ -0,0 +1,2 @@
+export * from './account-setup.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvYWNjb3VudC1zZXR1cC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hY2NvdW50LXNldHVwLnNlcnZpY2UnO1xuIl19

package/esm2022/src/lib/services/asset/assets.service.mjs

@@ -0,0 +1,51 @@
+import { Inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../user";
+/**
+ * Service to work with assets (documents, receipts, e.t.c.)
+ */
+export class AssetsService {
+    constructor(http, userSwitcherService, environment) {
+        this.http = http;
+        this.userSwitcherService = userSwitcherService;
+        this.environment = environment;
+        this.impersonatedClient = this.userSwitcherService.get();
+    }
+    /**
+     * Get asset link
+     * @param asset to get the link for
+     */
+    getLink(asset) {
+        return this.http.get(`${this.environment.apiV2}/assets/${asset.type}/${asset.id}`);
+    }
+    /**
+     * Download asset
+     * @param asset which should be downloaded
+     * @TODO refactor
+     */
+    download(asset) {
+        return `${this.environment.apiV2}/assets/${asset.type}/${asset.id}/download?bearer=${localStorage.getItem('token')}${this.impersonatedClient ? `&_switch_user=${this.impersonatedClient}` : ''}`;
+    }
+    // @Todo refactor to event dispatcher
+    /**
+     * Delete asset
+     * @param entityId: id of asset main entity (property, folder, transaction, e.t.c.)
+     * @param asset which should be deleted
+     */
+    delete(entityId, asset) {
+        return this.http.delete(`${this.environment.apiV2}/${asset.entityType}/${entityId}/${asset.type}/${asset.id}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: AssetsService, deps: [{ token: i1.HttpClient }, { token: i2.UserSwitcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: AssetsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: AssetsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.UserSwitcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/services/asset/index.mjs

@@ -0,0 +1,2 @@
+export * from './assets.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvYXNzZXQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXNzZXRzLnNlcnZpY2UnO1xuIl19

package/esm2022/src/lib/services/bank/bank-account-calculation.service.mjs

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import { BankAccountCollection } from '../../collections';
+import { BankAccount } from '../../models';
+import * as i0 from "@angular/core";
+export class BankAccountCalculationService {
+    /**
+     * Sum of bank accounts opening balances and their bank transactions allocated amounts
+     */
+    getTaxTankBalance(bankAccounts, bankTransactions, allocations) {
+        // wrap in a collection if a single bank account was provided
+        const bankAccountCollection = bankAccounts instanceof BankAccount ?
+            new BankAccountCollection([bankAccounts]) :
+            bankAccounts;
+        return bankTransactions.getByBankAccountsIds(bankAccountCollection.getIds()).getAllocatedAmount(allocations)
+            + bankAccountCollection.getOpeningBalance();
+    }
+    /**
+     * get difference between total loans amount and total cash amount
+     */
+    getNetPosition(bankAccounts, bankTransactions, allocations) {
+        return bankAccounts.currentBalance - this.getTaxTankBalance(bankAccounts.getLoanAccounts(), bankTransactions, allocations);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BankAccountCalculationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BankAccountCalculationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BankAccountCalculationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/services/bank/index.mjs

@@ -0,0 +1,2 @@
+export * from './bank-account-calculation.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvYmFuay9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9DQUFvQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9iYW5rLWFjY291bnQtY2FsY3VsYXRpb24uc2VydmljZSc7XG4iXX0=

package/esm2022/src/lib/services/data.service.mjs

@@ -0,0 +1,44 @@
+import { Injectable } from '@angular/core';
+import { plainToClass } from 'class-transformer';
+import clone from 'lodash/clone';
+import * as i0 from "@angular/core";
+export class DataService {
+    /**
+     * @TODO use excludeExtraneousValues when all models refactored (exposed all needed properties)
+     * Create new instance of class
+     * @param model Single object or array from which will be created model instance(s)
+     */
+    createModelInstance(model) {
+        return plainToClass(this.modelClass, model);
+    }
+    createCollectionInstance(collectionClass, items) {
+        return new collectionClass(items);
+    }
+    /**
+     * never return cache directly to prevent update
+     */
+    getCache() {
+        return clone(this.cache);
+    }
+    /**
+     * never return cache directly to prevent update
+     */
+    getCacheFirst() {
+        return clone(this.cache?.first);
+    }
+    /**
+     * @TODO vik any[] because of problems with base models extending abstractModel
+     */
+    setCache(data) {
+        this.cache = this.createCollectionInstance(this.collectionClass, data.map((item) => this.createModelInstance(item)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: DataService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: DataService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: DataService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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