bmd-extension 1.6.3

package/src/assets/init/src/entity-request/CustomerInsert.ts.txt

@@ -0,0 +1,42 @@
+import { Property } from "@tsed/common";
+
+import { Customer } from '../entity/Customer';
+import { Password } from "../util/password";
+
+export class CustomerInsert {
+    async toCustomer(): Promise<Customer> {
+        const customer = new Customer()
+        customer.phone = this.phone
+        customer.name = this.name
+        customer.email = this.email
+        customer.address = this.address
+        customer.gender = this.gender
+        customer.password = await Password.hash(this.password)
+
+        return customer
+    }
+    
+    // PROPERTIES
+
+    @Property()
+    phone: string
+
+    @Property()
+    name: string;
+
+    @Property()
+    phoneRelative: string
+
+    @Property()
+    address: string
+
+    @Property()
+    password: string
+
+    @Property()
+    email: string
+
+    @Property()
+    gender: string
+
+} // END FILE

package/src/assets/init/src/entity-request/CustomerUpdate.ts.txt

@@ -0,0 +1,40 @@
+// IMPORT LIBRARY
+import { Property } from "@tsed/common";
+
+// IMPORT CUSTOM
+import { Customer } from "../entity/Customer";
+
+export class CustomerUpdate {
+    // Transform to draw entity
+    toCustomer(): Customer {
+        const customer = new Customer()
+        customer.name = this.name
+        customer.email = this.email
+        customer.address = this.address
+        customer.password = this.password
+        customer.avatar = this.avatar
+
+        return customer
+    }
+
+    // PROPERTIES
+
+    @Property()
+    name: string;
+
+    @Property()
+    avatar: string;
+
+    @Property()
+    phoneRelative: string
+
+    @Property()
+    address: string
+
+    @Property()
+    password: string
+
+    @Property()
+    email: string
+
+} // END FILE

package/src/assets/init/src/entity-request/PermissionImport.ts.txt

@@ -0,0 +1,12 @@
+import { Property } from "@tsed/common";
+
+export class PermissionImport {
+    // PROPERTIES
+
+    @Property()
+    path: string;
+
+    @Property()
+    children: PermissionImport[];
+
+}

package/src/assets/init/src/entity-request/StaffUpdate.ts.txt

@@ -0,0 +1,33 @@
+import { Property } from "@tsed/common";
+
+import { Staff } from '../entity/Staff';
+
+export class StaffUpdate {
+    toStaff(): Staff {
+        const staff = new Staff()
+        staff.name = this.name
+        staff.avatar = this.avatar
+        staff.phone = this.phone
+        staff.email = this.email
+        staff.isBlock = this.isBlock
+        return staff
+    }
+
+    // PROPERTIES
+
+    @Property()
+    name: string;
+
+    @Property()
+    avatar: string;
+
+    @Property()
+    phone: string;
+
+    @Property()
+    email: string;
+
+    @Property()
+    isBlock: boolean;
+
+} // END FILE

package/src/assets/init/src/index.ts.txt

@@ -0,0 +1,13 @@
+//============= HANDLE PROCESS ENVIRONMENT VARIABLE =============
+import dotenv from 'dotenv'
+dotenv.config()
+
+//============= START SERVER =============
+import { Server } from "./Server"
+
+new Server().start()
+    .then(() => {
+    })
+    .catch((err) => {
+        console.error(err);
+    })

package/src/assets/init/src/middleware/auth/Verification.ts.txt

@@ -0,0 +1,16 @@
+import AuthStrategy from './strategy/AuthStrategy';
+import { Request } from 'express';
+
+class Verification {
+    private authStrategy: AuthStrategy
+
+    constructor(authStrategy: AuthStrategy) {
+        this.authStrategy = authStrategy
+    }
+
+    auth = async (req: Request): Promise<any> => {
+        await this.authStrategy.auth(req)
+    }
+}
+
+export default Verification

package/src/assets/init/src/middleware/auth/VerificationJWT.ts.txt

