taxtank-core 0.0.1 → 0.1.1

package/src/lib/collections/collection-dictionary.ts

@@ -0,0 +1,112 @@
+import has from 'lodash/has';
+import get from 'lodash/get';
+import flatten from 'lodash/flatten';
+import { AbstractCollection } from './abstract.collection';
+
+/**
+ * List of collections grouped by passed property
+ */
+export class CollectionDictionary<Collection extends AbstractCollection<object>> {
+  /**
+   * List of grouped collections
+   */
+  private items: { [key: string]: Collection } = {};
+
+  /**
+   * Constructor function of passed collection for creating new instances
+   */
+  private collectionConstructor: new (items: object[]) => Collection;
+
+  /**
+   * @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: Collection,
+    path: string = '',
+    prop: string = 'id'
+  ) {
+    this.collectionConstructor = collection.constructor as new (items: object[]) => Collection;
+
+    // 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(): string[] {
+    return Object.keys(this.items);
+  }
+
+  /**
+   * Get collection by key or return empty collection if key does not exist
+   */
+  get(key: string | number): Collection {
+    return this.items[key] ? this.items[key] : this.createCollection([]);
+  }
+
+  /**
+   * Add new item by key
+   */
+  add(key: string | number, value: Collection) {
+    this.items[key] = value;
+  }
+
+  /**
+   * Join several collections by ids
+   */
+  merge(keys: number[]): Collection {
+    return this.createCollection(
+      flatten(
+        keys.map((id: number): object[] => this.get(id.toString()).items)
+      )
+    );
+  }
+
+  /**
+   * Create instance of collection
+   */
+  createCollection(items: object[] = []): Collection {
+    return new this.collectionConstructor(items);
+  }
+
+  /**
+   * Group collection items by passed path into items object
+   */
+  private groupItems(collection: Collection, path: string, prop: string): void {
+    // Create empty initial object for groups
+    const obj: { [key: string]: Array<object> } = {};
+
+    // Group collection items
+    collection.items.forEach((item: object): void => {
+      let key: string = 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: string): void => {
+      this.items[key] = this.createCollection(obj[key]);
+    });
+  }
+}

package/src/lib/collections/depreciation-forecast.collection.ts

@@ -0,0 +1,25 @@
+import { AbstractCollection } from './abstract.collection';
+import { DepreciationForecast } from '../models/depreciation/depreciation-forecast';
+
+/**
+ * Collection of depreciations
+ */
+export class DepreciationForecastCollection extends AbstractCollection<DepreciationForecast> {
+  filterByYear(financialYear: number): any {
+    return new DepreciationForecastCollection(
+      this.items.filter((forecast: DepreciationForecast) => forecast.financialYear === financialYear)
+    );
+  }
+
+  getClaimAmountByMonth(month: number): number {
+    return this.items.reduce((sum: number, item: DepreciationForecast): number => sum + item.getClaimAmountByMonth(month), 0);
+  }
+
+  get amount(): number {
+    return this.getSummary('amount');
+  }
+
+  get claimAmount(): number {
+    return this.getSummary('claimAmount');
+  }
+}

package/src/lib/collections/depreciation.collection.ts

