@azteam/express 1.2.176 → 1.2.179

package/package.json

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

package/src/AdminController.js

@@ -28,66 +28,57 @@ class AdminController extends Controller {
         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.roles.READ]),
-                paginateMiddleware(this.paginateOptions),
-                async (req, res) => {
-                    const paginateData = await this.repository.find(req.query, req.paginate);
-                    return res.success(paginateData, this.guardResponse, this.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.roles.READ]),
-                paginateMiddleware(this.paginateOptions),
-                async (req, res) => {
-                    const paginateData = await this.repository.findTrash(req.query, req.paginate);
-
-                    return res.success(paginateData, this.guardResponse, this.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.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.guardResponse, this.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.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.guardResponse, this.allowResponse);
-                },
-            ],
+            method: [adminRoleMiddleware([this.roles.READ]), validateMiddleware(REQUEST_TYPE.PARAMS, rulesID), this.methodGetOneTrash],
         };
     }
 
@@ -99,23 +90,21 @@ class AdminController extends Controller {
         return item;
     }
 
+    methodPostCreatePublic = async (req, res) => {
+        const data = await this.beforeCreate(req.body, req.user);
+
+        let item = await this.repository.createByUser(req.user.id, data);
+
+        item = await this.afterCreate(item, req.user);
+
+        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),
-                async (req, res) => {
-                    const data = await this.beforeCreate(req.body, req.user);
-
-                    let item = await this.repository.createByUser(req.user.id, data);
-
-                    item = await this.afterCreate(item, req.user);
-
-                    return res.success(item, this.guardResponse, this.allowResponse);
-                },
-            ],
+            method: [adminRoleMiddleware([this.roles.CREATE]), validateMiddleware(REQUEST_TYPE.BODY, this.rulesCreate), this.methodPostCreatePublic],
         };
     }
 
@@ -127,6 +116,19 @@ 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,
@@ -135,101 +137,78 @@ class AdminController extends Controller {
                 adminRoleMiddleware([this.roles.UPDATE]),
                 validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
                 validateMiddleware(REQUEST_TYPE.BODY, this.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.guardResponse, this.allowResponse);
-                },
+                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.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.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.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);
-
-                    await this.repository.destroy(item);
-                    return res.success(true);
-                },
-            ],
+            method: [adminRoleMiddleware([this.roles.DESTROY]), validateMiddleware(REQUEST_TYPE.PARAMS, rulesID), this.methodDeleteDestroyTrash],
         };
     }
 
+    methodDPostImportSheet = async (req, res) => {
+        return res.success(true);
+    };
     postImportSheet() {
         return {
             disabled: !this.roles.CREATE,
-            path: '/',
-            method: [
-                adminRoleMiddleware([this.roles.CREATE]),
-                verifyGoogleAppMiddleware(),
-                async (req, res) => {
-                    const item = await this.repository.findOneTrashById(req.params.id);
-                },
-            ],
+            path: '/import_sheet',
+            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(),
-                async (req, res) => {
-                    const item = await this.repository.findOneTrashById(req.params.id);
-                },
-            ],
+            path: '/export_sheet',
+            method: [adminRoleMiddleware([this.roles.READ]), verifyGoogleAppMiddleware(), this.methodPostExportSheet],
         };
     }
 }

package/src/Server.js

@@ -261,11 +261,10 @@ class Server {
                 const listPublicRouter = controller.publicRouter();
 
                 _.map(listPublicRouter, (method) => {
-                    const {name, type, disabled} = method;
-
-                    if (!disabled) {
-                        const router = controller[name]();
+                    const {name, type} = method;
 
+                    const router = controller[name]();
+                    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;
@@ -293,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) {
@@ -318,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':
@@ -337,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) {