taxtank-core 0.1.0 → 0.1.1

package/src/lib/models/property/property-forecast.ts

@@ -0,0 +1,55 @@
+import { PropertyForecast as PropertyForecastBase } from '../../db/Models/property-forecast';
+import { FinancialYear } from '../financial-year/financial-year';
+import { Transform } from 'class-transformer';
+
+export class PropertyForecast extends PropertyForecastBase {
+  @Transform(({ value }) => +value)
+  income: number;
+
+  @Transform(({ value }) => -Math.abs(+value))
+  expense: number;
+
+  @Transform(({ value }) => -Math.abs(+value))
+  interest: number;
+
+  @Transform(({ value }) => -Math.abs(+value))
+  depreciation: number;
+
+  @Transform(({ value }) => +value)
+  loanBalance: number;
+
+  @Transform(({ value }) => +value)
+  marketValue: number;
+
+  /**
+   * Get cash position
+   * Cash Position = Income - Expense - Interest
+   */
+  get cashPosition(): number {
+    return this.income + this.expense + this.interest;
+  }
+
+
+  /**
+   * Get tax position
+   * Tax Position = Income - Expense - Interest - Depreciation
+   */
+  get taxPosition(): number {
+    return this.cashPosition + this.depreciation;
+  }
+
+  /**
+   * Get rental return percent
+   * Rental Return = Income / Market Value
+   */
+  get rentalReturn(): number {
+    return this.income / this.marketValue;
+  }
+
+  /**
+   * Check if forecast is for real current fin year (not selected in the sidebar)
+   */
+  isCurrentYear(): boolean {
+    return this.financialYear === new FinancialYear(new Date()).year;
+  }
+}

package/src/lib/models/property/property-owner.ts

@@ -0,0 +1,50 @@
+import { PropertyOwner as PropertyOwnerBase } from '../../db/Models/property-owner';
+import { PropertyOwnerStatusEnum } from '../../db/Enums/property-owner-status.enum';
+import { Transform, Type } from 'class-transformer';
+import { User } from '../user/user';
+import { RegistrationInvite } from '../registration-invite/registration-invite';
+import { Property } from './property';
+
+export class PropertyOwner extends PropertyOwnerBase {
+  @Type(() => Date)
+  fromDate: Date;
+
+  @Type(() => Date)
+  toDate: Date;
+
+  @Type(() => User)
+  user: User;
+
+  @Type(() => RegistrationInvite)
+  invite: RegistrationInvite;
+
+  @Type(() => Property)
+  property: Property;
+
+  @Transform(({obj}) => obj.user ? obj.user.email : obj.invite.email)
+  email: string;
+
+  isAccepted(): boolean {
+    return this.status === PropertyOwnerStatusEnum.APPROVED;
+  }
+
+  isPending(): boolean {
+    return this.status === PropertyOwnerStatusEnum.PENDING;
+  }
+
+  isRejected(): boolean {
+    return this.status === PropertyOwnerStatusEnum.REJECTED;
+  }
+
+  get statusName(): string {
+    return PropertyOwnerStatusEnum[this.status]?.toLowerCase();
+  }
+
+  /**
+   * Return full user name if user is already registered.
+   * Otherwise - return first name from invitation
+   */
+  get fullName(): string {
+    return this.user ? this.user.fullName : `${this.invite.firstName}`;
+  }
+}

package/src/lib/models/property/property-sold.ts

@@ -0,0 +1,10 @@
+import { PropertySold as PropertySoldBase } from '../../db/Models/property-sold';
+import { Type } from 'class-transformer';
+
+export class PropertySold extends PropertySoldBase {
+  @Type(() => Date)
+  date: Date;
+
+  @Type(() => Date)
+  contractDate: Date;
+}

package/src/lib/models/property/property-subscription.ts