@@ -0,0 +1,16 @@
+import { EndpointInfo, IMiddleware, Middleware, Req } from "@tsed/common";
+import { Request } from 'express';
+
+import Verification from "./Verification";
+import JWT from "./strategy/JWT";
+
+@Middleware()
+export class VerificationJWT implements IMiddleware {
+    public async use(
+        @Req() request: Request,
+        @EndpointInfo() endpoint: EndpointInfo
+    ) {
+        const verification = new Verification(new JWT())
+        await verification.auth(request)
+    }
+}

package/src/assets/init/src/middleware/auth/strategy/AuthStrategy.ts.txt

@@ -0,0 +1,5 @@
+import { Request, Response, NextFunction } from "express";
+
+export default interface AuthStrategy {
+    auth(req: Request): Promise<any>;
+}

package/src/assets/init/src/middleware/auth/strategy/JWT.ts.txt

@@ -0,0 +1,147 @@
+import { InternalServerError } from 'ts-httpexceptions';
+import { Request } from 'express';
+import jwt from 'jsonwebtoken';
+import { Unauthorized } from 'ts-httpexceptions';
+
+import AuthStrategy from './AuthStrategy';
+import { Staff } from '../../../entity/Staff';
+import { Customer } from '../../../entity/Customer';
+import logger from '../../../util/logger';
+import CONFIG from '../../../../config';
+// import { Driver } from '../../../entity/Driver';
+import { getCurrentTimeInt } from '../../../util/helper';
+
+export enum AuthType {
+    Staff = "ADMIN",
+    Customer = "CUSTOMER",
+    // Driver = 'DRIVER'
+}
+
+interface JWTSignedData {
+    id: number,
+    type: AuthType,
+    ia?: number
+}
+
+interface RequestHeaders {
+    token?: string,
+    version?: string
+}
+
+const VERSION = '1.0.0'
+
+export default class JWT implements AuthStrategy {
+
+    public async auth(req: Request): Promise<any> {
+        const { baseUrl } = req
+
+        if (this.checkRouter(baseUrl, AuthType.Staff)) {
+            return await this.authenticateStaff(req)
+        }
+
+        // if (this.checkRouter(baseUrl, AuthType.Driver)) {
+        //     return await this.authenticateDriver(req)
+        // }
+
+        return await this.authenticateCustomer(req)
+    }
+
+
+    private checkRouter(baseUrl: string, type: AuthType) {
+        return baseUrl.includes(`${CONFIG.PREFIX_URL}/${type.toLowerCase()}`);
+    }
+
+
+    // private async authenticateDriver(req: Request) {
+    //     const { token, version } = <RequestHeaders>req.headers
+
+    //     if (version != VERSION) {
+    //         throw new InternalServerError(`Phiên bản hiện tại chưa được cập nhật. 
+    //         Vui lòng thoát hoàn toàn ứng dụng (bao gồm chạy ngầm) rồi mở lại. 
+    //         Nếu vẫn chưa được hãy lên cửa hàng ứng dụng cập nhật lại phiên bản mới nhất.`)
+    //     }
+
+    //     const driverId = this.getAuthId(token, AuthType.Driver);
+    //     const driver = await Driver.findOneOrThrowId(driverId, null, 'Tài xế');
+    //     if (driver.isBlock) {
+    //         throw new Unauthorized("Tài khoản đã bị khoá!")
+    //     }
+
+    //     req.driver = driver;
+    //     req.authType = AuthType.Driver
+    // }
+
+
+    private async authenticateCustomer(req: Request) {
+        const { token, version } = <RequestHeaders>req.headers
+
+        if (version != VERSION) {
+            throw new InternalServerError(`Phiên bản hiện tại chưa được cập nhật. 
+            Vui lòng thoát hoàn toàn ứng dụng (bao gồm chạy ngầm) rồi mở lại. 
+            Nếu vẫn chưa được hãy lên cửa hàng ứng dụng cập nhật lại phiên bản mới nhất.`)
+        }
+
+        const customerId = this.getAuthId(token, AuthType.Customer);
+        const customer = await Customer.findOneOrThrowId(customerId, null, 'Tài khoản');
+        if (customer.isBlock) {
+            throw new Unauthorized("Tài khoản đã bị khoá!")
+        }
+
+        req.customer = customer;
+        req.authType = AuthType.Customer
+    }
+
+
+    private async authenticateStaff(req: Request) {
+        const { token } = req.headers
+
+        const staffId = this.getAuthId(token, AuthType.Staff);
+        const staff = await Staff.findOneOrThrowId(staffId, null, 'Tài khoản');
+        if (staff.isBlock) {
+            throw new Unauthorized("Tài khoản đã bị khoá!")
+        }
+
+        req.staff = staff;
+        req.authType = AuthType.Staff
+    }
+
+
+    public getAuthId(token: any, type: AuthType): number {
+        if (!token) {
+            throw new Unauthorized("Xác thực không hợp lệ!")
+        }
+
+        try {
+            const decoded = <JWTSignedData>jwt.verify(token, CONFIG.JWT_SECRET)
+            if (decoded.id && decoded.type == type) {
+                return decoded.id
+            } else {
+                throw new Unauthorized("Xác thực không hợp lệ!")
+            }
+        } catch (error) {
+            logger('error').error('Error Get Authenticate ID: ', JSON.stringify(error))
+            throw new Unauthorized("Xác thực không hợp lệ!")
+        }
+    }
+
+
+    static getIa(token: string): number {
+        if (!token) {
+            return 0
+        }
+
+        try {
+            const decoded = <JWTSignedData>jwt.verify(token, CONFIG.JWT_SECRET)
+            return decoded.ia
+        } catch (error) {
+            return 0
+        }
+    }
+
+
+    static sign(data: JWTSignedData): string {
+        data = { ...data, ia: getCurrentTimeInt() }
+        return jwt.sign(data, CONFIG.JWT_SECRET, { expiresIn: CONFIG.JWT_EXPIRE })
+    }
+
+}

