@azteam/express 1.2.175 → 1.2.176

package/package.json

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

package/src/AdminController.js

@@ -3,41 +3,41 @@ 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 || {};
     }
 
     getPaginatePublic() {
         return {
+            disabled: !this.roles.READ,
             path: '/',
             method: [
-                adminRoleMiddleware([this.options.roles.READ]),
-                paginateMiddleware(this.options.paginateOptions),
+                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.options.guardResponse, this.options.allowResponse);
+                    return res.success(paginateData, this.guardResponse, this.allowResponse);
                 },
             ],
         };
@@ -45,14 +45,15 @@ class AdminController extends Controller {
 
     getPaginateTrash() {
         return {
+            disabled: !this.roles.READ,
             path: '/',
             method: [
-                adminRoleMiddleware([this.options.roles.READ]),
-                paginateMiddleware(this.options.paginateOptions),
+                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.options.guardResponse, this.options.allowResponse);
+                    return res.success(paginateData, this.guardResponse, this.allowResponse);
                 },
             ],
         };
@@ -60,14 +61,15 @@ class AdminController extends Controller {
 
     getOnePublic() {
         return {
+            disabled: !this.roles.READ,
             path: '/:id',
             method: [
-                adminRoleMiddleware([this.options.roles.READ]),
+                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.options.guardResponse, this.options.allowResponse);
+                    return res.success(item, this.guardResponse, this.allowResponse);
                 },
             ],
         };
@@ -75,14 +77,15 @@ class AdminController extends Controller {
 
     getOneTrash() {
         return {
+            disabled: !this.roles.READ,
             path: '/:id',
             method: [
-                adminRoleMiddleware([this.options.roles.READ]),
+                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.options.guardResponse, this.options.allowResponse);
+                    return res.success(item, this.guardResponse, this.allowResponse);
                 },
             ],
         };
@@ -98,10 +101,11 @@ class AdminController extends Controller {
 
     postCreatePublic() {
         return {
+            disabled: !this.roles.CREATE,
             path: '/',
             method: [
-                adminRoleMiddleware([this.options.roles.CREATE]),
-                validateMiddleware(REQUEST_TYPE.BODY, this.options.rulesCreate),
+                adminRoleMiddleware([this.roles.CREATE]),
+                validateMiddleware(REQUEST_TYPE.BODY, this.rulesCreate),
                 async (req, res) => {
                     const data = await this.beforeCreate(req.body, req.user);
 
@@ -109,7 +113,7 @@ class AdminController extends Controller {
 
                     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);
                 },
             ],
         };
@@ -125,11 +129,12 @@ class AdminController extends Controller {
 
     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),
+                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);
@@ -140,7 +145,7 @@ class AdminController extends Controller {
 
                     item = await this.afterModify(item, req.user);
 
-                    return res.success(item, this.options.guardResponse, this.options.allowResponse);
+                    return res.success(item, this.guardResponse, this.allowResponse);
                 },
             ],
         };
@@ -148,9 +153,10 @@ class AdminController extends Controller {
 
     deletePublic() {
         return {
+            disabled: !this.roles.DELETE,
             path: '/:id',
             method: [
-                adminRoleMiddleware([this.options.roles.DELETE]),
+                adminRoleMiddleware([this.roles.DELETE]),
                 validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
                 async (req, res) => {
                     const item = await this.repository.findOneById(req.params.id);
@@ -165,9 +171,10 @@ class AdminController extends Controller {
 
     postRestoreTrash() {
         return {
+            disabled: !this.roles.RESTORE,
             path: '/:id',
             method: [
-                adminRoleMiddleware([this.options.roles.RESTORE]),
+                adminRoleMiddleware([this.roles.RESTORE]),
                 validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
                 async (req, res) => {
                     const item = await this.repository.findOneTrashById(req.params.id);
@@ -182,9 +189,10 @@ class AdminController extends Controller {
 
     deleteDestroyTrash() {
         return {
+            disabled: !this.roles.DESTROY,
             path: '/:id',
             method: [
-                adminRoleMiddleware([this.options.roles.DESTROY]),
+                adminRoleMiddleware([this.roles.DESTROY]),
                 validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
                 async (req, res) => {
                     const item = await this.repository.findOneTrashById(req.params.id);
@@ -196,6 +204,34 @@ class AdminController extends Controller {
             ],
         };
     }
+
+    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);
+                },
+            ],
+        };
+    }
+
+    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);
+                },
+            ],
+        };
+    }
 }
 
 export default AdminController;

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,30 +254,32 @@ class Server {
 
             const msg = [];
             _.map(this.controllers, (data) => {
-                const controller = data.controller;
+                const {controller} = data;
                 const controllerName = data.name;
                 const controllerVersion = data.version;
 
                 const listPublicRouter = controller.publicRouter();
 
                 _.map(listPublicRouter, (method) => {
-                    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);
+                    const {name, type, disabled} = method;
+
+                    if (!disabled) {
+                        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);
+                    }
                 });
             });