taxtank 0.1.0

package/projects/tt-core/src/lib/db/Models/transaction/transaction-base.ts

@@ -0,0 +1,111 @@
+import { Property } from '../property/property';
+import { ChartAccounts as ChartAccountsBase } from '../chart-accounts/chart-accounts';
+import { AppFile, CHART_ACCOUNTS_CATEGORIES, ChartAccounts } from '../../../models';
+import { SoleBusiness } from '../sole/sole-business';
+import { Exclude, Transform, Type } from 'class-transformer';
+import { TankTypeEnum } from '../../Enums/tank-type.enum';
+import { ObservableModel } from '../observable-model';
+
+export abstract class TransactionBase extends ObservableModel {
+  // @TODO update db scheme to always have a number
+  @Transform(({ value }) => value === null ? null : +value)
+  amount?: number;
+
+  @Type(() => AppFile)
+  file: AppFile;
+
+  property?: Property;
+  business?: SoleBusiness;
+  date?: Date;
+  chartAccounts?: ChartAccountsBase;
+  description?: string;
+
+  /**
+   * gst applies to sole trader expense/income, if he is registered and chartAccounts is eligible
+   */
+  isGST?: boolean;
+  claimPercent?: number;
+
+  @Transform(({ value }) => +value)
+  sharedClaimPercent?: number;
+
+  get gstCoefficient(): number {
+    return this.isGST ? ChartAccounts.GSTCoefficient : 1;
+  }
+
+  get claimRatio(): number {
+    return this.sharedClaimPercent / 100;
+  }
+
+  get tankType(): TankTypeEnum {
+    switch (true) {
+      case this.isPropertyTank():
+        return TankTypeEnum.PROPERTY;
+      case this.isWorkTank():
+        return TankTypeEnum.WORK;
+      case this.isSoleTank():
+        return TankTypeEnum.SOLE;
+      case this.isHoldingTank():
+        return TankTypeEnum.HOLDING;
+      case this.isOtherTank():
+        return TankTypeEnum.OTHER;
+      default:
+        return TankTypeEnum.PERSONAL;
+    }
+  }
+
+  /**
+   * @TODO remove when AllocateForm is refactored and not merging with Transaction class which cause the issue
+   */
+  set tankType(tankType: TankTypeEnum) {}
+
+  isPropertyTank(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.property.includes(this.chartAccounts?.category)
+  }
+
+  isWorkTank(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.work.includes(this.chartAccounts?.category);
+  }
+
+  isSoleTank(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.sole.includes(this.chartAccounts?.category);
+  }
+
+  isHoldingTank(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.holding.includes(this.chartAccounts?.category);
+  }
+
+  isOtherTank(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.other.includes(this.chartAccounts?.category);
+  }
+
+  isPersonalTank(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.personal.includes(this.chartAccounts?.category);
+  }
+
+  @Exclude()
+  get amountWithGst(): number {
+    return this.isGST ? this.amount * ChartAccounts.GSTCoefficient : this.amount;
+  }
+
+  @Exclude()
+  get gstAmount(): number {
+    return this.amountWithGst - this.amount;
+  }
+
+  @Exclude()
+  get gstClaimAmount(): number {
+    return this.gstAmount * this.claimRatio;
+  }
+
+  /**
+   * base grossAmount, extends in child classes
+   */
+  get grossAmount(): number {
+    return this.amount + this.gstAmount;
+  }
+
+  get grossClaimAmount(): number {
+    return this.grossAmount * this.claimRatio;
+  }
+}

package/projects/tt-core/src/lib/db/Models/transaction/transaction-meta-field.ts

@@ -0,0 +1,12 @@
+import { Transaction } from './transaction';
+import { ChartAccountsMetaField } from '../chart-accounts/chart-accounts-meta-field';
+import { AbstractModel } from '../abstract-model';
+
+export class TransactionMetaField extends AbstractModel {
+  value?: string;
+  deletedAt?: Date;
+  createdAt?: Date;
+  updatedAt?: Date;
+  transaction?: Transaction;
+  chartAccountsMetaField?: ChartAccountsMetaField;
+}

package/projects/tt-core/src/lib/db/Models/transaction/transaction.ts