@@ -0,0 +1,11 @@
+import { PropertySubscription as PropertySubscriptionBase } from '../../db/Models/property-subscription';
+import { Type } from 'class-transformer';
+import { User } from '../user/user';
+
+export class PropertySubscription extends PropertySubscriptionBase {
+  @Type(() => Date)
+  createdAt: Date;
+
+  @Type(() => User)
+  user: User;
+}

package/src/lib/models/property/property-valuation.ts

@@ -0,0 +1,24 @@
+import { PropertyValuation as PropertyValuationBase } from '../../db/Models/property-valuation';
+import { Exclude, Type } from 'class-transformer';
+import { PropertyDocument } from './property-document';
+import { FinancialYear } from '../financial-year/financial-year';
+
+export class PropertyValuation extends PropertyValuationBase {
+  @Type(() => Date)
+  date: Date;
+
+  @Type(() => PropertyDocument)
+  document: PropertyDocument;
+
+  // could be File when just added new image
+  @Exclude()
+  documentFile: File;
+
+  get financialYear(): number {
+    return new FinancialYear(this.date).year;
+  }
+
+  isCurrentYear(): boolean {
+    return this.financialYear === new FinancialYear(new Date()).year;
+  }
+}

package/src/lib/models/property/property.ts

@@ -0,0 +1,157 @@
+import { Property as PropertyBase } from '../../db/Models/property';
+import { CapitalCostProperty } from '../../db/Models/capital-cost-property';
+import { Documentable } from '../../interfaces/documentable.interface';
+import { IDocument } from '../../interfaces/document.interface';
+import { PropertyOwner } from '../../db/Models/property-owner';
+import { PropertySubscription } from './property-subscription';
+import { Exclude, Type } from 'class-transformer';
+import { Photoable } from '../../interfaces/photoable';
+import { Address } from '../address/address';
+import { PropertyCategory } from './property-category';
+import { PropertyValuation } from './property-valuation';
+import { PropertyForecast } from './property-forecast';
+import { PropertyCategoryMovement } from './property-category-movement';
+import { User } from '../user/user';
+import { FinancialYear } from '../financial-year/financial-year';
+
+export class Property extends PropertyBase implements Photoable, Documentable {
+  @Type(() => Date)
+  purchaseDate: Date;
+
+  @Type(() => Date)
+  settlementDate: Date;
+
+  @Type(() => Address)
+  address: Address;
+
+  @Type(() => PropertyCategory)
+  category: PropertyCategory;
+
+  @Type(() => PropertyValuation)
+  valuations: PropertyValuation[];
+
+  @Type(() => PropertyForecast)
+  forecasts: PropertyForecast[];
+
+  @Type(() => PropertyCategoryMovement)
+  categoryMovements: PropertyCategoryMovement[];
+
+  @Type(() => User)
+  user: User;
+
+  @Type(() => PropertySubscription)
+  subscriptions: PropertySubscription[];
+
+  // could be File when just added new image
+  @Exclude()
+  documentFile: File;
+
+  // @TODO refactor with spare tank
+  documents: IDocument[];
+
+  get name(): string {
+    return this.address.name;
+  }
+
+  get isActive(): boolean {
+    return !!this.subscriptions?.length;
+  }
+
+  isOwn(): boolean {
+    return this.user.id === +localStorage.getItem('userId');
+  }
+
+  /**
+   * Get initials of property. Required by Photoable interface
+   */
+  getInitials(): string {
+    return this.name.split(' ')[1].slice(0, 2);
+  }
+
+  /**
+   * Get property photo. Required by Photoable interface
+   */
+  getPhoto(): string {
+    return this.photo;
+  }
+
+  get capitalCostsTotalAmount(): number {
+    return this.capitalCosts.reduce((sum: number, capitalCost: CapitalCostProperty): number => sum + capitalCost.amount, 0);
+  }
+
+  get currentYearValuations(): PropertyValuation[] {
+    return this.valuations.filter((valuation: PropertyValuation): boolean => valuation.isCurrentYear());
+  }
+
+  get marketValue(): number {
+    return this.actualValuation?.marketValue || 0;
+  }
+
+  get currentYearForecast(): PropertyForecast {
+    return this.forecasts.find((forecast: PropertyForecast): boolean => forecast.isCurrentYear());
+  }
+
+  get forecastedRentalReturn(): number {
+    return this.currentYearForecast?.rentalReturn || 0;
+  }
+
+  get forecastedTaxPosition(): number {
+    return this.currentYearForecast?.taxPosition || 0;
+  }
+
+  get firstForecastYear(): number {
+    return this.forecasts.reduce((min: number, forecast: PropertyForecast): number => {
+      return min > forecast.financialYear ? forecast.financialYear : min;
+    }, new FinancialYear().year);
+  }
+
+  get marketValueGrowth(): number {
+    return (this.marketValue - this.purchasePrice) / this.marketValue;
+  }
+
+  get myShare(): PropertyOwner {
+    return this.owners.find((owner: PropertyOwner): boolean => owner.user.id === +localStorage.getItem('userId'));
+  }
+
+  /**
+   * exact claim percent includes ownership
+   */
+  get ownershipClaimPercent(): number {
+    return this.ownershipPercent * this.claimPercent / 100;
+  }
+
+  get actualValuation(): PropertyValuation {
+    return this.valuations.reduce((maxDateValuation: PropertyValuation, valuation: PropertyValuation) => {
+      return maxDateValuation.date > valuation.date ? maxDateValuation : valuation;
+    }, this.valuations[0]);
+  }
+
+  get ownershipPercent(): number {
+    return this.myShare.ownershipPercent;
+  }
+
+  get previousCategory(): PropertyCategory {
+    let previousCategory: PropertyCategory;
+
+    const movementsCount: number = this.categoryMovements.length;
+
+    if (movementsCount > 1) {
+      previousCategory = this.categoryMovements[movementsCount - 2].propertyCategory;
+    }
+
+    return previousCategory;
+  }
+
+  getCurrentSubscription(): PropertySubscription {
+    // always return first element because subscriptions array contains only one element
+    return this.subscriptions[0];
+  }
+
+  getForecastByYear(year: number): PropertyForecast {
+    return this.forecasts.find((forecast: PropertyForecast): boolean => forecast.financialYear === year);
+  }
+
+  get isShared(): boolean {
+    return this.owners.length > 1;
+  }
+}

