@azteam/express 1.2.175 → 1.2.178

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@azteam/express",
-    "version": "1.2.175",
+    "version": "1.2.178",
     "main": "src/index.js",
     "engines": {
         "node": ">= 12.0.0",

package/src/AdminController.js

@@ -3,88 +3,82 @@ import {NOT_EXISTS} from '@azteam/error';
 import {REQUEST_TYPE} from './constant';
 import {rulesID} from './validate';
 import Controller from './Controller';
-import {adminRoleMiddleware, paginateMiddleware, validateMiddleware} from './middleware';
+import {adminRoleMiddleware, paginateMiddleware, validateMiddleware, verifyGoogleAppMiddleware} from './middleware';
 
 class AdminController extends Controller {
     constructor(pathName, repository, options = {}) {
-        super(pathName, repository, {
-            roles: {
-                READ: 1,
-                CREATE: 2,
-                UPDATE: 3,
-                DELETE: 4,
-                RESTORE: 5,
-                DESTROY: 6,
-            }, // system roles
+        super(pathName, repository);
 
-            paginateOptions: {},
-            rulesCreate: {},
-            rulesModify: {},
+        this.roles = {
+            READ: null,
+            CREATE: null,
+            UPDATE: null,
+            DELETE: null,
+            RESTORE: null,
+            DESTROY: null,
 
-            guardResponse: {},
-            allowResponse: {},
+            ...options.roles,
+        };
+
+        this.paginateOptions = options.paginateOptions || {};
+        this.guardResponse = options.guardResponse || {};
+        this.allowResponse = options.allowResponse || {};
 
-            ...options,
-        });
+        this.rulesCreate = options.rulesCreate || {};
+        this.rulesModify = options.rulesModify || {};
     }
 
+    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.options.roles.READ]),
-                paginateMiddleware(this.options.paginateOptions),
-                async (req, res) => {
-                    const paginateData = await this.repository.find(req.query, req.paginate);
-
-                    return res.success(paginateData, this.options.guardResponse, this.options.allowResponse);
-                },
-            ],
+            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.options.roles.READ]),
-                paginateMiddleware(this.options.paginateOptions),
-                async (req, res) => {
-                    const paginateData = await this.repository.findTrash(req.query, req.paginate);
-
-                    return res.success(paginateData, this.options.guardResponse, this.options.allowResponse);
-                },
-            ],
+            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.options.roles.READ]),
-                validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
-                async (req, res) => {
-                    const item = await this.repository.findOneById(req.params.id);
-                    if (!item) return res.error(NOT_EXISTS);
-                    return res.success(item, this.options.guardResponse, this.options.allowResponse);
-                },
-            ],
+            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.options.roles.READ]),
-                validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
-                async (req, res) => {
-                    const item = await this.repository.findOneTrashById(req.params.id);
-                    if (!item) return res.error(NOT_EXISTS);
-                    return res.success(item, this.options.guardResponse, this.options.allowResponse);
-                },
-            ],
+            method: [adminRoleMiddleware([this.roles.READ]), validateMiddleware(REQUEST_TYPE.PARAMS, rulesID), this.methodGetOneTrash],
         };
     }
 
@@ -96,22 +90,21 @@ class AdminController extends Controller {
         return item;
     }
 
-    postCreatePublic() {
-        return {
-            path: '/',
-            method: [
-                adminRoleMiddleware([this.options.roles.CREATE]),
-                validateMiddleware(REQUEST_TYPE.BODY, this.options.rulesCreate),
-                async (req, res) => {
-                    const data = await this.beforeCreate(req.body, req.user);
+    methodPostCreatePublic = async (req, res) => {
+        const data = await this.beforeCreate(req.body, req.user);
 
-                    let item = await this.repository.createByUser(req.user.id, data);
+        let item = await this.repository.createByUser(req.user.id, data);
 
-                    item = await this.afterCreate(item, req.user);
+        item = await this.afterCreate(item, req.user);
 
-                    return res.success(item, this.options.guardResponse, this.options.allowResponse);
-                },
-            ],
+        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],
         };
     }
 
@@ -123,77 +116,99 @@ class AdminController extends Controller {
         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, req.user);
+
+        item = await this.repository.modifyByUser(req.user.id, item, data);
+
+        item = await this.afterModify(item, req.user);
+
+        return res.success(item, this.guardResponse, this.allowResponse);
+    };
+
     putModifyPublic() {
         return {
+            disabled: !this.roles.UPDATE,
             path: '/:id',
             method: [
-                adminRoleMiddleware([this.options.roles.UPDATE]),
+                adminRoleMiddleware([this.roles.UPDATE]),
                 validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
-                validateMiddleware(REQUEST_TYPE.BODY, this.options.rulesModify),
-                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, req.user);
-
-                    item = await this.repository.modifyByUser(req.user.id, item, data);
-
-                    item = await this.afterModify(item, req.user);
-
-                    return res.success(item, this.options.guardResponse, this.options.allowResponse);
-                },
+                validateMiddleware(REQUEST_TYPE.BODY, this.rulesModify),
+                this.methodPutModifyPublic,
             ],
         };
     }
 
