taxtank-core 0.0.2 → 0.0.3

package/lib/collections/abstract.collection.d.ts

@@ -0,0 +1,40 @@
+import { CollectionDictionary } from './collection-dictionary';
+/**
+ * collection abstract class. Contains common properties and methods for all collections
+ */
+export declare abstract class AbstractCollection<Model extends object> implements Iterable<Model> {
+    items: Model[];
+    constructor(items?: Model[]);
+    groupBy(prop: string): CollectionDictionary<AbstractCollection<Model>>;
+    /**
+     * Iterator that allow to iterate collection items
+     */
+    [Symbol.iterator](): Iterator<Model>;
+    /**
+     * get collection length
+     */
+    get length(): number;
+    /**
+     * method returns amount of fields from passed items
+     * @param field Name of field for calculation
+     * @param items (optional) Array of items need to be calculated. All collection's items by default
+     */
+    protected getSummary(field: string, items?: Model[]): number;
+    /**
+     * Get list of items ids
+     */
+    getIds(): number[];
+    /**
+     * Get single item by id
+     */
+    getById(id: number): Model;
+    getByIds(ids: number[]): Model[];
+    /**
+     * Get total sum of items by field
+     * @param field Name of the field for sum
+     */
+    sumBy(field: string): number;
+    toArray(): Model[];
+    get first(): Model;
+    get last(): Model;
+}

package/lib/collections/bank-account.collection.d.ts

@@ -0,0 +1,67 @@
+import { AbstractCollection } from './abstract.collection';
+import { BankAccountTypeEnum } from '../db/Enums/bank-account-type.enum';
+import { TankTypeEnum } from '../db/Enums/tank-type.enum';
+import { BankAccount } from '../models/bank/bank-account';
+import { BankAccountProperty } from '../models/bank/bank-account-property';
+import { Property } from '../models/property/property';
+/**
+ * Collection of bank accounts.
+ */
+export declare class BankAccountCollection extends AbstractCollection<BankAccount> {
+    /**
+     * get list of bank accounts with passed types
+     */
+    getByType(types: BankAccountTypeEnum | BankAccountTypeEnum[], isExclude?: boolean): BankAccount[];
+    /**
+     * get amount of initial loans
+     */
+    getInitialLoanAmount(): number;
+    /**
+     * get amount of current loans
+     */
+    getCurrentLoanAmount(): number;
+    /**
+     * get collection filtered by property id
+     */
+    getByPropertyId(id: number): BankAccountCollection;
+    /**
+     * get collection filtered by properties ids
+     */
+    getByPropertiesIds(ids: number[]): BankAccountCollection;
+    /**
+     * get collection of active bank accounts
+     */
+    getActiveBankAccounts(): BankAccountCollection;
+    /**
+     * get reduction of loan (reduction of principle) percentage
+     */
+    getPrincipleReductionPercent(): number;
+    /**
+     * Get collection of loan bank accounts
+     */
+    getLoanAccounts(): BankAccountCollection;
+    getSavingsAccounts(): BankAccountCollection;
+    getOpeningBalance(): number;
+    get currentBalance(): number;
+    /**
+     * Get Collection of bank accounts with property tank type
+     */
+    getPropertyBankAccounts(): BankAccountCollection;
+    /**
+     * Get Collection of bank accounts with work tank type
+     */
+    getWorkBankAccounts(): BankAccountCollection;
+    /**
+     * Get Collection of bank accounts by tank type
+     */
+    getByTankType(tankType: TankTypeEnum): BankAccountCollection;
+    /**
+     * Get list of all bank account properties
+     */
+    getBankAccountPropertiesList(): BankAccountProperty[];
+    /**
+     * Get lis of unique properties from all bank accounts properties
+     */
+    getProperties(): Property[];
+    getPropertyBalanceAmount(propertyId: number): number;
+}

package/lib/collections/bank-transaction.collection.d.ts