@@ -0,0 +1,113 @@
+import { TankTypeEnum } from '../db/Enums/tank-type.enum';
+import { AbstractCollection } from './abstract.collection';
+import { Depreciation } from '../models/depreciation/depreciation';
+import uniqBy from 'lodash/uniqBy';
+import compact from 'lodash/compact';
+import { DepreciationCapitalProject } from '../models/depreciation/depreciation-capital-project';
+
+export class DepreciationCollection extends AbstractCollection<Depreciation> {
+
+  /**
+   * Get total amount of all depreciations in the collection
+   */
+  get amount(): number {
+    return this.items.reduce((sum: number, depreciation: Depreciation): number => sum + depreciation.amount, 0);
+  }
+
+  get claimAmount(): number {
+    return this.items.reduce((sum: number, depreciation: Depreciation) => {
+      return sum + depreciation.claimAmount;
+    }, 0);
+  }
+
+  getClaimAmountByYear(year: number): number {
+    return this.items.reduce((sum: number, depreciation: Depreciation): number => {
+      return sum + depreciation.getClaimAmountByYear(year);
+    }, 0);
+  }
+
+  get assetValue(): number {
+    return this.sumBy('assetValue');
+  }
+
+  /**
+   * Get new depreciations collections filtered by tank type
+   */
+  getByTankType(tankType: TankTypeEnum): DepreciationCollection {
+    if (tankType === TankTypeEnum.PROPERTY) {
+      return new DepreciationCollection(
+        this.items.filter((depreciation: Depreciation): boolean => depreciation.isPropertyTank())
+      );
+    }
+
+    return new DepreciationCollection(
+      this.items.filter((depreciation: Depreciation): boolean => depreciation.isWorkTank())
+    );
+  }
+
+  getByPropertiesIds(ids: number[]) {
+    return new DepreciationCollection(
+      this.items.filter((depreciation: Depreciation): boolean => ids.includes(depreciation.property?.id))
+    );
+  }
+
+  getWithoutBorrowingExpenses(): DepreciationCollection {
+    return new DepreciationCollection(
+      this.items.filter((depreciation: Depreciation): boolean => !depreciation.isBorrowingExpense())
+    );
+  }
+
+  getWorkDepreciations(): DepreciationCollection {
+    return new DepreciationCollection(
+      this.items.filter((depreciation: Depreciation): boolean => depreciation.isWorkTank())
+    );
+  }
+
+  getPropertyDepreciations(): DepreciationCollection {
+    return new DepreciationCollection(
+      this.items.filter((depreciation: Depreciation): boolean => depreciation.isPropertyTank())
+    );
+  }
+
+  getPlantEquipment(): DepreciationCollection {
+    return new DepreciationCollection(
+      this.items.filter((depreciation: Depreciation): boolean => depreciation.isPlantEquipment())
+    );
+  }
+
+  getCapitalDepreciations(): DepreciationCollection {
+    return new DepreciationCollection(
+      this.items.filter((depreciation: Depreciation): boolean => depreciation.isCapital())
+    );
+  }
+
+  getBorrowingExpenseDepreciations(): DepreciationCollection {
+    return new DepreciationCollection(
+      this.items.filter((depreciation: Depreciation): boolean => depreciation.isBorrowingExpense())
+    );
+  }
+
+  getWrittenOffDepreciations(): DepreciationCollection {
+    return new DepreciationCollection(
+      this.items.filter((depreciation: Depreciation): boolean => depreciation.isWrittenOff())
+    );
+  }
+
+  getLowValuePoolDepreciations(): DepreciationCollection {
+    return new DepreciationCollection(
+      this.items.filter((depreciation: Depreciation): boolean => depreciation.isLowValuePool())
+    );
+  }
+
+  getCapitalProjects(): DepreciationCapitalProject[] {
+    return uniqBy(
+      compact(
+        this.items.map((depreciation: Depreciation): DepreciationCapitalProject => {
+          return depreciation.depreciationCapitalProject;
+        })
+      ),
+      'id'
+    );
+  }
+}
+

package/src/lib/collections/employee.collection.ts

@@ -0,0 +1,14 @@
+import { AbstractCollection } from './abstract.collection';
+import { User } from '../models/user/user';
+import { FirmTypeEnum } from '../db/Enums/firm-type.enum';
+
+
+export class EmployeeCollection extends AbstractCollection<User> {
+  get accountant(): User {
+    return this.items.filter((user: User) => user.employeeDetails.firm.type === FirmTypeEnum.ACCOUNTANT)[0] ?? null;
+  }
+
+  get advisors(): User[] {
+    return this.items.filter((user: User) => user.employeeDetails.firm.type === FirmTypeEnum.ADVISOR);
+  }
+}

package/src/lib/collections/income-source.collection.ts

