@azteam/express 1.2.115 → 1.2.118

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@azteam/express",
-    "version": "1.2.115",
+    "version": "1.2.118",
     "description": "",
     "main": "src/index.js",
     "repository": {

package/src/AdminController.js

@@ -0,0 +1,194 @@
+import { NOT_EXISTS, PERMISSION } from '@azteam/error';
+
+import { HTTP_METHOD, paginateMiddleware, REQUEST_TYPE, roleMiddleware, validateMiddleware, rulesID } from './ApiServer';
+import Controller from './Controller';
+
+import { USER_LEVEL } from './constant';
+
+
+class AdminController extends Controller {
+    constructor(pathName, repository, options = {}) {
+        this.options = {
+            roles: {
+                READ: 1,
+                CREATE: 2,
+                UPDATE: 3,
+                DELETE: 4,
+                RESTORE: 5,
+            }, // system roles
+
+            rulesCreate: {},
+            rulesModify: {},
+
+            guardResponse: {},
+            allowResponse: {},
+
+            ...options,
+        }
+
+        super(pathName, repository);
+    }
+
+
+    usePublic(controllers = []){
+        return super([
+            getPaginate,
+            getPaginateTrash,
+            getOne,
+            getOneTrash,
+            postCreate,
+            putModify,
+            deleteOne,
+            postRestore,
+        ]);
+    }
+
+
+    getPaginate() {
+        return {
+            path: `/${this.pathName}`,
+            method: [
+                roleMiddleware([this.options.roles.READ], USER_LEVEL.ADMIN),
+                paginateMiddleware(paginateOptions),
+                async function(req, res) {
+                    const paginateData = await this.repository.find(req.query, req.paginate);
+
+                    return res.success(paginateData, this.options.guardResponse, this.options.allowResponse);
+                },
+            ],
+        }
+    }
+
+    getPaginateTrash() {
+        return {
+            path: `/trash_${this.pathName}`,
+            method: [
+                roleMiddleware([this.options.roles.READ], USER_LEVEL.ADMIN),
+                paginateMiddleware(paginateOptions),
+                async function(req, res) {
+                    const paginateData = await this.repository.findTrash(req.query, req.paginate);
+
+                    return res.success(paginateData, this.options.guardResponse, this.options.allowResponse);
+                },
+            ],
+        }
+    }
+
+    getOne() {
+        return {
+            path: `/${this.pathName}/:id`,
+            method: [
+                roleMiddleware([this.options.roles.READ], USER_LEVEL.ADMIN),
+                validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
+                async function(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);
+                },
+            ],
+        }
+
+    }
+
+    getOneTrash() {
+        return {
+            path: `/trash_${this.pathName}/:id`,
+            method: [
+                roleMiddleware([this.options.roles.READ], USER_LEVEL.ADMIN),
+                validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
+                async function(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);
+                },
+            ],
+        }
+
+    }
+
+
+    beforePostCreate(data) {
+        return data;
+    }
+
+    postCreate() {
+        return {
+            path: `/${this.pathName}`,
+            method: [
+                roleMiddleware([this.options.roles.CREATE], USER_LEVEL.ADMIN),
+                validateMiddleware(REQUEST_TYPE.BODY, this.options.rulesCreate),
+                async function(req, res) {
+
+                    const data = this.beforePostCreate(req.body);
+
+                    const item = await this.repository.createByUser(req.user.id, data);
+
+                    return res.success(item, this.options.guardResponse, this.options.allowResponse);
+                },
+            ],
+        }
+    }
+
+
+    beforePutModify(item) {
+        return item;
+    }
+
+    putModify() {
+        return {
+            path: `/${this.pathName}/:id`,
+            method: [
+                roleMiddleware([this.options.roles.UPDATE], USER_LEVEL.ADMIN),
+                validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
+                validateMiddleware(REQUEST_TYPE.BODY, this.options.rulesModify),
+                async function(req, res) {
+
+                    let item = await this.options.roles.findOneById(req.params.id);
+                    if (!item) return res.error(NOT_EXISTS);
+
+                    item = await this.beforePutModify(item);
+
+                    item = await this.options.roles.modifyByUser(req.user.id, item, req.body);
+
+                    return res.success(item, this.options.guardResponse, this.options.allowResponse);
+                },
+            ],
+        }
+    }
+
+    deleteOne() {
+        return {
+            path: `/${this.pathName}/:id`,
+            method: [
+                roleMiddleware([this.options.roles.DELETE], USER_LEVEL.ADMIN),
+                validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
+                async function(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);
+                },
+            ],
+        }
+    }
+
+    postRestore() {
+        return {
+            path: `/trash_${this.pathName}/:id`,
+            method: [
+                roleMiddleware([this.options.roles.RESTORE], USER_LEVEL.ADMIN),
+                validateMiddleware(REQUEST_TYPE.PARAMS, rulesID),
+                async function(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);
+                },
+            ],
+        }
+    },
+}
+
+export default Controller;

package/src/Controller.js

@@ -0,0 +1,21 @@
+import { NOT_EXISTS, PERMISSION } from '@azteam/error';
+
+import { HTTP_METHOD, paginateMiddleware, REQUEST_TYPE, roleMiddleware, validateMiddleware, rulesID } from './ApiServer';
+import { USER_LEVEL } from './constant';
+
+
+class Controller {
+    constructor(pathName, repository) {
+        this.pathName = pathName;
+        this.repository = repository;
+    }
+
+
+    usePublic(controllers = []) {
+        return [
+            ...controllers
+        ]
+    }
+}
+
+export default Controller;

package/src/constant.js

@@ -11,3 +11,10 @@ export const REQUEST_TYPE = {
     BODY: 'body',
     QUERY: 'query',
 }
+
+export const USER_LEVEL = {
+    GUESS: 0,
+    USER: 1,
+    ADMIN: 50,
+    SYSTEM: 100,
+};

package/src/index.js

@@ -1,6 +1,9 @@
 import ApiServer from './ApiServer';
 import SocketServer from './SocketServer';
 
+import AdminController from './AdminController';
+
+
 export * from './middleware';
 export * from './constant';
 export * from './validate';
@@ -8,4 +11,6 @@ export * from './validate';
 export {
     ApiServer,
     SocketServer,
+
+    AdminController,
 }

package/src/validate.js

@@ -1,5 +1,3 @@
-/* schema */
-
 export const schemaID = (optional = false) => ({
     type: 'string',
     length: 24,
@@ -107,6 +105,8 @@ export const schemaObject = (props = {}, optional = false) => ({
     props,
     optional,
 });
+
+
 /* rules */
 
 export const rulesID = {