@azteam/express 1.2.282 → 1.2.284

package/lib/AdminController.js

@@ -34,7 +34,7 @@ function _assertThisInitialized(self) { if (self === void 0) { throw new Referen
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-var ALLOW_FIELDS = ['created_id', 'modified_id', 'restored_id', 'deleted_id', 'resource'];
+var ALLOW_FIELDS = ['created_at', 'created_id', 'modified_at', 'modified_id', 'deleted_at', 'deleted_id', 'restored_id', 'resource', 'priority', 'is_processing'];
 var AdminController = /*#__PURE__*/function (_Controller) {
   _inherits(AdminController, _Controller);
   var _super = _createSuper(AdminController);

package/lib/Server.js

@@ -229,7 +229,7 @@ var Server = /*#__PURE__*/function () {
             var responseGuard = guard;
             var responseAllows = allow;
             if (_lodash["default"].isArray(guard)) {
-              responseGuard = [].concat(_toConsumableArray(guard), ['__v', '_id', 'deleted_at', 'updated_at', 'created_id', 'modified_id', 'resource', 'is_processing', 'priority']);
+              responseGuard = [].concat(_toConsumableArray(guard), ['__v', '_id', 'created_at', 'created_id', 'modified_at', 'modified_id', 'deleted_at', 'deleted_id', 'restored_id', 'resource', 'is_processing', 'priority']);
             }
             if (resType === RES_TYPE.DOCS) {
               guardData.docs = _lodash["default"].map(data.docs, function (item) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@azteam/express",
-    "version": "1.2.282",
+    "version": "1.2.284",
     "main": "./lib/index.js",
     "module": "./src/index.js",
     "scripts": {

package/src/AdminController.js

@@ -0,0 +1,322 @@
+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_at',
+    'created_id',
+    'modified_at',
+    'modified_id',
+    'deleted_at',
+    'deleted_id',
+    'restored_id',
+    'resource',
+    'priority',
+    'is_processing',
+];
+
+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;