@@ -0,0 +1,44 @@
+import { AbstractCollection } from './abstract.collection';
+import { IncomeSource } from '../models/income-source/income-source';
+import { TankTypeEnum } from '../db/Enums/tank-type.enum';
+import { IncomeSourceTypeEnum } from '../db/Enums/income-source-type.enum';
+import { ISalaryForecast } from '../interfaces/salary-forecast.interface';
+
+/**
+ * Collection of income sources
+ */
+export class IncomeSourceCollection extends AbstractCollection<IncomeSource> {
+  filterByTank(tank: TankTypeEnum): IncomeSource[] {
+    return this.items.filter((incomeSource: IncomeSource) => {
+      switch (tank) {
+        case TankTypeEnum.OTHER:
+          return incomeSource.isOtherIncome();
+        default:
+          return incomeSource.isSalaryIncome() || incomeSource.isWorkIncome();
+      }
+    });
+  }
+
+  /**
+   * Filter income sources by provided tyoes
+   * @param types
+   */
+  filterByTypes(types: IncomeSourceTypeEnum[]): IncomeSource[] {
+    return this.items.filter((incomeSource: IncomeSource) => types.includes(incomeSource.type));
+  }
+
+  /**
+   * Get income source by provided Id
+   * @param id
+   */
+  getById(id: number): IncomeSource {
+    return this.items.find((incomeSource: IncomeSource) => incomeSource.id === id);
+  }
+
+  /**
+   * Get income sources list of forecasts
+   */
+  get forecasts(): ISalaryForecast[] {
+    return this.items.map((incomeSource: IncomeSource) => incomeSource.forecasts).flat();
+  }
+}

package/src/lib/collections/loan.collection.ts

@@ -0,0 +1,22 @@
+import { AbstractCollection } from './abstract.collection';
+import { Loan } from '../models/loan/loan';
+
+export class LoanCollection extends AbstractCollection<Loan> {
+  /**
+   * Get new collection of loans filtered by bank accounts ids
+   * @param ids list of bank accounts ids for filter
+   */
+  getByBankAccountsIds(ids: number[]): LoanCollection {
+    return new LoanCollection(
+      this.items.filter((loan: Loan): boolean => ids.includes(loan.bankAccount?.id))
+    );
+  }
+
+  /**
+   * Get single loan by bank account id
+   * @param id id of bank account
+   */
+  getByBankAccountId(id: number): Loan {
+    return this.items.find((loan: Loan): boolean => loan.bankAccount?.id === id);
+  }
+}

package/src/lib/collections/logbook.collection.ts

