OperationalService/api/app/lib/controllers/organization/index.js

'use strict';
const moment = require('moment')

async function allDeps (ctx) {
   try {
      const models = ctx.fs.dc.models;
      const { redis } = ctx.app

      let depRes = await redis.get('allDepartments')
      if (depRes) {
         depRes = JSON.parse(depRes)
         depRes = depRes.departments
      }

      ctx.status = 200;
      ctx.body = depRes || []
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {

      }
   }
}

async function editUser (ctx) {
   try {
      const models = ctx.fs.dc.models;
      const { pepUserId, role = [], correlationProject = [] } = ctx.request.body

      const existUserRes = await models.User.findOne({
         where: {
            pepUserId
         }
      })
      if (existUserRes && !existUserRes.deleted && !pepUserId) {
         // 新增已存在未删除
         throw '人员账号已添加'
      }

      let storageData = {
         pepUserId,
         role,
         correlationProject,
         updateTime: moment().format()
      }
      if (existUserRes) {
         // 存在且传递id 或者 不传id也存在
         // 修改 update
         storageData.deleted = false
         storageData.role = role
         if (
            storageData.role.includes('admin')
         ) {
            storageData.disabled = true
         }
         await models.User.update(storageData, {
            where: {
               pepUserId
            }
         })
      } else {
         // 新增
         await models.User.create(storageData)
      }

      ctx.status = 200
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {

      }
   }
}

async function putUser (ctx) {
   try {
      const models = ctx.fs.dc.models;
      const { pomsUserId } = ctx.params
      const { disabled = undefined, deleted = undefined } = ctx.request.body
      const existUserRes = await models.User.findOne({
         where: {
            id: pomsUserId
         }
      })

      if (existUserRes && existUserRes.role.includes('admin') && disabled) {
         throw '成员不能既是管理员又是普通成员'
      }

      const updateData = {
         disabled,
         deleted,
      }
      for (let k in updateData) {
         if (updateData[k] == undefined) {
            delete updateData[k]
         }
      }

      await models.User.update(updateData, {
         where: {
            id: pomsUserId
         }
      })
      ctx.status = 204
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {
         message: typeof error == 'string' ? error : undefined
      }
   }
}

async function delAdmin (ctx) {
   try {
      const models = ctx.fs.dc.models;
      const { pomsUserId } = ctx.params

      const existUserRes = await models.User.findOne({
         where: {
            id: pomsUserId
         }
      })
      if (existUserRes) {
         let updateValues = existUserRes.dataValues
         let adminIndex = updateValues.role.findIndex(r => r == 'admin')
         if (adminIndex > -1) {
            updateValues.role.splice(adminIndex, 1)
         }
         await models.User.update(updateValues, {
            where: {
               id: pomsUserId
            }
         })
      }

      ctx.status = 204;
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: error`);
      ctx.status = 400;
      ctx.body = {
         message: typeof error == 'string' ? error : undefined
      }
   }
}

async function user (ctx) {
   try {
      const models = ctx.fs.dc.models;
      const { clickHouse } = ctx.app.fs
      const { role, limit, page, } = ctx.query

      const excludeField = ['lastInTime', 'inTimes', 'onlineDuration', 'lastInAddress', 'deleted', 'updateTime']

      let findOption = {
         attributes: {
            exclude: excludeField,
         },
         where: {
            deleted: false,
            $not: {
               role: { $contained: ['SuperAdmin', 'admin'] }
            }
         },
         order: [['updateTime', 'DESC']]
      }
      if (role) {
         findOption.where.role = { $contains: [role] }
      }
      if (limit) {
         findOption.limit = limit
      }
      if (page && limit) {
         findOption.offset = page * limit
      }

      const userRes = await models.User.findAndCountAll(findOption)

      const adminRes = await models.User.findAll({
         where: {
            role: { $contains: ['admin'] }
         },
         attributes: {
            exclude: excludeField,
         },
         order: [['updateTime', 'DESC']]
      })

      let userIds = new Set()
      for (let u of userRes.rows.concat(adminRes)) {
         userIds.add(u.pepUserId)
      }
      let userPepRes = userIds.size ?
         await clickHouse.pepEmis.query(`SELECT DISTINCT user.id AS id, "user"."name" AS name, department.name AS depName, department.id AS depId FROM department_user LEFT JOIN user ON department_user.user=user.id LEFT JOIN department ON department.id=department_user.department WHERE user.id IN (${[...userIds].join(',')}) AND department.delete=false`).toPromise() :
         []

      for (let u of userRes.rows.concat(adminRes)) {
         const corUsers = userPepRes.filter(up => up.id == u.pepUserId)
         u.dataValues.name = corUsers[0].name
         u.dataValues.departments = corUsers.map(cu => {
            return {
               name: cu.depName,
               id: cu.depId
            }
         })
      }

      ctx.status = 200
      ctx.body = {
         admin: adminRes,
         users: userRes
      }
   } catch (error) {
      ctx.fs.logger.error(`path: ${ctx.path}, error: ${error}`);
      ctx.status = 400;
      ctx.body = {

      }
   }
}

module.exports = {
   allDeps,
   editUser,
   putUser,
   delAdmin,
   user,
};