@@ -0,0 +1,50 @@
+import { TransactionTypeEnum } from '../../Enums/transaction-type.enum';
+import { TransactionSourceEnum } from '../../Enums/transaction-source.enum';
+import { TransactionOperationEnum } from '../../Enums/transaction-operation.enum';
+import { User } from '../user/user';
+import { ChartAccounts } from '../chart-accounts/chart-accounts';
+import { IncomeSource } from '../incomeSource/income-source';
+import { TransactionMetaField } from './transaction-meta-field';
+import { TransactionAllocation } from './transaction-allocation';
+import { Loan } from '../loan/loan';
+import { TransactionBase } from './transaction-base';
+import { Property } from '../property/property';
+import { Depreciation } from '../depreciation/depreciation';
+import { SoleBusiness } from '../sole/sole-business';
+import { SoleInvoiceItem } from '../sole/sole-invoice-item';
+
+export class Transaction extends TransactionBase {
+  static className = 'Transaction';
+  type?: TransactionTypeEnum;
+  source?: TransactionSourceEnum;
+  date?: Date;
+  amount?: number;
+  description?: string;
+  tax?: number;
+  claimPercent?: number;
+  claimAmount?: number;
+  taxPayable?: number;
+  operation?: TransactionOperationEnum;
+  createdAt?: Date;
+  updatedAt?: Date;
+  deletedAt?: Date;
+  user?: User;
+  chartAccounts?: ChartAccounts;
+  incomeSource?: IncomeSource;
+  parentTransaction?: Transaction;
+  /**
+   * list of child transactions (fees)
+   */
+  childTransactions?: Transaction[];
+  property?: Property;
+  metaFields?: TransactionMetaField[];
+  transfer?: Transaction;
+  allocations?: TransactionAllocation[];
+  loan?: Loan;
+  depreciation?: Depreciation;
+  createdBy?: User;
+  updatedBy?: User;
+  business?: SoleBusiness;
+  isGST?: boolean;
+  invoiceItem?: SoleInvoiceItem;
+}

package/projects/tt-core/src/lib/db/Models/user/employee-details.ts

@@ -0,0 +1,10 @@
+import { User } from './user';
+import { Firm } from '../firm/firm';
+import { AbstractModel } from '../abstract-model';
+import { FirmBranchInterface } from '../../../models/firm/firm-branch.interface';
+
+export class EmployeeDetails extends AbstractModel {
+  user?: User;
+  firm?: Firm;
+  firmBranches: FirmBranchInterface[];
+}

package/projects/tt-core/src/lib/db/Models/user/registration-invite.ts

@@ -0,0 +1,14 @@
+import { RegistrationInviteStatusEnum } from '../../Enums/registration-invite-status.enum';
+import { User } from './user';
+import { AbstractModel } from '../abstract-model';
+
+export class RegistrationInvite extends AbstractModel {
+  email?: string;
+  firstName?: string;
+  lastName?: string;
+  message?: string;
+  status?: RegistrationInviteStatusEnum;
+  createdAt?: Date;
+  updatedAt?: Date;
+  user?: User;
+}

package/projects/tt-core/src/lib/db/Models/user/user-event-setting.ts

@@ -0,0 +1,11 @@
+import { User } from './user';
+import { UserEventType } from './user-event-type';
+import { AbstractModel } from '../abstract-model';
+
+export class UserEventSetting extends AbstractModel {
+  byEmail?: boolean;
+  byNotification?: boolean;
+  frequency?: number;
+  user?: User;
+  type?: UserEventType;
+}

package/projects/tt-core/src/lib/db/Models/user/user-event-type-category.ts

@@ -0,0 +1,5 @@
+import { AbstractModel } from '../abstract-model';
+
+export class UserEventTypeCategory extends AbstractModel {
+  name?: string;
+}

package/projects/tt-core/src/lib/db/Models/user/user-event-type.ts

@@ -0,0 +1,18 @@
+import { UserEventTypeFrequencyEnum } from '../../Enums/user-event-type-frequency.enum';
+import { UserEventTypeCategory } from './user-event-type-category';
+import { UserEventSetting } from './user-event-setting';
+import { AbstractModel } from '../abstract-model';
+
+export class UserEventType extends AbstractModel {
+  type?: number;
+  name?: string;
+  byEmail?: boolean;
+  byNotification?: boolean;
+  frequency?: UserEventTypeFrequencyEnum;
+  counter?: number;
+  status?: number;
+  roles?: unknown;
+  configurable?: boolean;
+  category?: UserEventTypeCategory;
+  settings?: UserEventSetting[];
+}