package/src/assets/init/src/middleware/error/handleError.ts.txt

@@ -0,0 +1,22 @@
+import { Request, Response, NextFunction } from "express";
+import logger from '../../util/logger'
+
+function logRequest(req: Request, err: any) {
+    const statusCode = err.status || 500
+    const messageSummary = `Request: ${req.method} ${req.url} - CODE: ${statusCode}`
+    const messageError = `${err.stack}`
+    const messageHeader = `Headers: ${JSON.stringify(req.headers, null, "\t")}`
+    const messageBody = `Body: ${JSON.stringify(req.body, null, "\t")}`
+    const messageQuery = `Query: ${JSON.stringify(req.query, null, "\t")}`
+    
+    console.log('err:', JSON.stringify(err))
+    logger('error').error(`\n${messageSummary}\n${messageHeader}\n${messageBody}\n${messageQuery}\n${messageError}`)
+}
+
+export default function handleError(err: any, req: Request, res: Response, next: NextFunction) {
+    const statusCode = err.status || 500
+    const message = err.message || "Server error!"
+
+    logRequest(req, err)
+    return res.status(statusCode).send({ message, data: {}, status: false })
+}

package/src/assets/init/src/middleware/error/handleNotFound.ts.txt

@@ -0,0 +1,7 @@
+import { Request, Response, NextFunction } from 'express';
+import { NotFound } from 'ts-httpexceptions'
+
+export default function handleNotFound(req: Request, res: Response, next: NextFunction) {
+    const error = new NotFound(`The request ${req.method}: ${req.url} was not found on this server.`)
+    next(error)
+}

package/src/assets/init/src/middleware/response/CustomSendResponse.ts.txt

@@ -0,0 +1,35 @@
+import { OverrideProvider, Res, ResponseData, SendResponseMiddleware, ConverterService, Req } from "@tsed/common";
+import { isStream } from "@tsed/core";
+
+@OverrideProvider(SendResponseMiddleware)
+export class CustomDefaultResponse {
+
+    constructor(private converterService: ConverterService) { }
+
+    public use(@Req() request: Req, @Res() response: Res): any {
+        const { ctx: { data, endpoint } } = request;
+
+        let message = ""
+        if (data && data.message) {
+            message = data.message
+            delete data.message
+        }
+
+        if (data === undefined) {
+            return response.send();
+        }
+
+        if (isStream(data)) {
+            data.pipe(response);
+            return response;
+        }
+
+        const payload = {
+            data,
+            message,
+            status: true
+        };
+
+        return response.json(payload);
+    }
+}

package/src/assets/init/src/middleware/response/responseAPI.ts.txt

