taxtank 0.1.0

package/projects/tt-core/src/lib/collections/subscription/service-product.collection.ts

@@ -0,0 +1,13 @@
+import { Collection } from '../collection';
+import { ServiceProduct } from '../../models';
+import { ServiceProductStatusEnum } from '../../db/Enums/subscription/service-product-status.enum';
+
+export class ServiceProductCollection extends Collection<ServiceProduct> {
+  get title(): string {
+    return this.mapBy('title').join(', ');
+  }
+
+  getActive(): this {
+    return this.filterBy('status', ServiceProductStatusEnum.ACTIVE);
+  }
+}

package/projects/tt-core/src/lib/collections/subscription/service-subscription.collection.ts

@@ -0,0 +1,107 @@
+import { Collection } from '../collection';
+import flatten from 'lodash/flatten';
+import { SubscriptionItemCollection } from './subscription-item.collection';
+import { Dictionary, ServiceProduct, ServiceSubscription, USER_ROLES, } from '../../models';
+import { UserRolesEnum } from 'taxtank-core/common';
+import intersection from 'lodash/intersection';
+
+export class ServiceSubscriptionCollection extends Collection<ServiceSubscription> {
+  getActive(): this {
+    return this.filter((subscription) => subscription.isActive);
+  }
+
+  getInactive(): this {
+    return this.filter((subscription) => !subscription.isActive);
+  }
+
+  getTrials(): this {
+    return this.filterBy('stripeId', null);
+  }
+
+  getActiveTrials(): this {
+    return this.getActive().getTrials();
+  }
+
+  getExpiredTrials(): this {
+    // @TODO vik remove paid products
+    return this.getInactive().getTrials();
+  }
+
+  getExpiredAfter(date?: Date): this {
+    return this.getInactive().filter((item) => !date || item.endDate >= date);
+  }
+
+  getPaid(): this {
+    return this.filter((subscription) => !!subscription.stripeId);
+  }
+
+  getRoles(): UserRolesEnum[] {
+    const roles = this.getActive().toArray().flatMap((subscription: ServiceSubscription) => subscription.roles);
+    if (roles.length > 0) {
+      roles.push(UserRolesEnum.SUBSCRIPTION);
+    }
+
+    return roles;
+  }
+
+  /**
+   * search roles including hierarchy
+   */
+  hasRoles(roles: UserRolesEnum | UserRolesEnum[]): boolean {
+    roles = roles instanceof Array ? roles : [roles];
+    if (!roles.length) {
+      return true;
+    }
+
+    roles = flatten(roles.map((role) => USER_ROLES[role]));
+    return !!intersection(this.getRoles(), roles).length;
+  }
+
+  getActivePaid(): ServiceSubscription {
+    return this.getActive().find((subscription) => !!subscription.stripeId);
+  }
+
+  /**
+   * @TODO vik remove trials replaced by paid item
+   */
+  getItems(): SubscriptionItemCollection {
+    return new SubscriptionItemCollection(flatten(this.sortBy('endDate', ['asc']).mapBy('items')));
+  }
+
+  groupByProduct(products: Collection<ServiceProduct>): Dictionary<ServiceSubscription> {
+    const dictionary: Dictionary<ServiceSubscription> = new Dictionary<ServiceSubscription>([]);
+
+    products.toArray().forEach((product: ServiceProduct) => {
+      const subscriptions = this.filterByProduct(product);
+      dictionary.add(product.id, (subscriptions.getPaid().last ?? subscriptions.getTrials().first));
+    });
+
+    return dictionary;
+  }
+
+  findByProduct(product: ServiceProduct): ServiceSubscription {
+    return this.find((subscription: ServiceSubscription) => subscription.roles.includes(product.role));
+  }
+
+  filterByProduct(product: ServiceProduct): this {
+    return this.filter((subscription: ServiceSubscription) => subscription.roles.includes(product.role));
+  }
+
+  filterByRole(role: UserRolesEnum): this {
+    return this.filter((subscription: ServiceSubscription) => subscription.roles.includes(role));
+  }
+
+  filterByRoles(roles: UserRolesEnum[]): this {
+    return this.filter((subscription: ServiceSubscription) =>
+      subscription.roles.some(r => roles.includes(r))
+    );
+  }
+
+  findByRole(role: UserRolesEnum): ServiceSubscription {
+    return this.filterByRole(role).first;
+  }
+
+  hasPropertyTank(): boolean {
+    return !!this.getItems().propertiesItem;
+  }
+}

package/projects/tt-core/src/lib/collections/subscription/subscription-item.collection.ts

