taxtank-core 0.0.2 → 0.0.3

package/esm2015/lib/collections/abstract.collection.js

@@ -0,0 +1,67 @@
+import { CollectionDictionary } from './collection-dictionary';
+import first from 'lodash/first';
+import last from 'lodash/last';
+/**
+ * collection abstract class. Contains common properties and methods for all collections
+ */
+export class AbstractCollection {
+    constructor(items = []) {
+        this.items = items;
+    }
+    groupBy(prop) {
+        return new CollectionDictionary(this, prop);
+    }
+    /**
+     * Iterator that allow to iterate collection items
+     */
+    [Symbol.iterator]() {
+        // .values() returns Iterator instance for array
+        return this.items.values();
+    }
+    /**
+     * get collection length
+     */
+    get length() {
+        return this.items.length;
+    }
+    /**
+     * method returns amount of fields from passed items
+     * @param field Name of field for calculation
+     * @param items (optional) Array of items need to be calculated. All collection's items by default
+     */
+    getSummary(field, items = this.toArray()) {
+        return items.reduce((sum, item) => sum += item[field], 0);
+    }
+    /**
+     * Get list of items ids
+     */
+    getIds() {
+        return this.items.map((item) => item['id']);
+    }
+    /**
+     * Get single item by id
+     */
+    getById(id) {
+        return this.items.find((item) => item['id'] === id);
+    }
+    getByIds(ids) {
+        return this.items.filter((item) => ids.includes(item['id']));
+    }
+    /**
+     * Get total sum of items by field
+     * @param field Name of the field for sum
+     */
+    sumBy(field) {
+        return +this.items.reduce((sum, item) => sum + Number(item[field]), 0).toFixed(2);
+    }
+    toArray() {
+        return [...this.items];
+    }
+    get first() {
+        return first(this.items);
+    }
+    get last() {
+        return last(this.items);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QuY29sbGVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9jb2xsZWN0aW9ucy9hYnN0cmFjdC5jb2xsZWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQy9ELE9BQU8sS0FBSyxNQUFNLGNBQWMsQ0FBQztBQUNqQyxPQUFPLElBQUksTUFBTSxhQUFhLENBQUM7QUFFL0I7O0dBRUc7QUFDSCxNQUFNLE9BQWdCLGtCQUFrQjtJQUl0QyxZQUNFLFFBQWlCLEVBQUU7UUFFbkIsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7SUFDckIsQ0FBQztJQUVELE9BQU8sQ0FBQyxJQUFZO1FBQ2xCLE9BQU8sSUFBSSxvQkFBb0IsQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDOUMsQ0FBQztJQUVEOztPQUVHO0lBQ0gsQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDO1FBQ2YsZ0RBQWdEO1FBQ2hELE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLEVBQUUsQ0FBQztJQUM3QixDQUFDO0lBRUQ7O09BRUc7SUFDSCxJQUFJLE1BQU07UUFDUixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDO0lBQzNCLENBQUM7SUFFRDs7OztPQUlHO0lBQ08sVUFBVSxDQUFDLEtBQWEsRUFBRSxRQUFpQixJQUFJLENBQUMsT0FBTyxFQUFFO1FBQ2pFLE9BQU8sS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQVcsRUFBRSxJQUFXLEVBQUUsRUFBRSxDQUFDLEdBQUcsSUFBSSxJQUFJLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFDM0UsQ0FBQztJQUVEOztPQUVHO0lBQ0gsTUFBTTtRQUNKLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFXLEVBQVUsRUFBRSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQzdELENBQUM7SUFFRDs7T0FFRztJQUNILE9BQU8sQ0FBQyxFQUFVO1FBQ2hCLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxJQUFXLEVBQVcsRUFBRSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQztJQUN0RSxDQUFDO0lBRUQsUUFBUSxDQUFDLEdBQWE7UUFDcEIsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQVcsRUFBVyxFQUFFLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQy9FLENBQUM7SUFFRDs7O09BR0c7SUFDSCxLQUFLLENBQUMsS0FBYTtRQUNqQixPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQyxHQUFXLEVBQUUsSUFBVyxFQUFVLEVBQUUsQ0FBQyxHQUFHLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUMzRyxDQUFDO0lBRUQsT0FBTztRQUNMLE9BQU8sQ0FBQyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUN6QixDQUFDO0lBRUQsSUFBSSxLQUFLO1FBQ1AsT0FBTyxLQUFLLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzNCLENBQUM7SUFFRCxJQUFJLElBQUk7UUFDTixPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDMUIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29sbGVjdGlvbkRpY3Rpb25hcnkgfSBmcm9tICcuL2NvbGxlY3Rpb24tZGljdGlvbmFyeSc7XHJcbmltcG9ydCBmaXJzdCBmcm9tICdsb2Rhc2gvZmlyc3QnO1xyXG5pbXBvcnQgbGFzdCBmcm9tICdsb2Rhc2gvbGFzdCc7XHJcblxyXG4vKipcclxuICogY29sbGVjdGlvbiBhYnN0cmFjdCBjbGFzcy4gQ29udGFpbnMgY29tbW9uIHByb3BlcnRpZXMgYW5kIG1ldGhvZHMgZm9yIGFsbCBjb2xsZWN0aW9uc1xyXG4gKi9cclxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEFic3RyYWN0Q29sbGVjdGlvbjxNb2RlbCBleHRlbmRzIG9iamVjdD4gaW1wbGVtZW50cyBJdGVyYWJsZTxNb2RlbD4ge1xyXG4gIC8vIGxpc3Qgb2YgY29sbGVjdGlvbidzIGl0ZW1zXHJcbiAgaXRlbXM6IE1vZGVsW107XHJcblxyXG4gIGNvbnN0cnVjdG9yKFxyXG4gICAgaXRlbXM6IE1vZGVsW10gPSBbXVxyXG4gICkge1xyXG4gICAgdGhpcy5pdGVtcyA9IGl0ZW1zO1xyXG4gIH1cclxuXHJcbiAgZ3JvdXBCeShwcm9wOiBzdHJpbmcpOiBDb2xsZWN0aW9uRGljdGlvbmFyeTxBYnN0cmFjdENvbGxlY3Rpb248TW9kZWw+PiB7XHJcbiAgICByZXR1cm4gbmV3IENvbGxlY3Rpb25EaWN0aW9uYXJ5KHRoaXMsIHByb3ApO1xyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogSXRlcmF0b3IgdGhhdCBhbGxvdyB0byBpdGVyYXRlIGNvbGxlY3Rpb24gaXRlbXNcclxuICAgKi9cclxuICBbU3ltYm9sLml0ZXJhdG9yXSgpOiBJdGVyYXRvcjxNb2RlbD4ge1xyXG4gICAgLy8gLnZhbHVlcygpIHJldHVybnMgSXRlcmF0b3IgaW5zdGFuY2UgZm9yIGFycmF5XHJcbiAgICByZXR1cm4gdGhpcy5pdGVtcy52YWx1ZXMoKTtcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIGdldCBjb2xsZWN0aW9uIGxlbmd0aFxyXG4gICAqL1xyXG4gIGdldCBsZW5ndGgoKTogbnVtYmVyIHtcclxuICAgIHJldHVybiB0aGlzLml0ZW1zLmxlbmd0aDtcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIG1ldGhvZCByZXR1cm5zIGFtb3VudCBvZiBmaWVsZHMgZnJvbSBwYXNzZWQgaXRlbXNcclxuICAgKiBAcGFyYW0gZmllbGQgTmFtZSBvZiBmaWVsZCBmb3IgY2FsY3VsYXRpb25cclxuICAgKiBAcGFyYW0gaXRlbXMgKG9wdGlvbmFsKSBBcnJheSBvZiBpdGVtcyBuZWVkIHRvIGJlIGNhbGN1bGF0ZWQuIEFsbCBjb2xsZWN0aW9uJ3MgaXRlbXMgYnkgZGVmYXVsdFxyXG4gICAqL1xyXG4gIHByb3RlY3RlZCBnZXRTdW1tYXJ5KGZpZWxkOiBzdHJpbmcsIGl0ZW1zOiBNb2RlbFtdID0gdGhpcy50b0FycmF5KCkpOiBudW1iZXIge1xyXG4gICAgcmV0dXJuIGl0ZW1zLnJlZHVjZSgoc3VtOiBudW1iZXIsIGl0ZW06IE1vZGVsKSA9PiBzdW0gKz0gaXRlbVtmaWVsZF0sIDApO1xyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogR2V0IGxpc3Qgb2YgaXRlbXMgaWRzXHJcbiAgICovXHJcbiAgZ2V0SWRzKCk6IG51bWJlcltdIHtcclxuICAgIHJldHVybiB0aGlzLml0ZW1zLm1hcCgoaXRlbTogTW9kZWwpOiBudW1iZXIgPT4gaXRlbVsnaWQnXSk7XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBHZXQgc2luZ2xlIGl0ZW0gYnkgaWRcclxuICAgKi9cclxuICBnZXRCeUlkKGlkOiBudW1iZXIpOiBNb2RlbCB7XHJcbiAgICByZXR1cm4gdGhpcy5pdGVtcy5maW5kKChpdGVtOiBNb2RlbCk6IGJvb2xlYW4gPT4gaXRlbVsnaWQnXSA9PT0gaWQpO1xyXG4gIH1cclxuXHJcbiAgZ2V0QnlJZHMoaWRzOiBudW1iZXJbXSk6IE1vZGVsW10ge1xyXG4gICAgcmV0dXJuIHRoaXMuaXRlbXMuZmlsdGVyKChpdGVtOiBNb2RlbCk6IGJvb2xlYW4gPT4gaWRzLmluY2x1ZGVzKGl0ZW1bJ2lkJ10pKTtcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIEdldCB0b3RhbCBzdW0gb2YgaXRlbXMgYnkgZmllbGRcclxuICAgKiBAcGFyYW0gZmllbGQgTmFtZSBvZiB0aGUgZmllbGQgZm9yIHN1bVxyXG4gICAqL1xyXG4gIHN1bUJ5KGZpZWxkOiBzdHJpbmcpOiBudW1iZXIge1xyXG4gICAgcmV0dXJuICt0aGlzLml0ZW1zLnJlZHVjZSgoc3VtOiBudW1iZXIsIGl0ZW06IE1vZGVsKTogbnVtYmVyID0+IHN1bSArIE51bWJlcihpdGVtW2ZpZWxkXSksIDApLnRvRml4ZWQoMik7XHJcbiAgfVxyXG5cclxuICB0b0FycmF5KCk6IE1vZGVsW10ge1xyXG4gICAgcmV0dXJuIFsuLi50aGlzLml0ZW1zXTtcclxuICB9XHJcblxyXG4gIGdldCBmaXJzdCgpOiBNb2RlbCB7XHJcbiAgICByZXR1cm4gZmlyc3QodGhpcy5pdGVtcyk7XHJcbiAgfVxyXG5cclxuICBnZXQgbGFzdCgpOiBNb2RlbCB7XHJcbiAgICByZXR1cm4gbGFzdCh0aGlzLml0ZW1zKTtcclxuICB9XHJcbn1cclxuIl19

package/esm2015/lib/collections/bank-account.collection.js

@@ -0,0 +1,135 @@
+import { AbstractCollection } from './abstract.collection';
+import flatten from 'lodash/flatten';
+import uniqBy from 'lodash/uniqBy';
+import concat from 'lodash/concat';
+import { TYPE_LOAN } from '../models/bank/type-loan.const';
+/**
+ * Collection of bank accounts.
+ */
+export class BankAccountCollection extends AbstractCollection {
+    /**
+     * get list of bank accounts with passed types
+     */
+    getByType(types, isExclude = false) {
+        // get types always as array (if only one passed)
+        const typesArray = concat(types);
+        return this.items.filter((bankAccount) => {
+            if (isExclude) {
+                return !typesArray.includes(bankAccount.type);
+            }
+            return typesArray.includes(bankAccount.type);
+        });
+    }
+    /**
+     * get amount of initial loans
+     */
+    getInitialLoanAmount() {
+        return this.getByType(TYPE_LOAN)
+            .reduce((sum, bankAccount) => {
+            return sum += bankAccount.balances.length ? bankAccount.getOpeningBalance() : 0;
+        }, 0);
+    }
+    /**
+     * get amount of current loans
+     */
+    getCurrentLoanAmount() {
+        return this.getByType(TYPE_LOAN)
+            .reduce((sum, bankAccount) => {
+            return sum += bankAccount.currentBalance;
+        }, 0);
+    }
+    /**
+     * get collection filtered by property id
+     */
+    getByPropertyId(id) {
+        return new BankAccountCollection(this.items.filter((bankAccount) => {
+            return bankAccount.bankAccountProperties.find((bankAccountProperty) => {
+                return bankAccountProperty.property.id === id;
+            });
+        }));
+    }
+    /**
+     * get collection filtered by properties ids
+     */
+    getByPropertiesIds(ids) {
+        return new BankAccountCollection(this.items.filter((bankAccount) => {
+            return bankAccount.bankAccountProperties.find((bankAccountProperty) => {
+                return ids.includes(bankAccountProperty.property.id);
+            });
+        }));
+    }
+    /**
+     * get collection of active bank accounts
+     */
+    getActiveBankAccounts() {
+        return new BankAccountCollection(this.items.filter((bankAccount) => {
+            return bankAccount.isActive();
+        }));
+    }
+    /**
+     * get reduction of loan (reduction of principle) percentage
+     */
+    getPrincipleReductionPercent() {
+        const initialLoans = this.getInitialLoanAmount();
+        const currentLoans = this.getCurrentLoanAmount();
+        if (!initialLoans) {
+            return 0;
+        }
+        return (initialLoans - currentLoans) / initialLoans * 100;
+    }
+    /**
+     * Get collection of loan bank accounts
+     */
+    getLoanAccounts() {
+        return new BankAccountCollection(this.getByType(TYPE_LOAN));
+    }
+    getSavingsAccounts() {
+        return new BankAccountCollection(this.getByType(TYPE_LOAN, true));
+    }
+    getOpeningBalance() {
+        return this.items.reduce((sum, bankAccount) => sum + bankAccount.getOpeningBalance(), 0);
+    }
+    get currentBalance() {
+        return this.sumBy('currentBalance');
+    }
+    /**
+     * Get Collection of bank accounts with property tank type
+     */
+    getPropertyBankAccounts() {
+        return new BankAccountCollection(this.items.filter((bankAccount) => bankAccount.isPropertyTank()));
+    }
+    /**
+     * Get Collection of bank accounts with work tank type
+     */
+    getWorkBankAccounts() {
+        return new BankAccountCollection(this.items.filter((bankAccount) => bankAccount.isWorkTank()));
+    }
+    /**
+     * Get Collection of bank accounts by tank type
+     */
+    getByTankType(tankType) {
+        return new BankAccountCollection(this.items.filter((bankAccount) => bankAccount.tankType === tankType));
+    }
+    /**
+     * Get list of all bank account properties
+     */
+    getBankAccountPropertiesList() {
+        return flatten(this.items.map((bankAccount) => {
+            return bankAccount.bankAccountProperties;
+        }));
+    }
+    /**
+     * Get lis of unique properties from all bank accounts properties
+     */
+    getProperties() {
+        return uniqBy(this.getBankAccountPropertiesList().map((bankAccountProperty) => {
+            return bankAccountProperty.property;
+        }), 'id');
+    }
+    getPropertyBalanceAmount(propertyId) {
+        return this.items.reduce((sum, bankAccount) => {
+            return sum + bankAccount.getPropertyBalanceAmount(propertyId);
+        }, 0);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bank-account.collection.js","sourceRoot":"","sources":["../../../../../projects/tt-core/src/lib/collections/bank-account.collection.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractCollection } from './abstract.collection';\nimport { BankAccountTypeEnum } from '../db/Enums/bank-account-type.enum';\nimport { TankTypeEnum } from '../db/Enums/tank-type.enum';\nimport { BankAccount } from '../models/bank/bank-account';\nimport { BankAccountProperty } from '../models/bank/bank-account-property';\nimport { Property } from '../models/property/property';\nimport flatten from 'lodash/flatten';\nimport uniqBy from 'lodash/uniqBy';\nimport concat from 'lodash/concat';\nimport { TYPE_LOAN } from '../models/bank/type-loan.const';\n\n/**\n * Collection of bank accounts.\n */\nexport class BankAccountCollection extends AbstractCollection<BankAccount> {\n  /**\n   * get list of bank accounts with passed types\n   */\n  getByType(types: BankAccountTypeEnum | BankAccountTypeEnum[], isExclude: boolean = false): BankAccount[] {\n    // get types always as array (if only one passed)\n    const typesArray: BankAccountTypeEnum[] = concat(types);\n    return this.items.filter((bankAccount: BankAccount) => {\n      if (isExclude) {\n        return !typesArray.includes(bankAccount.type);\n      }\n      return typesArray.includes(bankAccount.type);\n    });\n  }\n\n  /**\n   * get amount of initial loans\n   */\n  getInitialLoanAmount(): number {\n    return this.getByType(TYPE_LOAN)\n      .reduce((sum: number, bankAccount: BankAccount) => {\n        return sum += bankAccount.balances.length ? bankAccount.getOpeningBalance() : 0;\n      }, 0);\n  }\n\n  /**\n   * get amount of current loans\n   */\n  getCurrentLoanAmount(): number {\n    return this.getByType(TYPE_LOAN)\n      .reduce((sum: number, bankAccount: BankAccount) => {\n        return sum += bankAccount.currentBalance;\n      }, 0);\n  }\n\n  /**\n   * get collection filtered by property id\n   */\n  getByPropertyId(id: number): BankAccountCollection {\n    return new BankAccountCollection(this.items.filter((bankAccount: BankAccount) => {\n      return bankAccount.bankAccountProperties.find((bankAccountProperty: BankAccountProperty) => {\n        return bankAccountProperty.property.id === id;\n      });\n    }));\n  }\n\n  /**\n   * get collection filtered by properties ids\n   */\n  getByPropertiesIds(ids: number[]): BankAccountCollection {\n    return new BankAccountCollection(\n      this.items.filter((bankAccount: BankAccount) => {\n        return bankAccount.bankAccountProperties.find((bankAccountProperty: BankAccountProperty) => {\n          return ids.includes(bankAccountProperty.property.id);\n        });\n      })\n    );\n  }\n\n  /**\n   * get collection of active bank accounts\n   */\n  getActiveBankAccounts(): BankAccountCollection {\n    return new BankAccountCollection(this.items.filter((bankAccount: BankAccount) => {\n      return bankAccount.isActive();\n    }));\n  }\n\n  /**\n   * get reduction of loan (reduction of principle) percentage\n   */\n  getPrincipleReductionPercent(): number {\n    const initialLoans: number = this.getInitialLoanAmount();\n    const currentLoans: number = this.getCurrentLoanAmount();\n\n    if (!initialLoans) {\n      return 0;\n    }\n\n    return (initialLoans - currentLoans) / initialLoans * 100;\n  }\n\n  /**\n   * Get collection of loan bank accounts\n   */\n  getLoanAccounts(): BankAccountCollection {\n    return new BankAccountCollection(this.getByType(TYPE_LOAN));\n  }\n\n  getSavingsAccounts(): BankAccountCollection {\n    return new BankAccountCollection(this.getByType(TYPE_LOAN, true));\n  }\n\n  getOpeningBalance(): number {\n    return this.items.reduce((sum: number, bankAccount: BankAccount): number => sum + bankAccount.getOpeningBalance(), 0);\n  }\n\n  get currentBalance(): number {\n    return this.sumBy('currentBalance');\n  }\n\n  /**\n   * Get Collection of bank accounts with property tank type\n   */\n  getPropertyBankAccounts(): BankAccountCollection {\n    return new BankAccountCollection(\n      this.items.filter((bankAccount: BankAccount): boolean => bankAccount.isPropertyTank())\n    );\n  }\n\n  /**\n   * Get Collection of bank accounts with work tank type\n   */\n  getWorkBankAccounts(): BankAccountCollection {\n    return new BankAccountCollection(\n      this.items.filter((bankAccount: BankAccount): boolean => bankAccount.isWorkTank())\n    );\n  }\n\n  /**\n   * Get Collection of bank accounts by tank type\n   */\n  getByTankType(tankType: TankTypeEnum): BankAccountCollection {\n    return new BankAccountCollection(\n      this.items.filter((bankAccount: BankAccount): boolean => bankAccount.tankType === tankType)\n    );\n  }\n\n  /**\n   * Get list of all bank account properties\n   */\n  getBankAccountPropertiesList(): BankAccountProperty[] {\n    return flatten(\n      this.items.map((bankAccount: BankAccount): BankAccountProperty[] => {\n        return bankAccount.bankAccountProperties;\n      })\n    );\n  }\n\n  /**\n   * Get lis of unique properties from all bank accounts properties\n   */\n  getProperties(): Property[] {\n    return uniqBy(\n      this.getBankAccountPropertiesList().map((bankAccountProperty: BankAccountProperty) => {\n        return bankAccountProperty.property;\n      }),\n      'id'\n    );\n  }\n\n  getPropertyBalanceAmount(propertyId: number): number {\n    return this.items.reduce((sum: number, bankAccount: BankAccount): number => {\n      return sum + bankAccount.getPropertyBalanceAmount(propertyId);\n    }, 0);\n  }\n}\n"]}

package/esm2015/lib/collections/bank-transaction.collection.js

@@ -0,0 +1,119 @@
+import { TransactionOperationEnum } from '../db/Enums/transaction-operation.enum';
+import { AbstractCollection } from './abstract.collection';
+import { CollectionDictionary } from './collection-dictionary';
+/**
+ * Maximal delay between transfer transactions
+ */
+const TRANSACTION_TRANSFER_DELAY = 96 * 3600 * 1000;
+/**
+ * Collection of bank transactions.
+ * IMPORTANT: Create this collection based on bank transactions from TransactionAllocationService
+ * @TODO find way to accept interface with allocation instead of bankTransaction to prevent wrong usage
+ * because all amounts calculates with allocated amounts but not from bank transactions amounts.
+ */
+export class BankTransactionCollection extends AbstractCollection {
+    getAmount() {
+        return this.sumBy('amount');
+    }
+    /**
+     * Difference between total bank transactions amount and sum of allocations for passed bank transactions
+     */
+    getUnallocatedAmount(allocations) {
+        return +(this.getAmount() - allocations.getByBankTransactionsIds(this.getIds()).amount).toFixed(2);
+    }
+    /**
+     * get date of the last transaction
+     */
+    getLastTransactionDate() {
+        return new Date(Math.max.apply(Math, this.items.map((bankTransaction) => bankTransaction.date)));
+    }
+    /**
+     * get list of credit transactions
+     */
+    get creditTransactions() {
+        return new BankTransactionCollection(this.items.filter((bankTransaction) => bankTransaction.isCredit()));
+    }
+    /**
+     * get list of debit transactions
+     */
+    get debitTransactions() {
+        return new BankTransactionCollection(this.items.filter((bankTransaction) => bankTransaction.isDebit()));
+    }
+    /**
+     * get difference between debit and credit transactions amounts
+     */
+    get balanceAmount() {
+        return this.items.reduce((sum, bankTransaction) => sum + bankTransaction.balanceAmount, 0);
+    }
+    /**
+     * get list of transactions for passed month
+     * @param monthIndex Month number from 0 to 11
+     */
+    getTransactionsByMonth(monthIndex) {
+        return new BankTransactionCollection(this.items.filter((bankTransaction) => bankTransaction.date.getMonth() === monthIndex));
+    }
+    /**
+     * get list of transactions by provided bank accounts
+     * @param bankAccounts by which transactions should be returned
+     */
+    getByBankAccounts(bankAccounts) {
+        const bankAccountIds = bankAccounts.map((bankAccount) => bankAccount.id);
+        return this.items.filter((bankTransaction) => bankAccountIds.includes(bankTransaction.bankAccount.id));
+    }
+    /**
+     * get list of transactions by provided ids of bank accounts
+     * @param ids of bank accounts
+     */
+    getByBankAccountsIds(ids) {
+        return new BankTransactionCollection(this.items.filter((bankTransaction) => ids.includes(bankTransaction.bankAccount.id)));
+    }
+    /**
+     * Find Bank Transaction available for transfer
+     */
+    findTransfer(bankTransaction) {
+        return this.items.find((item) => {
+            return item.amount + bankTransaction.amount === 0 &&
+                Math.abs(bankTransaction.date.getTime() - item.date.getTime()) < TRANSACTION_TRANSFER_DELAY;
+        });
+    }
+    /**
+     * Group bank transactions by transaction id.
+     * Each group is bank transaction collection and contains bank transactions related to transactions via allocations
+     */
+    groupByTransaction(allocations) {
+        // Group allocations by transaction id
+        const allocationsByTransactions = new CollectionDictionary(allocations, 'transaction');
+        // Init an empty dictionary we will fill below
+        const bankTransactionsByTransactions = new CollectionDictionary(new BankTransactionCollection([]));
+        // Fill dictionary with the same keys as at allocationsByTransactions
+        allocationsByTransactions.keys.forEach((key) => {
+            bankTransactionsByTransactions.add(key, this.getByAllocations(allocationsByTransactions.get(key)));
+        });
+        return bankTransactionsByTransactions;
+    }
+    /**
+     * Get collection of bank transactions related with passed allocations
+     */
+    getByAllocations(allocations) {
+        return new BankTransactionCollection(this.items.filter((bankTransaction) => allocations.hasBankTransaction(bankTransaction)));
+    }
+    /**
+     * Set allocate operation for bank transactions with amounts equal to salary
+     */
+    preselectAllocateOperationForSalary(salaryIncomeSources) {
+        // incomeSource.salaryForecasts[0] because each income source has only one forecast for current fin year
+        const salaryAmounts = salaryIncomeSources.map((incomeSource) => { var _a; return ((_a = incomeSource.salaryForecasts[0]) === null || _a === void 0 ? void 0 : _a.netPay) || 0; });
+        this.items.forEach((bankTransaction) => {
+            if (salaryAmounts.includes(bankTransaction.amount)) {
+                bankTransaction.operation = TransactionOperationEnum.ALLOCATE;
+            }
+        });
+    }
+    /**
+     * Get collection of unallocated bankTransactions
+     */
+    getUnallocatedBankTransactions(allocations) {
+        return new BankTransactionCollection(this.items.filter((bankTransaction) => !bankTransaction.isAllocated(allocations)));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bank-transaction.collection.js","sourceRoot":"","sources":["../../../../../projects/tt-core/src/lib/collections/bank-transaction.collection.ts"],"names":[],"mappings":"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","sourcesContent":["import { TransactionOperationEnum } from '../db/Enums/transaction-operation.enum';\nimport { BankTransaction } from '../models/bank/bank-transaction';\nimport { MonthNumberEnum } from '../models/financial-year/month-number.enum';\nimport { IncomeSource } from '../models/income-source/income-source';\nimport { BankAccount } from '../models/bank/bank-account';\nimport { AbstractCollection } from './abstract.collection';\nimport { CollectionDictionary } from './collection-dictionary';\nimport { TransactionAllocationCollection } from './transaction-allocation.collection';\n\n/**\n * Maximal delay between transfer transactions\n */\nconst TRANSACTION_TRANSFER_DELAY: number = 96 * 3600 * 1000;\n\n/**\n * Collection of bank transactions.\n * IMPORTANT: Create this collection based on bank transactions from TransactionAllocationService\n * @TODO find way to accept interface with allocation instead of bankTransaction to prevent wrong usage\n * because all amounts calculates with allocated amounts but not from bank transactions amounts.\n */\nexport class BankTransactionCollection extends AbstractCollection<BankTransaction> {\n  getAmount(): number {\n    return this.sumBy('amount');\n  }\n\n  /**\n   * Difference between total bank transactions amount and sum of allocations for passed bank transactions\n   */\n  getUnallocatedAmount(allocations: TransactionAllocationCollection) {\n    return +(this.getAmount() - allocations.getByBankTransactionsIds(this.getIds()).amount).toFixed(2);\n  }\n\n  /**\n   * get date of the last transaction\n   */\n  getLastTransactionDate(): Date {\n    return new Date(Math.max.apply(Math, this.items.map((bankTransaction: BankTransaction) => bankTransaction.date)));\n  }\n\n  /**\n   * get list of credit transactions\n   */\n  get creditTransactions(): BankTransactionCollection {\n    return new BankTransactionCollection(\n      this.items.filter((bankTransaction: BankTransaction) => bankTransaction.isCredit())\n    );\n  }\n\n  /**\n   * get list of debit transactions\n   */\n  get debitTransactions(): BankTransactionCollection {\n    return new BankTransactionCollection(\n      this.items.filter((bankTransaction: BankTransaction) => bankTransaction.isDebit())\n    );\n  }\n\n  /**\n   * get difference between debit and credit transactions amounts\n   */\n  get balanceAmount(): number {\n    return this.items.reduce((sum: number, bankTransaction: BankTransaction) => sum + bankTransaction.balanceAmount, 0);\n  }\n\n  /**\n   * get list of transactions for passed month\n   * @param monthIndex Month number from 0 to 11\n   */\n  getTransactionsByMonth(monthIndex: MonthNumberEnum): BankTransactionCollection {\n    return new BankTransactionCollection(\n      this.items.filter((bankTransaction: BankTransaction) => bankTransaction.date.getMonth() === monthIndex)\n    );\n  }\n\n  /**\n   * get list of transactions by provided bank accounts\n   * @param bankAccounts by which transactions should be returned\n   */\n  getByBankAccounts(bankAccounts: BankAccount[]): BankTransaction[] {\n    const bankAccountIds: number[] = bankAccounts.map((bankAccount: BankAccount) => bankAccount.id);\n    return this.items.filter((bankTransaction: BankTransaction) => bankAccountIds.includes(bankTransaction.bankAccount.id));\n  }\n\n  /**\n   * get list of transactions by provided ids of bank accounts\n   * @param ids of bank accounts\n   */\n  getByBankAccountsIds(ids: number[]): BankTransactionCollection {\n    return new BankTransactionCollection(\n      this.items.filter((bankTransaction: BankTransaction) => ids.includes(bankTransaction.bankAccount.id))\n    );\n  }\n\n  /**\n   * Find Bank Transaction available for transfer\n   */\n  findTransfer(bankTransaction: BankTransaction): BankTransaction {\n    return this.items.find((item: BankTransaction): boolean => {\n      return item.amount + bankTransaction.amount === 0 &&\n        Math.abs(bankTransaction.date.getTime() - item.date.getTime()) < TRANSACTION_TRANSFER_DELAY;\n    });\n  }\n\n  /**\n   * Group bank transactions by transaction id.\n   * Each group is bank transaction collection and contains bank transactions related to transactions via allocations\n   */\n  groupByTransaction(allocations: TransactionAllocationCollection): CollectionDictionary<BankTransactionCollection> {\n    // Group allocations by transaction id\n    const allocationsByTransactions = new CollectionDictionary(allocations, 'transaction');\n    // Init an empty dictionary we will fill below\n    const bankTransactionsByTransactions: CollectionDictionary<BankTransactionCollection> = new CollectionDictionary(new BankTransactionCollection([]));\n\n    // Fill dictionary with the same keys as at allocationsByTransactions\n    allocationsByTransactions.keys.forEach((key: string): void => {\n      bankTransactionsByTransactions.add(key, this.getByAllocations(allocationsByTransactions.get(key)));\n    });\n\n    return bankTransactionsByTransactions;\n  }\n\n  /**\n   * Get collection of bank transactions related with passed allocations\n   */\n  getByAllocations(allocations: TransactionAllocationCollection): BankTransactionCollection {\n    return new BankTransactionCollection(\n      this.items.filter((bankTransaction: BankTransaction): boolean => allocations.hasBankTransaction(bankTransaction))\n    );\n  }\n\n  /**\n   * Set allocate operation for bank transactions with amounts equal to salary\n   */\n  preselectAllocateOperationForSalary(salaryIncomeSources: IncomeSource[]): void {\n    // incomeSource.salaryForecasts[0] because each income source has only one forecast for current fin year\n    const salaryAmounts: number[] = salaryIncomeSources.map((incomeSource: IncomeSource): number => incomeSource.salaryForecasts[0]?.netPay || 0);\n\n    this.items.forEach((bankTransaction: BankTransaction): void => {\n      if (salaryAmounts.includes(bankTransaction.amount)) {\n        bankTransaction.operation = TransactionOperationEnum.ALLOCATE;\n      }\n    });\n  }\n\n  /**\n   * Get collection of unallocated bankTransactions\n   */\n  getUnallocatedBankTransactions(allocations: TransactionAllocationCollection): BankTransactionCollection {\n    return new BankTransactionCollection(\n      this.items.filter((bankTransaction: BankTransaction): boolean => !bankTransaction.isAllocated(allocations))\n    );\n  }\n}\n"]}

package/esm2015/lib/collections/client-movement.collection.js

@@ -0,0 +1,31 @@
+import { AbstractCollection } from './abstract.collection';
+import { EmployeeCollection } from './employee.collection';
+import { FirmTypeEnum } from '../db/Enums/firm-type.enum';
+/**
+ * Collection of tax review
+ */
+export class ClientMovementCollection extends AbstractCollection {
+    get active() {
+        return new ClientMovementCollection(this.items.filter((clientMovement) => !clientMovement.dateTo));
+    }
+    get employees() {
+        return new EmployeeCollection(this.items.map((clientMovement) => clientMovement.employee));
+    }
+    get clients() {
+        return new EmployeeCollection(this.items.map((clientMovement) => clientMovement.client));
+    }
+    get accountant() {
+        var _a;
+        return (_a = this.items.filter((clientMovement) => clientMovement.firm.type === FirmTypeEnum.ACCOUNTANT)[0]) !== null && _a !== void 0 ? _a : null;
+    }
+    get advisors() {
+        return new ClientMovementCollection(this.items.filter((clientMovement) => clientMovement.firm.type === FirmTypeEnum.ADVISOR));
+    }
+    getByEmployeeId(id) {
+        return new ClientMovementCollection(this.items.filter((clientMovement) => clientMovement.employee.id === id));
+    }
+    getByFirmType(firmType) {
+        return new ClientMovementCollection(this.items.filter((clientMovement) => clientMovement.firm.type === firmType));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/collections/client-portfolio-report.collection.js

@@ -0,0 +1,40 @@
+/**
+ * Collection of employee clients tax summary information
+ */
+import { AbstractCollection } from './abstract.collection';
+export class ClientPortfolioReportCollection extends AbstractCollection {
+    get marketValue() {
+        return this.sumBy('marketValue');
+    }
+    get loanBalance() {
+        return this.sumBy('loanBalance');
+    }
+    get equityPosition() {
+        return this.sumBy('equityPosition');
+    }
+    /**
+     * Get average market value if there are more than 1 item in the collection
+     */
+    get averageMarketValue() {
+        return this.items.length > 1 ? this.marketValue / this.items.length : null;
+    }
+    /**
+     * Get average loan balance if there are more than 1 item in the collection
+     */
+    get averageLoanBalance() {
+        return this.items.length > 1 ? this.loanBalance / this.items.length : null;
+    }
+    /**
+     * Get average equity position if there are more than 1 item in the collection
+     */
+    get averageEquityPosition() {
+        return this.items.length > 1 ? this.equityPosition / this.items.length : null;
+    }
+    /**
+     * Return report by provided category name
+     */
+    getByCategoryName(name) {
+        return this.items.find((item) => item.category === name);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/collections/client.collection.js

@@ -0,0 +1,4 @@
+import { AbstractCollection } from './abstract.collection';
+export class ClientCollection extends AbstractCollection {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpZW50LmNvbGxlY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvY29sbGVjdGlvbnMvY2xpZW50LmNvbGxlY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFHM0QsTUFBTSxPQUFPLGdCQUFpQixTQUFRLGtCQUF3QjtDQUM3RCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFic3RyYWN0Q29sbGVjdGlvbiB9IGZyb20gJy4vYWJzdHJhY3QuY29sbGVjdGlvbic7XG5pbXBvcnQgeyBVc2VyIH0gZnJvbSAnLi4vbW9kZWxzL3VzZXIvdXNlcic7XG5cbmV4cG9ydCBjbGFzcyBDbGllbnRDb2xsZWN0aW9uIGV4dGVuZHMgQWJzdHJhY3RDb2xsZWN0aW9uPFVzZXI+IHtcbn1cbiJdfQ==

package/esm2015/lib/collections/collection-dictionary.js

@@ -0,0 +1,83 @@
+import has from 'lodash/has';
+import get from 'lodash/get';
+import flatten from 'lodash/flatten';
+/**
+ * List of collections grouped by passed property
+ */
+export class CollectionDictionary {
+    /**
+     * @param collection The Collection instance to be grouped
+     * @param path Path to the property to be grouped (Examples: 'transaction', 'property.category')
+     * @param prop Optional: Field to group by (Default 'id', Examples: 'id', 'amount', 'date')
+     */
+    constructor(collection, path = '', prop = 'id') {
+        /**
+         * List of grouped collections
+         */
+        this.items = {};
+        this.collectionConstructor = collection.constructor;
+        // Nothing to group when collection is empty
+        if (!collection.length) {
+            return;
+        }
+        // Check if the first collection item has property by path
+        if (!has(collection.items[0], path) && path) {
+            return;
+        }
+        this.groupItems(collection, path, prop);
+    }
+    /**
+     * List of collections keys
+     */
+    get keys() {
+        return Object.keys(this.items);
+    }
+    /**
+     * Get collection by key or return empty collection if key does not exist
+     */
+    get(key) {
+        return this.items[key] ? this.items[key] : this.createCollection([]);
+    }
+    /**
+     * Add new item by key
+     */
+    add(key, value) {
+        this.items[key] = value;
+    }
+    /**
+     * Join several collections by ids
+     */
+    merge(keys) {
+        return this.createCollection(flatten(keys.map((id) => this.get(id.toString()).items)));
+    }
+    /**
+     * Create instance of collection
+     */
+    createCollection(items = []) {
+        return new this.collectionConstructor(items);
+    }
+    /**
+     * Group collection items by passed path into items object
+     */
+    groupItems(collection, path, prop) {
+        // Create empty initial object for groups
+        const obj = {};
+        // Group collection items
+        collection.items.forEach((item) => {
+            let key = get(item, `${path ? path + '.' : ''}${prop}`);
+            // if object does not have property for grouping it will be grouped as 'other'
+            if (key === undefined) {
+                key = 'other';
+            }
+            if (!obj[key]) {
+                obj[key] = [];
+            }
+            obj[key].push(item);
+        });
+        // Create collections from groups
+        Object.keys(obj).forEach((key) => {
+            this.items[key] = this.createCollection(obj[key]);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGVjdGlvbi1kaWN0aW9uYXJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL2NvbGxlY3Rpb25zL2NvbGxlY3Rpb24tZGljdGlvbmFyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEdBQUcsTUFBTSxZQUFZLENBQUM7QUFDN0IsT0FBTyxHQUFHLE1BQU0sWUFBWSxDQUFDO0FBQzdCLE9BQU8sT0FBTyxNQUFNLGdCQUFnQixDQUFDO0FBR3JDOztHQUVHO0FBQ0gsTUFBTSxPQUFPLG9CQUFvQjtJQVcvQjs7OztPQUlHO0lBQ0gsWUFDRSxVQUFzQixFQUN0QixPQUFlLEVBQUUsRUFDakIsT0FBZSxJQUFJO1FBbEJyQjs7V0FFRztRQUNLLFVBQUssR0FBa0MsRUFBRSxDQUFDO1FBaUJoRCxJQUFJLENBQUMscUJBQXFCLEdBQUcsVUFBVSxDQUFDLFdBQWtELENBQUM7UUFFM0YsNENBQTRDO1FBQzVDLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFO1lBQ3RCLE9BQU87U0FDUjtRQUVELDBEQUEwRDtRQUMxRCxJQUFJLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsSUFBSSxDQUFDLElBQUksSUFBSSxFQUFFO1lBQzNDLE9BQU87U0FDUjtRQUVELElBQUksQ0FBQyxVQUFVLENBQUMsVUFBVSxFQUFFLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztJQUMxQyxDQUFDO0lBRUQ7O09BRUc7SUFDSCxJQUFJLElBQUk7UUFDTixPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ2pDLENBQUM7SUFFRDs7T0FFRztJQUNILEdBQUcsQ0FBQyxHQUFvQjtRQUN0QixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUN2RSxDQUFDO0lBRUQ7O09BRUc7SUFDSCxHQUFHLENBQUMsR0FBb0IsRUFBRSxLQUFpQjtRQUN6QyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEtBQUssQ0FBQztJQUMxQixDQUFDO0lBRUQ7O09BRUc7SUFDSCxLQUFLLENBQUMsSUFBYztRQUNsQixPQUFPLElBQUksQ0FBQyxnQkFBZ0IsQ0FDMUIsT0FBTyxDQUNMLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFVLEVBQVksRUFBRSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUMsS0FBSyxDQUFDLENBQ2xFLENBQ0YsQ0FBQztJQUNKLENBQUM7SUFFRDs7T0FFRztJQUNILGdCQUFnQixDQUFDLFFBQWtCLEVBQUU7UUFDbkMsT0FBTyxJQUFJLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUMvQyxDQUFDO0lBRUQ7O09BRUc7SUFDSyxVQUFVLENBQUMsVUFBc0IsRUFBRSxJQUFZLEVBQUUsSUFBWTtRQUNuRSx5Q0FBeUM7UUFDekMsTUFBTSxHQUFHLEdBQXFDLEVBQUUsQ0FBQztRQUVqRCx5QkFBeUI7UUFDekIsVUFBVSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxJQUFZLEVBQVEsRUFBRTtZQUM5QyxJQUFJLEdBQUcsR0FBVyxHQUFHLENBQUMsSUFBSSxFQUFFLEdBQUcsSUFBSSxDQUFDLENBQUMsQ0FBQyxJQUFJLEdBQUcsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEdBQUcsSUFBSSxFQUFFLENBQUMsQ0FBQztZQUVoRSw4RUFBOEU7WUFDOUUsSUFBSSxHQUFHLEtBQUssU0FBUyxFQUFFO2dCQUNyQixHQUFHLEdBQUcsT0FBTyxDQUFDO2FBQ2Y7WUFFRCxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxFQUFFO2dCQUNiLEdBQUcsQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUM7YUFDZjtZQUVELEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDdEIsQ0FBQyxDQUFDLENBQUM7UUFFSCxpQ0FBaUM7UUFDakMsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxHQUFXLEVBQVEsRUFBRTtZQUM3QyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFHLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztRQUNwRCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBoYXMgZnJvbSAnbG9kYXNoL2hhcyc7XG5pbXBvcnQgZ2V0IGZyb20gJ2xvZGFzaC9nZXQnO1xuaW1wb3J0IGZsYXR0ZW4gZnJvbSAnbG9kYXNoL2ZsYXR0ZW4nO1xuaW1wb3J0IHsgQWJzdHJhY3RDb2xsZWN0aW9uIH0gZnJvbSAnLi9hYnN0cmFjdC5jb2xsZWN0aW9uJztcblxuLyoqXG4gKiBMaXN0IG9mIGNvbGxlY3Rpb25zIGdyb3VwZWQgYnkgcGFzc2VkIHByb3BlcnR5XG4gKi9cbmV4cG9ydCBjbGFzcyBDb2xsZWN0aW9uRGljdGlvbmFyeTxDb2xsZWN0aW9uIGV4dGVuZHMgQWJzdHJhY3RDb2xsZWN0aW9uPG9iamVjdD4+IHtcbiAgLyoqXG4gICAqIExpc3Qgb2YgZ3JvdXBlZCBjb2xsZWN0aW9uc1xuICAgKi9cbiAgcHJpdmF0ZSBpdGVtczogeyBba2V5OiBzdHJpbmddOiBDb2xsZWN0aW9uIH0gPSB7fTtcblxuICAvKipcbiAgICogQ29uc3RydWN0b3IgZnVuY3Rpb24gb2YgcGFzc2VkIGNvbGxlY3Rpb24gZm9yIGNyZWF0aW5nIG5ldyBpbnN0YW5jZXNcbiAgICovXG4gIHByaXZhdGUgY29sbGVjdGlvbkNvbnN0cnVjdG9yOiBuZXcgKGl0ZW1zOiBvYmplY3RbXSkgPT4gQ29sbGVjdGlvbjtcblxuICAvKipcbiAgICogQHBhcmFtIGNvbGxlY3Rpb24gVGhlIENvbGxlY3Rpb24gaW5zdGFuY2UgdG8gYmUgZ3JvdXBlZFxuICAgKiBAcGFyYW0gcGF0aCBQYXRoIHRvIHRoZSBwcm9wZXJ0eSB0byBiZSBncm91cGVkIChFeGFtcGxlczogJ3RyYW5zYWN0aW9uJywgJ3Byb3BlcnR5LmNhdGVnb3J5JylcbiAgICogQHBhcmFtIHByb3AgT3B0aW9uYWw6IEZpZWxkIHRvIGdyb3VwIGJ5IChEZWZhdWx0ICdpZCcsIEV4YW1wbGVzOiAnaWQnLCAnYW1vdW50JywgJ2RhdGUnKVxuICAgKi9cbiAgY29uc3RydWN0b3IoXG4gICAgY29sbGVjdGlvbjogQ29sbGVjdGlvbixcbiAgICBwYXRoOiBzdHJpbmcgPSAnJyxcbiAgICBwcm9wOiBzdHJpbmcgPSAnaWQnXG4gICkge1xuICAgIHRoaXMuY29sbGVjdGlvbkNvbnN0cnVjdG9yID0gY29sbGVjdGlvbi5jb25zdHJ1Y3RvciBhcyBuZXcgKGl0ZW1zOiBvYmplY3RbXSkgPT4gQ29sbGVjdGlvbjtcblxuICAgIC8vIE5vdGhpbmcgdG8gZ3JvdXAgd2hlbiBjb2xsZWN0aW9uIGlzIGVtcHR5XG4gICAgaWYgKCFjb2xsZWN0aW9uLmxlbmd0aCkge1xuICAgICAgcmV0dXJuO1xuICAgIH1cblxuICAgIC8vIENoZWNrIGlmIHRoZSBmaXJzdCBjb2xsZWN0aW9uIGl0ZW0gaGFzIHByb3BlcnR5IGJ5IHBhdGhcbiAgICBpZiAoIWhhcyhjb2xsZWN0aW9uLml0ZW1zWzBdLCBwYXRoKSAmJiBwYXRoKSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgdGhpcy5ncm91cEl0ZW1zKGNvbGxlY3Rpb24sIHBhdGgsIHByb3ApO1xuICB9XG5cbiAgLyoqXG4gICAqIExpc3Qgb2YgY29sbGVjdGlvbnMga2V5c1xuICAgKi9cbiAgZ2V0IGtleXMoKTogc3RyaW5nW10ge1xuICAgIHJldHVybiBPYmplY3Qua2V5cyh0aGlzLml0ZW1zKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBHZXQgY29sbGVjdGlvbiBieSBrZXkgb3IgcmV0dXJuIGVtcHR5IGNvbGxlY3Rpb24gaWYga2V5IGRvZXMgbm90IGV4aXN0XG4gICAqL1xuICBnZXQoa2V5OiBzdHJpbmcgfCBudW1iZXIpOiBDb2xsZWN0aW9uIHtcbiAgICByZXR1cm4gdGhpcy5pdGVtc1trZXldID8gdGhpcy5pdGVtc1trZXldIDogdGhpcy5jcmVhdGVDb2xsZWN0aW9uKFtdKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBBZGQgbmV3IGl0ZW0gYnkga2V5XG4gICAqL1xuICBhZGQoa2V5OiBzdHJpbmcgfCBudW1iZXIsIHZhbHVlOiBDb2xsZWN0aW9uKSB7XG4gICAgdGhpcy5pdGVtc1trZXldID0gdmFsdWU7XG4gIH1cblxuICAvKipcbiAgICogSm9pbiBzZXZlcmFsIGNvbGxlY3Rpb25zIGJ5IGlkc1xuICAgKi9cbiAgbWVyZ2Uoa2V5czogbnVtYmVyW10pOiBDb2xsZWN0aW9uIHtcbiAgICByZXR1cm4gdGhpcy5jcmVhdGVDb2xsZWN0aW9uKFxuICAgICAgZmxhdHRlbihcbiAgICAgICAga2V5cy5tYXAoKGlkOiBudW1iZXIpOiBvYmplY3RbXSA9PiB0aGlzLmdldChpZC50b1N0cmluZygpKS5pdGVtcylcbiAgICAgIClcbiAgICApO1xuICB9XG5cbiAgLyoqXG4gICAqIENyZWF0ZSBpbnN0YW5jZSBvZiBjb2xsZWN0aW9uXG4gICAqL1xuICBjcmVhdGVDb2xsZWN0aW9uKGl0ZW1zOiBvYmplY3RbXSA9IFtdKTogQ29sbGVjdGlvbiB7XG4gICAgcmV0dXJuIG5ldyB0aGlzLmNvbGxlY3Rpb25Db25zdHJ1Y3RvcihpdGVtcyk7XG4gIH1cblxuICAvKipcbiAgICogR3JvdXAgY29sbGVjdGlvbiBpdGVtcyBieSBwYXNzZWQgcGF0aCBpbnRvIGl0ZW1zIG9iamVjdFxuICAgKi9cbiAgcHJpdmF0ZSBncm91cEl0ZW1zKGNvbGxlY3Rpb246IENvbGxlY3Rpb24sIHBhdGg6IHN0cmluZywgcHJvcDogc3RyaW5nKTogdm9pZCB7XG4gICAgLy8gQ3JlYXRlIGVtcHR5IGluaXRpYWwgb2JqZWN0IGZvciBncm91cHNcbiAgICBjb25zdCBvYmo6IHsgW2tleTogc3RyaW5nXTogQXJyYXk8b2JqZWN0PiB9ID0ge307XG5cbiAgICAvLyBHcm91cCBjb2xsZWN0aW9uIGl0ZW1zXG4gICAgY29sbGVjdGlvbi5pdGVtcy5mb3JFYWNoKChpdGVtOiBvYmplY3QpOiB2b2lkID0+IHtcbiAgICAgIGxldCBrZXk6IHN0cmluZyA9IGdldChpdGVtLCBgJHtwYXRoID8gcGF0aCArICcuJyA6ICcnfSR7cHJvcH1gKTtcblxuICAgICAgLy8gaWYgb2JqZWN0IGRvZXMgbm90IGhhdmUgcHJvcGVydHkgZm9yIGdyb3VwaW5nIGl0IHdpbGwgYmUgZ3JvdXBlZCBhcyAnb3RoZXInXG4gICAgICBpZiAoa2V5ID09PSB1bmRlZmluZWQpIHtcbiAgICAgICAga2V5ID0gJ290aGVyJztcbiAgICAgIH1cblxuICAgICAgaWYgKCFvYmpba2V5XSkge1xuICAgICAgICBvYmpba2V5XSA9IFtdO1xuICAgICAgfVxuXG4gICAgICBvYmpba2V5XS5wdXNoKGl0ZW0pO1xuICAgIH0pO1xuXG4gICAgLy8gQ3JlYXRlIGNvbGxlY3Rpb25zIGZyb20gZ3JvdXBzXG4gICAgT2JqZWN0LmtleXMob2JqKS5mb3JFYWNoKChrZXk6IHN0cmluZyk6IHZvaWQgPT4ge1xuICAgICAgdGhpcy5pdGVtc1trZXldID0gdGhpcy5jcmVhdGVDb2xsZWN0aW9uKG9ialtrZXldKTtcbiAgICB9KTtcbiAgfVxufVxuIl19

package/esm2015/lib/collections/depreciation-forecast.collection.js

@@ -0,0 +1,19 @@
+import { AbstractCollection } from './abstract.collection';
+/**
+ * Collection of depreciations
+ */
+export class DepreciationForecastCollection extends AbstractCollection {
+    filterByYear(financialYear) {
+        return new DepreciationForecastCollection(this.items.filter((forecast) => forecast.financialYear === financialYear));
+    }
+    getClaimAmountByMonth(month) {
+        return this.items.reduce((sum, item) => sum + item.getClaimAmountByMonth(month), 0);
+    }
+    get amount() {
+        return this.getSummary('amount');
+    }
+    get claimAmount() {
+        return this.getSummary('claimAmount');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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