mirror of
https://github.com/bigcapitalhq/bigcapital.git
synced 2026-02-16 04:40:32 +00:00
432 lines
13 KiB
TypeScript
432 lines
13 KiB
TypeScript
import { Inject, Service } from 'typedi';
|
|
import { Router, Request, Response } from 'express';
|
|
import { check, param, query, ValidationChain, matchedData } from 'express-validator';
|
|
import asyncMiddleware from '@/http/middleware/asyncMiddleware';
|
|
import validateMiddleware from '@/http/middleware/validateMiddleware';
|
|
import ItemsService from '@/services/Items/ItemsService';
|
|
import DynamicListing from '@/services/DynamicListing/DynamicListing';
|
|
import DynamicListingBuilder from '@/services/DynamicListing/DynamicListingBuilder';
|
|
import { dynamicListingErrorsToResponse } from '@/services/DynamicListing/hasDynamicListing';
|
|
|
|
@Service()
|
|
export default class ItemsController {
|
|
@Inject()
|
|
itemsService: ItemsService;
|
|
|
|
/**
|
|
* Router constructor.
|
|
*/
|
|
router() {
|
|
const router = Router();
|
|
|
|
router.post(
|
|
'/',
|
|
this.validateItemSchema,
|
|
validateMiddleware,
|
|
asyncMiddleware(this.validateCategoryExistance.bind(this)),
|
|
asyncMiddleware(this.validateCostAccountExistance.bind(this)),
|
|
asyncMiddleware(this.validateSellAccountExistance.bind(this)),
|
|
asyncMiddleware(this.validateInventoryAccountExistance.bind(this)),
|
|
asyncMiddleware(this.validateItemNameExistance.bind(this)),
|
|
asyncMiddleware(this.newItem.bind(this)),
|
|
);
|
|
router.post(
|
|
'/:id', [
|
|
...this.validateItemSchema,
|
|
...this.validateSpecificItemSchema,
|
|
],
|
|
validateMiddleware,
|
|
asyncMiddleware(this.validateItemExistance.bind(this)),
|
|
asyncMiddleware(this.validateCategoryExistance.bind(this)),
|
|
asyncMiddleware(this.validateCostAccountExistance.bind(this)),
|
|
asyncMiddleware(this.validateSellAccountExistance.bind(this)),
|
|
asyncMiddleware(this.validateInventoryAccountExistance.bind(this)),
|
|
asyncMiddleware(this.validateItemNameExistance.bind(this)),
|
|
asyncMiddleware(this.editItem.bind(this)),
|
|
);
|
|
router.delete(
|
|
'/:id',
|
|
this.validateSpecificItemSchema,
|
|
validateMiddleware,
|
|
asyncMiddleware(this.validateItemExistance.bind(this)),
|
|
asyncMiddleware(this.deleteItem.bind(this)),
|
|
);
|
|
router.get(
|
|
'/:id',
|
|
this.validateSpecificItemSchema,
|
|
validateMiddleware,
|
|
asyncMiddleware(this.validateItemExistance.bind(this)),
|
|
asyncMiddleware(this.getItem.bind(this)),
|
|
);
|
|
router.get(
|
|
'/',
|
|
this.validateListQuerySchema,
|
|
validateMiddleware,
|
|
asyncMiddleware(this.listItems.bind(this)),
|
|
);
|
|
return router;
|
|
}
|
|
|
|
/**
|
|
* Validate item schema.
|
|
*/
|
|
get validateItemSchema(): ValidationChain[] {
|
|
return [
|
|
check('name').exists(),
|
|
check('type').exists().trim().escape()
|
|
.isIn(['service', 'non-inventory', 'inventory']),
|
|
check('sku').optional({ nullable: true }).trim().escape(),
|
|
// Purchase attributes.
|
|
check('purchasable').optional().isBoolean().toBoolean(),
|
|
check('cost_price')
|
|
.if(check('purchasable').equals('true'))
|
|
.exists()
|
|
.isNumeric()
|
|
.toFloat(),
|
|
check('cost_account_id')
|
|
.if(check('purchasable').equals('true'))
|
|
.exists()
|
|
.isInt()
|
|
.toInt(),
|
|
// Sell attributes.
|
|
check('sellable').optional().isBoolean().toBoolean(),
|
|
check('sell_price')
|
|
.if(check('sellable').equals('true'))
|
|
.exists()
|
|
.isNumeric()
|
|
.toFloat(),
|
|
check('sell_account_id')
|
|
.if(check('sellable').equals('true'))
|
|
.exists()
|
|
.isInt()
|
|
.toInt(),
|
|
check('inventory_account_id')
|
|
.if(check('type').equals('inventory'))
|
|
.exists()
|
|
.isInt()
|
|
.toInt(),
|
|
check('sell_description').optional({ nullable: true }).trim().escape(),
|
|
check('cost_description').optional({ nullable: true }).trim().escape(),
|
|
|
|
check('category_id').optional({ nullable: true }).isInt().toInt(),
|
|
check('note').optional(),
|
|
|
|
check('media_ids').optional().isArray(),
|
|
check('media_ids.*').exists().isNumeric().toInt(),
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Validate specific item params schema.
|
|
*/
|
|
get validateSpecificItemSchema(): ValidationChain[] {
|
|
return [
|
|
param('id').exists().isNumeric().toInt(),
|
|
];
|
|
}
|
|
|
|
|
|
/**
|
|
* Validate list query schema
|
|
*/
|
|
get validateListQuerySchema() {
|
|
return [
|
|
query('column_sort_order').optional().isIn(['created_at', 'name', 'amount', 'sku']),
|
|
query('sort_order').optional().isIn(['desc', 'asc']),
|
|
query('page').optional().isNumeric().toInt(),
|
|
query('page_size').optional().isNumeric().toInt(),
|
|
query('custom_view_id').optional().isNumeric().toInt(),
|
|
query('stringified_filter_roles').optional().isJSON(),
|
|
]
|
|
}
|
|
|
|
/**
|
|
* Validates the given item existance on the storage.
|
|
* @param {Request} req -
|
|
* @param {Response} res -
|
|
* @param {NextFunction} next -
|
|
*/
|
|
async validateItemExistance(req: Request, res: Response, next: Function) {
|
|
const { Item } = req.models;
|
|
const itemId: number = req.params.id;
|
|
|
|
const foundItem = await Item.query().findById(itemId);
|
|
|
|
if (!foundItem) {
|
|
return res.status(400).send({
|
|
errors: [{ type: 'ITEM.NOT.FOUND', code: 100 }],
|
|
});
|
|
}
|
|
next();
|
|
}
|
|
|
|
/**
|
|
* Validate wether the given item name already exists on the storage.
|
|
* @param {Request} req
|
|
* @param {Response} res
|
|
* @param {NextFunction} next
|
|
*/
|
|
async validateItemNameExistance(req: Request, res: Response, next: Function) {
|
|
const { Item } = req.models;
|
|
const item = req.body;
|
|
const itemId: number = req.params.id;
|
|
|
|
const foundItems: [] = await Item.query().onBuild((builder: any) => {
|
|
builder.where('name', item.name);
|
|
|
|
if (itemId) {
|
|
builder.whereNot('id', itemId);
|
|
}
|
|
});
|
|
if (foundItems.length > 0) {
|
|
return res.status(400).send({
|
|
errors: [{ type: 'ITEM.NAME.ALREADY.EXISTS', code: 210 }],
|
|
});
|
|
}
|
|
next();
|
|
}
|
|
|
|
/**
|
|
* Validate wether the given category existance on the storage.
|
|
* @param {Request} req
|
|
* @param {Response} res
|
|
* @param {Function} next
|
|
*/
|
|
async validateCategoryExistance(req: Request, res: Response, next: Function) {
|
|
const { ItemCategory } = req.models;
|
|
const item = req.body;
|
|
|
|
if (item.category_id) {
|
|
const foundCategory = await ItemCategory.query().findById(item.category_id);
|
|
|
|
if (!foundCategory) {
|
|
return res.status(400).send({
|
|
errors: [{ type: 'ITEM_CATEGORY.NOT.FOUND', code: 140 }],
|
|
});
|
|
}
|
|
}
|
|
next();
|
|
}
|
|
|
|
/**
|
|
* Validate wether the given cost account exists on the storage.
|
|
* @param {Request} req
|
|
* @param {Response} res
|
|
* @param {Function} next
|
|
*/
|
|
async validateCostAccountExistance(req: Request, res: Response, next: Function) {
|
|
const { Account, AccountType } = req.models;
|
|
const item = req.body;
|
|
|
|
if (item.cost_account_id) {
|
|
const COGSType = await AccountType.query().findOne('key', 'cost_of_goods_sold');
|
|
const foundAccount = await Account.query().findById(item.cost_account_id)
|
|
|
|
if (!foundAccount) {
|
|
return res.status(400).send({
|
|
errors: [{ type: 'COST.ACCOUNT.NOT.FOUND', code: 120 }],
|
|
});
|
|
} else if (foundAccount.accountTypeId !== COGSType.id) {
|
|
return res.status(400).send({
|
|
errors: [{ type: 'COST.ACCOUNT.NOT.COGS.TYPE', code: 220 }],
|
|
});
|
|
}
|
|
}
|
|
next();
|
|
}
|
|
|
|
/**
|
|
* Validate wether the given sell account exists on the storage.
|
|
* @param {Request} req
|
|
* @param {Response} res
|
|
* @param {NextFunction} next
|
|
*/
|
|
async validateSellAccountExistance(req: Request, res: Response, next: Function) {
|
|
const { Account, AccountType } = req.models;
|
|
const item = req.body;
|
|
|
|
if (item.sell_account_id) {
|
|
const incomeType = await AccountType.query().findOne('key', 'income');
|
|
const foundAccount = await Account.query().findById(item.sell_account_id);
|
|
|
|
if (!foundAccount) {
|
|
return res.status(400).send({
|
|
errors: [{ type: 'SELL.ACCOUNT.NOT.FOUND', code: 130 }],
|
|
});
|
|
} else if (foundAccount.accountTypeId !== incomeType.id) {
|
|
return res.status(400).send({
|
|
errors: [{ type: 'SELL.ACCOUNT.NOT.INCOME.TYPE', code: 230 }],
|
|
})
|
|
}
|
|
}
|
|
next();
|
|
}
|
|
|
|
/**
|
|
* Validates wether the given inventory account exists on the storage.
|
|
* @param {Request} req
|
|
* @param {Response} res
|
|
* @param {NextFunction} next
|
|
*/
|
|
async validateInventoryAccountExistance(req: Request, res: Response, next: Function) {
|
|
const { Account, AccountType } = req.models;
|
|
const item = req.body;
|
|
|
|
if (item.inventory_account_id) {
|
|
const otherAsset = await AccountType.query().findOne('key', 'other_asset');
|
|
const foundAccount = await Account.query().findById(item.inventory_account_id);
|
|
|
|
if (!foundAccount) {
|
|
return res.status(400).send({
|
|
errors: [{ type: 'INVENTORY.ACCOUNT.NOT.FOUND', code: 200}],
|
|
});
|
|
} else if (otherAsset.id !== foundAccount.accountTypeId) {
|
|
return res.status(400).send({
|
|
errors: [{ type: 'INVENTORY.ACCOUNT.NOT.CURRENT.ASSET', code: 300 }],
|
|
});
|
|
}
|
|
}
|
|
next();
|
|
}
|
|
|
|
/**
|
|
* Stores the given item details to the storage.
|
|
* @param {Request} req
|
|
* @param {Response} res
|
|
*/
|
|
async newItem(req: Request, res: Response,) {
|
|
const { tenantId } = req;
|
|
|
|
const item = matchedData(req, {
|
|
locations: ['body'],
|
|
includeOptionals: true
|
|
});
|
|
const storedItem = await this.itemsService.newItem(tenantId, item);
|
|
|
|
return res.status(200).send({ id: storedItem.id });
|
|
}
|
|
|
|
/**
|
|
* Updates the given item details on the storage.
|
|
* @param {Request} req
|
|
* @param {Response} res
|
|
*/
|
|
async editItem(req: Request, res: Response) {
|
|
const { tenantId } = req;
|
|
|
|
const itemId: number = req.params.id;
|
|
const item = matchedData(req, {
|
|
locations: ['body'],
|
|
includeOptionals: true
|
|
});
|
|
const updatedItem = await this.itemsService.editItem(tenantId, item, itemId);
|
|
|
|
return res.status(200).send({ id: itemId });
|
|
}
|
|
|
|
/**
|
|
* Deletes the given item from the storage.
|
|
* @param {Request} req
|
|
* @param {Response} res
|
|
*/
|
|
async deleteItem(req: Request, res: Response) {
|
|
const itemId: number = req.params.id;
|
|
const { tenantId } = req;
|
|
|
|
await this.itemsService.deleteItem(tenantId, itemId);
|
|
|
|
return res.status(200).send({ id: itemId });
|
|
}
|
|
|
|
/**
|
|
* Retrieve details the given item id.
|
|
* @param {Request} req
|
|
* @param {Response} res
|
|
* @return {Response}
|
|
*/
|
|
async getItem(req: Request, res: Response) {
|
|
const itemId: number = req.params.id;
|
|
const { tenantId } = req;
|
|
|
|
const storedItem = await this.itemsService.getItemWithMetadata(tenantId, itemId);
|
|
|
|
return res.status(200).send({ item: storedItem });
|
|
}
|
|
|
|
/**
|
|
* Listing items with pagination metadata.
|
|
* @param {Request} req
|
|
* @param {Response} res
|
|
*/
|
|
async listItems(req: Request, res: Response) {
|
|
const filter = {
|
|
filter_roles: [],
|
|
sort_order: 'asc',
|
|
page: 1,
|
|
page_size: 10,
|
|
...req.query,
|
|
};
|
|
if (filter.stringified_filter_roles) {
|
|
filter.filter_roles = JSON.parse(filter.stringified_filter_roles);
|
|
}
|
|
const { Resource, Item, View } = req.models;
|
|
const resource = await Resource.query()
|
|
.remember()
|
|
.where('name', 'items')
|
|
.withGraphFetched('fields')
|
|
.first();
|
|
|
|
if (!resource) {
|
|
return res.status(400).send({
|
|
errors: [{ type: 'ITEMS.RESOURCE.NOT_FOUND', code: 200 }],
|
|
});
|
|
}
|
|
const viewMeta = await View.query()
|
|
.modify('allMetadata')
|
|
.modify('specificOrFavourite', filter.custom_view_id)
|
|
.where('resource_id', resource.id)
|
|
.first();
|
|
|
|
const listingBuilder = new DynamicListingBuilder();
|
|
const errorReasons = [];
|
|
|
|
listingBuilder.addModelClass(Item);
|
|
listingBuilder.addCustomViewId(filter.custom_view_id);
|
|
listingBuilder.addFilterRoles(filter.filter_roles);
|
|
listingBuilder.addSortBy(filter.sort_by, filter.sort_order);
|
|
listingBuilder.addView(viewMeta);
|
|
|
|
const dynamicListing = new DynamicListing(listingBuilder);
|
|
|
|
if (dynamicListing instanceof Error) {
|
|
const errors = dynamicListingErrorsToResponse(dynamicListing);
|
|
errorReasons.push(...errors);
|
|
}
|
|
if (errorReasons.length > 0) {
|
|
return res.status(400).send({ errors: errorReasons });
|
|
}
|
|
const items = await Item.query().onBuild((builder: any) => {
|
|
builder.withGraphFetched('costAccount');
|
|
builder.withGraphFetched('sellAccount');
|
|
builder.withGraphFetched('inventoryAccount');
|
|
builder.withGraphFetched('category');
|
|
|
|
dynamicListing.buildQuery()(builder);
|
|
return builder;
|
|
}).pagination(filter.page - 1, filter.page_size);
|
|
|
|
return res.status(200).send({
|
|
items: {
|
|
...items,
|
|
...(viewMeta
|
|
? {
|
|
viewMeta: {
|
|
custom_view_id: viewMeta.id,
|
|
view_columns: viewMeta.columns,
|
|
}
|
|
}
|
|
: {}),
|
|
},
|
|
});
|
|
}
|
|
} |