@@ -0,0 +1,21 @@
+import { Collection } from '../collection';
+import { ServiceProduct, ServiceSubscriptionItem } from '../../models';
+import { ServicePriceCollection } from './service-price.collection';
+
+export class SubscriptionItemCollection extends Collection<ServiceSubscriptionItem> {
+  get propertiesItem(): ServiceSubscriptionItem {
+    return this.filter((item: ServiceSubscriptionItem): boolean => item.price.product.isProperties()).last;
+  }
+
+  get propertyQuantity(): number {
+    return this.propertiesItem ? this.propertiesItem.quantity : 0;
+  }
+
+  hasProduct(product: ServiceProduct): boolean {
+    return !!this.findBy('price.product.id', product.id);
+  }
+
+  get prices(): ServicePriceCollection {
+    return new ServicePriceCollection(this.mapBy('price'));
+  }
+}

package/projects/tt-core/src/lib/collections/tax-review.collection.ts

@@ -0,0 +1,55 @@
+import { Collection } from './collection';
+import { TaxReview } from '../models/tax-review/tax-review';
+import { TaxReviewStatusEnum } from '../db/Enums/tax-review-status.enum';
+import { User } from '../models/user/user';
+import uniqBy from 'lodash/uniqBy'
+
+/**
+ * Collection of tax review
+ */
+export class TaxReviewCollection extends Collection<TaxReview> {
+  /**
+   * Get tax reviews items with SENT & COMPLETED statuses
+   */
+  getCompleted(): TaxReview[] {
+    return this.items
+      .filter((taxReview: TaxReview) => taxReview.isSent() || taxReview.isCompleted());
+  }
+
+  /**
+   * Get tax reviews items with WAITING_FOR_APPROVAL status
+   */
+  getReadyForReview(): TaxReview[] {
+    return this.items.filter((taxReview: TaxReview) => taxReview.isNew());
+  }
+
+  /**
+   * Get tax reviews items in work (In progress, Waiting for client, Waiting for Approval, Is approved)
+   */
+  getInWork(): TaxReview[] {
+    return this.items
+      .filter((taxReview: TaxReview) => taxReview.isInProgress() ||
+          taxReview.isWaitingForClient() ||
+          taxReview.isWaitingForApproval() ||
+          taxReview.isApproved());
+  }
+
+  /**
+   * get list of items filtered by status
+   * @param status
+   */
+  getByStatus(status: TaxReviewStatusEnum): TaxReview[] {
+    return this.items.filter((item: TaxReview): boolean => item.status === status);
+  }
+
+  /**
+   * get list of items by firm id
+   */
+  getByEmployeeId(employeeId: number): TaxReview[] {
+    return this.items.filter((item: TaxReview): boolean => item.employee.id === employeeId);
+  }
+
+  getEmployees(): User[] {
+    return uniqBy(this.items.map((review: TaxReview): User => review.employee), 'id');
+  }
+}

package/projects/tt-core/src/lib/collections/tax-summary/index.ts

@@ -0,0 +1,2 @@
+export * from './report-item.collection';
+export * from './tax-return-categories.const';

package/projects/tt-core/src/lib/collections/tax-summary/report-item.collection.ts