+    methodDeletePublic = async (req, res) => {
+        const item = await this.repository.findOneById(req.params.id);
+        if (!item) return res.error(NOT_EXISTS);
+
+        await this.repository.deleteByUser(req.user.id, item);
+        return res.success(true);
+    };
+
     deletePublic() {
         return {
+            disabled: !this.roles.DELETE,
             path: '/:id',
-            method: [
-                adminRoleMiddleware([this.options.roles.DELETE]),
-                validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
-                async (req, res) => {
-                    const item = await this.repository.findOneById(req.params.id);
-                    if (!item) return res.error(NOT_EXISTS);
-
-                    await this.repository.deleteByUser(req.user.id, item);
-                    return res.success(true);
-                },
-            ],
+            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 this.repository.restoreByUser(req.user.id, item);
+        return res.success(true);
+    };
+
     postRestoreTrash() {
         return {
+            disabled: !this.roles.RESTORE,
             path: '/:id',
-            method: [
-                adminRoleMiddleware([this.options.roles.RESTORE]),
-                validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
-                async (req, res) => {
-                    const item = await this.repository.findOneTrashById(req.params.id);
-                    if (!item) return res.error(NOT_EXISTS);
-
-                    await this.repository.restoreByUser(req.user.id, item);
-                    return res.success(true);
-                },
-            ],
+            method: [adminRoleMiddleware([this.roles.RESTORE]), validateMiddleware(REQUEST_TYPE.PARAMS, rulesID), this.methodPostRestoreTrash],
         };
     }
 
+    methodDeleteDestroyTrash = async (req, res) => {
+        const item = await this.repository.findOneTrashById(req.params.id);
+        if (!item) return res.error(NOT_EXISTS);
+
+        await this.repository.destroy(item);
+        return res.success(true);
+    };
+
     deleteDestroyTrash() {
         return {
+            disabled: !this.roles.DESTROY,
             path: '/:id',
-            method: [
-                adminRoleMiddleware([this.options.roles.DESTROY]),
-                validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
-                async (req, res) => {
-                    const item = await this.repository.findOneTrashById(req.params.id);
-                    if (!item) return res.error(NOT_EXISTS);
+            method: [adminRoleMiddleware([this.roles.DESTROY]), validateMiddleware(REQUEST_TYPE.PARAMS, rulesID), this.methodDeleteDestroyTrash],
+        };
+    }
 
-                    await this.repository.destroy(item);
-                    return res.success(true);
-                },
-            ],
+    methodDPostImportSheet = async (req, res) => {
+        return res.success(true);
+    };
+    postImportSheet() {
+        return {
+            disabled: !this.roles.CREATE,
+            path: '/',
+            method: [adminRoleMiddleware([this.roles.CREATE]), verifyGoogleAppMiddleware(), this.methodDPostImportSheet],
+        };
+    }
+
+    methodPostExportSheet = async (req, res) => {
+        return res.success(true);
+    };
+    postExportSheet() {
+        return {
+            disabled: !this.roles.READ,
+            path: '/',
+            method: [adminRoleMiddleware([this.roles.READ]), verifyGoogleAppMiddleware(), this.methodPostExportSheet],
         };
     }
 }

package/src/Controller.js

@@ -1,11 +1,7 @@
 class Controller {
-    constructor(pathName = '', repository = null, options = {}) {
+    constructor(pathName = '', repository = null) {
         this.pathName = pathName;
         this.repository = repository;
-
-        this.options = {
-            ...options,
-        };
     }
 
     publicRouter() {

package/src/Server.js

@@ -254,7 +254,7 @@ class Server {
 
             const msg = [];
             _.map(this.controllers, (data) => {
-                const controller = data.controller;
+                const {controller} = data;
                 const controllerName = data.name;
                 const controllerVersion = data.version;
 
@@ -264,20 +264,21 @@ class Server {
                     const {name, type} = method;
 
                     const router = controller[name]();
-
-                    router.path = `/${method.path}/${router.path}`;
-                    router.path = controller.pathName ? `/${controller.pathName}${router.path}` : router.path;
-                    router.path = controllerVersion.startsWith('v') ? `/${controllerVersion}${router.path}` : router.path;
-                    router.path = path.normalize(router.path);
-
-                    msg.push({
-                        controller: controllerName,
-                        version: controllerVersion,
-                        type,
-                        method: name,
-                        path: router.path,
-                    });
-                    app[type](router.path, ...router.method);
+                    if (!router.disabled) {
+                        router.path = `/${method.path}/${router.path}`;
+                        router.path = controller.pathName ? `/${controller.pathName}${router.path}` : router.path;
+                        router.path = controllerVersion.startsWith('v') ? `/${controllerVersion}${router.path}` : router.path;
+                        router.path = path.normalize(router.path);
+
+                        msg.push({
+                            controller: controllerName,
+                            version: controllerVersion,
+                            type,
+                            method: name,
+                            path: router.path,
+                        });
+                        app[type](router.path, ...router.method);
+                    }
                 });
             });
 
@@ -291,11 +292,11 @@ class Server {
                 throw new ErrorException(NOT_FOUND);
             });
 
-            app.use((e, req, res, next) => {
-                const error = errorCatch(e);
+            app.use((err, req, res, next) => {
+                const error = errorCatch(err);
 
                 if (error.errors[0].code === UNKNOWN) {
-                    console.error(req.originalUrl, e);
+                    console.error(req.originalUrl, err);
                 }
 
                 if (this.callbackError) {
@@ -316,7 +317,7 @@ class Server {
                     throw error;
                 }
 
-                let bind = typeof port === 'string' ? 'Pipe ' + port : 'Port ' + port;
+                const bind = typeof port === 'string' ? `Pipe ${port}` : `Port ${port}`;
 
                 switch (error.code) {
                     case 'EACCES':
@@ -335,18 +336,15 @@ class Server {
             server.listen(port);
 
             return server;
-        } else {
-            throw Error('No controllers in use API');
         }
-        return this;
+        throw Error('No controllers in use API');
     }
 
     startSocket(port) {
         if (!_.isEmpty(this.controllers)) {
-        } else {
-            throw Error('No controllers in use SOCKET');
+            return this;
         }
-        return this;
+        throw Error('No controllers in use SOCKET');
     }
 
     setAlertCallback(callback) {