@@ -0,0 +1,76 @@
+import { Request, Response, NextFunction } from "express";
+import { BadRequest, Unauthorized, Forbidden, InternalServerError } from "ts-httpexceptions"
+
+export default function responseAPI(req: Request, res: Response, next: NextFunction) {
+    res.sendAPI = (
+        data: Array<object> | object = {},
+        message: string = "",
+        status: boolean = true,
+        code: number = 200
+    ) => {
+        res.status(code)
+            .send({
+                data,
+                message,
+                status
+            })
+    }
+
+    res.sendOK = (
+        data: Array<object> | object = {},
+        message: string = ""
+    ) => {
+        const status = true
+        return res.sendAPI(data, message, status, 200)
+    }
+
+    res.sendCreated = (
+        message: string = "Created successfully!",
+        data: Array<object> | object = {}
+    ) => {
+        const status = true
+        return res.sendAPI(data, message, status, 201)
+    }
+
+    res.sendClientError = (
+        message: string = "Bad Request",
+        data: Array<object> | object = {}
+    ) => {
+        const err = new BadRequest(message)
+        next(err)
+    }
+
+    res.sendUnauthorized = (
+        message: string = "Unauthorized",
+        data: Array<object> | object = {}
+    ) => {
+        const err = new Unauthorized(message)
+        next(err)
+    }
+
+    res.sendForbidden = (
+        message: string = "Forbidden",
+        data: Array<object> | object = {}
+    ) => {
+        const err = new Forbidden(message)
+        next(err)
+    }
+
+    res.sendNotFound = (
+        message: string = "Not Found",
+        data: Array<object> | object = {}
+    ) => {
+        const status = false
+        return res.sendAPI(data, message, status, 200)
+    }
+
+    res.sendFail = (
+        message: string = "Internal Server Error",
+        data: Array<object> | object = {}
+    ) => {
+        const err = new InternalServerError(message)
+        next(err)
+    }
+
+    next()
+}

package/src/assets/init/src/middleware/validator/Validator.ts.txt

