taxtank-core 0.31.61 → 0.32.0

package/esm2022/lib/models/sole/sole-business.mjs

@@ -0,0 +1,57 @@
+import { __decorate } from "tslib";
+import { SoleBusiness as SoleBusinessBase } from '../../db/Models/sole/sole-business';
+import { User } from '../user';
+import { SoleBusinessAllocation } from './sole-business-allocation';
+import { SoleBusinessLoss } from './sole-business-loss';
+import { SoleInvoice } from './sole-invoice';
+import { SoleInvoiceTemplate } from './sole-invoice-template';
+import { Transform, Type } from 'class-transformer';
+import { VehicleClaim } from '../vehicle';
+import { Depreciation } from '../depreciation';
+import { Transaction } from '../transaction';
+import { SoleBusinessActivity } from '../../db/Models';
+import { IncomeSource } from '../income-source';
+import { AppFile } from '../file';
+export class SoleBusiness extends SoleBusinessBase {
+    /**
+     * Maximum number of businesses that a person can have, according to the ATO
+     */
+    static { this.businessesLimit = 6; }
+}
+__decorate([
+    Type(() => User)
+], SoleBusiness.prototype, "user", void 0);
+__decorate([
+    Type(() => SoleBusinessAllocation)
+], SoleBusiness.prototype, "allocations", void 0);
+__decorate([
+    Type(() => SoleBusinessLoss)
+], SoleBusiness.prototype, "losses", void 0);
+__decorate([
+    Type(() => SoleInvoice)
+], SoleBusiness.prototype, "invoices", void 0);
+__decorate([
+    Type(() => SoleInvoiceTemplate)
+], SoleBusiness.prototype, "invoiceTemplates", void 0);
+__decorate([
+    Type(() => VehicleClaim)
+], SoleBusiness.prototype, "vehicleClaims", void 0);
+__decorate([
+    Type(() => Transaction)
+], SoleBusiness.prototype, "transactions", void 0);
+__decorate([
+    Type(() => Depreciation)
+], SoleBusiness.prototype, "depreciations", void 0);
+__decorate([
+    Type(() => SoleBusinessActivity)
+], SoleBusiness.prototype, "activity", void 0);
+__decorate([
+    Type(() => IncomeSource)
+], SoleBusiness.prototype, "incomeSource", void 0);
+__decorate([
+    Transform(({ value }) => value || false)
+], SoleBusiness.prototype, "isPrimaryProduction", void 0);
+__decorate([
+    Type(() => AppFile)
+], SoleBusiness.prototype, "file", void 0);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/models/sole/sole-invoice.mjs

