taxtank-core 0.0.1 → 0.1.1

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

@@ -0,0 +1,22 @@
+import { TaxReturnCategory } from '../../db/Models/tax-return-category';
+import { TaxReturnCategoryItemDetails } from './tax-return-category-item-details';
+
+/**
+ * Used in tax summary reports to show amounts relating to a tax return category entity and details of what this
+ * amount is comprised of. Example here shows an amount of $951.96 and also details of what this amount is comprised of:
+ */
+export class TaxReturnCategoryItem {
+  amount: number;
+  details: TaxReturnCategoryItemDetails[];
+  items: TaxReturnCategoryItem[];
+  taxReturnCategory: TaxReturnCategory;
+  taxWithheld: number;
+
+  /**
+   * Get amount for one income source
+   * @param name Name of income source for filter
+   */
+  getAmountByIncomeSourceName(name: string): number {
+    return this.details.find((detail: TaxReturnCategoryItemDetails): boolean => detail.name === name)?.amount || 0;
+  }
+}

package/src/lib/models/tax-summary/tax-summary-section.ts

@@ -0,0 +1,32 @@
+import { TaxSummarySectionEnum } from '../../db/Enums/tax-summary-section.enum';
+import { TaxReturnCategoryItem } from './tax-return-category-item';
+import { TaxReturnCategoryItemCollection } from '../../collections/tax-return-category-item.collection';
+import { Transform, Type } from 'class-transformer';
+
+/**
+ * Base class for each sections of Tax Summary report, contains common properties/methods
+ * See also TaxSummary model
+ */
+export class TaxSummarySection {
+  section: TaxSummarySectionEnum;
+  netAmount: number;
+
+  @Type(() => TaxReturnCategoryItem)
+  @Transform(({value}) => new TaxReturnCategoryItemCollection(value))
+  items: TaxReturnCategoryItemCollection;
+
+  // id that will be added as HTML Id
+  @Transform(({obj}) => {
+    switch (obj.section) {
+      case TaxSummarySectionEnum.WORK_TANK:
+        return 'taxSummaryWorkTank';
+      case TaxSummarySectionEnum.PROPERTY_TANK:
+        return 'taxSummaryPropertyTank';
+      case TaxSummarySectionEnum.OTHER_INCOME:
+        return 'taxSummaryOtherIncome';
+      default:
+        return 'taxSummaryTotal';
+    }
+  })
+  id?: string;
+}

package/src/lib/models/tax-summary/tax-summary-type.enum.ts

@@ -0,0 +1,7 @@
+/**
+ * Enum for tax summary types
+ */
+export enum TaxSummaryTypeEnum {
+  ACTUALS = 'actuals',
+  FORECASTS = 'forecasts'
+}

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

@@ -0,0 +1,79 @@
+import { TaxReturnCategorySectionEnum } from '../../db/Enums/tax-return-category-section.enum';
+import { TaxSummarySection } from './tax-summary-section';
+import { Type } from 'class-transformer';
+
+/**
+ * @Todo refactor with base model when it will be provided
+ * Tax summary report structure
+ */
+export class TaxSummary {
+  @Type(() => TaxSummarySection)
+  work: TaxSummarySection;
+
+  @Type(() => TaxSummarySection)
+  property: TaxSummarySection;
+
+  @Type(() => TaxSummarySection)
+  otherIncome: TaxSummarySection;
+
+  @Type(() => TaxSummarySection)
+  summary: TaxSummarySection;
+
+  projectedTaxPosition: number;
+
+  get sections(): TaxSummarySection[] {
+    return [this.work, this.property, this.otherIncome, this.summary];
+  }
+
+  get taxPercent(): number {
+    return this.summary.items.grossTaxPayable / this.summary.netAmount;
+  }
+
+  /**
+   * Work Net Cash = Income - tax withheld - expenses - interest
+   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+   */
+  get workNetCash(): number {
+    return this.workNetTotal - Math.abs(this.summary.items.getTaxWithheld(TaxReturnCategorySectionEnum.WORK_TANK));
+  }
+
+  /**
+   * Work Net Total = Income - expenses - interest
+   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+   */
+  get workNetTotal(): number {
+    return this.work.items.salary - Math.abs(this.work.items.workExpenses);
+  }
+
+  /**
+   * Property Net Cash (Cash Position) = Rental Income - expenses - interest
+   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+   */
+  get propertyNetCash(): number {
+    return this.property.items.rentalIncome - Math.abs(this.property.items.rentalDeductions) - Math.abs(this.property.items.interestDeductions);
+  }
+
+  /**
+   * Property Net Total (Tax Position) = Rental Income - expenses - interest - depreciation
+   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+   */
+  get propertyNetTotal(): number {
+    return this.propertyNetCash - Math.abs(this.property.items.propertyDepreciations);
+  }
+
+  /**
+   * Other Net Cash = gross income – expenses – tax withheld - tax instalments
+   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+   */
+  get otherNetCash(): number {
+    return this.otherIncome.items.otherIncome - Math.abs(this.otherIncome.items.otherDeductions) - Math.abs(this.summary.items.getTaxWithheld(TaxReturnCategorySectionEnum.OTHER_INCOME)) - Math.abs(this.summary.items.taxInstalments);
+  }
+
+  /**
+   * Other Net Total = Gross income - expenses + tax offsets + tax instalments + franking credits
+   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+   */
+  get otherNetTotal(): number {
+    return this.otherIncome.items.otherIncome - Math.abs(this.otherIncome.items.otherDeductions) + Math.abs(this.summary.items.taxOffsets) + Math.abs(this.summary.items.taxInstalments) + Math.abs(this.summary.items.frankingCredits);
+  }
+}