@@ -0,0 +1,103 @@
+import { applyDecorators } from "@tsed/core";
+import { IResponseOptions, mapReturnedResponse, UseBefore } from "@tsed/common";
+import Joi, { ValidationResult, SchemaMap, ValidationErrorItem } from '@hapi/joi';
+
+import { capitalize, isEmptyObject } from '../../util/helper'
+import { MESSAGE_VALIDATOR_VI } from '../../util/language'
+
+export enum Language {
+    Vietnamese = 'VI',
+    English = 'EN'
+}
+
+const LANGUAGES = [Language.Vietnamese as string, Language.English as string]
+
+function validateRequest(req: any, rules: SchemaMap) {
+    const parameters = { ...req.body, ...req.query, ...req.headers, ...req.params }
+    const validateKeys = Object.keys(rules)
+
+    for (const key in parameters) {
+        if (!validateKeys.includes(key)) delete parameters[key]
+    }
+
+    const schema = Joi.object(rules)
+    const result = schema.validate(parameters)
+    return result
+}
+
+function handleLanguageRequest(req: any) {
+    const query = req.query
+    const defaultLanguage = 'en'
+    if (!query && !query.lang) return defaultLanguage
+
+    const requestLanguage = query.lang
+    if (!LANGUAGES.includes(requestLanguage)) return defaultLanguage
+
+    return requestLanguage
+}
+
+function getMessageEnglish(originMessage: string, originLabel: string): string {
+    const labelCapitalized = capitalize(originLabel)
+    const label = `"${labelCapitalized}"`
+    const message = originMessage.replace(/\"[a-z]*\"/gm, label)
+    return message
+}
+
+// function getMessageWithCustomLabels(labels: Object, language: string, error: ValidationErrorItem): any {
+//     const originLabel = error.context.label
+//     const originKey = error.context.key
+//     const originType = error.type
+
+//     const label = labels[originKey] || originLabel
+
+//     if (language == Language.Vietnamese) {
+//         const originLimit = error.context.limit || false
+//         const message = `"${label}"` + MESSAGE_VALIDATOR_VI[originType](originLimit)
+//         return message
+//     }
+
+//     return getMessageEnglish(error.message, label)
+// }
+
+function handleMessage(language: string, error: ValidationErrorItem, labels: any): string {
+    const originMessage = error.message
+    const originLabel = error.context.label
+
+    if (!isEmptyObject(labels))
+        return getMessageEnglish(originMessage, originLabel)
+
+    if (language == Language.Vietnamese) {
+        const labelsVietnamese = labels[Language.Vietnamese]
+        if (!labelsVietnamese) return getMessageEnglish(originMessage, originLabel)
+        // else return getMessageWithCustomLabels(labelsVietnamese, Language.Vietnamese, error)
+    }
+
+    const labelsEnglish = labels[Language.English]
+    if (!labelsEnglish) return getMessageEnglish(originMessage, originLabel)
+    // else return getMessageWithCustomLabels(labelsEnglish, Language.English, error)
+}
+
+function handleResultValidate(result: any, req: any, labels: any): string {
+    const language = handleLanguageRequest(req)
+    if (!result || !result.error) return
+
+    const errors = result.error.details
+    if (!errors || !errors.length) return
+
+    const error = errors[0]
+    const message = handleMessage(language, error, labels)
+    return message
+}
+
+export function Validator(rules: SchemaMap, labels: Object = {}, options: any = {}) {
+    const response = mapReturnedResponse(options);
+
+    return applyDecorators(
+        UseBefore((req: any, res: any, next: any) => {
+            const result = validateRequest(req, rules)
+            const message = handleResultValidate(result, req, labels)
+            if (message) return res.sendClientError(message)
+            else next();
+        })
+    );
+}

package/src/assets/init/src/services/CustomerService.ts.txt

@@ -0,0 +1,79 @@
+// IMPORT LIBRARY
+import { Service } from "@tsed/common";
+
+// IMPORT CUSTOM
+import { CoreService } from "../core/services/CoreService";
+import { BadRequest } from "ts-httpexceptions";
+import { Customer } from "../entity/Customer";
+import { Password } from "../util/password";
+
+interface GetCustomerParams {
+    search: string
+    page: number
+    limit: number
+}
+
+@Service()
+export class CustomerService extends CoreService {
+
+    public async findManyAndCount({ search, page, limit }: GetCustomerParams) {
+        let where = ` CONCAT(customer.name, ' ', customer.phone) LIKE '%${search}%' 
+        AND customer.isDeleted = false`
+
+        const [customers, total] = await Customer.createQueryBuilder('customer')
+            .where(where)
+            .skip((page - 1) * limit)
+            .take(limit)
+            .orderBy('customer.id', 'DESC')
+            .getManyAndCount()
+
+        return [customers, total]
+    }
+
+
+    public async login(phone: string, password: string): Promise<Customer> {
+        const customer = await Customer.findOneOrThrowOption({ where: { phone } }, 'Tài khoản')
+
+        await this.validatePassword(customer, password)
+
+        if (customer.isBlock) {
+            throw new BadRequest('Tài khoản này đã bị khoá!')
+        }
+
+        return customer
+    }
+
+
+    async validateDuplicate(customer: Customer, userId: number = null) {
+        const { phone, email } = customer
+
+        const oldCustomer = await Customer.findOne({ where: [{ phone }, { email }] })
+
+        if (oldCustomer && oldCustomer.id != userId) {
+            let message = ""
+
+            if (oldCustomer.phone == phone) {
+                message = "Số điện thoại"
+            } else if (oldCustomer.email == email) {
+                message = "Email"
+            }
+
+            throw new BadRequest(`${message} đã tồn tại`)
+        }
+    }
+
+
+    async validatePassword(customer: Customer, password: string) {
+        const customerWithPassword = await Customer.findOneOrThrowOption({
+            where: { id: customer.id },
+            select: ['id', 'password']
+        })
+
+        const validate = await Password.validate(password, customerWithPassword.password)
+        if (!validate) {
+            throw new BadRequest('Mật khẩu không chính xác.')
+        }
+
+    }
+
+} // END FILE

package/src/assets/init/src/services/InitService.ts.txt

@@ -0,0 +1,11 @@
+// IMPORT LIBRARY
+import { Service } from "@tsed/common";
+
+
+// IMPORT CUSTOM
+import { CoreService } from "../core/services/CoreService";
+
+@Service()
+export class InitService extends CoreService {
+
+} //END FILE