taxtank-core 0.32.88 → 0.33.1

package/esm2022/src/lib/collections/client-portfolio-report.collection.mjs

@@ -0,0 +1,40 @@
+/**
+ * Collection of employee clients tax summary information
+ */
+import { Collection } from './collection';
+export class ClientPortfolioReportCollection extends Collection {
+    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/esm2022/src/lib/collections/client.collection.mjs

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

package/esm2022/src/lib/collections/collection-dictionary.mjs

@@ -0,0 +1,110 @@
+import get from 'lodash/get';
+import flatten from 'lodash/flatten';
+import hasIn from 'lodash/hasIn';
+import intersection from 'lodash/intersection';
+import uniqBy from 'lodash/uniqBy';
+/**
+ * @TODO refactor with Map
+ * List of collections grouped by passed property
+ */
+export class CollectionDictionary {
+    constructor(collection, path = 'id') {
+        /**
+         * List of grouped collections
+         */
+        this.items = {};
+        this.collectionConstructor = collection.constructor;
+        // group if provided path was found in the 1st collection's item
+        if (collection.length && hasIn(collection.items[0], path.split('.')[0])) {
+            this.groupItems(collection, path);
+        }
+    }
+    /**
+     * List of collections keys
+     */
+    get keys() {
+        return Object.keys(this.items);
+    }
+    /**
+     * push new elements in existing item
+     */
+    addTo(key, ...models) {
+        if (!this.items[key]) {
+            this.add(key);
+        }
+        this.items[key].push(...models);
+    }
+    /**
+     * Add new item by key
+     */
+    add(key, value = this.createCollection([])) {
+        this.items[key] = value;
+    }
+    /**
+     * Get collection by key or return empty collection if key does not exist
+     */
+    get(key) {
+        return this.items[key] ? this.items[key] : this.createCollection([]);
+    }
+    /**
+     * @TODO bad name, it just gets items by keys, same as get method by multiple keys
+     * Join several collections by ids, return collection of uniq models (skip duplicates)
+     */
+    merge(keys) {
+        if (!this.length) {
+            return this.createCollection([]);
+        }
+        return this.createCollection(uniqBy(flatten(keys.map((key) => this.get(key.toString()).items)), 'id'));
+    }
+    /**
+     * Create instance of collection
+     */
+    createCollection(items = []) {
+        return new this.collectionConstructor(items);
+    }
+    get length() {
+        return this.keys.length;
+    }
+    /**
+     * @Todo find a better solution to get list of the sorted keys
+     * Get array of the "keys" by provided order
+     */
+    getSortedKeys(isDesc = false) {
+        return this.keys.sort((a, b) => {
+            if (a > b) {
+                return !isDesc ? 1 : -1;
+            }
+            if (a < b) {
+                return !isDesc ? -1 : 1;
+            }
+            return 0;
+        });
+    }
+    keysIntersection(keys) {
+        return intersection(keys.map((key) => key.toString()), this.keys);
+    }
+    /**
+     * Group collection items by passed path into items object
+     */
+    groupItems(collection, path) {
+        // Create empty initial object for groups
+        const obj = {};
+        // Group collection items
+        collection.items.forEach((item) => {
+            let key = get(item, path);
+            // 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,{"version":3,"file":"collection-dictionary.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/collections/collection-dictionary.ts"],"names":[],"mappings":"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","sourcesContent":["import get from 'lodash/get';\nimport flatten from 'lodash/flatten';\nimport hasIn from 'lodash/hasIn';\nimport { Collection as BaseCollection } from './collection';\nimport { AbstractModel } from '../db/Models';\nimport intersection from 'lodash/intersection';\nimport uniqBy from 'lodash/uniqBy';\n\n/**\n * @TODO refactor with Map\n * List of collections grouped by passed property\n */\nexport class CollectionDictionary<Collection extends BaseCollection<AbstractModel>> {\n  /**\n   * List of grouped collections\n   */\n  items: { [key: string]: Collection } = {};\n\n  /**\n   * Constructor function of passed collection for creating new instances\n   */\n  private collectionConstructor: new (items: object[]) => Collection;\n\n  constructor(collection: Collection, path = 'id') {\n    this.collectionConstructor = collection.constructor as new (items: object[]) => Collection;\n    // group if provided path was found in the 1st collection's item\n    if (collection.length && hasIn(collection.items[0], path.split('.')[0])) {\n      this.groupItems(collection, path);\n    }\n  }\n\n  /**\n   * List of collections keys\n   */\n  get keys(): string[] {\n    return Object.keys(this.items);\n  }\n\n  /**\n   * push new elements in existing item\n   */\n  addTo(key: string | number, ...models: AbstractModel[]): void {\n    if (!this.items[key]) {\n      this.add(key);\n    }\n\n    this.items[key].push(...models);\n  }\n\n  /**\n   * Add new item by key\n   */\n  add(key: string | number, value: Collection = this.createCollection([])) {\n    this.items[key] = value;\n  }\n\n  /**\n   * Get collection by key or return empty collection if key does not exist\n   */\n  get(key: string | number): Collection {\n    return this.items[key] ? this.items[key] : this.createCollection([]);\n  }\n\n  /**\n   * @TODO bad name, it just gets items by keys, same as get method by multiple keys\n   * Join several collections by ids, return collection of uniq models (skip duplicates)\n   */\n  merge(keys: number[] | string[]): Collection {\n    if (!this.length) {\n      return this.createCollection([]);\n    }\n\n    return this.createCollection(\n      uniqBy(flatten(keys.map((key: number | string): object[] => this.get(key.toString()).items)), 'id')\n    );\n  }\n\n  /**\n   * Create instance of collection\n   */\n  createCollection(items: object[] = []): Collection {\n    return new this.collectionConstructor(items);\n  }\n\n  get length(): number {\n    return this.keys.length;\n  }\n\n  /**\n   * @Todo find a better solution to get list of the sorted keys\n   * Get array of the \"keys\" by provided order\n   */\n  getSortedKeys(isDesc = false): string[] {\n    return this.keys.sort((a: any, b: any): number => {\n      if (a > b) {\n        return !isDesc ? 1 : -1;\n      }\n      if (a < b) {\n        return !isDesc ? -1 : 1;\n      }\n      return 0;\n    });\n  }\n\n  keysIntersection(keys: string[] | number[]): string[] {\n    return intersection(keys.map((key: string | number) => key.toString()), this.keys);\n  }\n\n  /**\n   * Group collection items by passed path into items object\n   */\n  private groupItems(collection: Collection, path: string): void {\n    // Create empty initial object for groups\n    const obj: { [key: string]: Array<object> } = {};\n\n    // Group collection items\n    collection.items.forEach((item: object): void => {\n      let key: string = get(item, path);\n\n      // if object does not have property for grouping it will be grouped as 'other'\n      if (key === undefined) {\n        key = 'other';\n      }\n\n      if (!obj[key]) {\n        obj[key] = [];\n      }\n\n      obj[key].push(item);\n    });\n\n    // Create collections from groups\n    Object.keys(obj).forEach((key: string): void => {\n      this.items[key] = this.createCollection(obj[key]);\n    });\n  }\n}\n"]}

package/esm2022/src/lib/collections/collection.mjs

@@ -0,0 +1,163 @@
+import { CollectionDictionary } from './collection-dictionary';
+import first from 'lodash/first';
+import last from 'lodash/last';
+import get from 'lodash/get';
+import { Dictionary, FinancialYear } from '../models';
+import orderBy from 'lodash/orderBy';
+/**
+ * Base collection class. Contains common properties and methods for all collections
+ */
+export class Collection {
+    constructor(items = []) {
+        /**
+         * index of current item, used to iterate over the collection
+         */
+        this.index = 0;
+        this.items = items;
+        // @TODO Alex: Think and implement some smart solution for default sort
+    }
+    /**
+     * Iterator that allow to iterate collection items
+     */
+    [Symbol.iterator]() {
+        return this.items.values();
+    }
+    create(items = []) {
+        return new this.constructor(items);
+    }
+    get length() {
+        return this.items.length;
+    }
+    toArray() {
+        return [...this.items];
+    }
+    get first() {
+        return first(this.items);
+    }
+    get last() {
+        return last(this.items);
+    }
+    get previous() {
+        return this.items[this.items.length - 2];
+    }
+    reset() {
+        this.index = 0;
+        return this.items[this.index];
+    }
+    next() {
+        if (this.index < this.length) {
+            this.index++;
+            return this.items[this.index];
+        }
+        return null;
+    }
+    back() {
+        if (this.index > 0) {
+            this.index--;
+            return this.items[this.index];
+        }
+        return null;
+    }
+    getIds() {
+        return this.items.map((item) => item['id']);
+    }
+    map(callback) {
+        return this.items.map(callback);
+    }
+    mapBy(path) {
+        return this
+            .filter((item) => !!get(item, path))
+            .map((item) => get(item, path));
+    }
+    sortBy(paths = ['id'], order = ['desc']) {
+        this.items = orderBy(this.items, paths instanceof Array ? paths : [paths], order instanceof Array ? order : [order]);
+        return this;
+    }
+    sort(callback) {
+        this.items.sort(callback);
+        return this;
+    }
+    /**
+     * Get total sum of items by field
+     */
+    sumBy(path, abs = false) {
+        return this.reduce((sum, item) => sum + (abs ? Math.abs(Number(get(item, path))) : Number(get(item, path))));
+    }
+    groupBy(path = 'id') {
+        return new CollectionDictionary(this, path);
+    }
+    indexBy(path = 'id') {
+        return new Dictionary(this.items, path);
+    }
+    filter(callback) {
+        return this.create(this.items.filter(callback));
+    }
+    filterBy(path, values) {
+        return this.filter((item) => (Array.isArray(values) ? values : [values]).includes(get(item, path)));
+    }
+    filterByRange(path, from, to) {
+        return this.filter((item) => get(item, path) >= from && get(item, path) <= to);
+    }
+    filterByFinancialYear(pathFrom, pathTo, financialYear = new FinancialYear()) {
+        if (pathTo) {
+            return this.filter(model => get(model, pathFrom) <= financialYear.endDate && !get(model, pathTo) || get(model, pathTo) >= financialYear.startDate);
+        }
+        return this.filterByRange(pathFrom, financialYear.startDate, financialYear.endDate);
+    }
+    find(callback) {
+        return this.items.find(callback);
+    }
+    findBy(path, value) {
+        return this.items.find((model) => value === get(model, path));
+    }
+    findIndexBy(path, value) {
+        return this.items.findIndex((item) => get(item, path) === value) ?? null;
+    }
+    push(...items) {
+        this.items.push(...items);
+        return this.create(this.items);
+    }
+    remove(...items) {
+        items.forEach((item) => {
+            const index = this.findIndexBy('id', item.id);
+            if (index < 0) {
+                return;
+            }
+            this.items.splice(index, 1);
+        });
+        return this;
+    }
+    /**
+     * @TODO it's filter, not remove
+     */
+    removeBy(path, values) {
+        return this.filter((item) => !(Array.isArray(values) ? values : [values]).includes(get(item, path)));
+    }
+    replaceBy(path, value, item) {
+        const index = this.findIndexBy(path, value);
+        if (index >= 0) {
+            this.items.splice(index, 1, item);
+        }
+        return this.create(this.items);
+    }
+    diff(items) {
+        return this.filter((model) => !items.map((item) => item.id).includes(model.id));
+    }
+    minBy(path) {
+        return this.items.reduce((prev, current) => (get(prev, path) < get(current, path) ? prev : current));
+    }
+    maxBy(path) {
+        return this.items.reduce((prev, current) => (get(prev, path) > get(current, path) ? prev : current));
+    }
+    /**
+     * float math issues https://stackoverflow.com/questions/12511057/float-sum-with-javascript
+     */
+    reduce(callback, init = 0) {
+        return +this.items.reduce(callback, init).toFixed(10);
+    }
+    slice(from, to) {
+        this.items = this.items.slice(from, to);
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/collections/collection.ts"],"names":[],"mappings":"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","sourcesContent":["import { CollectionDictionary } from './collection-dictionary';\r\nimport first from 'lodash/first';\r\nimport last from 'lodash/last';\r\nimport get from 'lodash/get';\r\nimport { AbstractModel } from '../db/Models';\r\nimport { Dictionary, FinancialYear } from '../models';\r\nimport orderBy from 'lodash/orderBy';\r\n\r\n/**\r\n * Base collection class. Contains common properties and methods for all collections\r\n */\r\nexport class Collection<Model extends AbstractModel> implements Iterable<Model> {\r\n  // list of collection's items\r\n  items: Model[];\r\n\r\n  /**\r\n   * index of current item, used to iterate over the collection\r\n   */\r\n  index = 0;\r\n\r\n  constructor(items: Model[] = []) {\r\n    this.items = items;\r\n    // @TODO Alex: Think and implement some smart solution for default sort\r\n  }\r\n\r\n  /**\r\n   * Iterator that allow to iterate collection items\r\n   */\r\n  [Symbol.iterator](): Iterator<Model> {\r\n    return this.items.values();\r\n  }\r\n\r\n  create(items: Model[] = []): this {\r\n    return new (this.constructor as any)(items);\r\n  }\r\n\r\n  get length(): number {\r\n    return this.items.length;\r\n  }\r\n\r\n  toArray(): Model[] {\r\n    return [...this.items];\r\n  }\r\n\r\n  get first(): Model {\r\n    return first(this.items);\r\n  }\r\n\r\n  get last(): Model {\r\n    return last(this.items);\r\n  }\r\n\r\n  get previous(): Model {\r\n    return this.items[this.items.length - 2];\r\n  }\r\n\r\n  reset(): Model {\r\n    this.index = 0;\r\n\r\n    return this.items[this.index];\r\n  }\r\n\r\n  next(): Model {\r\n    if (this.index < this.length) {\r\n      this.index++;\r\n\r\n      return this.items[this.index];\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  back(): Model {\r\n    if (this.index > 0) {\r\n      this.index--;\r\n\r\n      return this.items[this.index];\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  getIds(): number[] {\r\n    return this.items.map((item: Model): number => item['id']);\r\n  }\r\n\r\n  map(callback: (item: Model) => any): any[] {\r\n    return this.items.map(callback);\r\n  }\r\n\r\n  mapBy(path: string): any[] {\r\n    return this\r\n      .filter((item) => !!get(item, path))\r\n      .map((item: Model) => get(item, path));\r\n  }\r\n\r\n  sortBy(paths: string | string[] = ['id'], order: string | string[] = ['desc']): this {\r\n    this.items = orderBy(this.items, paths instanceof Array ? paths : [paths], order instanceof Array ? order : [order]);\r\n\r\n    return this;\r\n  }\r\n\r\n  sort(callback: (a: Model, b: Model) => number): this {\r\n    this.items.sort(callback);\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Get total sum of items by field\r\n   */\r\n  sumBy(path: string, abs = false): number {\r\n    return this.reduce(\r\n      (sum: number, item: Model): number => sum + (abs ? Math.abs(Number(get(item, path))) : Number(get(item, path)))\r\n    );\r\n  }\r\n\r\n  groupBy(path = 'id'): CollectionDictionary<this> {\r\n    return new CollectionDictionary(this, path);\r\n  }\r\n\r\n  indexBy(path = 'id'): Dictionary<Model> {\r\n    return new Dictionary(this.items, path);\r\n  }\r\n\r\n  filter(callback: (item: Model) => boolean): this {\r\n    return this.create(this.items.filter(callback));\r\n  }\r\n\r\n  filterBy(path: string, values: any): this {\r\n    return this.filter((item: Model) => (Array.isArray(values) ? values : [values]).includes(get(item, path)));\r\n  }\r\n\r\n  filterByRange(path: string, from: any, to: any): this {\r\n    return this.filter((item: Model): boolean => get(item, path) >= from && get(item, path) <= to);\r\n  }\r\n\r\n  filterByFinancialYear(pathFrom: string, pathTo?: string, financialYear: FinancialYear = new FinancialYear()): this {\r\n    if (pathTo) {\r\n      return this.filter(\r\n        model => get(model, pathFrom) <= financialYear.endDate && !get(model, pathTo) || get(model, pathTo) >= financialYear.startDate\r\n      );\r\n    }\r\n\r\n    return this.filterByRange(pathFrom, financialYear.startDate, financialYear.endDate);\r\n  }\r\n\r\n  find(callback: (item: Model) => boolean): Model | null {\r\n    return this.items.find(callback);\r\n  }\r\n\r\n  findBy(path: string, value: any): Model | null {\r\n    return this.items.find((model: Model) => value === get(model, path));\r\n  }\r\n\r\n  findIndexBy(path: string, value: any): number {\r\n    return this.items.findIndex((item: Model) => get(item, path) === value) ?? null;\r\n  }\r\n\r\n  push(...items: Model[]): this {\r\n    this.items.push(...items);\r\n\r\n    return this.create(this.items);\r\n  }\r\n\r\n  remove(...items: Model[]): this {\r\n    items.forEach((item) => {\r\n      const index: number = this.findIndexBy('id', item.id);\r\n      if (index < 0) {\r\n        return;\r\n      }\r\n\r\n      this.items.splice(index, 1);\r\n    });\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * @TODO it's filter, not remove\r\n   */\r\n  removeBy(path: string, values: any): this {\r\n    return this.filter((item: Model) => !(Array.isArray(values) ? values : [values]).includes(get(item, path)));\r\n  }\r\n\r\n  replaceBy(path: string, value: any, item: Model): this {\r\n    const index: number = this.findIndexBy(path, value);\r\n    if (index >= 0) {\r\n      this.items.splice(index, 1, item);\r\n    }\r\n\r\n    return this.create(this.items);\r\n  }\r\n\r\n  diff(items: Model[]): this {\r\n    return this.filter((model: Model) => !items.map((item: Model) => item.id).includes(model.id));\r\n  }\r\n\r\n  minBy(path: string): Model {\r\n    return this.items.reduce((prev: Model, current: Model) => (get(prev, path) < get(current, path) ? prev : current));\r\n  }\r\n\r\n  maxBy(path: string): Model {\r\n    return this.items.reduce((prev: Model, current: Model) => (get(prev, path) > get(current, path) ? prev : current));\r\n  }\r\n\r\n  /**\r\n   * float math issues https://stackoverflow.com/questions/12511057/float-sum-with-javascript\r\n   */\r\n  reduce(callback: (sum: number, item: Model) => number, init = 0): number {\r\n    return +this.items.reduce(callback, init).toFixed(10);\r\n  }\r\n\r\n  slice(from: number, to: number): this {\r\n    this.items = this.items.slice(from, to);\r\n\r\n    return this;\r\n  }\r\n}\r\n"]}

package/esm2022/src/lib/collections/depreciation-forecast.collection.mjs

@@ -0,0 +1,19 @@
+import { Collection } from './collection';
+/**
+ * Collection of depreciations
+ */
+export class DepreciationForecastCollection extends Collection {
+    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.sumBy('amount');
+    }
+    get claimAmount() {
+        return this.sumBy('claimAmount');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/collections/depreciation.collection.mjs

@@ -0,0 +1,116 @@
+import { TankTypeEnum } from '../db/Enums/tank-type.enum';
+import { Collection } from './collection';
+import uniqBy from 'lodash/uniqBy';
+import compact from 'lodash/compact';
+import { TransactionCollection } from './transaction';
+import round from 'lodash/round';
+export class DepreciationCollection extends Collection {
+    getSoleDepreciations() {
+        return this.filter((depreciation) => depreciation.isSoleTank());
+    }
+    getNew() {
+        return this.filter((depreciation) => depreciation.isNew());
+    }
+    /**
+     * Get total amount of all depreciations in the collection
+     */
+    get amount() {
+        return this.items.reduce((sum, depreciation) => sum + depreciation.amount, 0);
+    }
+    get claimAmount() {
+        return this.items.reduce((sum, depreciation) => sum + depreciation.currentYearForecast.claimAmount, 0);
+    }
+    getClaimedAmountByYear(year = +localStorage.getItem('financialYear')) {
+        const closeBalance = this.items.reduce((sum, depreciation) => sum + depreciation.getCloseBalanceByYear(year), 0);
+        return round(this.amount - closeBalance, 2);
+    }
+    getClaimAmountByYear(year = +localStorage.getItem('financialYear')) {
+        return this.items.reduce((sum, depreciation) => sum + depreciation.getClaimAmountByYear(year), 0);
+    }
+    getCloseBalanceByYear(year = +localStorage.getItem('financialYear')) {
+        return this.items.reduce((sum, depreciation) => sum + depreciation.getCloseBalanceByYear(year), 0);
+    }
+    getCurrentYearForecastAmount() {
+        return this.items.reduce((sum, depreciation) => sum + depreciation.currentYearForecast.amount, 0);
+    }
+    get closeBalance() {
+        return this.sumBy('currentYearForecast.closeBalance');
+    }
+    getByPropertiesIds(ids) {
+        return new DepreciationCollection(this.items.filter((depreciation) => ids.includes(depreciation.property?.id)));
+    }
+    getWithCapitalProject() {
+        return new DepreciationCollection(this.items.filter((depreciation) => !!depreciation.depreciationCapitalProject));
+    }
+    getWithoutCapitalProject() {
+        return new DepreciationCollection(this.items.filter((depreciation) => !depreciation.depreciationCapitalProject));
+    }
+    getWithoutBorrowingExpenses() {
+        return new DepreciationCollection(this.items.filter((depreciation) => !depreciation.isBorrowingExpense()));
+    }
+    getByChartAccountsCategories(categories) {
+        return this.create(this.items.filter((depreciation) => categories.includes(depreciation.chartAccounts.category)));
+    }
+    getAssets() {
+        return this.filter((depreciation) => depreciation.isAsset());
+    }
+    getPlantEquipment() {
+        return this.filter((depreciation) => depreciation.isPlantEquipmentPool());
+    }
+    getCapitalDepreciations() {
+        return this.filter((depreciation) => depreciation.isCapital());
+    }
+    getBorrowingExpenseDepreciations() {
+        return this.filter((depreciation) => depreciation.isBorrowingExpense());
+    }
+    getWrittenOffDepreciations() {
+        return this.filter((depreciation) => depreciation.isWrittenOff());
+    }
+    getLVPDepreciations() {
+        return this.filter((depreciation) => depreciation.isLVP());
+    }
+    getSBPDepreciations() {
+        return this.filter((depreciation) => depreciation.isSBP());
+    }
+    getCapitalProjects() {
+        return uniqBy(compact(this.items.map((depreciation) => depreciation.depreciationCapitalProject)), 'id');
+    }
+    /**
+     * Get a new collection of depreciations related to vehicles
+     */
+    getVehicleDepreciations() {
+        return this.filter((depreciation) => depreciation.isVehicleDepreciation());
+    }
+    getByTankType(tankType) {
+        return this.create(this.items.filter((depreciation) => {
+            switch (tankType) {
+                case TankTypeEnum.PROPERTY:
+                    return depreciation.isPropertyTank();
+                case TankTypeEnum.WORK:
+                    return depreciation.isWorkTank();
+                case TankTypeEnum.SOLE:
+                    return depreciation.isSoleTank();
+                // case for other tank or some extra
+                default:
+                    return false;
+            }
+        }));
+    }
+    /**
+     * Create TransactionCollection from depreciation items
+     */
+    toTransactions() {
+        return new TransactionCollection(this.items.map((item) => item.toTransaction()));
+    }
+    /**
+     * Get depreciations by vehicle claim. Only vehicle depreciations may be related to vehicle claim
+     */
+    getByVehicleClaim(vehicleClaim) {
+        return vehicleClaim.isSoleTank()
+            // sole tank may have multiple vehicle claims, so we need to filter by business.id
+            ? this.getVehicleDepreciations().filterBy('business.id', vehicleClaim.business.id)
+            // work tank may have only one vehicle claim, so we need to filter by tank type
+            : this.getVehicleDepreciations().filterBy('tankType', TankTypeEnum.WORK);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"depreciation.collection.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/collections/depreciation.collection.ts"],"names":[],"mappings":"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","sourcesContent":["import { TankTypeEnum } from '../db/Enums/tank-type.enum';\nimport { Collection } from './collection';\nimport { Depreciation } from '../models';\nimport uniqBy from 'lodash/uniqBy';\nimport compact from 'lodash/compact';\nimport { DepreciationCapitalProject } from '../models';\nimport { TransactionCollection } from './transaction';\nimport { ChartAccountsCategoryEnum } from '../db/Enums';\nimport { VehicleClaim } from '../models';\nimport round from 'lodash/round';\n\nexport class DepreciationCollection extends Collection<Depreciation> {\n  getSoleDepreciations(): this {\n    return this.filter((depreciation: Depreciation) => depreciation.isSoleTank());\n  }\n\n  getNew(): this {\n    return this.filter((depreciation: Depreciation) => depreciation.isNew());\n  }\n\n  /**\n   * Get total amount of all depreciations in the collection\n   */\n  get amount(): number {\n    return this.items.reduce((sum: number, depreciation: Depreciation): number => sum + depreciation.amount, 0);\n  }\n\n  get claimAmount(): number {\n    return this.items.reduce((sum: number, depreciation: Depreciation) => sum + depreciation.currentYearForecast.claimAmount, 0);\n  }\n\n  getClaimedAmountByYear(year: number = +localStorage.getItem('financialYear')): number {\n    const closeBalance = this.items.reduce(\n      (sum: number, depreciation: Depreciation): number => sum + depreciation.getCloseBalanceByYear(year), 0\n    );\n\n    return round(this.amount - closeBalance, 2);\n  }\n\n  getClaimAmountByYear(year: number = +localStorage.getItem('financialYear')): number {\n    return this.items.reduce((sum: number, depreciation: Depreciation): number => sum + depreciation.getClaimAmountByYear(year), 0);\n  }\n\n  getCloseBalanceByYear(year: number = +localStorage.getItem('financialYear')): number {\n    return this.items.reduce((sum: number, depreciation: Depreciation): number => sum + depreciation.getCloseBalanceByYear(year), 0);\n  }\n\n  getCurrentYearForecastAmount(): number {\n    return this.items.reduce((sum: number, depreciation: Depreciation): number => sum + depreciation.currentYearForecast.amount, 0);\n  }\n\n  get closeBalance(): number {\n    return this.sumBy('currentYearForecast.closeBalance');\n  }\n\n  getByPropertiesIds(ids: number[]): DepreciationCollection {\n    return new DepreciationCollection(\n      this.items.filter((depreciation: Depreciation): boolean => ids.includes(depreciation.property?.id))\n    );\n  }\n\n  getWithCapitalProject(): DepreciationCollection {\n    return new DepreciationCollection(\n      this.items.filter((depreciation: Depreciation): boolean => !!depreciation.depreciationCapitalProject)\n    );\n  }\n\n  getWithoutCapitalProject(): DepreciationCollection {\n    return new DepreciationCollection(\n      this.items.filter((depreciation: Depreciation): boolean => !depreciation.depreciationCapitalProject)\n    );\n  }\n\n  getWithoutBorrowingExpenses(): DepreciationCollection {\n    return new DepreciationCollection(\n      this.items.filter((depreciation: Depreciation): boolean => !depreciation.isBorrowingExpense())\n    );\n  }\n\n  getByChartAccountsCategories(categories: ChartAccountsCategoryEnum[]): this {\n    return this.create(\n      this.items.filter((depreciation: Depreciation): boolean => categories.includes(depreciation.chartAccounts.category))\n    );\n  }\n\n  getAssets(): this {\n    return this.filter((depreciation) => depreciation.isAsset());\n  }\n\n  getPlantEquipment(): this {\n    return this.filter((depreciation) => depreciation.isPlantEquipmentPool());\n  }\n\n  getCapitalDepreciations(): this {\n    return this.filter((depreciation) => depreciation.isCapital());\n  }\n\n  getBorrowingExpenseDepreciations(): DepreciationCollection {\n    return this.filter((depreciation: Depreciation) => depreciation.isBorrowingExpense());\n  }\n\n  getWrittenOffDepreciations(): DepreciationCollection {\n    return this.filter((depreciation: Depreciation) => depreciation.isWrittenOff());\n  }\n\n  getLVPDepreciations(): this {\n    return this.filter((depreciation: Depreciation) => depreciation.isLVP());\n  }\n\n  getSBPDepreciations(): this {\n    return this.filter((depreciation: Depreciation) => depreciation.isSBP());\n  }\n\n  getCapitalProjects(): DepreciationCapitalProject[] {\n    return uniqBy(\n      compact(\n        this.items.map((depreciation: Depreciation): DepreciationCapitalProject => depreciation.depreciationCapitalProject)\n      ),\n      'id'\n    );\n  }\n\n  /**\n   * Get a new collection of depreciations related to vehicles\n   */\n  getVehicleDepreciations(): this {\n    return this.filter((depreciation: Depreciation) => depreciation.isVehicleDepreciation());\n  }\n\n  getByTankType(tankType: TankTypeEnum): this {\n    return this.create(\n      this.items.filter((depreciation: Depreciation): boolean => {\n        switch (tankType) {\n          case TankTypeEnum.PROPERTY:\n            return depreciation.isPropertyTank();\n          case TankTypeEnum.WORK:\n            return depreciation.isWorkTank();\n          case TankTypeEnum.SOLE:\n            return depreciation.isSoleTank();\n          // case for other tank or some extra\n          default:\n            return false;\n        }\n      })\n    );\n  }\n\n  /**\n   * Create TransactionCollection from depreciation items\n   */\n  toTransactions(): TransactionCollection {\n    return new TransactionCollection(\n      this.items.map((item: Depreciation) => item.toTransaction())\n    );\n  }\n\n  /**\n   * Get depreciations by vehicle claim. Only vehicle depreciations may be related to vehicle claim\n   */\n  getByVehicleClaim(vehicleClaim: VehicleClaim): this {\n    return vehicleClaim.isSoleTank()\n      // sole tank may have multiple vehicle claims, so we need to filter by business.id\n      ? this.getVehicleDepreciations().filterBy('business.id', vehicleClaim.business.id)\n      // work tank may have only one vehicle claim, so we need to filter by tank type\n      : this.getVehicleDepreciations().filterBy('tankType', TankTypeEnum.WORK);\n  }\n}\n"]}

package/esm2022/src/lib/collections/employee.collection.mjs

@@ -0,0 +1,11 @@
+import { Collection } from './collection';
+import { FirmTypeEnum } from '../db/Enums/firm-type.enum';
+export class EmployeeCollection extends Collection {
+    get accountant() {
+        return this.items.filter((user) => user.employeeDetails.firm.type === FirmTypeEnum.ACCOUNTANT)[0] ?? null;
+    }
+    get advisors() {
+        return this.items.filter((user) => user.employeeDetails.firm.type === FirmTypeEnum.ADVISOR);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1wbG95ZWUuY29sbGVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9jb2xsZWN0aW9ucy9lbXBsb3llZS5jb2xsZWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFMUMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBRzFELE1BQU0sT0FBTyxrQkFBbUIsU0FBUSxVQUFnQjtJQUN0RCxJQUFJLFVBQVU7UUFDWixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBVSxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDLElBQUksQ0FBQyxJQUFJLEtBQUssWUFBWSxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLElBQUksQ0FBQztJQUNsSCxDQUFDO0lBRUQsSUFBSSxRQUFRO1FBQ1YsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQVUsRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLGVBQWUsQ0FBQyxJQUFJLENBQUMsSUFBSSxLQUFLLFlBQVksQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNwRyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb2xsZWN0aW9uIH0gZnJvbSAnLi9jb2xsZWN0aW9uJztcbmltcG9ydCB7IFVzZXIgfSBmcm9tICcuLi9tb2RlbHMvdXNlci91c2VyJztcbmltcG9ydCB7IEZpcm1UeXBlRW51bSB9IGZyb20gJy4uL2RiL0VudW1zL2Zpcm0tdHlwZS5lbnVtJztcblxuXG5leHBvcnQgY2xhc3MgRW1wbG95ZWVDb2xsZWN0aW9uIGV4dGVuZHMgQ29sbGVjdGlvbjxVc2VyPiB7XG4gIGdldCBhY2NvdW50YW50KCk6IFVzZXIge1xuICAgIHJldHVybiB0aGlzLml0ZW1zLmZpbHRlcigodXNlcjogVXNlcikgPT4gdXNlci5lbXBsb3llZURldGFpbHMuZmlybS50eXBlID09PSBGaXJtVHlwZUVudW0uQUNDT1VOVEFOVClbMF0gPz8gbnVsbDtcbiAgfVxuXG4gIGdldCBhZHZpc29ycygpOiBVc2VyW10ge1xuICAgIHJldHVybiB0aGlzLml0ZW1zLmZpbHRlcigodXNlcjogVXNlcikgPT4gdXNlci5lbXBsb3llZURldGFpbHMuZmlybS50eXBlID09PSBGaXJtVHlwZUVudW0uQURWSVNPUik7XG4gIH1cbn1cbiJdfQ==

package/esm2022/src/lib/collections/exportable.collection.mjs

@@ -0,0 +1,23 @@
+import { Collection } from './collection';
+import { plainToClass } from 'class-transformer';
+import { ExportDataTable } from '../models/export/export-data-table';
+export class ExportableCollection extends Collection {
+    getExportFooter() {
+        return [];
+    }
+    getBodyAoa(exportData) {
+        return exportData.body.map(row => {
+            return row.map(cell => {
+                return cell.value;
+            });
+        });
+    }
+    export(params) {
+        return plainToClass(ExportDataTable, {
+            header: this.getExportHeader(),
+            body: this.getExportBody(params),
+            footer: [this.getExportFooter()]
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/collections/holding/holding-sale.collection.mjs

@@ -0,0 +1,41 @@
+import { ExportableCollection } from '../exportable.collection';
+import { ExportCell } from '../../models/export/export-cell';
+import { ExportCellTypeEnum } from '../../models/export/export-cell-type.enum';
+import { plainToClass } from 'class-transformer';
+export class HoldingSaleCollection extends ExportableCollection {
+    filterByTaxFree(holdings, isTaxFree = false) {
+        return this.filterBy('holding.id', holdings.filterBy('isTaxFree', isTaxFree).getIds());
+    }
+    getExportHeader() {
+        return ['Ticker', 'Asset type', 'Date of buy', 'Date of sale', 'Cost base', 'Net sale', 'Ownership', 'Total capital Gain/(Loss)', 'My Capital Gain/(Loss)', 'Exempt or Concession'];
+    }
+    getExportFooter() {
+        return [
+            plainToClass(ExportCell, { value: '', type: ExportCellTypeEnum.STRING }),
+        ];
+    }
+    getExportBody(holdingsById) {
+        return this.items.map((sale) => [
+            plainToClass(ExportCell, {
+                value: holdingsById.get(sale.holding.id).type.ticker,
+                type: ExportCellTypeEnum.STRING
+            }),
+            plainToClass(ExportCell, {
+                value: holdingsById.get(sale.holding.id).type.categoryLabel,
+                type: ExportCellTypeEnum.STRING
+            }),
+            plainToClass(ExportCell, { value: holdingsById.get(sale.holding.id)?.date, type: ExportCellTypeEnum.DATE }),
+            plainToClass(ExportCell, { value: sale.date, type: ExportCellTypeEnum.DATE }),
+            plainToClass(ExportCell, { value: sale.getCostBase(holdingsById.get(sale.holding.id)), type: ExportCellTypeEnum.CURRENCY }),
+            plainToClass(ExportCell, { value: sale.netCost, type: ExportCellTypeEnum.CURRENCY }),
+            plainToClass(ExportCell, { value: holdingsById.get(sale.holding.id).ownershipPercent, type: ExportCellTypeEnum.PERCENT }),
+            plainToClass(ExportCell, { value: sale.totalCapitalGain, type: ExportCellTypeEnum.CURRENCY }),
+            plainToClass(ExportCell, { value: sale.grossCapitalGain, type: ExportCellTypeEnum.CURRENCY }),
+            plainToClass(ExportCell, {
+                value: sale.concession,
+                type: ExportCellTypeEnum.STRING
+            }),
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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