package/src/lib/models/transaction/income-amount-type.enum.ts

@@ -0,0 +1,7 @@
+/**
+ * Enum with income amount types (Net or Gross)
+ */
+export enum IncomeAmountTypeEnum {
+  NET,
+  GROSS
+}

package/src/lib/models/transaction/transaction-allocation.ts

@@ -0,0 +1,20 @@
+import { TransactionAllocation as TransactionAllocationBase } from '../../db/Models/transaction-allocation';
+import { BankTransaction } from '../bank/bank-transaction';
+import { Transaction } from './transaction';
+import { plainToClass, Type } from 'class-transformer';
+
+export class TransactionAllocation extends TransactionAllocationBase {
+  @Type(() => BankTransaction)
+  bankTransaction: BankTransaction;
+
+  @Type(() => Transaction)
+  transaction: Transaction;
+
+  /**
+   * Create a new instance of transaction allocation
+   * transaction could be empty since we can POST allocation inside a new transaction
+   */
+  static create(amount: number, bankTransaction: BankTransaction, transaction?: Transaction): TransactionAllocation {
+    return plainToClass(TransactionAllocation, {amount, transaction, bankTransaction});
+  }
+}

package/src/lib/models/transaction/transaction-metadata.ts

@@ -0,0 +1,8 @@
+import { TransactionMetadata as TransactionMetadataBase } from '../../db/Models/transaction-metadata';
+import { Type } from 'class-transformer';
+import { ChartAccountsMetadata } from '../chart-accounts/chart-accounts-metadata';
+
+export class TransactionMetadata extends TransactionMetadataBase {
+  @Type(() => ChartAccountsMetadata)
+  metadata: ChartAccountsMetadata;
+}

package/src/lib/models/transaction/transaction-receipt.ts

@@ -0,0 +1,9 @@
+import { TransactionReceipt as TransactionReceiptBase } from '../../db/Models/transaction-receipt';
+import { IAsset } from '../../interfaces/asset.interface';
+import { AssetTypeEnum } from '../../interfaces/asset-type.enum';
+import { AssetEntityTypeEnum } from '../../interfaces/asset-entity-type.enum';
+
+export class TransactionReceipt extends TransactionReceiptBase implements IAsset {
+  type: AssetTypeEnum = AssetTypeEnum.RECEIPTS;
+  entityType: AssetEntityTypeEnum = AssetEntityTypeEnum.TRANSACTIONS;
+}

package/src/lib/models/transaction/transaction.ts