@@ -0,0 +1,72 @@
+import { BankTransaction } from '../models/bank/bank-transaction';
+import { MonthNumberEnum } from '../models/financial-year/month-number.enum';
+import { IncomeSource } from '../models/income-source/income-source';
+import { BankAccount } from '../models/bank/bank-account';
+import { AbstractCollection } from './abstract.collection';
+import { CollectionDictionary } from './collection-dictionary';
+import { TransactionAllocationCollection } from './transaction-allocation.collection';
+/**
+ * Collection of bank transactions.
+ * IMPORTANT: Create this collection based on bank transactions from TransactionAllocationService
+ * @TODO find way to accept interface with allocation instead of bankTransaction to prevent wrong usage
+ * because all amounts calculates with allocated amounts but not from bank transactions amounts.
+ */
+export declare class BankTransactionCollection extends AbstractCollection<BankTransaction> {
+    getAmount(): number;
+    /**
+     * Difference between total bank transactions amount and sum of allocations for passed bank transactions
+     */
+    getUnallocatedAmount(allocations: TransactionAllocationCollection): number;
+    /**
+     * get date of the last transaction
+     */
+    getLastTransactionDate(): Date;
+    /**
+     * get list of credit transactions
+     */
+    get creditTransactions(): BankTransactionCollection;
+    /**
+     * get list of debit transactions
+     */
+    get debitTransactions(): BankTransactionCollection;
+    /**
+     * get difference between debit and credit transactions amounts
+     */
+    get balanceAmount(): number;
+    /**
+     * get list of transactions for passed month
+     * @param monthIndex Month number from 0 to 11
+     */
+    getTransactionsByMonth(monthIndex: MonthNumberEnum): BankTransactionCollection;
+    /**
+     * get list of transactions by provided bank accounts
+     * @param bankAccounts by which transactions should be returned
+     */
+    getByBankAccounts(bankAccounts: BankAccount[]): BankTransaction[];
+    /**
+     * get list of transactions by provided ids of bank accounts
+     * @param ids of bank accounts
+     */
+    getByBankAccountsIds(ids: number[]): BankTransactionCollection;
+    /**
+     * Find Bank Transaction available for transfer
+     */
+    findTransfer(bankTransaction: BankTransaction): BankTransaction;
+    /**
+     * Group bank transactions by transaction id.
+     * Each group is bank transaction collection and contains bank transactions related to transactions via allocations
+     */
+    groupByTransaction(allocations: TransactionAllocationCollection): CollectionDictionary<BankTransactionCollection>;
+    /**
+     * Get collection of bank transactions related with passed allocations
+     */
+    getByAllocations(allocations: TransactionAllocationCollection): BankTransactionCollection;
+    /**
+     * Set allocate operation for bank transactions with amounts equal to salary
+     */
+    preselectAllocateOperationForSalary(salaryIncomeSources: IncomeSource[]): void;
+    /**
+     * Get collection of unallocated bankTransactions
+     */
+    getUnallocatedBankTransactions(allocations: TransactionAllocationCollection): BankTransactionCollection;
+}

package/lib/collections/client-movement.collection.d.ts

@@ -0,0 +1,17 @@
+import { AbstractCollection } from './abstract.collection';
+import { ClientMovement } from '../models/client/client-movement';
+import { EmployeeCollection } from './employee.collection';
+import { ClientCollection } from './client.collection';
+import { FirmTypeEnum } from '../db/Enums/firm-type.enum';
+/**
+ * Collection of tax review
+ */
+export declare class ClientMovementCollection extends AbstractCollection<ClientMovement> {
+    get active(): ClientMovementCollection;
+    get employees(): EmployeeCollection;
+    get clients(): ClientCollection;
+    get accountant(): ClientMovement;
+    get advisors(): ClientMovementCollection;
+    getByEmployeeId(id: number): ClientMovementCollection;
+    getByFirmType(firmType: FirmTypeEnum): ClientMovementCollection;
+}

package/lib/collections/client-portfolio-report.collection.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Collection of employee clients tax summary information
+ */
+import { AbstractCollection } from './abstract.collection';
+import { ClientPortfolioReport } from '../models/client/client-portfolio-report';
+export declare class ClientPortfolioReportCollection extends AbstractCollection<ClientPortfolioReport> {
+    get marketValue(): number;
+    get loanBalance(): number;
+    get equityPosition(): number;
+    /**
+     * Get average market value if there are more than 1 item in the collection
+     */
+    get averageMarketValue(): number;
+    /**
+     * Get average loan balance if there are more than 1 item in the collection
+     */
+    get averageLoanBalance(): number;
+    /**
+     * Get average equity position if there are more than 1 item in the collection
+     */
+    get averageEquityPosition(): number;
+    /**
+     * Return report by provided category name
+     */
+    getByCategoryName(name: string): ClientPortfolioReport;
+}