@@ -0,0 +1,129 @@
+import { VehicleLogbook } from '../models/logbook/vehicle-logbook';
+import { FinancialYear } from '../models/financial-year/financial-year';
+import { LogbookPeriod } from '../models/logbook/logbook-period';
+import { Vehicle } from '../models/logbook/vehicle';
+import { plainToClass } from 'class-transformer';
+
+// Class contain array of vehicle logbooks and calculate the best period for logbook claim method
+export class LogbookCollection {
+  // array of all trips
+  trips: VehicleLogbook[];
+  // 12 weeks in milliseconds to check logbooks range
+  logbookClaimRange: number = 12 * 7 * 24 * 3600 * 1000;
+  // current financial year object
+  financialYear: FinancialYear;
+  // default best period used for comparison in calculation
+  private _bestPeriod: LogbookPeriod;
+
+  constructor(
+    vehicles: Vehicle[]
+  ) {
+    this.trips = vehicles.map((vehicle: Vehicle) => vehicle.logbook).flat();
+    this.financialYear = new FinancialYear();
+    this.setInitialBestPeriod();
+  }
+
+  // check if summary logbooks date range less than 84 days (12 weeks)
+  get isAutomaticLogbookCalculationAllowed(): boolean {
+    // forbid automatic logbook calculation if no logbook trips exist
+    if (!this.trips.length) {
+      return false;
+    }
+
+    // forbid automatic logbook calculation if logbook trips summary date range less than 12 weeks
+    return this.trips.slice(-1)[0].date.getTime() - this.trips[0].date.getTime() >= this.logbookClaimRange;
+  }
+
+  get bestPeriod(): LogbookPeriod {
+    // don't calculate if not allowed
+    if (!this.isAutomaticLogbookCalculationAllowed) {
+      return null;
+    }
+
+    this.calculateBestPeriod();
+
+    return this._bestPeriod;
+  }
+
+  private get workTrips(): VehicleLogbook[] {
+    return this.trips.filter((logbook: VehicleLogbook) => logbook.isWork);
+  }
+
+  // calculate best period for logbook claim method
+  private calculateBestPeriod(): void {
+
+    // set default best period values for real values comparison
+    this.setInitialBestPeriod();
+
+    // get best period with each trip date as start date
+    this.workTrips.forEach((logbook: VehicleLogbook) => {
+      const dateRange: {from: Date, to: Date} = this.getDateRange(logbook.date);
+
+      // get all trips included in current 12 weeks period
+      const tripsInRange: VehicleLogbook[] = this.trips.filter((l: VehicleLogbook) => {
+        return l.date >= dateRange.from && l.date <= dateRange.to;
+      });
+
+      // get work trips included in current 12 weeks period
+      const workTripsInRange: VehicleLogbook[] = tripsInRange.filter((l: VehicleLogbook) => l.isWork);
+
+      // calculate sum of work kilometers in current 12 weeks range
+      const currentRangeKilometers: number = this.getKilometersAmount(workTripsInRange);
+
+      // overwrite best period with current 12 weeks range if amount of kilometers is bigger
+      if (currentRangeKilometers > this._bestPeriod.kilometers) {
+        this._bestPeriod = {
+          from: dateRange.from,
+          to: dateRange.to,
+          kilometers: currentRangeKilometers,
+          workUsage: this.getLogbooksWorkUsage(tripsInRange, workTripsInRange)
+        };
+      }
+    });
+  }
+
+  private getDateRange(from: Date): {from: Date, to: Date} {
+    // set end date after 12 weeks after start date
+    let to: Date = new Date(from.getTime() + this.logbookClaimRange);
+
+    // set as period last 12 weeks of current year if period end date after end of current year
+    if (to > this.financialYear.endDate) {
+      to = this.financialYear.endDate;
+      from = new Date(to.getTime() - this.logbookClaimRange);
+    }
+
+    return {from, to};
+  }
+
+  // calculate kilometers amount for passed trips
+  private getKilometersAmount(logbooks: VehicleLogbook[]): number {
+    if (!logbooks.length) {
+      return 0;
+    }
+
+    return logbooks.map((logbook: VehicleLogbook) => logbook.odometerEnd - logbook.odometerStart)
+      .reduce((prev: number, next: number) => prev + Number(next));
+  }
+
+  // calculate work usage for passed trips
+  private getLogbooksWorkUsage(logbooks: VehicleLogbook[], workLogbooks: VehicleLogbook[]): number {
+    const kilometers: number = this.getKilometersAmount(logbooks);
+    const workKilometers: number = this.getKilometersAmount(workLogbooks);
+    return Math.round(workKilometers / kilometers * 100);
+  }
+
+  // set default best period with zero values and fin year start date for comparison in calculation
+  private setInitialBestPeriod(): void {
+    // set 1st of July of current year as default start date for best period
+    const startDate: Date = this.financialYear.startDate;
+    // set end custom-date after 12 weeks from start date
+    const endDate: Date = new Date(startDate.getTime() + this.logbookClaimRange);
+
+    this._bestPeriod = plainToClass(LogbookPeriod, {
+      from: startDate,
+      to: endDate,
+      kilometers: 0,
+      workUsage: 0
+    });
+  }
+}

package/src/lib/collections/message-document.collection.ts

@@ -0,0 +1,16 @@
+import { AbstractCollection } from './abstract.collection';
+import { MessageDocument } from '../models/chat/message-document';
+
+/**
+ * Collection of MessageDocument instances
+ */
+export class MessageDocumentCollection extends AbstractCollection<MessageDocument> {
+  /**
+   * get list of documents which are not attached to any message
+   */
+  getUnattached(): MessageDocumentCollection {
+    return new MessageDocumentCollection(
+      this.items.filter((doc: MessageDocument): boolean => !doc.message)
+    );
+  }
+}

package/src/lib/collections/message.collection.ts

@@ -0,0 +1,27 @@
+import { AbstractCollection } from './abstract.collection';
+import { Message } from '../models/chat/message';
+import { User } from '../models/user/user';
+
+
+export class MessageCollection extends AbstractCollection<Message> {
+  getFirstUnreadMessage(user: User): Message {
+    return this.items.find((message: Message): boolean => {
+        return !message.isRead() && message.isFromEmployee() !== user.isEmployee();
+      }
+    );
+  }
+
+  /**
+   * Get List of unread chats
+   */
+  getUnread(): Message[] {
+    return this.items.filter((message: Message): boolean => !message.readAt);
+  }
+
+  /**
+   * Check if chat has unread chats
+   */
+  hasUnread(): boolean {
+    return !!this.getUnread().length;
+  }
+}