package/src/lib/models/registration-invite/registration-invite.ts

@@ -0,0 +1,12 @@
+import { RegistrationInvite as RegistrationInviteBase } from '../../db/Models/registration-invite';
+import { Photoable } from '../../interfaces/photoable';
+
+export class RegistrationInvite extends RegistrationInviteBase implements Photoable {
+  getInitials(): string {
+    return `${this.firstName[0].toUpperCase()}${this.firstName[1]}`;
+  }
+
+  getPhoto(): string {
+    return null;
+  }
+}

package/src/lib/models/service-subscription/module-url-list.const.ts

@@ -0,0 +1,11 @@
+/**
+ * Constant with list of URLs
+ */
+export const MODULE_URL_LIST: { [key: string]: string } = {
+  dashboard: '/client/dashboard',
+  propertyTank: '/client/property-tank',
+  workTank: '/client/work-tank',
+  spareTank: '/client/spare-tank',
+  taxSummary: '/client/tax-summary',
+  myAccount: '/client/my-account/subscription'
+};

package/src/lib/models/service-subscription/service-payment.ts

@@ -0,0 +1,8 @@
+import { ServicePayment as BaseServicePayment } from '../../db/Models/service-payment';
+import { ServiceSubscription } from './service-subscription';
+import { Type } from 'class-transformer';
+
+export class ServicePayment extends BaseServicePayment {
+  @Type(() => ServiceSubscription)
+  subscription: ServiceSubscription;
+}

package/src/lib/models/service-subscription/service-price.ts

