@kne/fastify-account 1.0.0-alpha.1 → 1.0.0-alpha.10

package/libs/services/account.js

@@ -1,6 +1,7 @@
 const fp = require('fastify-plugin');
 const dayjs = require('dayjs');
 const bcrypt = require('bcryptjs');
+const crypto = require('crypto');
 
 function generateRandom6DigitNumber() {
   const randomNumber = Math.random() * 1000000;
@@ -12,9 +13,10 @@ function userNameIsEmail(username) {
 }
 
 module.exports = fp(async (fastify, options) => {
+  const { models, services } = fastify.account;
   const login = async ({ username, password, ip }) => {
     const isEmail = userNameIsEmail(username);
-    const user = await fastify.account.models.user.findOne({
+    const user = await models.user.findOne({
       where: Object.assign(
         {},
         isEmail
@@ -38,16 +40,23 @@ module.exports = fp(async (fastify, options) => {
 
     await passwordAuthentication({ accountId: user.userAccountId, password });
 
-    await fastify.account.models.loginLog.create({
-      userId: user.id,
+    await models.loginLog.create({
+      userId: user.uuid,
       ip
     });
 
-    return fastify.jwt.sign({ payload: { id: user.id } });
+    return {
+      token: fastify.jwt.sign({ payload: { id: user.uuid } }),
+      user: Object.assign({}, user.get({ plain: true }), { id: user.uuid })
+    };
   };
 
   const passwordAuthentication = async ({ accountId, password }) => {
-    const userAccount = await fastify.account.models.userAccount.findByPk(accountId);
+    const userAccount = await models.userAccount.findOne({
+      where: {
+        uuid: accountId
+      }
+    });
     if (!userAccount) {
       throw new Error('账号不存在');
     }
@@ -68,23 +77,31 @@ module.exports = fp(async (fastify, options) => {
     };
   };
 
+  const md5 = value => {
+    const hash = crypto.createHash('md5');
+    hash.update(value);
+    return hash.digest('hex');
+  };
+
   const resetPassword = async ({ userId, password }) => {
-    const userInfo = await fastify.account.models.user.findByPk(userId);
+    const userInfo = await models.user.findOne({
+      where: { uuid: userId }
+    });
     if (!userInfo) {
       throw new Error('用户不存在');
     }
-    const account = await fastify.account.models.userAccount.create(
+    const account = await models.userAccount.create(
       Object.assign({}, await passwordEncryption(password), {
         belongToUserId: userId
       })
     );
 
-    await userInfo.update({ userAccountId: account.id });
+    await userInfo.update({ userAccountId: account.uuid });
   };
 
   const register = async ({ avatar, nickname, gender, birthday, description, phone, email, code, password, status, invitationCode }) => {
     const type = phone ? 0 : 1;
-    const verificationCode = await fastify.account.models.verificationCode.findOne({
+    const verificationCode = await models.verificationCode.findOne({
       where: {
         name: type === 0 ? phone : email,
         type,
@@ -99,7 +116,7 @@ module.exports = fp(async (fastify, options) => {
     verificationCode.status = 2;
     await verificationCode.save();
 
-    return await fastify.account.services.user.addUser({
+    return await services.user.addUser({
       avatar,
       nickname,
       gender,
@@ -117,7 +134,7 @@ module.exports = fp(async (fastify, options) => {
 
     // 这里写发送逻辑
 
-    await fastify.account.models.verificationCode.update(
+    await models.verificationCode.update(
       {
         status: 2
       },
@@ -130,7 +147,7 @@ module.exports = fp(async (fastify, options) => {
       }
     );
 
-    await fastify.account.models.verificationCode.create({
+    await models.verificationCode.create({
       name: email,
       type: 1,
       code
@@ -140,7 +157,7 @@ module.exports = fp(async (fastify, options) => {
   };
 
   const verificationCodeValidate = async ({ name, type, code }) => {
-    const verificationCode = await fastify.account.models.verificationCode.findOne({
+    const verificationCode = await models.verificationCode.findOne({
       where: {
         name,
         type,
@@ -165,7 +182,7 @@ module.exports = fp(async (fastify, options) => {
 
     // 这里写发送逻辑
 
-    await fastify.account.models.verificationCode.update(
+    await models.verificationCode.update(
       {
         status: 2
       },
@@ -178,7 +195,7 @@ module.exports = fp(async (fastify, options) => {
       }
     );
 
-    await fastify.account.models.verificationCode.create({
+    await models.verificationCode.create({
       name: phone,
       type: 0,
       code
@@ -187,7 +204,8 @@ module.exports = fp(async (fastify, options) => {
     return code;
   };
 
-  fastify.account.services.account = {
+  services.account = {
+    md5,
     login,
     register,
     sendEmailCode,

package/libs/services/admin.js

@@ -6,31 +6,30 @@ const ROLE = {
 };
 
 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.getUserInfo(targetUser);
     if (
-      (await fastify.account.models.adminRole.count({
+      (await models.adminRole.count({
         where: {
           userId: user.id,
           role: ROLE['SuperAdmin']
@@ -54,130 +53,27 @@ 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
-        }
-      ]
-    });
-    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
-      };
-    }
-
-    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)
-        }
-      },
-      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);
-  };
-
   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,
+    checkIsSuperAdmin,
     generateTenantAdminVerifyCode,
     verifyTenantAdmin,
-    resetUserPassword,
-    addUser
+    addUser,
+    resetUserPassword
   };
 });

package/libs/services/application.js

@@ -0,0 +1,151 @@
+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 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 }) => {
+    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)
+      };
+    }
+    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,
+    saveApplication,
+    deleteApplication,
+    getApplicationList,
+    getApplicationListByIds
+  };
+});