@azteam/express 1.2.281 → 1.2.283

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@azteam/express",
-    "version": "1.2.281",
+    "version": "1.2.283",
     "main": "./lib/index.js",
     "module": "./src/index.js",
     "scripts": {
@@ -9,9 +9,9 @@
     "author": "toda <sp.azsolution.net@gmail.com>",
     "license": "MIT",
     "dependencies": {
-        "@azteam/crypto": "1.0.26",
-        "@azteam/error": "1.0.28",
-        "@azteam/http-client": "1.0.102",
+        "@azteam/crypto": "1.0.27",
+        "@azteam/error": "1.0.29",
+        "@azteam/http-client": "1.0.103",
         "@grpc/grpc-js": "1.6.7",
         "@grpc/proto-loader": "0.6.12",
         "body-parser": "1.19.0",

package/src/AdminController.js

@@ -0,0 +1,311 @@
+import _ from 'lodash';
+import {NOT_EXISTS} from '@azteam/error';
+
+import {REQUEST_TYPE} from './constant';
+import {rulesId, schemaBoolean, schemaEnum, schemaNumber} from './validate';
+import {adminRoleMiddleware, paginateMiddleware, validateMiddleware} from './middleware';
+import Controller from './Controller';
+
+const ALLOW_FIELDS = ['created_id', 'modified_id', 'restored_id', 'deleted_id', 'resource'];
+
+class AdminController extends Controller {
+    constructor(pathName, repository, options = {}) {
+        super(pathName, repository);
+
+        this.roles = {
+            EXEC: null,
+            READ: null,
+            CREATE: null,
+            UPDATE: null,
+            DELETE: null,
+            RESTORE: null,
+            DESTROY: null,
+            IMPORT: null,
+            EXPORT: null,
+
+            ...options.roles,
+        };
+
+        this.paginateOptions = options.paginateOptions || {};
+        this.guardResponse = options.guardResponse || [];
+        this.allowResponse = options.allowResponse ? [...options.allowResponse, ...ALLOW_FIELDS] : ALLOW_FIELDS;
+
+        this.rulesCreate = {
+            ...options.rulesCreate,
+            priority: schemaNumber(true),
+            status: schemaEnum([0, 1, 2], true),
+        };
+
+        this.rulesModify = {
+            isForceModify: schemaBoolean(true),
+            ..._.mapValues(this.rulesCreate, function (obj) {
+                return {...obj, optional: true};
+            }),
+        };
+
+        if (this.paginateOptions) {
+            this.paginateOptions.allowSearchFields = [
+                ...this.paginateOptions.allowSearchFields,
+                'status',
+                'created_at_start',
+                'created_at_end',
+                'modified_at_start',
+                'modified_at_end',
+            ];
+            this.paginateOptions.allowSortFields = [...this.paginateOptions.allowSortFields, 'created_at', 'modified_at', 'status'];
+        }
+    }
+
+    methodGetPaginatePublic = async (req, res) => {
+        const paginateData = await this.repository.find(req.query, req.paginate);
+        return res.success(paginateData, this.guardResponse, this.allowResponse);
+    };
+
+    getPaginatePublic() {
+        return {
+            disabled: !this.roles.READ,
+            path: '/',
+            method: [adminRoleMiddleware([this.roles.READ]), paginateMiddleware(this.paginateOptions), this.methodGetPaginatePublic],
+        };
+    }
+
+    methodGetPaginateTrash = async (req, res) => {
+        const paginateData = await this.repository.findTrash(req.query, req.paginate);
+        return res.success(paginateData, this.guardResponse, this.allowResponse);
+    };
+
+    getPaginateTrash() {
+        return {
+            disabled: !this.roles.READ,
+            path: '/',
+            method: [adminRoleMiddleware([this.roles.READ]), paginateMiddleware(this.paginateOptions), this.methodGetPaginateTrash],
+        };
+    }
+
+    methodGetOnePublic = async (req, res) => {
+        const item = await this.repository.findOneById(req.params.id);
+        if (!item) return res.error(NOT_EXISTS);
+        return res.success(item, this.guardResponse, this.allowResponse);
+    };
+
+    getOnePublic() {
+        return {
+            disabled: !this.roles.READ,
+            path: '/:id',
+            method: [adminRoleMiddleware([this.roles.READ]), validateMiddleware(REQUEST_TYPE.PARAMS, rulesId), this.methodGetOnePublic],
+        };
+    }
+
+    methodGetOneTrash = async (req, res) => {
+        const item = await this.repository.findOneTrashById(req.params.id);
+        if (!item) return res.error(NOT_EXISTS);
+        return res.success(item, this.guardResponse, this.allowResponse);
+    };
+
+    getOneTrash() {
+        return {
+            disabled: !this.roles.READ,
+            path: '/:id',
+            method: [adminRoleMiddleware([this.roles.READ]), validateMiddleware(REQUEST_TYPE.PARAMS, rulesId), this.methodGetOneTrash],
+        };
+    }
+
+    async beforeCreate(data) {
+        return data;
+    }
+
+    async afterCreate(item) {
+        return item;
+    }
+
+    methodPostCreatePublic = async (req, res) => {
+        const data = await this.beforeCreate(req.body);
+
+        let item = await this.repository.createByUser(req.user.id, data);
+
+        item = await this.afterCreate(item);
+
+        return res.success(item, this.guardResponse, this.allowResponse);
+    };
+
+    postCreatePublic() {
+        return {
+            disabled: !this.roles.CREATE,
+            path: '/',
+            method: [adminRoleMiddleware([this.roles.CREATE]), validateMiddleware(REQUEST_TYPE.BODY, this.rulesCreate), this.methodPostCreatePublic],
+        };
+    }
+
+    async beforeModify(data) {
+        return data;
+    }
+
+    async afterModify(item) {
+        return item;
+    }
+
+    methodPutModifyPublic = async (req, res) => {
+        let item = await this.repository.findOneById(req.params.id);
+        if (!item) return res.error(NOT_EXISTS);
+
+        const data = await this.beforeModify(req.body);
+
+        item.loadData(data);
+        item.modified_id = req.user.id;
+        await item.save();
+
+        item = await this.afterModify(item);
+
+        return res.success(item, this.guardResponse, this.allowResponse);
+    };
+
+    putModifyPublic() {
+        return {
+            disabled: !this.roles.UPDATE,
+            path: '/:id',
+            method: [
+                adminRoleMiddleware([this.roles.UPDATE]),
+                validateMiddleware(REQUEST_TYPE.PARAMS, rulesId),
+                validateMiddleware(REQUEST_TYPE.BODY, this.rulesModify),
+                this.methodPutModifyPublic,
+            ],
+        };
+    }
+
+    putModifyStatusAvailablePublic() {
+        return {
+            disabled: !this.roles.UPDATE,
+            path: '/available/:id',
+            method: [
+                adminRoleMiddleware([this.roles.UPDATE]),
+                validateMiddleware(REQUEST_TYPE.PARAMS, rulesId),
+                async (req, res) => {
+                    let item = await this.repository.findOneById(req.params.id);
+                    if (!item) return res.error(NOT_EXISTS);
+
+                    await item.modifyStatusAvailable(req.user.id);
+
+                    item = await this.afterModify(item);
+
+                    return res.success(item, this.guardResponse, this.allowResponse);
+                },
+            ],
+        };
+    }
+
+    putModifyStatusUnavailablePublic() {
+        return {
+            disabled: !this.roles.UPDATE,
+            path: '/unavailable/:id',
+            method: [
+                adminRoleMiddleware([this.roles.UPDATE]),
+                validateMiddleware(REQUEST_TYPE.PARAMS, rulesId),
+                async (req, res) => {
+                    let item = await this.repository.findOneById(req.params.id);
+                    if (!item) return res.error(NOT_EXISTS);
+
+                    await item.modifyStatusUnavailable(req.body.message, req.user.id);
+
+                    item = await this.afterModify(item);
+
+                    return res.success(item, this.guardResponse, this.allowResponse);
+                },
+            ],
+        };
+    }
+
+    putModifyStatusWaitingPublic() {
+        return {
+            disabled: !this.roles.UPDATE,
+            path: '/waiting/:id',
+            method: [
+                adminRoleMiddleware([this.roles.UPDATE]),
+                validateMiddleware(REQUEST_TYPE.PARAMS, rulesId),
+                async (req, res) => {
+                    let item = await this.repository.findOneById(req.params.id);
+                    if (!item) return res.error(NOT_EXISTS);
+
+                    await item.modifyStatusWaiting(req.user.id);
+
+                    item = await this.afterModify(item);
+
+                    return res.success(item, this.guardResponse, this.allowResponse);
+                },
+            ],
+        };
+    }
+
+    async afterDelete(item) {
+        return item;
+    }
+
+    methodDeletePublic = async (req, res) => {
+        const item = await this.repository.findOneById(req.params.id);
+        if (!item) return res.error(NOT_EXISTS);
+
+        await item.delete(req.user.id);
+
+        await this.afterDelete(item);
+
+        return res.success(true);
+    };
+
+    deletePublic() {
+        return {
+            disabled: !this.roles.DELETE,
+            path: '/:id',
+            method: [adminRoleMiddleware([this.roles.DELETE]), validateMiddleware(REQUEST_TYPE.PARAMS, rulesId), this.methodDeletePublic],
+        };
+    }
+
+    methodPostRestoreTrash = async (req, res) => {
+        const item = await this.repository.findOneTrashById(req.params.id);
+        if (!item) return res.error(NOT_EXISTS);
+
+        await item.restore(req.user.id);
+
+        return res.success(true);
+    };
+
+    postRestoreTrash() {
+        return {
+            disabled: !this.roles.RESTORE,
+            path: '/:id',
+            method: [adminRoleMiddleware([this.roles.RESTORE]), validateMiddleware(REQUEST_TYPE.PARAMS, rulesId), this.methodPostRestoreTrash],
+        };
+    }
+
+    async afterDestroy(item) {
+        return item;
+    }
+
+    methodDeleteDestroyTrash = async (req, res) => {
+        const item = await this.repository.findOne(
+            {
+                _id: req.params.id,
+            },
+            {
+                force: true,
+            }
+        );
+        if (!item) return res.error(NOT_EXISTS);
+
+        const oldItem = _.cloneDeep(item);
+
+        await this.repository.destroy(item.id);
+
+        await this.afterDestroy(oldItem);
+
+        return res.success(true);
+    };
+
+    deleteDestroyTrash() {
+        return {
+            disabled: !this.roles.DESTROY,
+            path: '/:id',
+            method: [adminRoleMiddleware([this.roles.DESTROY]), validateMiddleware(REQUEST_TYPE.PARAMS, rulesId), this.methodDeleteDestroyTrash],
+        };
+    }
+}
+
+export default AdminController;

package/src/Controller.js

@@ -0,0 +1,38 @@
+class Controller {
+    constructor(pathName = '', repository = null) {
+        this.pathName = pathName;
+        this.repository = repository;
+    }
+
+    publicRouter() {
+        let child = this;
+        const result = [];
+
+        while (Object.getPrototypeOf(child.__proto__)) {
+            const data = Object.getOwnPropertyNames(Object.getPrototypeOf(child));
+
+            data.map(function (methodName) {
+                const matches = methodName.match(/^(get|post|put|patch|delete)/);
+                if (matches) {
+                    let path = '/';
+                    if (methodName.endsWith('Public')) {
+                        path += 'public';
+                    } else if (methodName.endsWith('Trash')) {
+                        path += 'trash';
+                    }
+
+                    result.push({
+                        type: matches[0],
+                        name: methodName,
+                        path,
+                    });
+                }
+                return true;
+            });
+            child = child.__proto__;
+        }
+        return result;
+    }
+}
+
+export default Controller;