@@ -0,0 +1,8 @@
+import { ServicePrice as BaseServicePrice } from '../../db/Models/service-price';
+import { ServiceProduct } from './service-product';
+import { Type } from 'class-transformer';
+
+export class ServicePrice extends BaseServicePrice {
+  @Type(() => ServiceProduct)
+  product: ServiceProduct;
+}

package/src/lib/models/service-subscription/service-product.ts

@@ -0,0 +1,11 @@
+import { ServiceProduct as BaseServiceProduct } from '../../db/Models/service-product';
+
+export class ServiceProduct extends BaseServiceProduct {
+  isProperty(): boolean {
+    return this.title === 'Property';
+  }
+
+  isWork(): boolean {
+    return this.title === 'Work Tank';
+  }
+}

package/src/lib/models/service-subscription/service-subscription-item.ts

@@ -0,0 +1,12 @@
+import { ServiceSubscriptionItem as ServiceSubscriptionItemBase } from '../../db/Models/service-subscription-item';
+import { ServicePrice } from './service-price';
+import { Type } from 'class-transformer';
+
+export class ServiceSubscriptionItem extends ServiceSubscriptionItemBase {
+  @Type(() => ServicePrice)
+  price: ServicePrice;
+
+  get total(): number {
+    return this.price.amount * this.quantity;
+  }
+}

package/src/lib/models/service-subscription/service-subscription.ts

@@ -0,0 +1,151 @@
+import { ServiceSubscription as ServiceSubscriptionBase } from '../../db/Models/service-subscription';
+import { ServiceSubscriptionItem } from './service-subscription-item';
+import { SubscriptionTypeEnum } from './subscription-type.enum';
+import { SUBSCRIPTION_TITLE } from './subscription-title.const';
+import { SUBSCRIPTION_DESCRIPTION } from './subscription-description.const';
+import { UserRolesEnum } from '../../db/Enums/user-roles.enum';
+import { Type } from 'class-transformer';
+
+const PROPERTY_INVESTOR_MAX_PROPERTIES = 2;
+
+export class ServiceSubscription extends ServiceSubscriptionBase {
+  @Type(() => Date)
+  startDate: Date;
+
+  @Type(() => Date)
+  endDate: Date;
+
+  @Type(() => ServiceSubscriptionItem)
+  items: ServiceSubscriptionItem[];
+
+  // Number of days after which the trial time will be expired
+  lastTrialDays: number = 4;
+
+  get isTrial(): boolean {
+    return !this.stripeId;
+  }
+
+  get price(): number {
+    return this.items.reduce((sum: number, item: ServiceSubscriptionItem) => sum + item.total, 0);
+  }
+
+  get propertyQuantity(): number {
+    return this.propertyTankItem ? this.propertyTankItem.quantity : 0;
+  }
+
+  /**
+   * get type of subscription
+   */
+  get type(): SubscriptionTypeEnum {
+    const workTankProduct: ServiceSubscriptionItem = this.items.find((item: ServiceSubscriptionItem): boolean => {
+      return item.price.product.isWork();
+    });
+
+    if (!this.workTankItem || !this.isActive) {
+      return SubscriptionTypeEnum.WITHOUT_SUBSCRIPTION;
+    }
+
+    if (this.items.length === 1 && !!workTankProduct) {
+      return SubscriptionTypeEnum.INDIVIDUAL;
+    }
+
+    const propertyTankProduct: ServiceSubscriptionItem = this.items.find((item: ServiceSubscriptionItem): boolean => {
+      return item.price.product.isProperty();
+    });
+
+    if (!!this.propertyTankItem && propertyTankProduct.quantity === PROPERTY_INVESTOR_MAX_PROPERTIES) {
+      return SubscriptionTypeEnum.INVESTOR;
+    }
+
+    return SubscriptionTypeEnum.INVESTOR_PLUS;
+  }
+
+  /**
+   * get title of subscription
+   */
+  get title(): string {
+    return SUBSCRIPTION_TITLE[this.type];
+  }
+
+  /**
+   * get description of subscription
+   */
+  get description(): string {
+    return SUBSCRIPTION_DESCRIPTION[this.type];
+  }
+
+  get workTankItem(): ServiceSubscriptionItem {
+    return this.items.find((item: ServiceSubscriptionItem): boolean => item.price.product.isWork());
+  }
+
+  get propertyTankItem(): ServiceSubscriptionItem {
+    return this.items.find((item: ServiceSubscriptionItem): boolean => item.price.product.isProperty());
+  }
+
+  /**
+   * This check on getIsActive need for firm. Accountant has a endDate, but user has not endDate
+   * and for user we add check for endDate
+   */
+  get isActive(): boolean {
+    return this.endDate ? new Date(this.endDate).getTime() > new Date().getTime() : true;
+  }
+
+  get daysRemain(): number {
+    const daysRemains: number = Math.round(
+      (new Date(this.endDate).getTime() - new Date().getTime()) / (1000 * 3600 * 24)
+    );
+
+    return daysRemains > 0 ? daysRemains : 0;
+  }
+
+  getTitle(): string {
+    return this.isTrial ? 'Trial period' : this.title;
+  }
+
+  /**
+   * Check if subscription is Individual
+   * Subscription is individual when user have only one product and only work tank
+   */
+  isIndividual(): boolean {
+    return this.type === SubscriptionTypeEnum.INDIVIDUAL;
+  }
+
+  /**
+   * Check if subscription is Investor
+   * Subscription is investor when user have property tank product and max count of properties is 2
+   */
+  isInvestor(): boolean {
+    return this.type === SubscriptionTypeEnum.INVESTOR;
+  }
+
+  /**
+   * Check if subscription is Investor Plus
+   * Subscription is investor when user have property tank product and max count of properties more than 2
+   */
+  isInvestorPlus(): boolean {
+    return this.type === SubscriptionTypeEnum.INVESTOR_PLUS;
+  }
+
+  /**
+   * Check if trial expired
+   */
+  isTrialExpired(): boolean {
+    return this.daysRemain && this.daysRemain <= 0;
+  }
+
+  isTrialExpiring(): boolean {
+    return this.daysRemain > 0 && this.daysRemain <= this.lastTrialDays;
+  }
+
+  hasPropertyTank(): boolean {
+    return !!this.items.find((subscriptionItem: ServiceSubscriptionItem) => {
+      return subscriptionItem.price.product.role.includes(UserRolesEnum.PROPERTY_TANK);
+    });
+  }
+
+  hasWorkTank() {
+    return !!this.items.find((subscriptionItem: ServiceSubscriptionItem) => {
+      return subscriptionItem.price.product.role.includes(UserRolesEnum.WORK_TANK);
+    });
+  }
+}

