mirror of
https://github.com/bigcapitalhq/bigcapital.git
synced 2026-02-24 00:29:49 +00:00
752 lines
21 KiB
TypeScript
752 lines
21 KiB
TypeScript
import { omit, sumBy } from 'lodash';
|
|
import moment from 'moment';
|
|
import { Inject, Service } from 'typedi';
|
|
import * as R from 'ramda';
|
|
import { Knex } from 'knex';
|
|
import composeAsync from 'async/compose';
|
|
import events from '@/subscribers/events';
|
|
import InventoryService from '@/services/Inventory/Inventory';
|
|
import SalesInvoicesCost from '@/services/Sales/SalesInvoicesCost';
|
|
import TenancyService from '@/services/Tenancy/TenancyService';
|
|
import DynamicListingService from '@/services/DynamicListing/DynamicListService';
|
|
import { formatDateFields, transformToMap } from 'utils';
|
|
import {
|
|
IBillDTO,
|
|
IBill,
|
|
ISystemUser,
|
|
IBillEditDTO,
|
|
IPaginationMeta,
|
|
IFilterMeta,
|
|
IBillsFilter,
|
|
IBillsService,
|
|
IItemEntry,
|
|
IItemEntryDTO,
|
|
IBillCreatedPayload,
|
|
IBillEditedPayload,
|
|
IBIllEventDeletedPayload,
|
|
IBillEventDeletingPayload,
|
|
IBillEditingPayload,
|
|
IBillCreatingPayload,
|
|
IVendor,
|
|
} from '@/interfaces';
|
|
import { ServiceError } from '@/exceptions';
|
|
import ItemsEntriesService from '@/services/Items/ItemsEntriesService';
|
|
import JournalPosterService from '@/services/Sales/JournalPosterService';
|
|
import { ERRORS } from './constants';
|
|
import EntriesService from '@/services/Entries';
|
|
import { PurchaseInvoiceTransformer } from './PurchaseInvoices/PurchaseInvoiceTransformer';
|
|
import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
|
|
import UnitOfWork from '@/services/UnitOfWork';
|
|
import { BranchTransactionDTOTransform } from '@/services/Branches/Integrations/BranchTransactionDTOTransform';
|
|
import { WarehouseTransactionDTOTransform } from '@/services/Warehouses/Integrations/WarehouseTransactionDTOTransform';
|
|
import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
|
|
|
|
/**
|
|
* Vendor bills services.
|
|
* @service
|
|
*/
|
|
@Service('Bills')
|
|
export default class BillsService
|
|
extends SalesInvoicesCost
|
|
implements IBillsService
|
|
{
|
|
@Inject()
|
|
inventoryService: InventoryService;
|
|
|
|
@Inject()
|
|
tenancy: TenancyService;
|
|
|
|
@Inject()
|
|
eventPublisher: EventPublisher;
|
|
|
|
@Inject('logger')
|
|
logger: any;
|
|
|
|
@Inject()
|
|
dynamicListService: DynamicListingService;
|
|
|
|
@Inject()
|
|
itemsEntriesService: ItemsEntriesService;
|
|
|
|
@Inject()
|
|
journalPosterService: JournalPosterService;
|
|
|
|
@Inject()
|
|
entriesService: EntriesService;
|
|
|
|
@Inject()
|
|
transformer: TransformerInjectable;
|
|
|
|
@Inject()
|
|
uow: UnitOfWork;
|
|
|
|
@Inject()
|
|
private branchDTOTransform: BranchTransactionDTOTransform;
|
|
|
|
@Inject()
|
|
private warehouseDTOTransform: WarehouseTransactionDTOTransform;
|
|
|
|
/**
|
|
* Validates the given bill existance.
|
|
* @async
|
|
* @param {number} tenantId -
|
|
* @param {number} billId -
|
|
*/
|
|
public async getBillOrThrowError(tenantId: number, billId: number) {
|
|
const { Bill } = this.tenancy.models(tenantId);
|
|
|
|
const foundBill = await Bill.query()
|
|
.findById(billId)
|
|
.withGraphFetched('entries');
|
|
|
|
if (!foundBill) {
|
|
throw new ServiceError(ERRORS.BILL_NOT_FOUND);
|
|
}
|
|
return foundBill;
|
|
}
|
|
|
|
/**
|
|
* Validates the bill number existance.
|
|
* @async
|
|
* @param {Request} req
|
|
* @param {Response} res
|
|
* @param {Function} next
|
|
*/
|
|
private async validateBillNumberExists(
|
|
tenantId: number,
|
|
billNumber: string,
|
|
notBillId?: number
|
|
) {
|
|
const { Bill } = this.tenancy.models(tenantId);
|
|
const foundBills = await Bill.query()
|
|
.where('bill_number', billNumber)
|
|
.onBuild((builder) => {
|
|
if (notBillId) {
|
|
builder.whereNot('id', notBillId);
|
|
}
|
|
});
|
|
|
|
if (foundBills.length > 0) {
|
|
throw new ServiceError(ERRORS.BILL_NUMBER_EXISTS);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validate the bill has no payment entries.
|
|
* @param {number} tenantId
|
|
* @param {number} billId - Bill id.
|
|
*/
|
|
private async validateBillHasNoEntries(tenantId, billId: number) {
|
|
const { BillPaymentEntry } = this.tenancy.models(tenantId);
|
|
|
|
// Retireve the bill associate payment made entries.
|
|
const entries = await BillPaymentEntry.query().where('bill_id', billId);
|
|
|
|
if (entries.length > 0) {
|
|
throw new ServiceError(ERRORS.BILL_HAS_ASSOCIATED_PAYMENT_ENTRIES);
|
|
}
|
|
return entries;
|
|
}
|
|
|
|
/**
|
|
* Validate the bill number require.
|
|
* @param {string} billNo -
|
|
*/
|
|
private validateBillNoRequire(billNo: string) {
|
|
if (!billNo) {
|
|
throw new ServiceError(ERRORS.BILL_NO_IS_REQUIRED);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validate bill transaction has no associated allocated landed cost transactions.
|
|
* @param {number} tenantId
|
|
* @param {number} billId
|
|
*/
|
|
private async validateBillHasNoLandedCost(tenantId: number, billId: number) {
|
|
const { BillLandedCost } = this.tenancy.models(tenantId);
|
|
|
|
const billLandedCosts = await BillLandedCost.query().where(
|
|
'billId',
|
|
billId
|
|
);
|
|
if (billLandedCosts.length > 0) {
|
|
throw new ServiceError(ERRORS.BILL_HAS_ASSOCIATED_LANDED_COSTS);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validate transaction entries that have landed cost type should not be
|
|
* inventory items.
|
|
* @param {number} tenantId -
|
|
* @param {IItemEntryDTO[]} newEntriesDTO -
|
|
*/
|
|
public async validateCostEntriesShouldBeInventoryItems(
|
|
tenantId: number,
|
|
newEntriesDTO: IItemEntryDTO[]
|
|
) {
|
|
const { Item } = this.tenancy.models(tenantId);
|
|
|
|
const entriesItemsIds = newEntriesDTO.map((e) => e.itemId);
|
|
const entriesItems = await Item.query().whereIn('id', entriesItemsIds);
|
|
|
|
const entriesItemsById = transformToMap(entriesItems, 'id');
|
|
|
|
// Filter the landed cost entries that not associated with inventory item.
|
|
const nonInventoryHasCost = newEntriesDTO.filter((entry) => {
|
|
const item = entriesItemsById.get(entry.itemId);
|
|
|
|
return entry.landedCost && item.type !== 'inventory';
|
|
});
|
|
if (nonInventoryHasCost.length > 0) {
|
|
throw new ServiceError(
|
|
ERRORS.LANDED_COST_ENTRIES_SHOULD_BE_INVENTORY_ITEMS
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the default cost account to the bill entries.
|
|
*/
|
|
private setBillEntriesDefaultAccounts(tenantId: number) {
|
|
return async (entries: IItemEntry[]) => {
|
|
const { Item } = this.tenancy.models(tenantId);
|
|
|
|
const entriesItemsIds = entries.map((e) => e.itemId);
|
|
const items = await Item.query().whereIn('id', entriesItemsIds);
|
|
|
|
return entries.map((entry) => {
|
|
const item = items.find((i) => i.id === entry.itemId);
|
|
|
|
return {
|
|
...entry,
|
|
...(item.type !== 'inventory' && {
|
|
costAccountId: entry.costAccountId || item.costAccountId,
|
|
}),
|
|
};
|
|
});
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Retrieve the bill entries total.
|
|
* @param {IItemEntry[]} entries
|
|
* @returns {number}
|
|
*/
|
|
private getBillEntriesTotal(tenantId: number, entries: IItemEntry[]): number {
|
|
const { ItemEntry } = this.tenancy.models(tenantId);
|
|
|
|
return sumBy(entries, (e) => ItemEntry.calcAmount(e));
|
|
}
|
|
|
|
/**
|
|
* Retrieve the bill landed cost amount.
|
|
* @param {IBillDTO} billDTO
|
|
* @returns {number}
|
|
*/
|
|
private getBillLandedCostAmount(tenantId: number, billDTO: IBillDTO): number {
|
|
const costEntries = billDTO.entries.filter((entry) => entry.landedCost);
|
|
|
|
return this.getBillEntriesTotal(tenantId, costEntries);
|
|
}
|
|
|
|
/**
|
|
* Converts create bill DTO to model.
|
|
* @param {number} tenantId
|
|
* @param {IBillDTO} billDTO
|
|
* @param {IBill} oldBill
|
|
* @returns {IBill}
|
|
*/
|
|
private async billDTOToModel(
|
|
tenantId: number,
|
|
billDTO: IBillDTO,
|
|
vendor: IVendor,
|
|
authorizedUser: ISystemUser,
|
|
oldBill?: IBill
|
|
) {
|
|
const { ItemEntry } = this.tenancy.models(tenantId);
|
|
|
|
const amount = sumBy(billDTO.entries, (e) => ItemEntry.calcAmount(e));
|
|
|
|
// Retrieve the landed cost amount from landed cost entries.
|
|
const landedCostAmount = this.getBillLandedCostAmount(tenantId, billDTO);
|
|
|
|
// Bill number from DTO or from auto-increment.
|
|
const billNumber = billDTO.billNumber || oldBill?.billNumber;
|
|
|
|
const initialEntries = billDTO.entries.map((entry) => ({
|
|
reference_type: 'Bill',
|
|
...omit(entry, ['amount']),
|
|
}));
|
|
const entries = await composeAsync(
|
|
// Sets the default cost account to the bill entries.
|
|
this.setBillEntriesDefaultAccounts(tenantId)
|
|
)(initialEntries);
|
|
|
|
const initialDTO = {
|
|
...formatDateFields(omit(billDTO, ['open', 'entries']), [
|
|
'billDate',
|
|
'dueDate',
|
|
]),
|
|
amount,
|
|
landedCostAmount,
|
|
currencyCode: vendor.currencyCode,
|
|
exchangeRate: billDTO.exchangeRate || 1,
|
|
billNumber,
|
|
entries,
|
|
// Avoid rewrite the open date in edit mode when already opened.
|
|
...(billDTO.open &&
|
|
!oldBill?.openedAt && {
|
|
openedAt: moment().toMySqlDateTime(),
|
|
}),
|
|
userId: authorizedUser.id,
|
|
};
|
|
return R.compose(
|
|
this.branchDTOTransform.transformDTO(tenantId),
|
|
this.warehouseDTOTransform.transformDTO(tenantId)
|
|
)(initialDTO);
|
|
}
|
|
|
|
/**
|
|
* Creates a new bill and stored it to the storage.
|
|
* ----
|
|
* Precedures.
|
|
* ----
|
|
* - Insert bill transactions to the storage.
|
|
* - Insert bill entries to the storage.
|
|
* - Increment the given vendor id.
|
|
* - Record bill journal transactions on the given accounts.
|
|
* - Record bill items inventory transactions.
|
|
* ----
|
|
* @param {number} tenantId - The given tenant id.
|
|
* @param {IBillDTO} billDTO -
|
|
* @return {Promise<IBill>}
|
|
*/
|
|
public async createBill(
|
|
tenantId: number,
|
|
billDTO: IBillDTO,
|
|
authorizedUser: ISystemUser
|
|
): Promise<IBill> {
|
|
const { Bill, Contact } = this.tenancy.models(tenantId);
|
|
|
|
// Retrieves the given bill vendor or throw not found error.
|
|
const vendor = await Contact.query()
|
|
.modify('vendor')
|
|
.findById(billDTO.vendorId)
|
|
.throwIfNotFound();
|
|
|
|
// Validate the bill number uniqiness on the storage.
|
|
await this.validateBillNumberExists(tenantId, billDTO.billNumber);
|
|
|
|
// Validate items IDs existance.
|
|
await this.itemsEntriesService.validateItemsIdsExistance(
|
|
tenantId,
|
|
billDTO.entries
|
|
);
|
|
// Validate non-purchasable items.
|
|
await this.itemsEntriesService.validateNonPurchasableEntriesItems(
|
|
tenantId,
|
|
billDTO.entries
|
|
);
|
|
// Validates the cost entries should be with inventory items.
|
|
await this.validateCostEntriesShouldBeInventoryItems(
|
|
tenantId,
|
|
billDTO.entries
|
|
);
|
|
// Transform the bill DTO to model object.
|
|
const billObj = await this.billDTOToModel(
|
|
tenantId,
|
|
billDTO,
|
|
vendor,
|
|
authorizedUser
|
|
);
|
|
// Write new bill transaction with associated transactions under UOW env.
|
|
return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
|
|
// Triggers `onBillCreating` event.
|
|
await this.eventPublisher.emitAsync(events.bill.onCreating, {
|
|
trx,
|
|
billDTO,
|
|
tenantId,
|
|
} as IBillCreatingPayload);
|
|
|
|
// Inserts the bill graph object to the storage.
|
|
const bill = await Bill.query(trx).upsertGraph(billObj);
|
|
|
|
// Triggers `onBillCreated` event.
|
|
await this.eventPublisher.emitAsync(events.bill.onCreated, {
|
|
tenantId,
|
|
bill,
|
|
billId: bill.id,
|
|
trx,
|
|
} as IBillCreatedPayload);
|
|
|
|
return bill;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Edits details of the given bill id with associated entries.
|
|
*
|
|
* Precedures:
|
|
* -------
|
|
* - Update the bill transaction on the storage.
|
|
* - Update the bill entries on the storage and insert the not have id and delete
|
|
* once that not presented.
|
|
* - Increment the diff amount on the given vendor id.
|
|
* - Re-write the inventory transactions.
|
|
* - Re-write the bill journal transactions.
|
|
* ------
|
|
* @param {number} tenantId - The given tenant id.
|
|
* @param {Integer} billId - The given bill id.
|
|
* @param {IBillEditDTO} billDTO - The given new bill details.
|
|
* @return {Promise<IBill>}
|
|
*/
|
|
public async editBill(
|
|
tenantId: number,
|
|
billId: number,
|
|
billDTO: IBillEditDTO,
|
|
authorizedUser: ISystemUser
|
|
): Promise<IBill> {
|
|
const { Bill, Contact } = this.tenancy.models(tenantId);
|
|
|
|
const oldBill = await this.getBillOrThrowError(tenantId, billId);
|
|
|
|
// Retrieve vendor details or throw not found service error.
|
|
const vendor = await Contact.query()
|
|
.findById(billDTO.vendorId)
|
|
.modify('vendor')
|
|
.throwIfNotFound();
|
|
|
|
// Validate bill number uniqiness on the storage.
|
|
if (billDTO.billNumber) {
|
|
await this.validateBillNumberExists(tenantId, billDTO.billNumber, billId);
|
|
}
|
|
// Validate the entries ids existance.
|
|
await this.itemsEntriesService.validateEntriesIdsExistance(
|
|
tenantId,
|
|
billId,
|
|
'Bill',
|
|
billDTO.entries
|
|
);
|
|
// Validate the items ids existance on the storage.
|
|
await this.itemsEntriesService.validateItemsIdsExistance(
|
|
tenantId,
|
|
billDTO.entries
|
|
);
|
|
// Accept the purchasable items only.
|
|
await this.itemsEntriesService.validateNonPurchasableEntriesItems(
|
|
tenantId,
|
|
billDTO.entries
|
|
);
|
|
// Transforms the bill DTO to model object.
|
|
const billObj = await this.billDTOToModel(
|
|
tenantId,
|
|
billDTO,
|
|
vendor,
|
|
authorizedUser,
|
|
oldBill
|
|
);
|
|
// Validate landed cost entries that have allocated cost could not be deleted.
|
|
await this.entriesService.validateLandedCostEntriesNotDeleted(
|
|
oldBill.entries,
|
|
billObj.entries
|
|
);
|
|
// Validate new landed cost entries should be bigger than new entries.
|
|
await this.entriesService.validateLocatedCostEntriesSmallerThanNewEntries(
|
|
oldBill.entries,
|
|
billObj.entries
|
|
);
|
|
// Edits bill transactions and associated transactions under UOW envirement.
|
|
return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
|
|
// Triggers `onBillEditing` event.
|
|
await this.eventPublisher.emitAsync(events.bill.onEditing, {
|
|
trx,
|
|
tenantId,
|
|
oldBill,
|
|
billDTO,
|
|
} as IBillEditingPayload);
|
|
|
|
// Update the bill transaction.
|
|
const bill = await Bill.query(trx).upsertGraph({
|
|
id: billId,
|
|
...billObj,
|
|
});
|
|
// Triggers event `onBillEdited`.
|
|
await this.eventPublisher.emitAsync(events.bill.onEdited, {
|
|
tenantId,
|
|
billId,
|
|
oldBill,
|
|
bill,
|
|
trx,
|
|
} as IBillEditedPayload);
|
|
|
|
return bill;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Deletes the bill with associated entries.
|
|
* @param {Integer} billId
|
|
* @return {void}
|
|
*/
|
|
public async deleteBill(tenantId: number, billId: number) {
|
|
const { ItemEntry, Bill } = this.tenancy.models(tenantId);
|
|
|
|
// Retrieve the given bill or throw not found error.
|
|
const oldBill = await this.getBillOrThrowError(tenantId, billId);
|
|
|
|
// Validate the givne bill has no associated landed cost transactions.
|
|
await this.validateBillHasNoLandedCost(tenantId, billId);
|
|
|
|
// Validate the purchase bill has no assocaited payments transactions.
|
|
await this.validateBillHasNoEntries(tenantId, billId);
|
|
|
|
// Validate the given bill has no associated reconciled with vendor credits.
|
|
await this.validateBillHasNoAppliedToCredit(tenantId, billId);
|
|
|
|
// Deletes bill transaction with associated transactions under
|
|
// unit-of-work envirement.
|
|
return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
|
|
// Triggers `onBillDeleting` event.
|
|
await this.eventPublisher.emitAsync(events.bill.onDeleting, {
|
|
trx,
|
|
tenantId,
|
|
oldBill,
|
|
} as IBillEventDeletingPayload);
|
|
|
|
// Delete all associated bill entries.
|
|
await ItemEntry.query(trx)
|
|
.where('reference_type', 'Bill')
|
|
.where('reference_id', billId)
|
|
.delete();
|
|
|
|
// Delete the bill transaction.
|
|
await Bill.query(trx).findById(billId).delete();
|
|
|
|
// Triggers `onBillDeleted` event.
|
|
await this.eventPublisher.emitAsync(events.bill.onDeleted, {
|
|
tenantId,
|
|
billId,
|
|
oldBill,
|
|
trx,
|
|
} as IBIllEventDeletedPayload);
|
|
});
|
|
}
|
|
|
|
validateBillHasNoAppliedToCredit = async (
|
|
tenantId: number,
|
|
billId: number
|
|
) => {
|
|
const { VendorCreditAppliedBill } = this.tenancy.models(tenantId);
|
|
|
|
const appliedTransactions = await VendorCreditAppliedBill.query().where(
|
|
'billId',
|
|
billId
|
|
);
|
|
if (appliedTransactions.length > 0) {
|
|
throw new ServiceError(ERRORS.BILL_HAS_APPLIED_TO_VENDOR_CREDIT);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Parses bills list filter DTO.
|
|
* @param filterDTO -
|
|
*/
|
|
private parseListFilterDTO(filterDTO) {
|
|
return R.compose(this.dynamicListService.parseStringifiedFilter)(filterDTO);
|
|
}
|
|
|
|
/**
|
|
* Retrieve bills data table list.
|
|
* @param {number} tenantId -
|
|
* @param {IBillsFilter} billsFilter -
|
|
*/
|
|
public async getBills(
|
|
tenantId: number,
|
|
filterDTO: IBillsFilter
|
|
): Promise<{
|
|
bills: IBill;
|
|
pagination: IPaginationMeta;
|
|
filterMeta: IFilterMeta;
|
|
}> {
|
|
const { Bill } = this.tenancy.models(tenantId);
|
|
|
|
// Parses bills list filter DTO.
|
|
const filter = this.parseListFilterDTO(filterDTO);
|
|
|
|
// Dynamic list service.
|
|
const dynamicFilter = await this.dynamicListService.dynamicList(
|
|
tenantId,
|
|
Bill,
|
|
filter
|
|
);
|
|
const { results, pagination } = await Bill.query()
|
|
.onBuild((builder) => {
|
|
builder.withGraphFetched('vendor');
|
|
dynamicFilter.buildQuery()(builder);
|
|
})
|
|
.pagination(filter.page - 1, filter.pageSize);
|
|
|
|
// Tranform the bills to POJO.
|
|
const bills = await this.transformer.transform(
|
|
tenantId,
|
|
results,
|
|
new PurchaseInvoiceTransformer()
|
|
);
|
|
return {
|
|
bills,
|
|
pagination,
|
|
filterMeta: dynamicFilter.getResponseMeta(),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Retrieve all due bills or for specific given vendor id.
|
|
* @param {number} tenantId -
|
|
* @param {number} vendorId -
|
|
*/
|
|
public async getDueBills(
|
|
tenantId: number,
|
|
vendorId?: number
|
|
): Promise<IBill[]> {
|
|
const { Bill } = this.tenancy.models(tenantId);
|
|
|
|
const dueBills = await Bill.query().onBuild((query) => {
|
|
query.orderBy('bill_date', 'DESC');
|
|
query.modify('dueBills');
|
|
|
|
if (vendorId) {
|
|
query.where('vendor_id', vendorId);
|
|
}
|
|
});
|
|
return dueBills;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the given bill details with associated items entries.
|
|
* @param {Integer} billId - Specific bill.
|
|
* @returns {Promise<IBill>}
|
|
*/
|
|
public async getBill(tenantId: number, billId: number): Promise<IBill> {
|
|
const { Bill } = this.tenancy.models(tenantId);
|
|
|
|
const bill = await Bill.query()
|
|
.findById(billId)
|
|
.withGraphFetched('vendor')
|
|
.withGraphFetched('entries.item')
|
|
.withGraphFetched('branch');
|
|
|
|
if (!bill) {
|
|
throw new ServiceError(ERRORS.BILL_NOT_FOUND);
|
|
}
|
|
return this.transformer.transform(
|
|
tenantId,
|
|
bill,
|
|
new PurchaseInvoiceTransformer()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Mark the bill as open.
|
|
* @param {number} tenantId
|
|
* @param {number} billId
|
|
*/
|
|
public async openBill(tenantId: number, billId: number): Promise<void> {
|
|
const { Bill } = this.tenancy.models(tenantId);
|
|
|
|
// Retrieve the given bill or throw not found error.
|
|
const oldBill = await this.getBillOrThrowError(tenantId, billId);
|
|
|
|
if (oldBill.isOpen) {
|
|
throw new ServiceError(ERRORS.BILL_ALREADY_OPEN);
|
|
}
|
|
//
|
|
return this.uow.withTransaction(tenantId, async (trx) => {
|
|
// Record the bill opened at on the storage.
|
|
await Bill.query(trx).findById(billId).patch({
|
|
openedAt: moment().toMySqlDateTime(),
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Records the inventory transactions from the given bill input.
|
|
* @param {Bill} bill - Bill model object.
|
|
* @param {number} billId - Bill id.
|
|
* @return {Promise<void>}
|
|
*/
|
|
public async recordInventoryTransactions(
|
|
tenantId: number,
|
|
billId: number,
|
|
override?: boolean,
|
|
trx?: Knex.Transaction
|
|
): Promise<void> {
|
|
const { Bill } = this.tenancy.models(tenantId);
|
|
|
|
// Retireve bill with assocaited entries and allocated cost entries.
|
|
const bill = await Bill.query(trx)
|
|
.findById(billId)
|
|
.withGraphFetched('entries.allocatedCostEntries');
|
|
|
|
// Loads the inventory items entries of the given sale invoice.
|
|
const inventoryEntries =
|
|
await this.itemsEntriesService.filterInventoryEntries(
|
|
tenantId,
|
|
bill.entries
|
|
);
|
|
const transaction = {
|
|
transactionId: bill.id,
|
|
transactionType: 'Bill',
|
|
exchangeRate: bill.exchangeRate,
|
|
|
|
date: bill.billDate,
|
|
direction: 'IN',
|
|
entries: inventoryEntries,
|
|
createdAt: bill.createdAt,
|
|
|
|
warehouseId: bill.warehouseId,
|
|
};
|
|
await this.inventoryService.recordInventoryTransactionsFromItemsEntries(
|
|
tenantId,
|
|
transaction,
|
|
override,
|
|
trx
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Reverts the inventory transactions of the given bill id.
|
|
* @param {number} tenantId - Tenant id.
|
|
* @param {number} billId - Bill id.
|
|
* @return {Promise<void>}
|
|
*/
|
|
public async revertInventoryTransactions(
|
|
tenantId: number,
|
|
billId: number,
|
|
trx?: Knex.Transaction
|
|
) {
|
|
// Deletes the inventory transactions by the given reference id and type.
|
|
await this.inventoryService.deleteInventoryTransactions(
|
|
tenantId,
|
|
billId,
|
|
'Bill',
|
|
trx
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Validate the given vendor has no associated bills transactions.
|
|
* @param {number} tenantId
|
|
* @param {number} vendorId - Vendor id.
|
|
*/
|
|
public async validateVendorHasNoBills(tenantId: number, vendorId: number) {
|
|
const { Bill } = this.tenancy.models(tenantId);
|
|
|
|
const bills = await Bill.query().where('vendor_id', vendorId);
|
|
|
|
if (bills.length > 0) {
|
|
throw new ServiceError(ERRORS.VENDOR_HAS_BILLS);
|
|
}
|
|
}
|
|
}
|