package/src/lib/collections/property.collection.ts

@@ -0,0 +1,88 @@
+import { AbstractCollection } from './abstract.collection';
+import { Property } from '../models/property/property';
+import { FinancialYear } from '../models/financial-year/financial-year';
+
+export class PropertyCollection extends AbstractCollection<Property> {
+  /**
+   * Get new property collection filtered by category id
+   * @param id id of category for filter
+   */
+  getByCategoryId(id: number): PropertyCollection {
+    return new PropertyCollection(
+      this.items.filter((property: Property): boolean => property.category.id === id)
+    );
+  }
+
+  /**
+   * Get new property collection filtered by active status
+   */
+  getActiveProperties(): PropertyCollection {
+    return new PropertyCollection(
+      this.items.filter((property: Property): boolean => property.isActive)
+    );
+  }
+
+  /**
+   * Get new property collection filtered by owner
+   */
+  getOwnProperties(): PropertyCollection {
+    return new PropertyCollection(
+      this.items.filter((property: Property): boolean => property.isOwn())
+    );
+  }
+
+  /**
+   * Get new property collection filtered by shared
+   */
+  getSharedProperties(): PropertyCollection {
+    return new PropertyCollection(
+      this.items.filter((property: Property): boolean => !property.isOwn())
+    );
+  }
+
+  /**
+   * Get total purchase price for all properties in the collection
+   */
+  get purchasePrice(): number {
+    return this.sumBy('purchasePrice');
+  }
+
+  get growthPercent(): number {
+    return this.sumBy('growthPercent');
+  }
+
+  get marketValue(): number {
+    return this.sumBy('marketValue');
+  }
+
+  get forecastedRentalReturn(): number {
+    return this.sumBy('forecastedRentalReturn');
+  }
+
+  get forecastedTaxPosition(): number {
+    return this.sumBy('forecastedTaxPosition');
+  }
+
+  get firstForecastYear(): number {
+    return this.items.reduce((min: number, property: Property): number => {
+      const current: number = property.firstForecastYear;
+      return min > current ? current : min;
+    }, new FinancialYear().year);
+  }
+
+  get marketValueGrowth(): number {
+    return this.sumBy('marketValueGrowth');
+  }
+
+  getOwnerOccupiedProperties(): PropertyCollection {
+    return new PropertyCollection(
+      this.items.filter((property: Property): boolean => property.category.isOwnerOccupied())
+    );
+  }
+
+  get earliestPurchaseDate(): Date {
+    return this.items.reduce((min: Date, property: Property): Date => {
+      return min < property.purchaseDate ? min : property.purchaseDate;
+    }, new FinancialYear(new Date()).startDate);
+  }
+}

package/src/lib/collections/service-price.collection.ts

@@ -0,0 +1,13 @@
+import { AbstractCollection } from './abstract.collection';
+import { ServicePrice } from '../models/service-subscription/service-price';
+
+
+export class ServicePriceCollection extends AbstractCollection<ServicePrice> {
+  get work(): ServicePrice {
+    return this.items.filter((price: ServicePrice) => price.product.isWork())[0];
+  }
+
+  get property(): ServicePrice {
+    return this.items.filter((price: ServicePrice) => price.product.isProperty())[0];
+  }
+}

package/src/lib/collections/service-subscription.collection.ts

@@ -0,0 +1,20 @@
+import { AbstractCollection } from './abstract.collection';
+import { ServiceSubscription } from '../models/service-subscription/service-subscription';
+
+export class ServiceSubscriptionCollection extends AbstractCollection<ServiceSubscription> {
+  get individual(): ServiceSubscription {
+    return this.items.filter((subscription: ServiceSubscription) => subscription.isIndividual())[0];
+  }
+
+  get investor(): ServiceSubscription {
+    return this.items.filter((subscription: ServiceSubscription) => subscription.isInvestor())[0];
+  }
+
+  get investorPlus(): ServiceSubscription {
+    return this.items.filter((subscription: ServiceSubscription) => subscription.isInvestorPlus())[0];
+  }
+
+  getRecommended(properties: number): ServiceSubscription {
+    return this.items.filter((subscription: ServiceSubscription) => subscription.propertyQuantity === properties)[0] ?? this.investor;
+  }
+}