@@ -0,0 +1,241 @@
+import { Transaction as TransactionBase } from '../../db/Models/transaction';
+import { TransactionTypeEnum } from '../../db/Enums/transaction-type.enum';
+import { ChartAccountsCategoryEnum } from '../../db/Enums/chart-accounts-category.enum';
+import { TransactionOperationEnum } from '../../db/Enums/transaction-operation.enum';
+import { ChartAccountsListEnum } from '../../db/Enums/chart-accounts-list.enum';
+import { ChartAccountsMetadataListEnum } from '../../db/Enums/chart-accounts-metadata-list.enum';
+import { TransactionSourceEnum } from '../../db/Enums/transaction-source.enum';
+import { DepreciationTypeEnum } from '../../db/Enums/depreciation-type.enum';
+import { DepreciationCalculationEnum } from '../../db/Enums/depreciation-calculation.enum';
+import { Exclude, plainToClass, Type } from 'class-transformer';
+import { Property } from '../property/property';
+import { TransactionReceipt } from './transaction-receipt';
+import { ChartAccounts } from '../chart-accounts/chart-accounts';
+import { IncomeSource } from '../income-source/income-source';
+import { TransactionMetadata } from './transaction-metadata';
+import { Loan } from '../loan/loan';
+import { TransactionAllocation } from './transaction-allocation';
+import { CHART_ACCOUNTS_CATEGORIES } from '../chart-accounts/chart-accounts-categories.const';
+import { IncomeAmountTypeEnum } from './income-amount-type.enum';
+import { IReceipt } from '../../interfaces/receipt.interface';
+import { ITank } from '../../interfaces/tank.interface';
+import { TransactionAllocationCollection } from '../../collections/transaction-allocation.collection';
+import { Depreciation } from '../depreciation/depreciation';
+
+// @TODO refactor with baseModel in constructor
+export class Transaction extends TransactionBase implements IReceipt, ITank {
+  // list of child transactions (fees)
+  @Type(() => Transaction)
+  transactions: Transaction[] = [];
+
+  @Type(() => Property)
+  property: Property;
+
+  @Type(() => TransactionReceipt)
+  receipt: TransactionReceipt;
+
+  @Type(() => ChartAccounts)
+  chartAccounts: ChartAccounts;
+
+  @Type(() => IncomeSource)
+  incomeSource: IncomeSource;
+
+  @Type(() => TransactionMetadata)
+  metadata: TransactionMetadata[] = [];
+
+  @Type(() => Transaction)
+  transfer: Transaction;
+
+  @Type(() => Loan)
+  loan: Loan;
+
+  @Type(() => Date)
+  date: Date;
+
+  @Type(() => TransactionAllocation)
+  allocations: TransactionAllocation[] = [];
+
+  // could be File when just added new image
+  @Exclude({toPlainOnly: true})
+  file: File;
+
+  tax: number = 0;
+  operation: TransactionOperationEnum = TransactionOperationEnum.FIND_AND_MATCH;
+  allocatedAmount: number;
+  unallocatedAmount: number;
+  isSelected: boolean;
+  claimPercent: number = 100;
+  amount: number = 0;
+
+  isDebit(): boolean {
+    return this.type === TransactionTypeEnum.DEBIT;
+  }
+
+  isCredit(): boolean {
+    return this.type === TransactionTypeEnum.CREDIT;
+  }
+
+  isIncome(): boolean {
+    if (!this.chartAccounts) {
+      return this.isCredit();
+    }
+
+    return CHART_ACCOUNTS_CATEGORIES.income.includes(this.chartAccounts.category);
+  }
+
+  isExpense(): boolean {
+    if (!this.chartAccounts) {
+      return this.isDebit();
+    }
+
+    return CHART_ACCOUNTS_CATEGORIES.expense.includes(this.chartAccounts.category);
+  }
+
+  isPersonal(): boolean {
+    return !this.tankType;
+  }
+
+  get chartAccountsCategories(): ChartAccountsCategoryEnum[] {
+    switch (true) {
+      case this.isPersonal():
+        return CHART_ACCOUNTS_CATEGORIES.personal;
+
+      case this.isPropertyTank():
+        return CHART_ACCOUNTS_CATEGORIES.property;
+
+      default:
+        return CHART_ACCOUNTS_CATEGORIES.work;
+    }
+  }
+
+  /**
+   * Check if transaction has 'Klms travelled for work' chart accounts category
+   */
+  get isKlmsChartAccountsCategory(): boolean {
+    return this.chartAccounts.id === ChartAccountsListEnum.KLMS_TRAVELLED_FOR_WORK;
+  }
+
+  /**
+   * Get transaction date
+   */
+  getDate(): Date {
+    return this.date;
+  }
+
+  /**
+   * Check if transaction type is vehicle
+   */
+  isVehicleTransaction(): boolean {
+    return this.chartAccounts.isVehicleExpense();
+  }
+
+  /**
+   * Get net amount (clean amount after all deductions)
+   */
+  getNetAmount(): number {
+    // @TODO fix hack while transactions refactoring (use class-transformer)
+    return +(Math.round(this.getIncomeAmountByType(IncomeAmountTypeEnum.NET) * 100) / 100).toFixed(2);
+  }
+
+  /**
+   * Get gross income amount
+   */
+  getGrossIncome(): number {
+    // @TODO fix hack while transactions refactoring (use class-transformer)
+    return +(Math.round(this.getIncomeAmountByType(IncomeAmountTypeEnum.GROSS) * 100) / 100).toFixed(2);
+  }
+
+  /**
+   * find franking credits metadata and return value
+   */
+  get frankingCredit(): number {
+    return this.getMetadataFieldValue(ChartAccountsMetadataListEnum.FRANKING_CREDIT);
+  }
+
+  get untaxedElement(): number {
+    return this.getMetadataFieldValue(ChartAccountsMetadataListEnum.UNTAXED_ELEMENT);
+  }
+
+  /**
+   * Check if transaction reconcile operation if TRANSFER
+   * @TODO bad usage of get (and all is* methods), getter should sound like a noun
+   */
+  get isTransfer(): boolean {
+    return this.operation === TransactionOperationEnum.TRANSFER;
+  }
+
+  /**
+   * Get value of transaction metadata field
+   * @param field for which value should be returned
+   */
+  private getMetadataFieldValue(field: ChartAccountsMetadataListEnum): number {
+    return +this.metadata.find((transactionMetadata: TransactionMetadata): boolean => {
+      return transactionMetadata.chartAccountsMetadata.id === field;
+    })?.value || 0;
+  }
+
+  /**
+   * Returns Net or Gross income amount based on provided income type
+   * @param incomeType by which amount should be returned
+   */
+  private getIncomeAmountByType(incomeType: IncomeAmountTypeEnum): number {
+    // modifier that determines whether the values of the transaction fields will be added or subtracted
+    const modifier: number = incomeType === IncomeAmountTypeEnum.GROSS ? 1 : -1;
+
+    switch (true) {
+      case this.isPropertyTank():
+        return this.amount +
+          (this.transactions
+            .reduce((sum: number, transaction: Transaction): number => sum + Math.abs(transaction.amount), 0) * modifier);
+      case this.isWorkTank():
+        return this.amount + ((this.tax + this.frankingCredit) * modifier);
+      default:
+        return this.amount || 0;
+    }
+  }
+
+  isInterest(): boolean {
+    return this.chartAccounts.id === ChartAccountsListEnum.INTEREST_ON_LOAN;
+  }
+
+  isCash(): boolean {
+    return this.source === TransactionSourceEnum.CASH;
+  }
+
+  /**
+   * Create Depreciation instance based on Transaction
+   */
+  toDepreciation(): Depreciation {
+    return plainToClass(Depreciation, {
+      date: this.date,
+      amount: this.amount,
+      chartAccounts: this.chartAccounts,
+      description: this.description,
+      type: DepreciationTypeEnum.PLANT_EQUIPMENT,
+      claimPercent: this.claimPercent,
+      property: this.property,
+      calculation: this.property ? this.property.depreciationCalculation : DepreciationCalculationEnum.PRIME_COST
+    });
+  }
+
+  /**
+   * Check if transaction is completely allocated
+   */
+  isAllocated(allocations: TransactionAllocationCollection): boolean {
+    return this.getNetAmount() === this.getAllocatedAmount(allocations);
+  }
+
+  /**
+   * Get transaction allocated amount
+   */
+  getAllocatedAmount(allocations: TransactionAllocationCollection): number {
+    return allocations.getByTransactionsIds([this.id]).amount;
+  }
+
+  /**
+   * Get transaction unallocated amount
+   */
+  getUnallocatedAmount(allocations: TransactionAllocationCollection): number {
+    return this.getNetAmount() - this.getAllocatedAmount(allocations);
+  }
+}