@@ -0,0 +1,149 @@
+import { __decorate } from "tslib";
+import { SoleInvoice as SoleInvoiceBase } from '../../db/Models/sole/sole-invoice';
+import { User } from '../user';
+import { SoleBusiness } from './sole-business';
+import { SoleInvoiceItem } from './sole-invoice-item';
+import { SoleContact } from './sole-contact';
+import { Type } from 'class-transformer';
+import { SoleInvoiceStatusesEnum } from '../../db/Enums/sole-invoice-statuses.enum';
+import { BankAccount } from '../bank';
+import { SoleInvoiceTaxTypeEnum } from '../../db/Enums/sole-invoice-tax-type.enum';
+import { Collection, SoleInvoiceItemCollection } from '../../collections';
+import { ChartAccounts } from '../chart-accounts';
+import round from 'lodash/round';
+export class SoleInvoice extends SoleInvoiceBase {
+    constructor() {
+        super(...arguments);
+        this.status = SoleInvoiceStatusesEnum.DRAFT;
+        this.taxType = SoleInvoiceTaxTypeEnum.NO_TAX;
+    }
+    static { this.NUMBER_LENGTH = 4; }
+    /**
+     * Get items array as collection
+     */
+    get itemsCollection() {
+        return new SoleInvoiceItemCollection(this.items);
+    }
+    /**
+     * Total price of all items
+     */
+    get price() {
+        return this.itemsCollection.sumBy('totalPrice');
+    }
+    /**
+     * Total invoice price without GST
+     */
+    get netPrice() {
+        if (this.isTaxInclusive()) {
+            return this.price - this.GSTAmount;
+        }
+        return this.price;
+    }
+    /**
+     * Total final price (net + GST)
+     */
+    get grossPrice() {
+        if (this.isTaxExclusive()) {
+            return this.price + this.GSTAmount;
+        }
+        return this.price;
+    }
+    /**
+     * Total GST amount
+     */
+    get GSTAmount() {
+        switch (this.taxType) {
+            case SoleInvoiceTaxTypeEnum.TAX_INCLUSIVE:
+                return this.inclusiveGSTAmount;
+            case SoleInvoiceTaxTypeEnum.TAX_EXCLUSIVE:
+                return this.exclusiveGSTAmount;
+            case SoleInvoiceTaxTypeEnum.NO_TAX:
+                return 0;
+        }
+    }
+    /**
+     * When tax inclusive, GST amount is included to total price
+     */
+    get inclusiveGSTAmount() {
+        const gstPrice = this.itemsCollection.gstPrice;
+        return round(gstPrice - (gstPrice / (1 + ChartAccounts.GSTRatio)), 2);
+    }
+    /**
+     * When tax exclusive, GST amount should be added additionally to total price
+     */
+    get exclusiveGSTAmount() {
+        return round(this.itemsCollection.gstPrice * ChartAccounts.GSTRatio, 2);
+    }
+    isDraft() {
+        return this.status === SoleInvoiceStatusesEnum.DRAFT;
+    }
+    isCancelled() {
+        return this.status === SoleInvoiceStatusesEnum.CANCELED;
+    }
+    isPending() {
+        return this.status === SoleInvoiceStatusesEnum.PENDING;
+    }
+    isPaid() {
+        return this.status === SoleInvoiceStatusesEnum.PAID;
+    }
+    isPaidCash() {
+        return this.status === SoleInvoiceStatusesEnum.PAID_CASH;
+    }
+    isOverdue() {
+        return this.isPending() && this.dateTo < new Date();
+    }
+    isUnpaid() {
+        return this.isPending() && this.dateTo >= new Date();
+    }
+    /**
+     * GST is not available for invoices without taxes
+     */
+    isNoTax() {
+        return this.taxType === SoleInvoiceTaxTypeEnum.NO_TAX;
+    }
+    /**
+     * GST amount is not included in items prices for invoices with tax exclusive,
+     * we should add GST amount additionaly to subtotal price to get total price
+     */
+    isTaxExclusive() {
+        return this.taxType === SoleInvoiceTaxTypeEnum.TAX_EXCLUSIVE;
+    }
+    /**
+     * GST amount already included in items prices for invoices with tax inclusive,
+     * we should subtract GST amount from total price to get subtotal price
+     */
+    isTaxInclusive() {
+        return this.taxType === SoleInvoiceTaxTypeEnum.TAX_INCLUSIVE;
+    }
+    getNumber() {
+        return String(this.number).padStart(SoleInvoice.NUMBER_LENGTH, '0');
+    }
+    get name() {
+        return `invoice-${this.getNumber()}.pdf`;
+    }
+    getTransactionsIds() {
+        return new Collection(this.items).mapBy('transaction.id');
+    }
+}
+__decorate([
+    Type(() => Date)
+], SoleInvoice.prototype, "dateFrom", void 0);
+__decorate([
+    Type(() => Date)
+], SoleInvoice.prototype, "dateTo", void 0);
+__decorate([
+    Type(() => User)
+], SoleInvoice.prototype, "user", void 0);
+__decorate([
+    Type(() => SoleBusiness)
+], SoleInvoice.prototype, "business", void 0);
+__decorate([
+    Type(() => SoleInvoiceItem)
+], SoleInvoice.prototype, "items", void 0);
+__decorate([
+    Type(() => SoleContact)
+], SoleInvoice.prototype, "payer", void 0);
+__decorate([
+    Type(() => BankAccount)
+], SoleInvoice.prototype, "bankAccount", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sole-invoice.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/models/sole/sole-invoice.ts"],"names":[],"mappings":"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","sourcesContent":["import {SoleInvoice as SoleInvoiceBase} from '../../db/Models/sole/sole-invoice';\nimport {User} from '../user';\nimport {SoleBusiness} from './sole-business';\nimport {SoleInvoiceItem} from './sole-invoice-item';\nimport {SoleContact} from './sole-contact';\nimport {Type} from 'class-transformer';\nimport {SoleInvoiceStatusesEnum} from '../../db/Enums/sole-invoice-statuses.enum';\nimport {BankAccount} from '../bank';\nimport {SoleInvoiceTaxTypeEnum} from '../../db/Enums/sole-invoice-tax-type.enum';\nimport {Collection, SoleInvoiceItemCollection} from '../../collections';\nimport {ChartAccounts} from '../chart-accounts';\nimport round from 'lodash/round';\n\nexport class SoleInvoice extends SoleInvoiceBase {\n  static NUMBER_LENGTH = 4;\n\n  @Type(() => Date)\n  dateFrom: Date;\n\n  @Type(() => Date)\n  dateTo: Date;\n\n  @Type(() => User)\n  user: User;\n\n  @Type(() => SoleBusiness)\n  business: SoleBusiness;\n\n  @Type(() => SoleInvoiceItem)\n  items: SoleInvoiceItem[];\n\n  @Type(() => SoleContact)\n  payer: SoleContact;\n\n  @Type(() => BankAccount)\n  bankAccount: BankAccount;\n\n  status: SoleInvoiceStatusesEnum = SoleInvoiceStatusesEnum.DRAFT;\n  taxType: SoleInvoiceTaxTypeEnum = SoleInvoiceTaxTypeEnum.NO_TAX;\n\n  /**\n   * Get items array as collection\n   */\n  get itemsCollection(): SoleInvoiceItemCollection {\n    return new SoleInvoiceItemCollection(this.items);\n  }\n\n  /**\n   * Total price of all items\n   */\n  private get price(): number {\n    return this.itemsCollection.sumBy('totalPrice');\n  }\n\n  /**\n   * Total invoice price without GST\n   */\n  get netPrice(): number {\n    if (this.isTaxInclusive()) {\n      return this.price - this.GSTAmount;\n    }\n\n    return this.price;\n  }\n\n  /**\n   * Total final price (net + GST)\n   */\n  get grossPrice(): number {\n    if (this.isTaxExclusive()) {\n      return this.price + this.GSTAmount;\n    }\n\n    return this.price;\n  }\n\n  /**\n   * Total GST amount\n   */\n  get GSTAmount(): number {\n    switch (this.taxType) {\n      case SoleInvoiceTaxTypeEnum.TAX_INCLUSIVE:\n        return this.inclusiveGSTAmount;\n      case SoleInvoiceTaxTypeEnum.TAX_EXCLUSIVE:\n        return this.exclusiveGSTAmount;\n      case SoleInvoiceTaxTypeEnum.NO_TAX:\n        return 0;\n    }\n  }\n\n  /**\n   * When tax inclusive, GST amount is included to total price\n   */\n  private get inclusiveGSTAmount(): number {\n    const gstPrice = this.itemsCollection.gstPrice;\n\n    return round(gstPrice - (gstPrice / (1 + ChartAccounts.GSTRatio)), 2);\n  }\n\n  /**\n   * When tax exclusive, GST amount should be added additionally to total price\n   */\n  private get exclusiveGSTAmount(): number {\n    return round(this.itemsCollection.gstPrice * ChartAccounts.GSTRatio, 2)\n  }\n\n  isDraft(): boolean {\n    return this.status === SoleInvoiceStatusesEnum.DRAFT;\n  }\n\n  isCancelled(): boolean {\n    return this.status === SoleInvoiceStatusesEnum.CANCELED;\n  }\n\n  isPending(): boolean {\n    return this.status === SoleInvoiceStatusesEnum.PENDING;\n  }\n\n  isPaid(): boolean {\n    return this.status === SoleInvoiceStatusesEnum.PAID;\n  }\n\n  isPaidCash(): boolean {\n    return this.status === SoleInvoiceStatusesEnum.PAID_CASH;\n  }\n\n  isOverdue(): boolean {\n    return this.isPending() && this.dateTo < new Date();\n  }\n\n  isUnpaid(): boolean {\n    return this.isPending() && this.dateTo >= new Date();\n  }\n\n  /**\n   * GST is not available for invoices without taxes\n   */\n  isNoTax(): boolean {\n    return this.taxType === SoleInvoiceTaxTypeEnum.NO_TAX;\n  }\n\n  /**\n   * GST amount is not included in items prices for invoices with tax exclusive,\n   * we should add GST amount additionaly to subtotal price to get total price\n   */\n  isTaxExclusive(): boolean {\n    return this.taxType === SoleInvoiceTaxTypeEnum.TAX_EXCLUSIVE;\n  }\n\n  /**\n   * GST amount already included in items prices for invoices with tax inclusive,\n   * we should subtract GST amount from total price to get subtotal price\n   */\n  isTaxInclusive(): boolean {\n    return this.taxType === SoleInvoiceTaxTypeEnum.TAX_INCLUSIVE;\n  }\n\n  getNumber(): string {\n    return String(this.number).padStart(SoleInvoice.NUMBER_LENGTH, '0');\n  }\n\n  get name(): string {\n    return `invoice-${this.getNumber()}.pdf`;\n  }\n\n  getTransactionsIds(): number[] {\n    return new Collection(this.items).mapBy('transaction.id');\n  }\n}\n"]}

package/esm2022/lib/models/tax-return/tax-return-item.mjs

@@ -0,0 +1,40 @@
+import { __decorate } from "tslib";
+import { Type } from 'class-transformer';
+import { TaxReturnItem as TaxReturnItemBase } from '../../db/Models';
+import { TaxReturnCategory } from './tax-return-category';
+import { TaxReturn } from './tax-return';
+import { TaxReturnItemEnum } from '../../db/Enums';
+export class TaxReturnItem extends TaxReturnItemBase {
+    // used for business schedule report, the order is important
+    static { this.BUSINESS_SCHEDULE_LIST = [
+        TaxReturnItemEnum.NO_ABN_GIVEN,
+        TaxReturnItemEnum.VOLUNTARY_AGREEMENT,
+        TaxReturnItemEnum.LABOUR_HIRE_OR_OTHER,
+        TaxReturnItemEnum.OTHER_BUSINESS_INCOME,
+        TaxReturnItemEnum.ASSESSABLE_GOVERNMENT_PAYMENTS,
+        TaxReturnItemEnum.PURCHASES_AND_OTHER_COSTS,
+        TaxReturnItemEnum.COMMISSION_EXPENSES,
+        TaxReturnItemEnum.SUPERANNUATION_EXPENSES,
+        TaxReturnItemEnum.BAD_DEBTS,
+        TaxReturnItemEnum.LEASE_EXPENSES,
+        TaxReturnItemEnum.RENT_EXPENSES,
+        TaxReturnItemEnum.INTEREST_EXPENSES_WITHIN_AUSTRALIA,
+        TaxReturnItemEnum.INTEREST_EXPENSES_OVERSEAS,
+        TaxReturnItemEnum.DEPRECIATION_EXPENSES,
+        TaxReturnItemEnum.MOTOR_VEHICLE_EXPENSES,
+        TaxReturnItemEnum.ALL_OTHER_EXPENSES
+    ]; }
+}
+__decorate([
+    Type(() => Date)
+], TaxReturnItem.prototype, "createdAt", void 0);
+__decorate([
+    Type(() => Date)
+], TaxReturnItem.prototype, "updatedAt", void 0);
+__decorate([
+    Type(() => TaxReturnCategory)
+], TaxReturnItem.prototype, "taxReturnCategory", void 0);
+__decorate([
+    Type(() => TaxReturn)
+], TaxReturnItem.prototype, "taxReturns", void 0);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/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/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: "16.2.12", ngImport: i0, type: AppCurrencyPipe, deps: null, target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: AppCurrencyPipe, isStandalone: true, name: "appCurrency" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AppCurrencyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'appCurrency',
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLWN1cnJlbmN5LnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvcGlwZXMvYXBwLWN1cnJlbmN5LnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7QUFDcEQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDOztBQUUvQzs7R0FFRztBQUtILE1BQU0sT0FBTyxlQUFnQixTQUFRLFlBQVk7SUFDL0MsU0FBUyxDQUFDLEtBQXNCLEVBQUUsWUFBcUIsRUFBRSxPQUFnRSxFQUFFLFVBQW1CLEVBQUUsTUFBZTtRQUM3SixzRkFBc0Y7UUFDdEYsVUFBVSxHQUFHLFVBQVUsSUFBSSxNQUFNLEdBQUcsQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxFQUFFLEtBQUssSUFBSSxDQUFDLENBQUMsQ0FBQztRQUVsRixPQUFPLEtBQUssQ0FBQyxTQUFTLENBQUMsS0FBSyxFQUFFLFlBQVksRUFBRSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQzNFLENBQUM7K0dBTlUsZUFBZTs2R0FBZixlQUFlOzs0RkFBZixlQUFlO2tCQUozQixJQUFJO21CQUFDO29CQUNKLElBQUksRUFBRSxhQUFhO29CQUNuQixVQUFVLEVBQUUsSUFBSTtpQkFDakIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDdXJyZW5jeVBpcGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuXG4vKipcbiAqIGV4dGVuZGVkIHZlcnNpb24gb2YgY3VycmVuY3kgcGlwZVxuICovXG5AUGlwZSh7XG4gIG5hbWU6ICdhcHBDdXJyZW5jeScsXG4gIHN0YW5kYWxvbmU6IHRydWUsXG59KVxuZXhwb3J0IGNsYXNzIEFwcEN1cnJlbmN5UGlwZSBleHRlbmRzIEN1cnJlbmN5UGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICB0cmFuc2Zvcm0odmFsdWU6IG51bWJlciB8IHN0cmluZywgY3VycmVuY3lDb2RlPzogc3RyaW5nLCBkaXNwbGF5PzogJ2NvZGUnIHwgJ3N5bWJvbCcgfCAnc3ltYm9sLW5hcnJvdycgfCBzdHJpbmcgfCBib29sZWFuLCBkaWdpdHNJbmZvPzogc3RyaW5nLCBsb2NhbGU/OiBzdHJpbmcpOiBhbnkge1xuICAgIC8vIDIgbm9uLXplcm8gZGVjaW1hbHMgYnkgZGVmYXVsdCAoNDMuNDMzNDQgPT4gNDMuNDMsIDAuMDAwMDExNDIwMTU1MzE1MSA9PiAkMC4wMDAwMTEpXG4gICAgZGlnaXRzSW5mbyA9IGRpZ2l0c0luZm8gPz8gJzEuMC0nICsgKHZhbHVlLnRvU3RyaW5nKCkubWF0Y2goL1sxLTldLyk/LmluZGV4IHx8IDIpO1xuXG4gICAgcmV0dXJuIHN1cGVyLnRyYW5zZm9ybSh2YWx1ZSwgY3VycmVuY3lDb2RlLCBkaXNwbGF5LCBkaWdpdHNJbmZvLCBsb2NhbGUpO1xuICB9XG59XG4iXX0=

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

@@ -0,0 +1,169 @@
+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 clone from 'lodash/clone';
+import { UserRolesEnum } from '../../db/Enums/user-roles.enum';
+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.get(),
+            this.employeeInviteService.get()
+        ]).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 = clone(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]))));
+        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: "16.2.12", 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: "16.2.12", ngImport: i0, type: AccountSetupService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccountSetupService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ 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 { ClientInvite, IncomeSource, Transaction, User } from '../../models';\nimport { AccountSetupItemCollection, ClientMovementCollection, IncomeSourceCollection, TransactionCollection } from '../../collections';\nimport { Observable, combineLatest, of } from 'rxjs';\nimport { map, mergeMap } from 'rxjs/operators';\nimport intersection from 'lodash/intersection';\nimport clone from 'lodash/clone';\nimport { UserRolesEnum } from '../../db/Enums/user-roles.enum';\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.get(),\n          this.employeeInviteService.get()\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 = clone(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, ClientInvite[]]) => [...movements.toArray(), ...invites])\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/lib/services/affiliate/rewardful/rewardful.service.mjs

@@ -0,0 +1,34 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Service to work with Rewardful (affiliate program) API
+ * https://developers.rewardful.com/javascript-api/overview#executing-code-when-rewardful-loads
+ */
+export class RewardfulService {
+    constructor(environment) {
+        this.environment = environment;
+    }
+    getReferralCode() {
+        return new Observable((observer) => {
+            if (!this.environment.rewardfulId) {
+                return observer.next(null);
+            }
+            window['rewardful']('ready', () => {
+                observer.next(window['Rewardful'].referral);
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RewardfulService, deps: [{ token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RewardfulService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RewardfulService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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