package/projects/tt-core/src/lib/db/Models/user/user-event.ts

@@ -0,0 +1,16 @@
+import { UserEventStatusEnum } from '../../Enums/user-event-status.enum';
+import { User } from './user';
+import { UserEventType } from './user-event-type';
+import {  AbstractModel  } from '../abstract-model';
+
+export class UserEvent extends AbstractModel {
+  status?: UserEventStatusEnum;
+  counter?: number;
+  entityId?: number;
+  email?: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+  user?: User;
+  initiator?: User;
+  type?: UserEventType;
+}

package/projects/tt-core/src/lib/db/Models/user/user.ts

@@ -0,0 +1,65 @@
+import { UserTitleEnum } from '../../Enums/user-title.enum';
+import { UserStatusEnum } from '../../Enums/user-status.enum';
+import { UserRolesEnum } from 'taxtank-core/common';
+import { Property } from '../property/property';
+import { PropertySubscription } from '../property/property-subscription';
+import { ServiceSubscription } from '../subscription/service-subscription';
+import { UserEventSetting } from './user-event-setting';
+import { BankConnection } from '../bank/bank-connection';
+import { TaxReview } from '../firm/accountant/tax-review';
+import { PropertyShare } from '../property/property-share';
+import { Address } from '../address';
+import { Phone } from '../phone';
+import { ClientMovement } from '../firm/client-movement';
+import { ClientDetails } from '../client';
+import { EmployeeDetails } from './employee-details';
+import { SoleDetails } from '../sole/sole-details';
+import { File } from '../file';
+import { ObservableModel } from '../observable-model';
+import { SetupItem } from '../setup-item';
+import { GenderEnum } from '../../Enums';
+
+export class User extends ObservableModel {
+  static className = 'User';
+  intercomId?: number;
+  createdAt?: Date;
+  updatedAt?: Date;
+  email?: string;
+  hashedEmail?: string;
+  password?: string;
+  firstName?: string;
+  lastName?: string;
+  title?: UserTitleEnum;
+  gender?: GenderEnum;
+  // @TODO vik
+  // photo?: string;
+  status?: UserStatusEnum;
+  isConfirmed?: boolean;
+  verificationCode?: string;
+  referer?: User;
+  referenceCode?: string;
+  rewardfulReferralKey?: string;
+  stripeId?: string;
+  basiqId?: string;
+  roles?: UserRolesEnum[];
+  financialYear?: number;
+  dateOfBirth?: Date;
+  lastSeen?: Date;
+  deletedAt?: Date;
+  properties?: Property[];
+  propertySubscriptions?: PropertySubscription[];
+  subscriptions?: ServiceSubscription[];
+  eventSettings?: UserEventSetting[];
+  bankConnections?: BankConnection[];
+  taxReviews?: TaxReview[];
+  propertyShares?: PropertyShare[];
+  address?: Address;
+  phone?: Phone;
+  clientMovements?: ClientMovement[];
+  clientDetails?: ClientDetails;
+  employeeDetails?: EmployeeDetails;
+  soleDetails?: SoleDetails;
+  file: File;
+  isGoogleAuthenticatorEnabled?: boolean;
+  blacklistSetupItems: SetupItem[];
+}

package/projects/tt-core/src/lib/db/Models/vehicle/vehicle-claim-details.ts

@@ -0,0 +1,10 @@
+import { VehicleClaimDetailsMethodEnum } from '../../Enums/vehicle-claim-details-method.enum';
+import { User } from '../user/user';
+import { AbstractModel } from '../abstract-model';
+
+export class VehicleClaimDetails extends AbstractModel {
+  financialYear?: number;
+  method?: VehicleClaimDetailsMethodEnum;
+  user?: User;
+  isManual?: boolean;
+}

package/projects/tt-core/src/lib/db/Models/vehicle/vehicle-claim.ts

@@ -0,0 +1,13 @@
+import { User } from '../user/user';
+import { SoleBusiness } from '../sole/sole-business';
+import { VehicleClaimDetails } from './vehicle-claim-details';
+import { ObservableModel } from '../observable-model';
+
+export class VehicleClaim extends ObservableModel {
+  static className = 'VehicleClaim';
+  kilometers?: number;
+  workUsage?: number;
+  details?: VehicleClaimDetails;
+  user?: User;
+  business?: SoleBusiness;
+}