package/src/lib/models/user/my-account-history-initiated-by.enum.ts

@@ -0,0 +1,4 @@
+export enum MyAccountHistoryInitiatedByEnum {
+  OWNER = 0,
+  ACCOUNTANT = 1
+}

package/src/lib/models/user/my-account-history-status.enum.ts

@@ -0,0 +1,4 @@
+export enum MyAccountHistoryStatusEnum {
+  SUCCESS = 0,
+  ERROR = 1
+}

package/src/lib/models/user/my-account-history-type.enum.ts

@@ -0,0 +1,5 @@
+export enum MyAccountHistoryTypeEnum {
+  REVIEW = 0,
+  UPGRADE_PLAN = 1,
+  UPLOAD_DOCUMENT = 2
+}

package/src/lib/models/user/my-account-history.ts

@@ -0,0 +1,12 @@
+import { MyAccountHistoryTypeEnum } from './my-account-history-type.enum';
+import { MyAccountHistoryInitiatedByEnum } from './my-account-history-initiated-by.enum';
+import { MyAccountHistoryStatusEnum } from './my-account-history-status.enum';
+
+export class MyAccountHistory {
+  id: number;
+  name: string;
+  type: MyAccountHistoryTypeEnum;
+  initiatedBy: MyAccountHistoryInitiatedByEnum;
+  date: Date;
+  status: MyAccountHistoryStatusEnum;
+}

