@kne/fastify-account 1.0.0-alpha.2 → 1.0.0-alpha.21

package/libs/services/admin.js

@@ -2,35 +2,34 @@ const fp = require('fastify-plugin');
 
 const ROLE = {
   SuperAdmin: 'SuperAdmin',
-  TenantAdmin: 'TenantAdmin'
+  Common: 'Common'
 };
 
 module.exports = fp(async (fastify, options) => {
+  const { models, services } = fastify.account;
   const initSuperAdmin = async user => {
-    if ((await fastify.account.models.adminRole.count()) > 0) {
+    if ((await models.adminRole.count()) > 0) {
       throw new Error('系统已经初始化完成，不能执行该操作');
     }
-    await fastify.account.models.adminRole.create({
+    await models.adminRole.create({
       userId: user.id,
       role: ROLE['SuperAdmin']
     });
   };
 
-  const superAdminAuthenticate = async user => {
-    if (
-      (await fastify.account.models.adminRole.count({
+  const checkIsSuperAdmin = async user => {
+    return (
+      (await models.adminRole.count({
         where: {
           userId: user.id,
           role: ROLE['SuperAdmin']
         }
-      })) === 0
-    ) {
-      throw new Error('不能执行该操作，需要超级管理员权限');
-    }
+      })) > 0
+    );
   };
 
   const addUser = async ({ avatar, nickname, phone, email, password, description }) => {
-    return await fastify.account.services.user.addUser({
+    return await services.user.addUser({
       avatar,
       nickname,
       phone,
@@ -42,9 +41,9 @@ module.exports = fp(async (fastify, options) => {
   };
 
   const setSuperAdmin = async targetUser => {
-    const user = await fastify.account.services.user.getUserInfo(targetUser);
+    const user = await services.user.getUser(targetUser);
     if (
-      (await fastify.account.models.adminRole.count({
+      (await models.adminRole.count({
         where: {
           userId: user.id,
           role: ROLE['SuperAdmin']
@@ -54,130 +53,47 @@ module.exports = fp(async (fastify, options) => {
       throw new Error('当前用户已经是超级管理员');
     }
 
-    await fastify.account.models.adminRole.create({
+    await models.adminRole.create({
       userId: user.id,
       role: ROLE['SuperAdmin']
     });
   };
 
-  const getAllUserList = async ({ filter, perPage, currentPage }) => {
-    const { count, rows } = await fastify.account.models.user.findAndCountAll({
-      include: [
-        {
-          attributes: ['role'],
-          model: fastify.account.models.adminRole
-        },
-        {
-          model: fastify.account.models.tenant
+  const cancelSuperAdmin = async targetUser => {
+    const user = await services.user.getUser(targetUser);
+    if (
+      !(await models.adminRole.count({
+        where: {
+          userId: user.id,
+          role: ROLE['SuperAdmin']
         }
-      ]
-    });
-    return {
-      pageData: rows,
-      totalCount: count
-    };
-  };
-
-  const getAllTenantList = async ({ filter, perPage, currentPage }) => {
-    const queryFilter = {};
-    if (filter?.name) {
-      queryFilter.name = {
-        [fastify.sequelize.Sequelize.Op.like]: `%${filter.name}%`
-      };
-    }
-
-    if (filter?.serviceStartTime) {
-      queryFilter.serviceStartTime = {
-        [fastify.sequelize.Sequelize.Op.gt]: filter.serviceStartTime
-      };
-    }
-
-    if (filter?.serviceEndTime) {
-      queryFilter.serviceEndTime = {
-        [fastify.sequelize.Sequelize.Op.lt]: filter.serviceEndTime
-      };
+      })) > 0
+    ) {
+      throw new Error('当前用户不是超级管理员');
     }
 
-    const { count, rows } = await fastify.account.models.tenant.findAndCountAll({
-      where: queryFilter,
-      offset: currentPage * (currentPage - 1),
-      limit: perPage
-    });
-
-    const res = await fastify.account.models.tenantUser.findAll({
-      attributes: ['tenantId', fastify.sequelize.instance.fn('count', fastify.sequelize.instance.col('tenantId'))],
-      where: {
-        tenantId: {
-          [fastify.sequelize.Sequelize.Op.in]: rows.map(({ id }) => id)
-        }
+    await models.adminRole.update(
+      {
+        role: ROLE['Common']
       },
-      group: 'tenantId'
-    });
-
-    return {
-      pageData: rows,
-      totalCount: count
-    };
-  };
-
-  const addTenant = async tenant => {
-    if (await fastify.account.models.tenant.count({ where: { name: tenant.name } })) {
-      throw new Error('租户名称不能重复');
-    }
-
-    const t = await fastify.sequelize.instance.transaction();
-    try {
-      const currentTenant = await fastify.account.models.tenant.create(tenant);
-      await fastify.account.models.tenantRole.create(
-        {
-          name: '系统默认角色',
-          tenantId: currentTenant.id,
-          description: '创建租户时自动生成，可以设置权限，不可更改删除，所有租户用户默认拥有该角色',
-          type: 1
-        },
-        { transaction: t }
-      );
-      await fastify.account.models.tenantOrg.create(
-        {
-          name: '根组织',
-          tenantId: currentTenant.id
-        },
-        { transaction: t }
-      );
-      await t.commit();
-    } catch (e) {
-      await t.rollback();
-      throw e;
-    }
-  };
-
-  const saveTenant = async tenant => {
-    const currentTenant = await fastify.account.models.tenant.findByPk(tenant.id);
-    if (!currentTenant) {
-      throw new Error('租户不存在，请刷新以后重试');
-    }
-    await currentTenant.update(tenant);
+      {
+        where: {
+          userId: user.id
+        }
+      }
+    );
   };
 
-  const generateTenantAdminVerifyCode = async () => {};
-
-  const verifyTenantAdmin = async () => {};
-
   const resetUserPassword = async ({ userId, password }) => {
-    await fastify.account.services.account.resetPassword({ userId, password });
+    await services.account.resetPassword({ userId, password });
   };
 
-  fastify.account.services.admin = {
+  services.admin = {
     initSuperAdmin,
     setSuperAdmin,
-    getAllUserList,
-    getAllTenantList,
-    addTenant,
-    saveTenant,
-    superAdminAuthenticate,
-    generateTenantAdminVerifyCode,
-    verifyTenantAdmin,
-    resetUserPassword,
-    addUser
+    cancelSuperAdmin,
+    checkIsSuperAdmin,
+    addUser,
+    resetUserPassword
   };
 });

package/libs/services/application.js

@@ -0,0 +1,170 @@
+const fp = require('fastify-plugin');
+const isNil = require('lodash/isNil');
+module.exports = fp(async (fastify, options) => {
+  const { models, services } = fastify.account;
+
+  const getApplicationInstance = async ({ id }) => {
+    if (!id) {
+      throw new Error('应用Id不能为空');
+    }
+    const application = await models.application.findOne({
+      where: {
+        uuid: id
+      }
+    });
+    if (!application) {
+      throw new Error('应用不存在');
+    }
+
+    return application;
+  };
+
+  const getApplication = async ({ id }) => {
+    const application = await getApplicationInstance({ id });
+    return Object.assign({}, application.get({ plain: true }), {
+      id: application.uuid
+    });
+  };
+
+  const getApplicationByCode = async ({ code }) => {
+    const application = await models.application.findOne({
+      where: {
+        code
+      }
+    });
+    if (application) {
+      await getApplicationInstance({ id: application.uuid });
+      return Object.assign({}, application.get({ plain: true }), {
+        id: application.uuid
+      });
+    }
+    return null;
+  };
+
+  const addApplication = async application => {
+    const currentApplication = await models.application.create(application);
+    return Object.assign({}, currentApplication.get({ plain: true }), {
+      id: currentApplication.uuid
+    });
+  };
+
+  const saveApplication = async ({ id, ...others }) => {
+    const application = await getApplicationInstance({ id });
+    ['name', 'code', 'avatar', 'url', 'description'].forEach(name => {
+      if (!isNil(others[name])) {
+        application[name] = others[name];
+      }
+    });
+
+    await application.save();
+  };
+
+  const deleteApplication = async ({ id }) => {
+    const application = await getApplicationInstance({ id });
+    if (
+      (await models.tenantApplication.count({
+        where: {
+          applicationId: application.uuid
+        }
+      })) > 0
+    ) {
+      throw new Error('应用已经开放给其他租户使用，不能删除');
+    }
+
+    const permissionIdList = (
+      await models.permission.findAll({
+        where: { applicationId: application.uuid }
+      })
+    ).map(({ id }) => id);
+
+    const t = await fastify.sequelize.instance.transaction();
+
+    try {
+      await models.tenantPermission.destroy(
+        {
+          where: {
+            permissionId: {
+              [fastify.sequelize.Sequelize.Op.in]: permissionIdList
+            }
+          }
+        },
+        { transaction: t }
+      );
+
+      await models.tenantRolePermission.destroy(
+        {
+          where: {
+            permissionId: {
+              [fastify.sequelize.Sequelize.Op.in]: permissionIdList
+            }
+          }
+        },
+        { transaction: t }
+      );
+
+      await models.permission.destroy({
+        where: {
+          applicationId: application.uuid
+        },
+        transaction: t
+      });
+      await application.destroy({ transaction: t });
+      await t.commit();
+    } catch (e) {
+      await t.rollback();
+      throw e;
+    }
+  };
+
+  const getApplicationList = async ({ tenantId, appName }) => {
+    const query = {};
+    if (tenantId) {
+      const tenant = await services.tenant.getTenant({ id: tenantId });
+      if (!tenant) {
+        throw new Error('租户不存在');
+      }
+      const tenantApplications = await models.tenantApplication.findAll({
+        where: { tenantId }
+      });
+      query.uuid = {
+        [fastify.sequelize.Sequelize.Op.in]: tenantApplications.map(({ applicationId }) => applicationId)
+      };
+    }
+    if (appName) {
+      query['code'] = appName;
+    }
+    const list = await models.application.findAll({
+      where: query
+    });
+
+    return list.map(item => {
+      return Object.assign({}, item.get({ plain: true }), {
+        id: item.uuid
+      });
+    });
+  };
+
+  const getApplicationListByIds = async ({ ids }) => {
+    const applications = await models.application.findAll({
+      where: {
+        uuid: {
+          [fastify.sequelize.Sequelize.Op.in]: ids
+        }
+      }
+    });
+
+    return applications.map(item => {
+      return Object.assign({}, item.get({ plain: true }), { id: item.uuid });
+    });
+  };
+
+  services.application = {
+    addApplication,
+    getApplication,
+    getApplicationByCode,
+    saveApplication,
+    deleteApplication,
+    getApplicationList,
+    getApplicationListByIds
+  };
+});