mirror of
https://github.com/bigcapitalhq/bigcapital.git
synced 2026-02-15 20:30:33 +00:00
99e6fe273f
fix: constraints of delete item from storage. fix: constraints of delete item category from storage. fix: localize database seeds files. fix: view meta data in accounts list response.
479 lines
16 KiB
TypeScript
479 lines
16 KiB
TypeScript
import { Inject, Service } from 'typedi';
|
|
import { difference } from 'lodash';
|
|
import { kebabCase } from 'lodash'
|
|
import TenancyService from 'services/Tenancy/TenancyService';
|
|
import { ServiceError } from 'exceptions';
|
|
import { IAccountDTO, IAccount, IAccountsFilter, IFilterMeta } from 'interfaces';
|
|
import {
|
|
EventDispatcher,
|
|
EventDispatcherInterface,
|
|
} from 'decorators/eventDispatcher';
|
|
import DynamicListingService from 'services/DynamicListing/DynamicListService';
|
|
import events from 'subscribers/events';
|
|
|
|
@Service()
|
|
export default class AccountsService {
|
|
@Inject()
|
|
tenancy: TenancyService;
|
|
|
|
@Inject()
|
|
dynamicListService: DynamicListingService;
|
|
|
|
@Inject('logger')
|
|
logger: any;
|
|
|
|
@EventDispatcher()
|
|
eventDispatcher: EventDispatcherInterface;
|
|
|
|
/**
|
|
* Retrieve account type or throws service error.
|
|
* @param {number} tenantId -
|
|
* @param {number} accountTypeId -
|
|
* @return {IAccountType}
|
|
*/
|
|
private async getAccountTypeOrThrowError(tenantId: number, accountTypeId: number) {
|
|
const { AccountType } = this.tenancy.models(tenantId);
|
|
|
|
this.logger.info('[accounts] validating account type existance.', { tenantId, accountTypeId });
|
|
const accountType = await AccountType.query().findById(accountTypeId);
|
|
|
|
if (!accountType) {
|
|
this.logger.info('[accounts] account type not found.');
|
|
throw new ServiceError('account_type_not_found');
|
|
}
|
|
return accountType;
|
|
}
|
|
|
|
/**
|
|
* Retrieve parent account or throw service error.
|
|
* @param {number} tenantId
|
|
* @param {number} accountId
|
|
* @param {number} notAccountId
|
|
*/
|
|
private async getParentAccountOrThrowError(tenantId: number, accountId: number, notAccountId?: number) {
|
|
const { Account } = this.tenancy.models(tenantId);
|
|
|
|
this.logger.info('[accounts] validating parent account existance.', {
|
|
tenantId, accountId, notAccountId,
|
|
});
|
|
const parentAccount = await Account.query().findById(accountId)
|
|
.onBuild((query) => {
|
|
if (notAccountId) {
|
|
query.whereNot('id', notAccountId);
|
|
}
|
|
});
|
|
if (!parentAccount) {
|
|
this.logger.info('[accounts] parent account not found.', { tenantId, accountId });
|
|
throw new ServiceError('parent_account_not_found');
|
|
}
|
|
return parentAccount;
|
|
}
|
|
|
|
/**
|
|
* Throws error if the account type was not unique on the storage.
|
|
* @param {number} tenantId
|
|
* @param {string} accountCode
|
|
* @param {number} notAccountId
|
|
*/
|
|
private async isAccountCodeUniqueOrThrowError(tenantId: number, accountCode: string, notAccountId?: number) {
|
|
const { Account } = this.tenancy.models(tenantId);
|
|
|
|
this.logger.info('[accounts] validating the account code unique on the storage.', {
|
|
tenantId, accountCode, notAccountId,
|
|
});
|
|
const account = await Account.query().where('code', accountCode)
|
|
.onBuild((query) => {
|
|
if (notAccountId) {
|
|
query.whereNot('id', notAccountId);
|
|
}
|
|
});
|
|
|
|
if (account.length > 0) {
|
|
this.logger.info('[accounts] account code is not unique.', { tenantId, accountCode });
|
|
throw new ServiceError('account_code_not_unique');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Throws service error if parent account has different type.
|
|
* @param {IAccountDTO} accountDTO
|
|
* @param {IAccount} parentAccount
|
|
*/
|
|
private throwErrorIfParentHasDiffType(accountDTO: IAccountDTO, parentAccount: IAccount) {
|
|
if (accountDTO.accountTypeId !== parentAccount.accountTypeId) {
|
|
throw new ServiceError('parent_has_different_type');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retrieve account of throw service error in case account not found.
|
|
* @param {number} tenantId
|
|
* @param {number} accountId
|
|
* @return {IAccount}
|
|
*/
|
|
private async getAccountOrThrowError(tenantId: number, accountId: number) {
|
|
const { accountRepository } = this.tenancy.repositories(tenantId);
|
|
|
|
this.logger.info('[accounts] validating the account existance.', { tenantId, accountId });
|
|
const account = await accountRepository.findById(accountId);
|
|
|
|
if (!account) {
|
|
this.logger.info('[accounts] the given account not found.', { accountId });
|
|
throw new ServiceError('account_not_found');
|
|
}
|
|
return account;
|
|
}
|
|
|
|
/**
|
|
* Diff account type between new and old account, throw service error
|
|
* if they have different account type.
|
|
*
|
|
* @param {IAccount|IAccountDTO} oldAccount
|
|
* @param {IAccount|IAccountDTO} newAccount
|
|
*/
|
|
private async isAccountTypeChangedOrThrowError(
|
|
oldAccount: IAccount|IAccountDTO,
|
|
newAccount: IAccount|IAccountDTO,
|
|
) {
|
|
if (oldAccount.accountTypeId !== newAccount.accountTypeId) {
|
|
throw new ServiceError('account_type_not_allowed_to_changed');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validates the account name uniquiness.
|
|
* @param {number} tenantId
|
|
* @param {string} accountName
|
|
* @param {number} notAccountId - Ignore the account id.
|
|
*/
|
|
private async validateAccountNameUniquiness(tenantId: number, accountName: string, notAccountId?: number) {
|
|
const { Account } = this.tenancy.models(tenantId);
|
|
|
|
this.logger.info('[accounts] validating account name uniquiness.', { tenantId, accountName, notAccountId });
|
|
const foundAccount = await Account.query().findOne('name', accountName).onBuild((query) => {
|
|
if (notAccountId) {
|
|
query.whereNot('id', notAccountId);
|
|
}
|
|
});
|
|
if (foundAccount) {
|
|
throw new ServiceError('account_name_not_unqiue');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a new account on the storage.
|
|
* @param {number} tenantId
|
|
* @param {IAccount} accountDTO
|
|
* @returns {IAccount}
|
|
*/
|
|
public async newAccount(tenantId: number, accountDTO: IAccountDTO) {
|
|
const { accountRepository } = this.tenancy.repositories(tenantId);
|
|
|
|
// Validate account name uniquiness.
|
|
await this.validateAccountNameUniquiness(tenantId, accountDTO.name);
|
|
|
|
// Validate the account code uniquiness.
|
|
if (accountDTO.code) {
|
|
await this.isAccountCodeUniqueOrThrowError(tenantId, accountDTO.code);
|
|
}
|
|
await this.getAccountTypeOrThrowError(tenantId, accountDTO.accountTypeId);
|
|
|
|
if (accountDTO.parentAccountId) {
|
|
const parentAccount = await this.getParentAccountOrThrowError(
|
|
tenantId, accountDTO.parentAccountId
|
|
);
|
|
this.throwErrorIfParentHasDiffType(accountDTO, parentAccount);
|
|
}
|
|
const account = await accountRepository.insert({
|
|
...accountDTO,
|
|
slug: kebabCase(accountDTO.name),
|
|
});
|
|
this.logger.info('[account] account created successfully.', { account, accountDTO });
|
|
|
|
// Triggers `onAccountCreated` event.
|
|
this.eventDispatcher.dispatch(events.accounts.onCreated);
|
|
|
|
return account;
|
|
}
|
|
|
|
/**
|
|
* Edits details of the given account.
|
|
* @param {number} tenantId
|
|
* @param {number} accountId
|
|
* @param {IAccountDTO} accountDTO
|
|
*/
|
|
public async editAccount(tenantId: number, accountId: number, accountDTO: IAccountDTO) {
|
|
const { accountRepository } = this.tenancy.repositories(tenantId);
|
|
const oldAccount = await this.getAccountOrThrowError(tenantId, accountId);
|
|
|
|
// Validate account name uniquiness.
|
|
await this.validateAccountNameUniquiness(tenantId, accountDTO.name, accountId);
|
|
|
|
await this.isAccountTypeChangedOrThrowError(oldAccount, accountDTO);
|
|
|
|
// Validate the account code not exists on the storage.
|
|
if (accountDTO.code && accountDTO.code !== oldAccount.code) {
|
|
await this.isAccountCodeUniqueOrThrowError(
|
|
tenantId,
|
|
accountDTO.code,
|
|
oldAccount.id
|
|
);
|
|
}
|
|
if (accountDTO.parentAccountId) {
|
|
const parentAccount = await this.getParentAccountOrThrowError(
|
|
accountDTO.parentAccountId, oldAccount.id,
|
|
);
|
|
this.throwErrorIfParentHasDiffType(accountDTO, parentAccount);
|
|
}
|
|
// Update the account on the storage.
|
|
const account = await accountRepository.edit(oldAccount.id, accountDTO);
|
|
this.logger.info('[account] account edited successfully.', {
|
|
account, accountDTO, tenantId
|
|
});
|
|
// Triggers `onAccountEdited` event.
|
|
this.eventDispatcher.dispatch(events.accounts.onEdited);
|
|
|
|
return account;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the given account details.
|
|
* @param {number} tenantId
|
|
* @param {number} accountId
|
|
*/
|
|
public async getAccount(tenantId: number, accountId: number) {
|
|
return this.getAccountOrThrowError(tenantId, accountId);
|
|
}
|
|
|
|
/**
|
|
* Detarmine if the given account id exists on the storage.
|
|
* @param {number} tenantId
|
|
* @param {number} accountId
|
|
*/
|
|
public async isAccountExists(tenantId: number, accountId: number) {
|
|
const { Account } = this.tenancy.models(tenantId);
|
|
|
|
this.logger.info('[account] validating the account existance.', { tenantId, accountId });
|
|
const foundAccounts = await Account.query()
|
|
.where('id', accountId);
|
|
|
|
return foundAccounts.length > 0;
|
|
}
|
|
|
|
/**
|
|
* Throws error if the account was prefined.
|
|
* @param {IAccount} account
|
|
*/
|
|
private throwErrorIfAccountPredefined(account: IAccount) {
|
|
if (account.predefined) {
|
|
throw new ServiceError('account_predefined');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Throws error if account has children accounts.
|
|
* @param {number} tenantId
|
|
* @param {number} accountId
|
|
*/
|
|
private async throwErrorIfAccountHasChildren(tenantId: number, accountId: number) {
|
|
const { Account } = this.tenancy.models(tenantId);
|
|
|
|
this.logger.info('[account] validating if the account has children.', {
|
|
tenantId, accountId,
|
|
});
|
|
const childAccounts = await Account.query().where(
|
|
'parent_account_id',
|
|
accountId,
|
|
);
|
|
if (childAccounts.length > 0) {
|
|
throw new ServiceError('account_has_children');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Throws service error if the account has associated transactions.
|
|
* @param {number} tenantId
|
|
* @param {number} accountId
|
|
*/
|
|
private async throwErrorIfAccountHasTransactions(tenantId: number, accountId: number) {
|
|
const { AccountTransaction } = this.tenancy.models(tenantId);
|
|
const accountTransactions = await AccountTransaction.query().where(
|
|
'account_id', accountId,
|
|
);
|
|
if (accountTransactions.length > 0) {
|
|
throw new ServiceError('account_has_associated_transactions');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deletes the account from the storage.
|
|
* @param {number} tenantId
|
|
* @param {number} accountId
|
|
*/
|
|
public async deleteAccount(tenantId: number, accountId: number) {
|
|
const { accountRepository } = this.tenancy.repositories(tenantId);
|
|
const account = await this.getAccountOrThrowError(tenantId, accountId);
|
|
|
|
this.throwErrorIfAccountPredefined(account);
|
|
|
|
await this.throwErrorIfAccountHasChildren(tenantId, accountId);
|
|
await this.throwErrorIfAccountHasTransactions(tenantId, accountId);
|
|
|
|
await accountRepository.deleteById(account.id);
|
|
this.logger.info('[account] account has been deleted successfully.', {
|
|
tenantId, accountId,
|
|
});
|
|
|
|
// Triggers `onAccountDeleted` event.
|
|
this.eventDispatcher.dispatch(events.accounts.onDeleted);
|
|
}
|
|
|
|
/**
|
|
* Retrieve the given accounts details or throw error if one account not exists.
|
|
* @param {number} tenantId
|
|
* @param {number[]} accountsIds
|
|
* @return {IAccount[]}
|
|
*/
|
|
private async getAccountsOrThrowError(tenantId: number, accountsIds: number[]): IAccount[] {
|
|
const { Account } = this.tenancy.models(tenantId);
|
|
|
|
this.logger.info('[account] trying to validate accounts not exist.', { tenantId, accountsIds });
|
|
const storedAccounts = await Account.query().whereIn('id', accountsIds);
|
|
const storedAccountsIds = storedAccounts.map((account) => account.id);
|
|
const notFoundAccounts = difference(accountsIds, storedAccountsIds);
|
|
|
|
if (notFoundAccounts.length > 0) {
|
|
this.logger.error('[account] accounts not exists on the storage.', { tenantId, notFoundAccounts });
|
|
throw new ServiceError('accounts_not_found');
|
|
}
|
|
return storedAccounts;
|
|
}
|
|
|
|
/**
|
|
* Validate whether one of the given accounts is predefined.
|
|
* @param {IAccount[]} accounts -
|
|
* @return {IAccount[]} - Predefined accounts
|
|
*/
|
|
private validatePrefinedAccounts(accounts: IAccount[]) {
|
|
const predefined = accounts.filter((account: IAccount) => account.predefined);
|
|
|
|
if (predefined.length > 0) {
|
|
this.logger.error('[accounts] some accounts predefined.', { predefined });
|
|
throw new ServiceError('predefined_accounts');
|
|
}
|
|
return predefined;
|
|
}
|
|
|
|
/**
|
|
* Validating the accounts have associated transactions.
|
|
* @param {number} tenantId
|
|
* @param {number[]} accountsIds
|
|
*/
|
|
private async validateAccountsHaveTransactions(tenantId: number, accountsIds: number[]) {
|
|
const { AccountTransaction } = this.tenancy.models(tenantId);
|
|
const accountsTransactions = await AccountTransaction.query()
|
|
.whereIn('account_id', accountsIds)
|
|
.count('id as transactions_count')
|
|
.groupBy('account_id')
|
|
.select('account_id');
|
|
|
|
const accountsHasTransactions: number[] = [];
|
|
|
|
accountsTransactions.forEach((transaction) => {
|
|
if (transaction.transactionsCount > 0) {
|
|
accountsHasTransactions.push(transaction.accountId);
|
|
}
|
|
});
|
|
if (accountsHasTransactions.length > 0) {
|
|
throw new ServiceError('accounts_have_transactions');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deletes the given accounts in bulk.
|
|
* @param {number} tenantId
|
|
* @param {number[]} accountsIds
|
|
*/
|
|
public async deleteAccounts(tenantId: number, accountsIds: number[]) {
|
|
const { Account } = this.tenancy.models(tenantId);
|
|
const accounts = await this.getAccountsOrThrowError(tenantId, accountsIds);
|
|
|
|
this.validatePrefinedAccounts(accounts);
|
|
await this.validateAccountsHaveTransactions(tenantId, accountsIds);
|
|
await Account.query().whereIn('id', accountsIds).delete();
|
|
|
|
this.logger.info('[account] given accounts deleted in bulk successfully.', {
|
|
tenantId, accountsIds
|
|
});
|
|
|
|
// Triggers `onBulkDeleted` event.
|
|
this.eventDispatcher.dispatch(events.accounts.onBulkDeleted);
|
|
}
|
|
|
|
/**
|
|
* Activate accounts in bulk.
|
|
* @param {number} tenantId
|
|
* @param {number[]} accountsIds
|
|
* @param {boolean} activate
|
|
*/
|
|
public async activateAccounts(tenantId: number, accountsIds: number[], activate: boolean = true) {
|
|
const { Account } = this.tenancy.models(tenantId);
|
|
await this.getAccountsOrThrowError(tenantId, accountsIds);
|
|
|
|
this.logger.info('[account] trying activate/inactive the given accounts ids.', { accountsIds });
|
|
await Account.query().whereIn('id', accountsIds)
|
|
.patch({
|
|
active: activate ? 1 : 0,
|
|
});
|
|
this.logger.info('[account] accounts have been activated successfully.', { tenantId, accountsIds });
|
|
|
|
// Triggers `onAccountBulkActivated` event.
|
|
this.eventDispatcher.dispatch(events.accounts.onActivated);
|
|
}
|
|
|
|
/**
|
|
* Activates/Inactivates the given account.
|
|
* @param {number} tenantId
|
|
* @param {number} accountId
|
|
* @param {boolean} activate
|
|
*/
|
|
public async activateAccount(tenantId: number, accountId: number, activate?: boolean) {
|
|
const { Account } = this.tenancy.models(tenantId);
|
|
const account = await this.getAccountOrThrowError(tenantId, accountId);
|
|
|
|
this.logger.info('[account] trying to activate/inactivate the given account id.');
|
|
await Account.query().where('id', accountId)
|
|
.patch({
|
|
active: activate ? 1 : 0,
|
|
})
|
|
this.logger.info('[account] account have been activated successfully.', { tenantId, accountId });
|
|
|
|
// Triggers `onAccountActivated` event.
|
|
this.eventDispatcher.dispatch(events.accounts.onActivated);
|
|
}
|
|
|
|
/**
|
|
* Retrieve accounts datatable list.
|
|
* @param {number} tenantId
|
|
* @param {IAccountsFilter} accountsFilter
|
|
*/
|
|
public async getAccountsList(
|
|
tenantId: number,
|
|
filter: IAccountsFilter,
|
|
): Promise<{ accounts: IAccount[], filterMeta: IFilterMeta }> {
|
|
const { Account } = this.tenancy.models(tenantId);
|
|
const dynamicList = await this.dynamicListService.dynamicList(tenantId, Account, filter);
|
|
|
|
this.logger.info('[accounts] trying to get accounts datatable list.', { tenantId, filter });
|
|
const accounts = await Account.query().onBuild((builder) => {
|
|
builder.withGraphFetched('type');
|
|
dynamicList.buildQuery()(builder);
|
|
});
|
|
|
|
return {
|
|
accounts,
|
|
filterMeta: dynamicList.getResponseMeta(),
|
|
};
|
|
}
|
|
}
|