package/src/lib/models/user/occupation.ts

@@ -0,0 +1,4 @@
+import { Occupation as OccupationBase } from '../../db/Models/occupation';
+
+export class Occupation extends OccupationBase {
+}

package/src/lib/models/user/user-roles.const.ts

@@ -0,0 +1,13 @@
+import { UserRolesEnum } from '../../db/Enums/user-roles.enum';
+
+export const USER_ROLES: {[key: string]: UserRolesEnum[]} = {
+  ROLE_FIRM_OWNER: [UserRolesEnum.FIRM_OWNER],
+  ROLE_FIRM_MANAGER: [UserRolesEnum.FIRM_MANAGER, UserRolesEnum.FIRM_OWNER],
+  ROLE_ACCOUNTANT: [UserRolesEnum.FIRM_MANAGER, UserRolesEnum.FIRM_OWNER, UserRolesEnum.ACCOUNTANT],
+  ROLE_CLIENT: [UserRolesEnum.CLIENT],
+  ROLE_USER: [UserRolesEnum.USER],
+  ROLE_USER_SUBSCRIPTION: [UserRolesEnum.SUBSCRIPTION],
+  ROLE_USER_WORK: [UserRolesEnum.WORK_TANK],
+  ROLE_USER_PROPERTY: [UserRolesEnum.PROPERTY_TANK],
+  ROLE_PREVIOUS_ADMIN: [UserRolesEnum.SWITCH_USER]
+};

package/src/lib/models/user/user-to-register.ts

@@ -0,0 +1,7 @@
+/**
+ * Class with basic information about registering user
+ */
+export class UserToRegister {
+  firstName: string;
+  email: string;
+}

package/src/lib/models/user/user-work-position.const.ts

@@ -0,0 +1,7 @@
+import { UserRolesEnum } from '../../db/Enums/user-roles.enum';
+
+export const USER_WORK_POSITION: {[key: string]: string} = {
+  [UserRolesEnum.EMPLOYEE]: 'Employee',
+  [UserRolesEnum.FIRM_MANAGER]: 'Manager',
+  [UserRolesEnum.FIRM_OWNER]: 'Firm Owner'
+};

package/src/lib/models/user/user.ts