package/lib/collections/client.collection.d.ts

@@ -0,0 +1,4 @@
+import { AbstractCollection } from './abstract.collection';
+import { User } from '../models/user/user';
+export declare class ClientCollection extends AbstractCollection<User> {
+}

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

@@ -0,0 +1,44 @@
+import { AbstractCollection } from './abstract.collection';
+/**
+ * List of collections grouped by passed property
+ */
+export declare class CollectionDictionary<Collection extends AbstractCollection<object>> {
+    /**
+     * List of grouped collections
+     */
+    private items;
+    /**
+     * Constructor function of passed collection for creating new instances
+     */
+    private collectionConstructor;
+    /**
+     * @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);
+    /**
+     * List of collections keys
+     */
+    get keys(): string[];
+    /**
+     * Get collection by key or return empty collection if key does not exist
+     */
+    get(key: string | number): Collection;
+    /**
+     * Add new item by key
+     */
+    add(key: string | number, value: Collection): void;
+    /**
+     * Join several collections by ids
+     */
+    merge(keys: number[]): Collection;
+    /**
+     * Create instance of collection
+     */
+    createCollection(items?: object[]): Collection;
+    /**
+     * Group collection items by passed path into items object
+     */
+    private groupItems;
+}

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

@@ -0,0 +1,11 @@
+import { AbstractCollection } from './abstract.collection';
+import { DepreciationForecast } from '../models/depreciation/depreciation-forecast';
+/**
+ * Collection of depreciations
+ */
+export declare class DepreciationForecastCollection extends AbstractCollection<DepreciationForecast> {
+    filterByYear(financialYear: number): any;
+    getClaimAmountByMonth(month: number): number;
+    get amount(): number;
+    get claimAmount(): number;
+}

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

@@ -0,0 +1,27 @@
+import { TankTypeEnum } from '../db/Enums/tank-type.enum';
+import { AbstractCollection } from './abstract.collection';
+import { Depreciation } from '../models/depreciation/depreciation';
+import { DepreciationCapitalProject } from '../models/depreciation/depreciation-capital-project';
+export declare class DepreciationCollection extends AbstractCollection<Depreciation> {
+    /**
+     * Get total amount of all depreciations in the collection
+     */
+    get amount(): number;
+    get claimAmount(): number;
+    getClaimAmountByYear(year: number): number;
+    get assetValue(): number;
+    /**
+     * Get new depreciations collections filtered by tank type
+     */
+    getByTankType(tankType: TankTypeEnum): DepreciationCollection;
+    getByPropertiesIds(ids: number[]): DepreciationCollection;
+    getWithoutBorrowingExpenses(): DepreciationCollection;
+    getWorkDepreciations(): DepreciationCollection;
+    getPropertyDepreciations(): DepreciationCollection;
+    getPlantEquipment(): DepreciationCollection;
+    getCapitalDepreciations(): DepreciationCollection;
+    getBorrowingExpenseDepreciations(): DepreciationCollection;
+    getWrittenOffDepreciations(): DepreciationCollection;
+    getLowValuePoolDepreciations(): DepreciationCollection;
+    getCapitalProjects(): DepreciationCapitalProject[];
+}

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

@@ -0,0 +1,6 @@
+import { AbstractCollection } from './abstract.collection';
+import { User } from '../models/user/user';
+export declare class EmployeeCollection extends AbstractCollection<User> {
+    get accountant(): User;
+    get advisors(): User[];
+}

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

@@ -0,0 +1,25 @@
+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 declare class IncomeSourceCollection extends AbstractCollection<IncomeSource> {
+    filterByTank(tank: TankTypeEnum): IncomeSource[];
+    /**
+     * Filter income sources by provided tyoes
+     * @param types
+     */
+    filterByTypes(types: IncomeSourceTypeEnum[]): IncomeSource[];
+    /**
+     * Get income source by provided Id
+     * @param id
+     */
+    getById(id: number): IncomeSource;
+    /**
+     * Get income sources list of forecasts
+     */
+    get forecasts(): ISalaryForecast[];
+}

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

