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

package/libs/services/tenant.js

@@ -1,595 +1,72 @@
 const fp = require('fastify-plugin');
-const isNil = require('lodash/isNil');
-const { Unauthorized } = require('http-errors');
-const transform = require('lodash/transform');
-const groupBy = require('lodash/groupBy');
-const pick = require('lodash/pick');
+
 module.exports = fp(async (fastify, options) => {
-  const getUserTenant = async authenticatePayload => {
-    const user = await fastify.account.services.user.getUserInfo(authenticatePayload);
-    const tenantUserList = await fastify.account.models.tenantUser.findAll({
+  const { models, services } = fastify.account;
+
+  const getTenantInstance = async ({ id }) => {
+    const tenant = await models.tenant.findOne({
       where: {
-        userId: user.id
+        uuid: id
       }
     });
-
-    const tenantList =
-      tenantUserList.length > 0
-        ? await fastify.account.models.tenant.findAll({
-            where: {
-              id: {
-                [fastify.sequelize.Sequelize.Op.in]: tenantUserList.map(({ tenantId }) => tenantId)
-              },
-              status: 0
-            }
-          })
-        : [];
-
-    const currentTenantUser = user.currentTenantId && tenantUserList.find(({ tenantId }) => tenantId === user.currentTenantId);
-    const currentTenant = currentTenantUser && tenantList.find(({ id }) => id === currentTenantUser.tenantId);
-
-    return {
-      currentTenant,
-      currentTenantUser,
-      tenantList,
-      tenantUserList,
-      userInfo: user
-    };
-  };
-
-  const getTenantInfo = async ({ id }) => {
-    const tenant = await fastify.account.models.tenant.findByPk(id);
     if (!tenant) {
       throw new Error('租户不存在');
     }
-    return tenant;
-  };
-
-  const getRoleList = async ({ tenantId, currentPage, perPage, filter }) => {
-    const queryFilter = {};
-    if (!isNil(filter?.type)) {
-      queryFilter.type = filter.type;
-    }
-    const { count, rows } = await fastify.account.models.tenantRole.findAndCountAll({
-      where: Object.assign({}, queryFilter, { tenantId }),
-      offset: currentPage * (currentPage - 1),
-      limit: perPage
-    });
-
-    return { pageData: rows, totalCount: count };
-  };
-
-  const addRole = async ({ tenantId, name, description }) => {
-    if (!(await fastify.account.models.tenant.findByPk(tenantId))) {
-      throw new Error('租户不存在');
-    }
-
-    return await fastify.account.models.tenantRole.create({
-      tenantId,
-      name,
-      description
-    });
-  };
-
-  const saveRole = async ({ id, ...otherInfo }) => {
-    const tenantRole = await fastify.account.models.tenantRole.findByPk(id, {
-      where: {
-        type: 0
-      }
-    });
-
-    if (!tenantRole) {
-      throw new Error('角色不存在');
-    }
-
-    ['name', 'description'].forEach(name => {
-      if (otherInfo[name]) {
-        tenantRole[name] = otherInfo[name];
-      }
-    });
-
-    await tenantRole.save();
-  };
 
-  const removeRole = async ({ id }) => {
-    const tenantRole = await fastify.account.models.tenantRole.findByPk(id, {
-      where: {
-        type: 0
-      }
-    });
-
-    if (!tenantRole) {
-      throw new Error('角色不存在');
+    if (tenant.status !== 0) {
+      throw new Error('租户已关闭');
     }
-
-    if (
-      (await fastify.account.models.tenantUserRole.count({
-        where: {
-          tenantRoleId: tenantRole.id
-        }
-      })) > 0
-    ) {
-      throw new Error('该角色已经被使用，请在租户用户种处理掉所有使用该角色的租户用户后重试');
-    }
-
-    if (tenantRole.type === 1) {
-      throw new Error('该角色为系统默认角色，不能删除');
-    }
-
-    await tenantRole.destroy();
-  };
-
-  const getTenantUserPermissionList = async ({ tenantRoleIds }) => {
-    const tenantRoleApplication = await fastify.account.models.tenantRoleApplication.findAll({
-      attributes: ['applicationId'],
-      where: {
-        roleId: {
-          [fastify.sequelize.Sequelize.Op.in]: tenantRoleIds
-        }
-      }
-    });
-
-    const applications = await fastify.account.models.application.findAll({
-      attributes: ['id', 'code', 'name'],
-      where: {
-        id: {
-          [fastify.sequelize.Sequelize.Op.in]: tenantRoleApplication.map(({ applicationId }) => applicationId)
-        }
-      }
-    });
-
-    const tenantRolePermission = await fastify.account.models.tenantRolePermission.findAll({
-      attributes: ['permissionId'],
-      include: {
-        attributes: ['code', 'name', 'isModule', 'paths'],
-        model: fastify.account.models.permission
-      },
-      where: {
-        roleId: {
-          [fastify.sequelize.Sequelize.Op.in]: tenantRoleIds
-        }
-      }
-    });
-
-    const permissions = await fastify.account.models.permission.findAll({
-      attributes: ['id', 'code', 'name', 'isModule', 'pid', 'applicationId', 'paths'],
-      where: {
-        [fastify.sequelize.Sequelize.Op.or]: [
-          {
-            id: {
-              [fastify.sequelize.Sequelize.Op.in]: tenantRolePermission.map(({ permissionId }) => permissionId)
-            }
-          },
-          {
-            isMust: true
-          }
-        ]
-      }
-    });
-
-    const permissionMapping = transform(
-      await fastify.account.models.permission.findAll({
-        where: {
-          id: {
-            [fastify.sequelize.Sequelize.Op.in]: permissions.map(({ paths }) => paths).reduce((list, item) => [...list, ...(item || [])], [])
-          }
-        }
-      }),
-      (result, value) => {
-        result[value.id] = { code: value.code, name: value.name };
-      },
-      {}
-    );
-
-    const applicationsMapping = transform(
-      applications,
-      (result, value) => {
-        result[value.id] = value;
-      },
-      {}
-    );
-
-    const findEndChildren = permissions => {
-      const output = [];
-      const core = (list, node) => {
-        const { children, other } = groupBy(list, item => (item.pid === node.id ? 'children' : 'other'));
-        if (!(other && other.length > 0)) {
-          return;
-        }
-        if (!(children && children.length > 0)) {
-          node.id !== 0 && output.push(node);
-          return;
-        }
-
-        children.forEach(node => {
-          core(other, node);
-        });
-        return output;
-      };
-      core(permissions, { id: 0 });
-      return output;
-    };
-
-    const userPermissionList = findEndChildren(permissions).map(({ code, applicationId, paths }) => {
-      return `${applicationsMapping[applicationId].code}${
-        paths && paths.length > 0
-          ? `:${paths
-              .map(id => {
-                return permissionMapping[id].code;
-              })
-              .join(':')}`
-          : ''
-      }:${code}`;
-    });
-
-    return {
-      applications: applications,
-      permissions: permissions.map(item =>
-        Object.assign(
-          {},
-          {
-            code: item.code,
-            name: item.name,
-            isModule: item.isModule,
-            paths: (item.paths || []).map(id => permissionMapping[id])
-          }
-        )
-      ),
-      userPermissionList
-    };
+    return tenant;
   };
 
-  const tenantUserAuthenticate = async user => {
-    if (!user.currentTenantId) {
-      throw new Unauthorized('没有找到当前绑定租户');
-    }
-    const tenant = await fastify.account.models.tenant.findByPk(user.currentTenantId, {
-      where: {
-        status: 0
-      }
-    });
-    if (!tenant) {
-      throw new Error('当前绑定租户不存在或者已经被关闭');
-    }
-
-    const tenantUser = await fastify.account.models.tenantUser.findOne({
-      attributes: ['id', 'avatar', 'description', 'phone', 'email'],
-      include: [
-        {
-          attributes: ['id', 'name'],
-          model: fastify.account.models.tenantOrg
-        },
-        {
-          attributes: ['id', 'name'],
-          model: fastify.account.models.tenantRole
-        }
-      ],
-      where: {
-        tenantId: tenant.id,
-        userId: user.id,
-        status: 0
-      }
-    });
+  const getTenant = async ({ id }) => {
+    const tenant = await getTenantInstance({ id });
 
-    // 获取当前租户默认角色
-    const defaultTenant = await fastify.account.models.tenantRole.findOne({
-      where: {
-        type: 1,
-        tenantId: tenant.id
-      }
-    });
-
-    if (!defaultTenant) {
-      throw new Error('租户默认角色未设置，请联系管理员');
-    }
-
-    const tenantRoleIds = tenantUser.tenantRoles.map(({ id }) => id);
-    tenantRoleIds.push(defaultTenant.id);
-
-    const { userPermissionList } = await getTenantUserPermissionList({ tenantRoleIds });
-    if (!tenantUser) {
-      throw new Error('当前租户用户不存在或者已经被关闭');
-    }
-
-    const outputTenantUser = Object.assign({}, tenantUser.get({ plain: true }));
-    outputTenantUser.tenantOrgs = outputTenantUser?.tenantOrgs.map(({ id, name }) => ({ id, name }));
-    outputTenantUser.tenantRoles = outputTenantUser?.tenantRoles.map(({ id, name }) => ({ id, name }));
-    return {
-      tenant: pick(tenant, ['id', 'name', 'description']),
-      tenantUser: Object.assign({}, outputTenantUser, {
-        permissions: userPermissionList
-      }),
-      user
-    };
+    return Object.assign({}, tenant.get({ plain: true }), { id: tenant.uuid });
   };
 
   const closeTenant = async ({ tenantId }) => {
-    const tenant = await getTenantInfo({ id: tenantId });
+    const tenant = await getTenant({ id: tenantId });
     tenant.status = 12;
     await tenant.save();
   };
 
   const openTenant = async ({ tenantId }) => {
-    const tenant = await getTenantInfo({ id: tenantId });
+    const tenant = await getTenant({ id: tenantId });
     tenant.status = 0;
     await tenant.save();
   };
 
-  const addTenantOrg = async org => {
-    if (await fastify.account.models.tenantOrg.count({ where: { name: org.name } })) {
-      throw new Error('组织名称不能重复');
+  const saveTenant = async tenant => {
+    const currentTenant = await services.tenant.getTenantInstance({ id: tenant.id });
+    if (!currentTenant) {
+      throw new Error('租户不存在，请刷新以后重试');
     }
-
-    return await fastify.account.models.tenantOrg.create({
-      name: org.name,
-      enName: org.enName,
-      tenantId: org.tenantId,
-      pid: org.pid
-    });
+    await currentTenant.update(tenant);
   };
 
-  const saveTenantOrg = async ({ id, ...otherInfo }) => {
-    const tenantOrg = await fastify.account.models.tenantOrg.findByPk(id, {
-      where: {
-        type: 0
-      }
-    });
-
-    if (!tenantOrg) {
-      throw new Error('该组织不存在');
-    }
-    if (
-      await fastify.account.models.tenantOrg.count({
-        where: {
-          name: otherInfo.name,
-          pid: otherInfo.pid,
-          tenantId: otherInfo.tenantId
-        }
-      })
-    ) {
-      throw new Error('组织名称在同一父组织下有重复');
-    }
-
-    ['name', 'enName', 'tenantId', 'pid'].forEach(name => {
-      if (otherInfo[name]) {
-        tenantOrg[name] = otherInfo[name];
-      }
-    });
-
-    await tenantOrg.save();
-  };
-
-  const deleteTenantOrg = async ({ id, tenantId }) => {
-    const tenantOrg = await fastify.account.models.tenantOrg.findByPk(id, {
-      where: {
-        type: 0
-      }
-    });
-
-    if (!tenantOrg) {
-      throw new Error('该组织不存在');
-    }
-
-    const { rows } = await fastify.account.models.tenantOrg.findAndCountAll({
-      where: { tenantId, pid: id }
-    });
-
-    if (rows?.length) {
-      throw new Error('组织下有用户或子组织无法删除');
-    }
-
-    await tenantOrg.destroy();
-  };
-
-  const getTenantOrgList = async ({ tenantId }) => {
-    const { count, rows } = await fastify.account.models.tenantOrg.findAndCountAll({
-      where: { tenantId }
-    });
-
-    return { pageData: rows, totalCount: count };
-  };
-
-  const getTenantUserList = async ({ tenantId }) => {
-    if (!(await fastify.account.models.tenant.findByPk(tenantId))) {
-      throw new Error('租户不存在');
-    }
-    const { count, rows } = await fastify.account.models.tenantUser.findAndCountAll({
-      include: [fastify.account.models.tenantRole, fastify.account.models.tenantOrg, fastify.account.models.user],
-      where: { tenantId }
-    });
-
-    return { pageData: rows, totalCount: count };
-  };
-
-  const saveTenantUserInfoValidate = async ({ tenantId, roleIds, orgIds, userId }) => {
-    await getTenantInfo({ id: tenantId });
-    if (
-      roleIds.length > 0 &&
-      (await fastify.account.models.tenantRole.count({
-        where: {
-          id: {
-            [fastify.sequelize.Sequelize.Op.in]: roleIds
-          }
-        }
-      })) < roleIds.length
-    ) {
-      throw new Error('包含租户不存在的角色');
-    }
-    if (orgIds.length === 0) {
-      const tenantOrg = await fastify.account.models.tenantOrg.findOne({
-        where: {
-          pid: 0,
-          tenantId
-        }
-      });
-      if (!tenantOrg) {
-        throw new Error('租户根节点不存在');
-      }
-      orgIds = [tenantOrg.id];
+  const addTenant = async tenant => {
+    if (await models.tenant.count({ where: { name: tenant.name } })) {
+      throw new Error('租户名称不能重复');
     }
 
-    if (
-      (await fastify.account.models.tenantOrg.count({
-        where: {
-          tenantId,
-          id: {
-            [fastify.sequelize.Sequelize.Op.in]: orgIds
-          }
-        }
-      })) < orgIds.length
-    ) {
-      throw new Error('包含租户不存在组织');
-    }
-
-    if (!(await fastify.account.models.user.findByPk(userId))) {
-      throw new Error('用户不存在，应该先创建用户再创建租户用户');
-    }
-  };
-
-  const addTenantUser = async ({ tenantId, roleIds, orgIds, userId, ...tenantUser }) => {
-    const tenant = await getTenantInfo({ id: tenantId });
-
-    const currentAccountNumber = await fastify.account.models.tenantUser.count({
-      where: { tenantId }
-    });
-
-    if (currentAccountNumber >= tenant.accountNumber) {
-      throw new Error('租户用户数量已达上限');
-    }
-
-    await saveTenantUserInfoValidate({ tenantId, roleIds, orgIds, userId });
-
     const t = await fastify.sequelize.instance.transaction();
-
-    if (
-      (await fastify.account.models.tenantUser.count({
-        where: {
-          userId,
-          tenantId
-        }
-      })) > 0
-    ) {
-      throw new Error('该用户已经属于该租户，不能重复添加');
-    }
-
     try {
-      const currentTenantUser = await fastify.account.models.tenantUser.create(
+      const currentTenant = await models.tenant.create(tenant);
+      await models.tenantRole.create(
         {
-          name: tenantUser.name,
-          avatar: tenantUser.avatar,
-          phone: tenantUser.phone,
-          email: tenantUser.email,
-          description: tenantUser.description,
-          tenantId,
-          userId
+          name: '系统默认角色',
+          tenantId: currentTenant.uuid,
+          description: '创建租户时自动生成，可以设置权限，不可更改删除，所有租户用户默认拥有该角色',
+          type: 1
         },
         { transaction: t }
       );
-      roleIds.length > 0 &&
-        (await fastify.account.models.tenantUserRole.bulkCreate(
-          roleIds.map(roleId => {
-            return {
-              tenantRoleId: roleId,
-              tenantId,
-              tenantUserId: currentTenantUser.id
-            };
-          }),
-          { transaction: t }
-        ));
-
-      await fastify.account.models.tenantUserOrg.bulkCreate(
-        orgIds.map(orgId => {
-          return {
-            tenantOrgId: orgId,
-            tenantId,
-            tenantUserId: currentTenantUser.id
-          };
-        }),
-        { transaction: t }
-      );
-
-      await t.commit();
-    } catch (e) {
-      await t.rollback();
-      throw e;
-    }
-  };
-
-  const saveTenantUser = async ({ id, tenantId, roleIds, orgIds, userId, ...tenantUser }) => {
-    const currentTenantUser = await fastify.account.models.tenantUser.findByPk(id);
-    if (!currentTenantUser) {
-      throw new Error('租户用户不存在');
-    }
-    if (tenantId !== currentTenantUser.tenantId) {
-      throw new Error('租户Id和当前租户用户的租户Id不一致');
-    }
-    await saveTenantUserInfoValidate({ tenantId, roleIds, orgIds, userId: currentTenantUser.userId });
-
-    const tenantRoleIds = (
-      await fastify.account.models.tenantUserRole.findAll({
-        attributes: ['tenantRoleId'],
-        where: {
-          tenantId,
-          tenantUserId: currentTenantUser.id
-        }
-      })
-    ).map(({ tenantRoleId }) => tenantRoleId);
-
-    const tenantOrgIds = (
-      await fastify.account.models.tenantUserOrg.findAll({
-        attributes: ['tenantOrgId'],
-        where: {
-          tenantId,
-          tenantUserId: currentTenantUser.id
-        }
-      })
-    ).map(({ tenantOrgId }) => tenantOrgId);
-
-    const t = await fastify.sequelize.instance.transaction();
-
-    try {
-      ['name', 'avatar', 'phone', 'email', 'description'].forEach(name => {
-        if (!isNil(tenantUser[name])) {
-          currentTenantUser[name] = tenantUser[name];
-        }
-      });
-      await currentTenantUser.save({ transaction: t });
-      // 修改角色
-      const needDeleteTenantRole = tenantRoleIds.filter(targetId => roleIds.indexOf(targetId) === -1);
-      const needAddTenantRole = roleIds.filter(targetId => tenantRoleIds.indexOf(targetId) === -1);
-      await fastify.account.models.tenantUserRole.destroy({
-        where: {
-          tenantId,
-          tenantUserId: currentTenantUser.id,
-          tenantRoleId: {
-            [fastify.sequelize.Sequelize.Op.in]: needDeleteTenantRole
-          }
-        },
-        transaction: t
-      });
-      await fastify.account.models.tenantUserRole.bulkCreate(
-        needAddTenantRole.map(tenantRoleId => {
-          return { tenantId, tenantUserId: currentTenantUser.id, tenantRoleId };
-        }),
-        { transaction: t }
-      );
-      //修改组织
-      const needDeleteTenantOrg = tenantOrgIds.filter(targetId => orgIds.indexOf(targetId) === -1);
-      const needAddTenantOrg = orgIds.filter(targetId => tenantOrgIds.indexOf(targetId) === -1);
-      await fastify.account.models.tenantUserOrg.destroy({
-        where: {
-          tenantId,
-          tenantUserId: currentTenantUser.id,
-          tenantOrgId: {
-            [fastify.sequelize.Sequelize.Op.in]: needDeleteTenantOrg
-          }
+      await models.tenantOrg.create(
+        {
+          name: '根组织',
+          tenantId: currentTenant.uuid
         },
-        transaction: t
-      });
-      await fastify.account.models.tenantUserOrg.bulkCreate(
-        needAddTenantOrg.map(tenantOrgId => {
-          return { tenantId, tenantUserId: currentTenantUser.id, tenantOrgId };
-        }),
         { transaction: t }
       );
       await t.commit();
@@ -599,135 +76,57 @@ module.exports = fp(async (fastify, options) => {
     }
   };
 
-  const deleteTenantUser = async ({ tenantId, tenantUserId }) => {
-    await getTenantInfo({ id: tenantId });
-    const tenantUser = await fastify.account.models.tenantUser.findByPk(tenantUserId);
-    if (!tenantUser) {
-      throw new Error('租户用户不存在');
-    }
-
-    const t = await fastify.sequelize.instance.transaction();
-
-    try {
-      await fastify.account.models.tenantUserOrg.destroy({
-        where: {
-          tenantId,
-          tenantUserId: tenantUser.id
-        },
-        transaction: t
-      });
-      await fastify.account.models.tenantUserRole.destroy({
-        where: {
-          tenantId,
-          tenantUserId: tenantUser.id
-        },
-        transaction: t
-      });
-      await tenantUser.destroy({ transaction: t });
-      await t.commit();
-    } catch (e) {
-      await t.rollback();
-      throw e;
+  const getAllTenantList = async ({ filter, perPage, currentPage }) => {
+    const queryFilter = {};
+    if (filter?.name) {
+      queryFilter.name = {
+        [fastify.sequelize.Sequelize.Op.like]: `%${filter.name}%`
+      };
     }
-  };
 
-  const closeTenantUser = async ({ tenantId, tenantUserId }) => {
-    await getTenantInfo({ id: tenantId });
-    const tenantUser = await fastify.account.models.tenantUser.findByPk(tenantUserId);
-    if (!tenantUser) {
-      throw new Error('租户用户不存在');
+    if (filter?.serviceStartTime) {
+      queryFilter.serviceStartTime = {
+        [fastify.sequelize.Sequelize.Op.gt]: filter.serviceStartTime
+      };
     }
-    tenantUser.status = 12;
-
-    await tenantUser.save();
-  };
 
-  const openTenantUser = async ({ tenantId, tenantUserId }) => {
-    await getTenantInfo({ id: tenantId });
-    const tenantUser = await fastify.account.models.tenantUser.findByPk(tenantUserId);
-    if (!tenantUser) {
-      throw new Error('租户用户不存在');
+    if (filter?.serviceEndTime) {
+      queryFilter.serviceEndTime = {
+        [fastify.sequelize.Sequelize.Op.lt]: filter.serviceEndTime
+      };
     }
-    tenantUser.status = 0;
-
-    await tenantUser.save();
-  };
 
-  const getInviteList = async ({ tenantId, filter, currentPage, perPage }) => {
-    const queryFilter = {};
-    const { count, rows } = await fastify.account.models.tenantToken.findAndCountAll({
-      where: Object.assign({}, queryFilter, { tenantId, type: 10 }),
+    const { count, rows } = await models.tenant.findAndCountAll({
+      where: queryFilter,
       offset: currentPage * (currentPage - 1),
       limit: perPage
     });
-    return { pageData: rows, totalCount: count };
-  };
-
-  const generateTenantToken = async ({ type, tenantId, info, tenantUserId }) => {
-    await getTenantInfo({ id: tenantId });
-    const token = fastify.jwt.sign({ tenantId });
-    return await fastify.account.models.tenantToken.create({
-      token,
-      tenantId,
-      info,
-      tenantUserId,
-      type
-    });
-  };
 
-  const decodeTenantToken = async ({ type, tenantId, token }) => {
-    if (
-      (await fastify.account.models.tenantToken.count({
-        where: {
-          type,
-          tenantId,
-          token
+    /*const res = await 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)
         }
-      })) === 0
-    ) {
-      throw new Error('token已过期');
-    }
-
-    return fastify.jwt.decode(token);
-  };
-
-  const addInviteToken = async ({ info, tenantId, tenantUserId }) => {
-    return await generateTenantToken({ info, tenantId, tenantUserId, type: 10 });
-  };
-
-  const deleteInviteToken = async ({ id }) => {
-    const token = await fastify.account.models.tenantToken.findByPk(id);
-    if (!token) {
-      throw new Error('数据不存在');
-    }
+      },
+      group: 'tenantId'
+    });*/
 
-    await token.destroy();
+    return {
+      pageData: rows.map(item => {
+        return Object.assign({}, item.get({ pain: true }), { id: item.uuid });
+      }),
+      totalCount: count
+    };
   };
 
-  fastify.account.services.tenant = {
-    getUserTenant,
+  services.tenant = {
+    getTenantInstance,
+    getTenant,
     closeTenant,
     openTenant,
-    tenantUserAuthenticate,
-    getTenantInfo,
-    getRoleList,
-    addRole,
-    saveRole,
-    removeRole,
-    addTenantOrg,
-    deleteTenantOrg,
-    saveTenantOrg,
-    getTenantOrgList,
-    getTenantUserList,
-    addTenantUser,
-    saveTenantUser,
-    deleteTenantUser,
-    closeTenantUser,
-    openTenantUser,
-    getInviteList,
-    generateTenantToken,
-    decodeTenantToken,
-    addInviteToken,
-    deleteInviteToken
+    saveTenant,
+    addTenant,
+    getAllTenantList
   };
 });