package/src/lib/models/service-subscription/subscription-description.const.ts

@@ -0,0 +1,8 @@
+import { SubscriptionTypeEnum } from './subscription-type.enum';
+
+export const SUBSCRIPTION_DESCRIPTION: {[key: number]: string} = {
+  [SubscriptionTypeEnum.WITHOUT_SUBSCRIPTION]: 'Without subscription',
+  [SubscriptionTypeEnum.INDIVIDUAL]: 'Manage income and expenses via live bank feeds. Keep receipts safe, maximise deductions & minimise tax.',
+  [SubscriptionTypeEnum.INVESTOR]: 'Property made easy with smart tax tools and real-time information to help control how much tax you pay.',
+  [SubscriptionTypeEnum.INVESTOR_PLUS]: 'Add your whole portfolio, including investment properties, home and properties in trusts. For 3+ properties an extra $6 will be charged per property.'
+};

package/src/lib/models/service-subscription/subscription-title.const.ts

@@ -0,0 +1,8 @@
+import { SubscriptionTypeEnum } from './subscription-type.enum';
+
+export const SUBSCRIPTION_TITLE: {[key: number]: string} = {
+  [SubscriptionTypeEnum.WITHOUT_SUBSCRIPTION]: 'Without subscription',
+  [SubscriptionTypeEnum.INDIVIDUAL]: 'Individual',
+  [SubscriptionTypeEnum.INVESTOR]: 'Investor',
+  [SubscriptionTypeEnum.INVESTOR_PLUS]: 'Investor plus'
+};