@@ -0,0 +1,121 @@
+import { Collection } from '../collection';
+import { ReportItem } from '../../models/tax-summary/report-item';
+import { TaxReturnCategoryListEnum } from '../../db/Enums';
+import { ReportItemDetails } from '../../models/tax-summary/report-item-details';
+import { TaxSummarySectionEnum } from '../../db/Enums/tax-summary-section.enum';
+import { IncomeSource } from '../../models';
+import compact from 'lodash/compact';
+
+/**
+ * collection for tax return category items
+ */
+export class ReportItemCollection extends Collection<ReportItem> {
+  /**
+   * Recursively get collection of report items by Tax Summary Section.
+   * Search items which has details
+   */
+  getBySection(section: TaxSummarySectionEnum): ReportItemCollection {
+    const result: ReportItem[] = [];
+
+    for (const reportItem of this.items) {
+      if ((reportItem.details.length || reportItem.amount) && reportItem.taxReturnCategory.section === section) {
+        result.push(reportItem)
+      } else {
+        result.push(...reportItem.items.getBySection(section).toArray());
+      }
+    }
+
+    return this.create(result);
+  }
+
+  getByCategory(categoryId: TaxReturnCategoryListEnum): ReportItem[] {
+    const result: ReportItem[] = [];
+
+    for (const reportItem of this.items) {
+      if (reportItem.taxReturnCategory.id === categoryId) {
+        result.push(reportItem);
+      } else if (reportItem.items && reportItem.items.getByCategory(categoryId).length) {
+        result.push(...reportItem.items.getByCategory(categoryId));
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Recursively find report item by Tax Return Category ID
+   */
+  findByCategory(categoryId: TaxReturnCategoryListEnum): ReportItem {
+    let result: ReportItem;
+
+    for (const reportItem of this.items) {
+      if (result) {
+        break;
+      }
+
+      if (reportItem.taxReturnCategory.id === categoryId) {
+        result = reportItem;
+      } else {
+        result = reportItem.items.findByCategory(categoryId);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * get Collection of report items by Tax Return Categories IDs (one item per category)
+   */
+  findByCategories(categories: TaxReturnCategoryListEnum[]): ReportItemCollection {
+    return this.create(
+      compact(categories.map((category: TaxReturnCategoryListEnum) => this.findByCategory(category)))
+    );
+  }
+
+  /**
+   * Get Collection of report items by Tax Return Categories IDs (all items per category)
+   */
+  getByCategories(categories: TaxReturnCategoryListEnum[]): ReportItemCollection {
+    const reportItems: ReportItem[] = [];
+    categories.forEach((category) => {
+      reportItems.push(...this.getByCategory(category));
+    });
+
+    return this.create(reportItems);
+  }
+
+  /**
+   * A short call to a chain of methods that we often use.
+   * Get total amount of report items by Tax Return categories and Tax Summary Section.
+   */
+  sumByCategoriesAndSection(categories: TaxReturnCategoryListEnum[], section: TaxSummarySectionEnum): number {
+    return this.findByCategories(categories).getBySection(section).sumBy('amount');
+  }
+
+  /**
+   * @TODO vik refactor once Nicole approved
+   * unlike sumByCategoriesAndSection, which find just one reportItem per category,
+   * this method will search for recursively for all matches
+   */
+  sumByCategories(categories: TaxReturnCategoryListEnum[]): number {
+    return this.getByCategories(categories).sumBy('amount');
+  }
+
+  /**
+   * Get collection of all report item details related to passed income source
+   * @TODO Alex: consider to create and move to ReportItemDetailsCollection
+   */
+  getDetailsByIncomeSource(incomeSource: IncomeSource): Collection<ReportItemDetails> {
+    const result: ReportItemDetails[] = [];
+
+    for (const reportItem of this.items) {
+      if (reportItem.details.length) {
+        result.push(...reportItem.details.filter((details: ReportItemDetails) => details.name === incomeSource.name));
+      } else {
+        result.push(...reportItem.items.getDetailsByIncomeSource(incomeSource).toArray());
+      }
+    }
+
+    return new Collection<ReportItemDetails>(result);
+  }
+}

package/projects/tt-core/src/lib/collections/tax-summary/tax-return-categories.const.ts

@@ -0,0 +1,129 @@
+import { TaxReturnCategoryListEnum } from '../../db/Enums';
+
+/**
+ * @TODO vik check (tax_return_category/tax_return_item/chart_accounts)
+ */
+export const TAX_RETURN_CATEGORIES: { [key: string]: { [key: string]: TaxReturnCategoryListEnum[] } } = {
+  work: {
+    income: [
+      TaxReturnCategoryListEnum.WORK_SALARY,
+      TaxReturnCategoryListEnum.WORK_GOVERNMENT_ALLOWANCES,
+      TaxReturnCategoryListEnum.WORK_ANNUITIES_SUPER_INCOME_STREAMS,
+      TaxReturnCategoryListEnum.WORK_ATTRIBUTED_PSI_INCOME,
+      TaxReturnCategoryListEnum.WORK_GROSS_INTEREST,
+      TaxReturnCategoryListEnum.WORK_ALLOWANCES_EARNINGS_TIPS_DIRECTOR_FEES,
+      TaxReturnCategoryListEnum.WORK_EMPLOYER_LUMP_SUM_PAYMENTS,
+      TaxReturnCategoryListEnum.WORK_ETP,
+      TaxReturnCategoryListEnum.WORK_GOVERNMENT_PENSIONS,
+      TaxReturnCategoryListEnum.WORK_SUPERANNUATION_LUMP_SUM_PAYMENTS,
+      TaxReturnCategoryListEnum.WORK_SHARE_SCHEMES,
+      TaxReturnCategoryListEnum.WORK_PARTNERSHIPS,
+      TaxReturnCategoryListEnum.WORK_TRUSTS,
+      TaxReturnCategoryListEnum.WORK_OTHER_INCOME,
+    ],
+    expenses: [
+      TaxReturnCategoryListEnum.WORK_CAR_EXPENSES,
+      TaxReturnCategoryListEnum.WORK_TRAVEL_EXPENSES,
+      TaxReturnCategoryListEnum.WORK_CLOTHES_EXPENSES,
+      TaxReturnCategoryListEnum.WORK_SELF_EDUCATION_EXPENSES,
+      TaxReturnCategoryListEnum.WORK_OTHER_EXPENSES,
+      TaxReturnCategoryListEnum.WORK_LVP_DEDUCTION,
+      TaxReturnCategoryListEnum.WORK_DONATION,
+      TaxReturnCategoryListEnum.WORK_TAX_AFFAIRS,
+      TaxReturnCategoryListEnum.WORK_OTHER_DEDUCTIONS,
+      TaxReturnCategoryListEnum.WORK_SUPER_CONTRIBUTION,
+    ],
+    depreciation: [
+      TaxReturnCategoryListEnum.WORK_RELATED_DEPRECIATION
+    ],
+    interest: [],
+    taxWithheld: [
+      TaxReturnCategoryListEnum.TAX_WITHHELD
+    ],
+  },
+  property: {
+    income: [
+      TaxReturnCategoryListEnum.GROSS_RENT
+    ],
+    expenses: [
+      TaxReturnCategoryListEnum.OTHER_RENTAL_DEDUCTIONS
+    ],
+    interest: [
+      TaxReturnCategoryListEnum.INTEREST_DEDUCTIONS
+    ],
+    depreciation: [
+      TaxReturnCategoryListEnum.CAPITAL_WORKS,
+      // @TODO Nik/Alex (it was TaxReturnCategoryListEnum.DEPRECIATION which doesn't exist)
+      TaxReturnCategoryListEnum.PLANT_AND_EQUIPMENT
+    ]
+  },
+  holdings: {
+    income: [
+      TaxReturnCategoryListEnum.HOLDING_GROSS_INCOME,
+      TaxReturnCategoryListEnum.HOLDING_DIVIDENDS,
+      TaxReturnCategoryListEnum.HOLDING_BONUSES_FROM_LIFE_INSURANCE,
+      TaxReturnCategoryListEnum.HOLDING_FORESTRY_MANAGED_INVESTMENT_SCHEMES,
+      TaxReturnCategoryListEnum.HOLDING_OTHER_INCOME,
+      TaxReturnCategoryListEnum.HOLDING_PARTNERSHIPS,
+      TaxReturnCategoryListEnum.HOLDING_TRUSTS,
+    ],
+    expenses: [
+      TaxReturnCategoryListEnum.HOLDING_INTEREST_DEDUCTIONS,
+      TaxReturnCategoryListEnum.HOLDING_DIVIDEND_DEDUCTION,
+      TaxReturnCategoryListEnum.HOLDING_UPP,
+      TaxReturnCategoryListEnum.HOLDING_INVESTMENT_SCHEME,
+      TaxReturnCategoryListEnum.HOLDING_INVESTMENT_SCHEME_DEDUCTION,
+      TaxReturnCategoryListEnum.HOLDING_OTHER_DEDUCTION,
+    ],
+    taxCredits: [
+      TaxReturnCategoryListEnum.TAX_CREDITS
+    ],
+    taxOffsets: [
+      TaxReturnCategoryListEnum.TAX_OFFSETS,
+      TaxReturnCategoryListEnum.TAX_OFFSETS_LOW,
+      TaxReturnCategoryListEnum.TAX_OFFSETS_MIDDLE,
+    ]
+  },
+  sole: {
+    income: [
+      TaxReturnCategoryListEnum.PSI_SBE_INCOME,
+      TaxReturnCategoryListEnum.GROSS_PAYMENTS_NO_ABN_GIVEN,
+      TaxReturnCategoryListEnum.GROSS_PAYMENTS_VOLUNTARY_AGREEMENT,
+      TaxReturnCategoryListEnum.GROSS_PAYMENTS_LABOUR_HIRE_OR_OTHER,
+      TaxReturnCategoryListEnum.ASSESSABLE_GOVERNMENT_PAYMENTS,
+      TaxReturnCategoryListEnum.OTHER_BUSINESS_INCOME,
+    ],
+    expenses: [
+      TaxReturnCategoryListEnum.PURCHASES_AND_OTHER_COSTS,
+      TaxReturnCategoryListEnum.CONTRACTORS_SUBCONTRACTORS_COMMISSION_EXPENSES,
+      TaxReturnCategoryListEnum.SUPERANNUATION_EXPENSES,
+      TaxReturnCategoryListEnum.BAD_DEBTS,
+      TaxReturnCategoryListEnum.LEASE_EXPENSES,
+      TaxReturnCategoryListEnum.RENT_EXPENSES,
+      TaxReturnCategoryListEnum.INTEREST_EXPENSES_WITHIN_AUSTRALIA,
+      TaxReturnCategoryListEnum.INTEREST_EXPENSES_OVERSEAS,
+      TaxReturnCategoryListEnum.MOTOR_VEHICLE_EXPENSES,
+      TaxReturnCategoryListEnum.ALL_OTHER_EXPENSES,
+    ],
+    depreciation: [
+      TaxReturnCategoryListEnum.DEPRECIATION_EXPENSES,
+    ],
+    loss: [
+      TaxReturnCategoryListEnum.DEFERRED_BUSINESS_LOSSES_FROM_PRIOR_YEAR,
+    ],
+    lossCurrent: [
+      TaxReturnCategoryListEnum.DEFERRED_BUSINESS_LOSSES,
+    ],
+  },
+  summary: {
+    income: [
+      TaxReturnCategoryListEnum.GROSS_TAX_PAYABLE, TaxReturnCategoryListEnum.TAX_PAYABLE
+    ],
+    taxCredits: [
+      TaxReturnCategoryListEnum.TAX_CREDITS
+    ],
+    taxOffsets: [
+      TaxReturnCategoryListEnum.TAX_OFFSETS,
+    ]
+  }
+}

package/projects/tt-core/src/lib/collections/transaction/index.ts

@@ -0,0 +1,3 @@
+export * from './transaction.collection';
+export * from './transaction-allocation.collection';
+export * from './transaction-base.collection';

package/projects/tt-core/src/lib/collections/transaction/transaction-allocation.collection.ts

@@ -0,0 +1,51 @@
+import { Collection } from '../collection';
+import { BankTransaction, Transaction, TransactionAllocation } from '../../models';
+import { BankTransactionCollection } from '../bank-transaction.collection';
+import { CollectionDictionary } from '../collection-dictionary';
+
+export class TransactionAllocationCollection extends Collection<TransactionAllocation> {
+  get amount(): number {
+    return this.sumBy('amount');
+  }
+
+  getByTransactionsIds(ids: number[]): TransactionAllocationCollection {
+    return new TransactionAllocationCollection(
+      this.items.filter((allocation: TransactionAllocation): boolean => ids.includes(allocation.transaction.id))
+    );
+  }
+
+  getByBankTransactionsIds(ids: number[]): TransactionAllocationCollection {
+    return new TransactionAllocationCollection(
+      this.items.filter((allocation: TransactionAllocation): boolean => ids.includes(allocation.bankTransaction.id))
+    );
+  }
+
+  /**
+   * Group allocations by bank account via bank transactions collection
+   */
+  groupByBankAccount(bankTransactions: BankTransactionCollection): CollectionDictionary<TransactionAllocationCollection> {
+    // Group bank transactions by bank account id
+    const bankTransactionsByBankAccount = bankTransactions.groupBy('bankAccount.id');
+    // Create empty dictionary of transaction allocations
+    const allocationsByBankAccount = new TransactionAllocationCollection([]).groupBy();
+    // Fill allocations dictionary with bank transactions dictionary keys and allocations related with each bank transaction collection
+    bankTransactionsByBankAccount.keys.forEach((key: string): void => {
+      allocationsByBankAccount.add(key, this.getByBankTransactionsIds(bankTransactionsByBankAccount.get(key).getIds()));
+    });
+    return allocationsByBankAccount;
+  }
+
+  /**
+   * check if collection includes allocation of passed transaction
+   */
+  hasTransaction(transaction: Transaction): boolean {
+    return !!this.items.find((allocation: TransactionAllocation): boolean => allocation.transaction.id === transaction.id);
+  }
+
+  /**
+   * Check if bank transaction is related with current allocations
+   */
+  hasBankTransaction(bankTransaction: BankTransaction): boolean {
+    return !!this.items.find((allocation: TransactionAllocation): boolean => allocation.bankTransaction.id === bankTransaction.id);
+  }
+}

package/projects/tt-core/src/lib/collections/transaction/transaction-base.collection.ts

@@ -0,0 +1,6 @@
+import { ExportableCollection } from '../exportable.collection';
+import { TransactionBase } from '../../db/Models';
+
+export abstract class TransactionBaseCollection<Model extends TransactionBase> extends ExportableCollection<Model> {
+
+}