@@ -0,0 +1,14 @@
+import { AbstractCollection } from './abstract.collection';
+import { Loan } from '../models/loan/loan';
+export declare 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;
+    /**
+     * Get single loan by bank account id
+     * @param id id of bank account
+     */
+    getByBankAccountId(id: number): Loan;
+}

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

@@ -0,0 +1,19 @@
+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';
+export declare class LogbookCollection {
+    trips: VehicleLogbook[];
+    logbookClaimRange: number;
+    financialYear: FinancialYear;
+    private _bestPeriod;
+    constructor(vehicles: Vehicle[]);
+    get isAutomaticLogbookCalculationAllowed(): boolean;
+    get bestPeriod(): LogbookPeriod;
+    private get workTrips();
+    private calculateBestPeriod;
+    private getDateRange;
+    private getKilometersAmount;
+    private getLogbooksWorkUsage;
+    private setInitialBestPeriod;
+}

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

@@ -0,0 +1,11 @@
+import { AbstractCollection } from './abstract.collection';
+import { MessageDocument } from '../models/chat/message-document';
+/**
+ * Collection of MessageDocument instances
+ */
+export declare class MessageDocumentCollection extends AbstractCollection<MessageDocument> {
+    /**
+     * get list of documents which are not attached to any message
+     */
+    getUnattached(): MessageDocumentCollection;
+}

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

@@ -0,0 +1,14 @@
+import { AbstractCollection } from './abstract.collection';
+import { Message } from '../models/chat/message';
+import { User } from '../models/user/user';
+export declare class MessageCollection extends AbstractCollection<Message> {
+    getFirstUnreadMessage(user: User): Message;
+    /**
+     * Get List of unread chats
+     */
+    getUnread(): Message[];
+    /**
+     * Check if chat has unread chats
+     */
+    hasUnread(): boolean;
+}

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

@@ -0,0 +1,33 @@
+import { AbstractCollection } from './abstract.collection';
+import { Property } from '../models/property/property';
+export declare class PropertyCollection extends AbstractCollection<Property> {
+    /**
+     * Get new property collection filtered by category id
+     * @param id id of category for filter
+     */
+    getByCategoryId(id: number): PropertyCollection;
+    /**
+     * Get new property collection filtered by active status
+     */
+    getActiveProperties(): PropertyCollection;
+    /**
+     * Get new property collection filtered by owner
+     */
+    getOwnProperties(): PropertyCollection;
+    /**
+     * Get new property collection filtered by shared
+     */
+    getSharedProperties(): PropertyCollection;
+    /**
+     * Get total purchase price for all properties in the collection
+     */
+    get purchasePrice(): number;
+    get growthPercent(): number;
+    get marketValue(): number;
+    get forecastedRentalReturn(): number;
+    get forecastedTaxPosition(): number;
+    get firstForecastYear(): number;
+    get marketValueGrowth(): number;
+    getOwnerOccupiedProperties(): PropertyCollection;
+    get earliestPurchaseDate(): Date;
+}

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

@@ -0,0 +1,6 @@
+import { AbstractCollection } from './abstract.collection';
+import { ServicePrice } from '../models/service-subscription/service-price';
+export declare class ServicePriceCollection extends AbstractCollection<ServicePrice> {
+    get work(): ServicePrice;
+    get property(): ServicePrice;
+}

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

@@ -0,0 +1,8 @@
+import { AbstractCollection } from './abstract.collection';
+import { ServiceSubscription } from '../models/service-subscription/service-subscription';
+export declare class ServiceSubscriptionCollection extends AbstractCollection<ServiceSubscription> {
+    get individual(): ServiceSubscription;
+    get investor(): ServiceSubscription;
+    get investorPlus(): ServiceSubscription;
+    getRecommended(properties: number): ServiceSubscription;
+}

package/lib/collections/tax-return-category-item.collection.d.ts