package/src/lib/models/service-subscription/subscription-type.enum.ts

@@ -0,0 +1,6 @@
+export enum SubscriptionTypeEnum {
+  WITHOUT_SUBSCRIPTION = 0,
+  INDIVIDUAL = 1,
+  INVESTOR = 2,
+  INVESTOR_PLUS = 3
+}

package/src/lib/models/tax-review/tax-review.ts

@@ -0,0 +1,96 @@
+import { TaxReview as TaxReviewBase } from '../../db/Models/tax-review';
+import { TaxReviewStatusEnum } from '../../db/Enums/tax-review-status.enum';
+import { User } from '../user/user';
+import { Type } from 'class-transformer';
+
+export class TaxReview extends TaxReviewBase {
+  @Type(() => User)
+  client: User;
+
+  @Type(() => User)
+  employee: User;
+  status: TaxReviewStatusEnum;
+
+  /**
+   * if tax review status is 'Cancelled'
+   */
+  isCancelled(): boolean {
+    return this.status === TaxReviewStatusEnum.CANCELLED;
+  }
+
+  /**
+   * if tax review status is 'New'
+   */
+  isNew(): boolean {
+    return this.status === TaxReviewStatusEnum.NEW;
+  }
+
+  /**
+   * if tax review status is 'In progress'
+   */
+  isInProgress(): boolean {
+    return this.status === TaxReviewStatusEnum.IN_PROGRESS;
+  }
+
+  /**
+   * if tax review status is 'Waiting for client'
+   */
+  isWaitingForClient(): boolean {
+    return this.status === TaxReviewStatusEnum.WAITING_FOR_CLIENT;
+  }
+
+  /**
+   * if tax review status is 'Waiting for approval'
+   */
+  isWaitingForApproval(): boolean {
+    return this.status === TaxReviewStatusEnum.WAITING_FOR_APPROVAL;
+  }
+
+  /**
+   * if tax review status is 'Approved'
+   */
+  isApproved(): boolean {
+    return this.status === TaxReviewStatusEnum.APPROVED;
+  }
+
+  /**
+   * if tax review status is 'Completed'
+   */
+  isCompleted(): boolean {
+    return this.status === TaxReviewStatusEnum.COMPLETED;
+  }
+
+  /**
+   * if tax review status is 'Sent'
+   */
+  isSent(): boolean {
+    return this.status === TaxReviewStatusEnum.SENT;
+  }
+
+  /**
+   * if tax review status is 'Amend'
+   */
+  isAmend(): boolean {
+    return this.status === TaxReviewStatusEnum.AMEND;
+  }
+
+  /**
+   * If tax review is inactive
+   */
+  isInactive(): boolean {
+    return this.isCancelled() || this.isCompleted();
+  }
+
+  /**
+   * If tax review is active
+   */
+  isActive(): boolean {
+    return this.isNew() ||
+      this.isInProgress() ||
+      this.isWaitingForClient() ||
+      this.isWaitingForApproval() ||
+      this.isApproved() ||
+      this.isSent() ||
+      this.isAmend();
+  }
+}

package/src/lib/models/tax-summary/tax-return-category-item-details.ts

@@ -0,0 +1,14 @@
+import { TaxReturnCategorySectionEnum } from '../../db/Enums/tax-return-category-section.enum';
+
+/**
+ * Used in tax summary reports to show specific details relating to an amount in the report.
+ * See structure in TaxReturnCategoryItem class.
+ * Example an amount of $550 for property income could be comprised of 2 different property amounts of $300 and $250.
+ * This is useful in providing drill-down information for the tax summary report.
+ */
+export class TaxReturnCategoryItemDetails {
+  amount: number;
+  name: string;
+  type: number;
+  section: TaxReturnCategorySectionEnum;
+}