feat: remove path alias.

feat: remove Webpack and depend on nodemon.
feat: refactoring expenses.
feat: optimize system users with caching.
feat: architecture tenant optimize.
This commit is contained in:
Ahmed Bouhuolia
2020-09-15 00:51:39 +02:00
parent ad00f140d1
commit a22c8395f3
293 changed files with 3391 additions and 1637 deletions

View File

@@ -0,0 +1,431 @@
import { Inject, Service } from 'typedi';
import { Router, Request, Response } from 'express';
import { check, param, query, ValidationChain, matchedData } from 'express-validator';
import asyncMiddleware from 'api/middleware/asyncMiddleware';
import validateMiddleware from 'api/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,
}
}
: {}),
},
});
}
}