@@ -0,0 +1,68 @@
+import { AbstractCollection } from './abstract.collection';
+import { TaxReturnCategoryItem } from '../models/tax-summary/tax-return-category-item';
+import { TaxReturnCategorySectionEnum } from '../db/Enums/tax-return-category-section.enum';
+/**
+ * collection for tax return category items
+ */
+export declare class TaxReturnCategoryItemCollection extends AbstractCollection<TaxReturnCategoryItem> {
+    /**
+     * Work income
+     */
+    get salary(): number;
+    /**
+     * Work expenses
+     */
+    get workExpenses(): number;
+    /**
+     * Property income
+     */
+    get rentalIncome(): number;
+    /**
+     * Property rental deductions
+     */
+    get rentalDeductions(): number;
+    /**
+     * Property expenses
+     */
+    get propertyExpenses(): number;
+    /**
+     * Property interest
+     */
+    get interestDeductions(): number;
+    /**
+     * Property capital works depreciations
+     */
+    get capitalWorks(): number;
+    /**
+     * Property plant & equipment depreciations
+     */
+    get plantEquipment(): number;
+    /**
+     * Total property depreciaions
+     */
+    get propertyDepreciations(): number;
+    get partnershipsAndTrusts(): number;
+    get pciAndSbeIncome(): number;
+    get capitalGains(): number;
+    get foreignSourceIncome(): number;
+    /**
+     * Other income
+     */
+    get otherIncome(): number;
+    /**
+     * Other expenses
+     */
+    get otherDeductions(): number;
+    get taxInstalments(): number;
+    get frankingCredits(): number;
+    get taxOffsets(): number;
+    get borrowingExpenses(): number;
+    get grossTaxPayable(): number;
+    /**
+     * taxWithheld by section (work or other)
+     */
+    getTaxWithheld(section?: TaxReturnCategorySectionEnum): number;
+    getTaxCreditsCollection(): TaxReturnCategoryItemCollection;
+    getTotalAmountByIncomeSourceName(name: string): number;
+    private getByCategory;
+}

package/lib/collections/tax-review.collection.d.ts

@@ -0,0 +1,35 @@
+import { AbstractCollection } from './abstract.collection';
+import { TaxReview } from '../models/tax-review/tax-review';
+import { TaxReviewStatusEnum } from '../db/Enums/tax-review-status.enum';
+import { User } from '../models/user/user';
+/**
+ * Collection of tax review
+ */
+export declare class TaxReviewCollection extends AbstractCollection<TaxReview> {
+    /**
+     * Get tax reviews items with SENT & COMPLETED statuses
+     */
+    getCompleted(): TaxReview[];
+    /**
+     * Get tax reviews items with WAITING_FOR_APPROVAL status
+     */
+    getReadyForReview(): TaxReview[];
+    /**
+     * Get tax reviews items in work (In progress, Waiting for client, Waiting for Approval, Is approved)
+     */
+    getInWork(): TaxReview[];
+    /**
+     * Get percentage of completed reviews of the total review amount
+     */
+    getCompletedPercentage(): number;
+    /**
+     * get list of items filtered by status
+     * @param status
+     */
+    getByStatus(status: TaxReviewStatusEnum): TaxReview[];
+    /**
+     * get list of items by firm id
+     */
+    getByEmployeeId(employeeId: number): TaxReview[];
+    getEmployees(): User[];
+}

package/lib/collections/transaction-allocation.collection.d.ts

@@ -0,0 +1,23 @@
+import { AbstractCollection } from './abstract.collection';
+import { TransactionAllocation } from '../models/transaction/transaction-allocation';
+import { BankTransactionCollection } from './bank-transaction.collection';
+import { CollectionDictionary } from './collection-dictionary';
+import { Transaction } from '../models/transaction/transaction';
+import { BankTransaction } from '../models/bank/bank-transaction';
+export declare class TransactionAllocationCollection extends AbstractCollection<TransactionAllocation> {
+    get amount(): number;
+    getByTransactionsIds(ids: number[]): TransactionAllocationCollection;
+    getByBankTransactionsIds(ids: number[]): TransactionAllocationCollection;
+    /**
+     * Group allocations by bank account via bank transactions collection
+     */
+    groupByBankAccount(bankTransactions: BankTransactionCollection): CollectionDictionary<TransactionAllocationCollection>;
+    /**
+     * check if collection includes allocation of passed transaction
+     */
+    hasTransaction(transaction: Transaction): boolean;
+    /**
+     * Check if bank transaction is related with current allocations
+     */
+    hasBankTransaction(bankTransaction: BankTransaction): boolean;
+}