@@ -0,0 +1,160 @@
+import { User as BaseUser } from '../../db/Models/user';
+import { UserStatusEnum } from '../../db/Enums/user-status.enum';
+import { UserRolesEnum } from '../../db/Enums/user-roles.enum';
+import { Address } from '../address/address';
+import { USER_WORK_POSITION } from './user-work-position.const';
+import { ClientDetails } from '../client/client-details';
+import { EmployeeDetails } from '../employee/employee-details';
+import { Type } from 'class-transformer';
+import { Phone } from '../phone/phone';
+import { ServiceSubscription } from '../service-subscription/service-subscription';
+import { ServiceSubscriptionItem } from '../service-subscription/service-subscription-item';
+import { Photoable } from '../../interfaces/photoable';
+
+export class User extends BaseUser implements Photoable {
+  @Type(() => ServiceSubscription)
+  subscriptions: ServiceSubscription[];
+
+  @Type(() => ClientDetails)
+  clientDetails: ClientDetails;
+
+  @Type(() => EmployeeDetails)
+  employeeDetails: EmployeeDetails;
+
+  @Type(() => Address)
+  address: Address;
+
+  @Type(() => Phone)
+  phone: Phone;
+
+  @Type(() => Date)
+  createdAt: Date;
+
+  // @TODO Alex remove this hack
+  @Type(() => User)
+  clients: User[];
+
+  get fullName(): string {
+    return `${this.firstName} ${this.lastName}`;
+  }
+
+  get activeSubscription(): ServiceSubscription {
+    return this.subscriptions.find((ss: ServiceSubscription): boolean => ss.isActive);
+  }
+
+  get lastSubscription(): ServiceSubscription {
+    return this.subscriptions[this.subscriptions.length - 1];
+  }
+
+  /**
+   * @TODO refactor
+   *
+   */
+  get position(): string {
+    switch (true) {
+      case this.isFirmOwner():
+        return USER_WORK_POSITION[UserRolesEnum.FIRM_OWNER];
+      case this.isManager():
+        return USER_WORK_POSITION[UserRolesEnum.FIRM_MANAGER];
+      case this.isEmployee():
+        return USER_WORK_POSITION[UserRolesEnum.EMPLOYEE];
+      default:
+        return '';
+    }
+  }
+
+  hasRole(role: UserRolesEnum): boolean {
+    return this.roles.includes(role);
+  }
+
+  isOnboarding(): boolean {
+    return this.status === UserStatusEnum.ON_BOARDING;
+  }
+
+  hasSubscription(): boolean {
+    return this.roles.includes(UserRolesEnum.SUBSCRIPTION);
+  }
+
+  isLoggedIn(): boolean {
+    return this.id === +localStorage.getItem('userId');
+  }
+
+  isClient(): boolean {
+    return this.roles.includes(UserRolesEnum.CLIENT);
+  }
+
+  isEmployee(): boolean {
+    return this.isAccountant() || this.isAdvisor();
+  }
+
+  isAccountant(): boolean {
+    return this.roles.includes(UserRolesEnum.ACCOUNTANT);
+  }
+
+  isAdvisor(): boolean {
+    return this.roles.includes(UserRolesEnum.ADVISOR);
+  }
+
+  isImpersonator(): boolean {
+    return this.roles.includes(UserRolesEnum.SWITCH_USER);
+  }
+
+  /**
+   * Check if current user is firm owner
+   */
+  isFirmOwner(): boolean {
+    return this.roles.includes(UserRolesEnum.FIRM_OWNER);
+  }
+
+  /**
+   * Check if current user is firm manager
+   */
+  isManager(): boolean {
+    return this.roles.includes(UserRolesEnum.FIRM_MANAGER) || this.roles.includes(UserRolesEnum.FIRM_OWNER);
+  }
+
+  /**
+   * check if user has property tank access
+   */
+  hasPropertyTank(): boolean {
+    return this.roles ?
+      this.roles.includes(UserRolesEnum.PROPERTY_TANK) :
+      !!this.getSubscriptionRole(UserRolesEnum.PROPERTY_TANK);
+  }
+
+  /**
+   * check if user has property tank access
+   */
+  hasWorkTank(): boolean {
+    return this.roles ?
+      this.roles.includes(UserRolesEnum.WORK_TANK) :
+      !!this.getSubscriptionRole(UserRolesEnum.WORK_TANK);
+  }
+
+  /**
+   * Get user subscription role by provided role type
+   * @param roleType by which role should be returned
+   */
+  getSubscriptionRole(roleType: UserRolesEnum): ServiceSubscriptionItem {
+    /**
+     * Add @TODO for Alex to check if we should use getLastSubscription here
+     */
+    return this.activeSubscription?.items
+      .find((subscriptionItem: ServiceSubscriptionItem) => subscriptionItem.price.product.role.includes(roleType));
+  }
+
+  /**
+   * Get user's photo link
+   */
+  getPhoto(): string {
+    return this.photo;
+  }
+
+  /**
+   * get user's initials
+   */
+  getInitials(): string {
+    return `${this.firstName[0].toUpperCase()}${this.lastName[0].toUpperCase()}`;
+  }
+}
+

package/src/lib/models/user-event/user-event-category.enum.ts

@@ -0,0 +1,9 @@
+/**
+ * Enum with user event categories
+ */
+export enum UserEventCategoryEnum {
+  USER = 1,
+  CO_OWNER = 2,
+  FIRM = 3,
+  BASIQ = 4
+}

package/src/lib/models/user-event/user-event-category.ts

@@ -0,0 +1,9 @@
+import { UserEventCategoryEnum } from './user-event-category.enum';
+
+/**
+ * Category of user event type
+ */
+export class UserEventCategory {
+  name: string;
+  type: UserEventCategoryEnum;
+}