package/projects/tt-core/src/lib/db/Models/vehicle/vehicle-logbook.ts

@@ -0,0 +1,18 @@
+import { Vehicle } from './vehicle';
+import { User } from '../user/user';
+import { SoleBusiness } from '../sole/sole-business';
+import { AbstractModel } from '../abstract-model';
+
+export class VehicleLogbook extends AbstractModel {
+  date?: Date;
+  odometerStart?: number;
+  odometerEnd?: number;
+  isPersonal?: boolean;
+  description?: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+  business?: SoleBusiness;
+  vehicle?: Vehicle;
+  createdBy?: User;
+  updatedBy?: User;
+}

package/projects/tt-core/src/lib/db/Models/vehicle/vehicle.ts

@@ -0,0 +1,9 @@
+import { User } from '../user/user';
+import { VehicleLogbook } from './vehicle-logbook';
+import { AbstractModel } from '../abstract-model';
+
+export class Vehicle extends AbstractModel {
+  name?: string;
+  user?: User;
+  logbook?: VehicleLogbook[];
+}

package/projects/tt-core/src/lib/db-static/chart-accounts/chart-accounts-values.ts

@@ -0,0 +1,11 @@
+import { ChartAccountsValue } from '../../db/Models';
+import { plainToClass } from 'class-transformer';
+import ChartAccountValues from '../../db/Json/chart-accounts/chart-accounts-value.json';
+import { Collection } from '../../collections';
+
+/**
+ * @TODO vik performance problems, try https://angular.io/guide/dependency-injection-providers?
+ */
+export const CHART_ACCOUNTS_VALUES = new Collection(
+  ChartAccountValues.map((value) => plainToClass(ChartAccountsValue, value))
+).groupBy('chartAccounts.id');

package/projects/tt-core/src/lib/forms/abstract.form.ts

@@ -0,0 +1,224 @@
+import { AbstractControl, AbstractControlOptions, AsyncValidatorFn, FormControl, FormGroup, ValidatorFn, Validators } from '@angular/forms';
+import { EventEmitter, Type } from '@angular/core';
+import { plainToClass } from 'class-transformer';
+import isEqual from 'lodash/isEqual';
+import { Observable, combineLatest } from 'rxjs';
+import { startWith } from 'rxjs/operators';
+
+/**
+ * Default Controls Interface with loose typing
+ */
+export interface ControlsInterface {
+  [key: string]: AbstractControl<any, any>;
+}
+
+/**
+ * Abstract form class
+ * @TODO rename to AbstractFormGroup
+ * @TODO Alex TT-2190: refactor: check and improve logic
+ * @TODO Model extends AbstractModel
+ */
+export abstract class AbstractForm<Model, Controls extends ControlsInterface = ControlsInterface> extends FormGroup<Controls> {
+  static inputMaxLength = 30;
+  /**
+   * Initial form value for comparison with changes to check saved/unsaved state
+   * @TODO typehint to model interface when all db/models migrated to interfaces
+   */
+  initialValue;
+  protected excludeExtraneousValues = false;
+  protected modelClass: Type<Model>;
+  model: Model;
+  submitted: boolean;
+  includeDisabledFields = false;
+
+  /**
+   * @TODO Alex bad name, it's also about unchanged
+   * Flag display if some form values changed
+   */
+  unsaved = false;
+
+  onSubmit: EventEmitter<Model> = new EventEmitter();
+
+  protected constructor(
+    controls: Controls,
+    // @TODO vik required, otherwise modelClass won't exist
+    model?: Model,
+    validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null,
+    asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null
+  ) {
+    super(controls, validatorOrOpts, asyncValidator);
+    this.model = model || this.createModelInstance();
+    // @TODO Alex no idea how it works, since modelClass used in createModelInstance
+    this.modelClass = this.model.constructor as new () => Model;
+    this.initialValue = this.value;
+
+    if (model && !model['id']) {
+      this.markAsUnsaved();
+    }
+
+    this.listenValueChanges();
+  }
+
+  get saved(): boolean {
+    return !this.unsaved;
+  }
+
+  get currentValue(): Model {
+    return this.createModelInstance(Object.assign({}, this.model, this.getRawValue()));
+  }
+
+  toggleEnabledState(control?: AbstractControl): void {
+    if (control) {
+      control.enabled ? control.disable() : control.enable();
+    } else {
+      this.enabled ? this.disable() : this.enable()
+    }
+  }
+
+  setEnabledState(control: AbstractControl, enabled = true): void {
+    enabled ? control.enable() : control.disable();
+  }
+
+  /**
+   * Check validation and return a new instance of generic model.
+   * Merge form value to initial object
+   * @param data Additional data object which be merged to form value
+   */
+  submit(data: object = {}): Model {
+    this.submitted = true;
+    this.markAllAsTouched();
+
+    if (!this.disabled && !this.valid) {
+      return null;
+    }
+
+    const value = this.includeDisabledFields ? this.getRawValue() : this.value;
+    const model: Model = this.createModelInstance(Object.assign({}, this.model, value, data));
+
+    this.onSubmit.emit(model);
+    return model;
+  }
+
+  addControl(name: string, control: Controls[string], options?: { emitEvent?: boolean }): this {
+    // keep form state (enabled/disabled).
+    // addControl enables form when added enabled form control
+    // https://github.com/angular/angular/issues/23236
+    if (this.disabled) {
+      control.disable();
+    }
+
+    super.addControl(name, control, options);
+
+    return this;
+  }
+
+  markAsUnsaved(): void {
+    this.unsaved = true;
+  }
+
+  markAsSaved(): void {
+    this.unsaved = false;
+  }
+
+  /**
+   * @TODO use excludeExtraneousValues when all models refactored (exposed all needed properties)
+   * @param data
+   */
+  createModelInstance(data: object = {}): Model {
+    return plainToClass(this.modelClass, data, { excludeExtraneousValues: this.excludeExtraneousValues });
+  }
+
+  /**
+   * emit current form values
+   */
+  emitValues(): void {
+    Object.values(this.controls).forEach((control: AbstractControl) => {
+      if ([null, undefined].includes(control.value)) {
+        return;
+      }
+
+      control.updateValueAndValidity({ onlySelf: false, emitEvent: true });
+    });
+  }
+
+  private listenValueChanges(): void {
+    this.valueChanges.subscribe(() => {
+      !!this.model && !!this.model['id'] && isEqual(this.value, this.initialValue) ? this.markAsSaved() : this.markAsUnsaved();
+    })
+  }
+
+  /**
+   * upgraded version of patchValue to skip duplicated changes
+   */
+  patchField(name: string, value: any): void {
+    const control = this.get(name);
+    if (!control || control.value === value) {
+      return;
+    }
+
+    // @TODO remove when all number fields refactored to prime inputnumber
+    if (typeof value === 'number' && name !== 'amount') {
+      value = +value.toFixed(2);
+    }
+
+    control.patchValue(value);
+  }
+
+  patch(fields: { [key: string]: any }): void {
+    Object.entries(fields).forEach(([key, value]) => {
+      this.patchField(key, value);
+    });
+  }
+
+  fieldChanged(name: string): boolean {
+    return this.get(name).value !== this.initialValue[name];
+  }
+
+  addValidators(validators: ValidatorFn | ValidatorFn[], controls: AbstractControl[] = []): void {
+    if (!controls.length) {
+      return super.addValidators(validators);
+    }
+
+    controls.forEach(control => {
+      control.addValidators(Validators.required);
+    });
+  }
+
+  removeValidators(validators: ValidatorFn | ValidatorFn[], controls: AbstractControl[] = []): void {
+    if (!controls.length) {
+      return super.removeValidators(validators);
+    }
+
+    controls.forEach(control => {
+      control.removeValidators(Validators.required);
+    });
+  }
+
+  disable(opts?: { onlySelf?: boolean; emitEvent?: boolean; }, controls: AbstractControl[] = []): void {
+    if (!controls.length) {
+      return super.disable(opts);
+    }
+
+    controls.forEach(control => {
+      control.disable(opts);
+    });
+  }
+
+  enable(opts?: { onlySelf?: boolean; emitEvent?: boolean; }, controls: AbstractControl[] = []): void {
+    if (!controls.length) {
+      return super.enable(opts);
+    }
+
+    controls.forEach(control => {
+      control.enable(opts);
+    });
+  }
+
+  controlsChanges(controlNames: string[]): Observable<any> {
+    const controls = controlNames.map(controlName => this.get(controlName));
+    // combineLatest will not emit an init value till each observable emits at least one value. we need to add startWith
+    return combineLatest(
+      controls.map(control => control.valueChanges.pipe(startWith(control.value)))
+    );
+  }
+}