@gingkoo/base-server 0.0.1-alpha.0 → 0.0.1-alpha.10

package/backend/routers/team/routers/roles.js

@@ -0,0 +1,92 @@
+'use strict';
+const express = require('express');
+const { parseQueryParams } = require('../../../utils/page-query-helper/index');
+const rolesService = require('../services/roles');
+const router = express.Router();
+
+// 查询角色
+router.get('/', async function (req, res) {
+  let queryParams = parseQueryParams(req.query, ['ORG_ID'], true, 50);
+  let searchParam = {};
+  for (let v in req.query) {
+    if (v !== 'page' && v !== 'size') {
+      searchParam[v] = req.query[v];
+    }
+  }
+
+  const results = await rolesService.getRolesLists(queryParams.pageInfo, searchParam);
+  if (!results) {
+    return res.sendErr('');
+  }
+  return res.sendOk(results);
+});
+
+// 新增角色
+router.post('/', async function (req, res) {
+  const { ROLE_ID = '', ROLE_NAME = '' } = req.body;
+  if (ROLE_ID.length == 0) return res.sendErr('角色ID不能为空');
+  if (ROLE_NAME.length == 0) return res.sendErr('角色名称不能为空');
+  let data = await rolesService.isExistRoleId(ROLE_ID);
+  if (data.error) {
+    return res.sendErr(data.error);
+  }
+  if (data.results.length) return res.sendErr('角色ID已存在');
+
+  let result = await rolesService.addRoles(req.body);
+  if (result.error) {
+    return res.sendErr(result.error);
+  }
+
+  return res.sendOk('');
+});
+
+// 修改角色
+router.put('/:ROLEID', async function (req, res) {
+  const { ROLE_ID = '', ROLE_NAME = '' } = req.body;
+  if (ROLE_ID.length == 0) return res.sendErr('角色ID不能为空');
+  if (ROLE_NAME.length == 0) return res.sendErr('角色名称不能为空');
+  let data = await rolesService.isExistRoleId(ROLE_ID);
+  if (data.error) {
+    return res.sendErr(data.error);
+  }
+  if (data.results.length == 0) return res.sendErr('角色ID不存在');
+  let result = await rolesService.modifyRoles(req.body);
+  if (result.error) {
+    return res.sendErr(result.error);
+  }
+
+  return res.sendOk();
+});
+//删除角色
+router.delete('/:ROLEID', async function (req, res) {
+  const { ROLEID } = req.params;
+  if (ROLEID.length == 0) return res.sendErr('id不能为空');
+  let data = await rolesService.delRoles(ROLEID);
+  if (data.error) {
+    return res.sendErr(data.error);
+  }
+
+  return res.sendOk();
+});
+
+module.exports = router;
+
+function dateFormat(fmt, date) {
+  date = new Date(date);
+  let ret;
+  const opt = {
+    'Y+': date.getFullYear().toString(), // 年
+    'm+': (date.getMonth() + 1).toString(), // 月
+    'd+': date.getDate().toString(), // 日
+    'H+': date.getHours().toString(), // 时
+    'M+': date.getMinutes().toString(), // 分
+    'S+': date.getSeconds().toString(), // 秒
+  };
+  for (let k in opt) {
+    ret = new RegExp('(' + k + ')').exec(fmt);
+    if (ret) {
+      fmt = fmt.replace(ret[1], ret[1].length == 1 ? opt[k] : opt[k].padStart(ret[1].length, '0'));
+    }
+  }
+  return fmt;
+}

package/backend/routers/team/routers/teaminfo.js

@@ -0,0 +1,27 @@
+'use strict';
+const express = require('express');
+const router = express.Router();
+const teaminfoService = require('../services/teaminfo');
+// 查询团队信息
+router.get('/', async function (req, res) {
+  const { error, results } = await teaminfoService.getTeamInfoList();
+  if (error) {
+    return res.sendErr(results.error);
+  }
+  if (results.length > 0) {
+    return res.sendOk(results[0]);
+  } else {
+    return res.sendOk({});
+  }
+});
+
+router.put('/', async function (req, res) {
+  let param = req.body;
+  const { error, results } = teaminfoService.modifyTeamInfo(param);
+  if (error) {
+    return res.sendErr(error);
+  }
+  return res.sendOk('');
+});
+
+module.exports = router;

package/backend/routers/team/routers/usergroup.js

@@ -0,0 +1,213 @@
+'use strict';
+const express = require('express');
+const router = express.Router();
+const { parseQueryParams } = require('../../../utils/page-query-helper/index');
+const userService = require('../../../common/services/user');
+const userGroupService = require('../services/usergroup');
+const memberService = require('../services/member');
+
+/**
+ * @api  {post}  /team/usergroup/api/group  新增成员组
+ * @apiDescription 新增成员组
+ * @apiVersion 1.0.0
+ *      type         部门id(DEPT_ID)
+ *      inputId      用户组id(GROUP_ID)
+ *      name         用户组名称(GROUP_NAME)
+ * */
+router.post('/api/group', async function (req, res) {
+  const { pid, inputId, name } = req.body;
+  if (!pid || !inputId || !name) return res.sendErr('参数错误');
+  var reg = /^[a-zA-Z_-]([a-zA-Z0-9_-]+)?$/;
+  if (!reg.test(inputId)) return res.sendErr('节点id只支持以英文字字母或下划线开头的组合!');
+  let groupUser = await userGroupService.getGroupUsers({
+    GROUP_ID: inputId,
+  });
+  if (groupUser.error) return res.sendErr('操作失败');
+  if (groupUser.results.length > 0) return res.sendErr('部门id重复');
+  let idmDept = await memberService.isExistMemberId({ DEPT_NO: inputId });
+  if (idmDept.error) return res.sendErr('数据库操作失败');
+  if (idmDept.results.length > 0) return res.sendErr('部门id重复');
+
+  let result = await userGroupService.addUserGroup({
+    GROUP_ID: inputId,
+    DEPT_ID: pid,
+    GROUP_NAME: name,
+  });
+  if (result.error) return res.sendErr('操作失败');
+  return res.sendOk();
+});
+
+router.delete('/api/group', async function (req, res) {
+  const { id } = req.body;
+  if (!id) return res.sendErr('参数失败');
+  let result = await userGroupService.deleteGroup({
+    GROUP_ID: id,
+  });
+  if (!result) return res.sendErr('操作失败');
+
+  let groupUser = await userGroupService.delGroupUser({
+    GROUP_ID: id,
+  });
+  if (!groupUser) return res.sendErr('删除失败');
+  return res.sendOk();
+});
+
+router.put('/api/group', async function (req, res) {
+  const { id, name } = req.body;
+  if (!id || !name) return res.sendErr('参数错误');
+  let result = await userGroupService.modifyGroup({ GROUP_NAME: name }, { GROUP_ID: id });
+  if (!result) return res.sendErr('操作失败');
+
+  return res.sendOk();
+});
+
+/***
+ *  @api   {get}/team/usergroup
+ *  @apiDescription 查询用户组成员
+ *  @apiVersion  1.0.0
+ *           GROUP_ID  用户组id(GROUP_ID)
+ * */
+router.get('/', async function (req, res) {
+  const { params, pageInfo } = parseQueryParams(req.query, ['ORG_ID'], true, 50);
+  const { GROUP_ID } = params;
+  if (!GROUP_ID) return res.sendErr('参数错误');
+  let isHasLeader = params.LEADER;
+  delete params.LEADER;
+  let result = await userGroupService.getGroupUserList(params, pageInfo);
+  if (!result) return res.sendErr('操作失败');
+  let GroupUser = await userGroupService.getGroupUsers({ GROUP_ID });
+  if (GroupUser.error) return res.sendErr('查询失败');
+  if (GroupUser.results.length > 0) {
+    const [teaminfo] = GroupUser.results;
+    const { GROUP_LEADER } = teaminfo;
+    result.content = result.content.map((v) => {
+      if (v.USER_ID == GROUP_LEADER) {
+        return {
+          ...v,
+          LEADER: '负责人',
+        };
+      } else {
+        return {
+          ...v,
+          LEADER: '',
+        };
+      }
+    });
+  }
+  if (isHasLeader) {
+    let reuslts = [];
+    result.content.map((user) => {
+      if (user.LEADER == '负责人') {
+        if (user.USER_NAME.indexOf(isHasLeader) > -1) {
+          reuslts.push(user);
+        }
+      }
+    });
+    result.content = reuslts;
+  }
+  return res.sendOk(result);
+});
+
+/***
+ * @api   {post}  /team/usergroup
+ * @apiDescription 新增用户组成员
+ * @apiVersion  1.0.0
+ *            GROUP_ID 用户组id(GROUP_ID)
+ *            USER_ID  用户的userid
+ * */
+router.post('/', async function (req, res) {
+  let userid = req.get('X-UserId');
+  const { GROUP_ID, USER_ID } = req.body;
+  if (!GROUP_ID || !USER_ID) return res.sendErr('参数错误');
+  let users = USER_ID.split(',');
+  users = users.map((v) => {
+    if (v == 'currentUser') {
+      return userid;
+    } else {
+      return v;
+    }
+  });
+  let userGroup = await userGroupService.getGroupUser(GROUP_ID, users);
+  if (!userGroup) return res.sendErr('数据库操作失败！');
+  if (userGroup.length > 0) {
+    for (let i = 0; i < userGroup.length; i++) {
+      const { USER_ID } = userGroup[i];
+      let curUser = await userService.getUserInfo(USER_ID);
+      if (Object.keys(curUser).length > 0) {
+        const { USER_NAME } = curUser;
+        return res.sendErr(USER_NAME + '已存在');
+      }
+    }
+  }
+
+  for (let i = 0; i < users.length; i++) {
+    let result = await userGroupService.addGroupUser({
+      GROUP_ID,
+      USER_ID: users[i],
+    });
+    if (!result) return res.sendErr('添加失败');
+  }
+  return res.sendOk();
+});
+
+/**
+ * @api  {delete} /team/usergroup
+ * @apiDescription  批量删除用户组成员
+ * @apiVersion  1.0.0
+ *           GROUP_ID 用户组id(GROUP_ID)
+ *           ids      用户的userid(USER_ID)
+ * */
+router.delete('/', async function (req, res) {
+  const { GROUP_ID, ids } = req.body;
+  if (!GROUP_ID || !ids) return res.sendErr('参数错误');
+  let users = ids.split(',');
+  for (let i = 0; i < users.length; i++) {
+    let result = await userGroupService.delGroupUser({
+      GROUP_ID,
+      USER_ID: users[i],
+    });
+    if (!result) return res.sendErr('操作失败');
+  }
+  return res.sendOk();
+});
+
+/**
+ * @api  {put} /team/usergroup
+ * @apiDescription  修改用户组成员
+ * @apiVersion  1.0.0
+ *           GROUP_ID 用户组id(GROUP_ID)
+ *           ids      用户的userid(USER_ID)
+ * */
+router.put('/', async function (req, res) {
+  const { GROUP_ID, REMARKS, USER_ID, USER_ROLE } = req.body;
+  if (!GROUP_ID || !USER_ID) return res.sendErr('参数错误');
+  let result = await userGroupService.modifyGroupUser(req.body);
+  if (!result) return res.sendErr('操作失败');
+  return res.sendOk();
+});
+
+/**
+ * @api  {post} /team/api/usergroup/leader
+ * @apiDescription  新增负责人
+ * @apiVersion  1.0.0
+ *           ids      用户的userid(USER_ID)
+ *           GROUP_ID  组的id
+ * */
+router.post('/api/usergroup/leader', async function (req, res) {
+  const { ids, GROUP_ID } = req.body;
+  if (!ids) return res.sendErr('请选择负责人');
+  let users = ids.split(',');
+  if (users.length > 1) return res.sendErr('负责人只能选中一个');
+  let result = await userGroupService.modifyGroup(
+    {
+      GROUP_LEADER: users[0],
+    },
+    {
+      GROUP_ID: GROUP_ID,
+    },
+  );
+  if (!result) return res.sendErr('操作失败');
+  return res.sendOk();
+});
+
+module.exports = router;

package/backend/routers/team/services/mapping.js

@@ -0,0 +1,101 @@
+'use strict';
+const isPlainObject = require('lodash/isPlainObject');
+const dictService = require('../../../common/services/dict');
+const userService = require('../../../common/services/user');
+const deptService = require('../../../common/services/dept');
+// 字典表需要的组
+const DICT_GROUPS = [
+  'REPOS_TYPE', // 文档库类型
+  'ROULE_TYPE',
+  'ROULE_ID',
+  'IDM_EDUCATION', //学校类型
+  'IDM_USER_POSITION', //职位
+  'IDM_USER_STATUS', //是否在在职
+  'IDM_USER_TYPE', //员工类型
+  'IDM_USER_GENDER', //性别
+  'ORGAN_TYPE',
+];
+
+// 和项目无关的
+const NOT_RELATED = [
+  'USER_LIST', // 所有用户
+  'DEPT_LIST', //部门
+];
+const mappingService = {
+  DICT_GROUPS,
+  NOT_RELATED,
+  /**
+   * @param {string[]} list
+   */
+  async getMapping(list = []) {
+    if (!Array.isArray(list)) return null;
+    let relatedList = NOT_RELATED.slice();
+    // 分类
+    let dictGroups = []; // 字典表内
+    let related = []; // 非字典表
+    if (!list.length) {
+      dictGroups = DICT_GROUPS.slice();
+      related = relatedList;
+    } else {
+      list.forEach((v) => {
+        if (~DICT_GROUPS.indexOf(v)) {
+          dictGroups.push(v);
+        } else if (~relatedList.indexOf(v)) {
+          related.push(v);
+        }
+      });
+    }
+
+    let data = {};
+
+    // 先搂字典表
+    if (Array.isArray(dictGroups) && dictGroups.length) {
+      let dicts = await dictService.getDicts(dictGroups);
+      if (isPlainObject(dicts)) {
+        Object.entries(dicts).forEach((dict) => {
+          let [key, value] = dict;
+          if (Array.isArray(value) && value.length) {
+            data[key] = value.reduce((mo, item) => {
+              let { value, ...rest } = item;
+              mo[value] = rest;
+              return mo;
+            }, {});
+          }
+        });
+      }
+    }
+
+    let servicesMap = {
+      USER_LIST: userService.getUsers(),
+      DEPT_LIST: deptService.getDepts(),
+    };
+
+    // 再拿项目相关表的数据
+    if (Array.isArray(related) && related.length) {
+      related = related.filter((it) => it in servicesMap);
+      let res = await Promise.all(related.map((it) => servicesMap[it]));
+      related.forEach((it, index) => {
+        if (it === 'USER_LIST' && res[index]) {
+          data[it] = res[index].reduce((mo, item) => {
+            if (item.USER_ID) {
+              mo[item.USER_ID] = item.USER_NAME;
+            }
+            return mo;
+          }, {});
+        }
+        if (it === 'DEPT_LIST' && res[index]) {
+          data[it] = res[index].reduce((mo, item) => {
+            if (item.DEPT_NO) {
+              mo[item.DEPT_NO] = item.DEPT_NAME;
+            }
+            return mo;
+          }, {});
+        }
+      });
+    }
+
+    return data;
+  },
+};
+
+module.exports = mappingService;

package/backend/routers/team/services/member.js

@@ -0,0 +1,206 @@
+'use strict';
+const {
+  sqlExecutor,
+  insertSqlBuilder,
+  updateSqlBuilder,
+  deleteSqlBuilder,
+  queryBaseSqlBuilder,
+} = require('@gingkoo/node-tools');
+const entity = require('../../../common/entity');
+const { idmLevelType } = require('../../../common/enum');
+
+const memberService = {
+  async isExitMember(userid) {
+    const { sql, params } = await queryBaseSqlBuilder(entity.IDM_USERS, { USER_ID: userid });
+    let result = await sqlExecutor(sql, params);
+    return result;
+  },
+
+  async delMember(userid) {
+    let body = {
+      STATUS: '01',
+    };
+    const { sql, params } = await updateSqlBuilder(entity.IDM_USERS, body, { USER_ID: userid });
+    let result = await sqlExecutor(sql, params);
+    return result;
+  },
+  /***
+   * 修改用户/部门
+   * */
+  async modifyGroupDepts(idm, value, type) {
+    let databaseName =
+      type == idmLevelType.IDM_LENVEL_TYPE.GROUP ? entity.IDM_GROUPS : entity.IDM_DEPTS;
+    let mdoifyFieldName = type == idmLevelType.IDM_LENVEL_TYPE.GROUP ? 'GROUP_NAME' : 'DEPT_NAME';
+    let queryCrity = type == idmLevelType.IDM_LENVEL_TYPE.GROUP ? 'GROUP_ID' : 'DEPT_NO';
+    const { sql, params } = await updateSqlBuilder(
+      databaseName,
+      {
+        [mdoifyFieldName]: value,
+      },
+      { [queryCrity]: idm },
+    );
+
+    let results = await sqlExecutor(sql, params);
+    return results;
+  },
+
+  /***
+   * 查询部门下的子部门
+   * */
+  async getIdmDeptChildDept(parentId) {
+    let sql = `SELECT ORG_ID,DEPT_NO,DEPT_PARENT FROM idm_depts WHERE DEPT_PARENT LIKE '${parentId}/%' AND ORG_ID =?`;
+    let result = await sqlExecutor(sql, [global.orgid]);
+    if (result.error) {
+      return null;
+    }
+    return result.results;
+  },
+
+  /***
+   * 删除部门
+   * */
+  async delGroupDepts(filter) {
+    let filters = filter || {};
+    filter.ORG_ID = global.orgid;
+    const { sql, params } = await deleteSqlBuilder(entity.IDM_DEPTS, filters);
+    const result = await sqlExecutor(sql, params);
+    if (result.error) return null;
+    return result;
+  },
+
+  /**
+   *  判断部门的id是否存在
+   *  filter{}
+   */
+
+  async isExistMemberId(filter) {
+    let filters = filter || {};
+    filters.ORG_ID = global.orgid;
+    const { sql, params } = await queryBaseSqlBuilder(entity.IDM_DEPTS, filter);
+    const result = await sqlExecutor(sql, params);
+    return result;
+  },
+
+  /**
+   * 查询当前部门下的PARENTid
+   *
+   * */
+  async getIdmDeptParentId(parentId) {
+    let sql = '';
+    if (parentId == global.orgid) {
+      sql = `SELECT DEPT_PARENT FROM ${entity.IDM_DEPTS} WHERE ORG_ID=? AND char_length(DEPT_PARENT) = (char_length(replace(DEPT_PARENT,'/','')) + 1) `;
+    } else {
+      sql = `SELECT DEPT_PARENT FROM ${
+        entity.IDM_DEPTS
+      } WHERE DEPT_PARENT like '${parentId}%' AND char_length(DEPT_PARENT)>${
+        parentId.length
+      } AND char_length(DEPT_PARENT)<=${parentId.length + 2} AND ORG_ID =?`;
+    }
+
+    let result = await sqlExecutor(sql, [global.orgid]);
+    if (result.error) {
+      return null;
+    }
+    return result.results;
+  },
+
+  /**
+   * 新增 用户/部门
+   * */
+  async addGroupDepts(filter) {
+    let filters = filter || {};
+    filters.ORG_ID = global.orgid;
+    const { sql, params } = await insertSqlBuilder(entity.IDM_DEPTS, filters);
+    let result = await sqlExecutor(sql, params);
+    return result;
+  },
+
+  /**
+   * 删除部门
+   * */
+  async deleteDept(filter = {}) {
+    filter.ORG_ID = global.orgid;
+    const { sql, params } = await deleteSqlBuilder(entity.IDM_DEPTS, filter);
+    const result = await sqlExecutor(sql, params);
+    return result;
+  },
+  /**
+   * 删除部门
+   * */
+  async deleteGroupDept(filter = {}) {
+    filter.ORG_ID = global.orgid;
+    const { sql, params } = await deleteSqlBuilder(entity.IDM_GROUPS, filter);
+    const result = await sqlExecutor(sql, params);
+    return result;
+  },
+
+  /**
+   * 查询部门信息
+   * */
+  async getIdmGroup(filter = {}) {
+    filter.ORG_ID = global.orgid;
+    const { sql, params } = await queryBaseSqlBuilder(entity.IDM_GROUPS, filter);
+    let result = await sqlExecutor(sql, params);
+    return result;
+  },
+
+  /**
+   * 删除成员组成员
+   *  筛选条件  filter{}
+   * */
+  async deleteGrouopMember(filter = {}) {
+    filter.ORG_ID = global.orgid;
+    const { sql, params } = await deleteSqlBuilder(entity.IDM_GROUP_MEMBERS, filter);
+    const result = await sqlExecutor(sql, params);
+    return result;
+  },
+
+  /****
+   * 查询组成员是否存在
+   * @param USER_ID  用户id
+   * @param GROUP_ID     部门
+   * */
+  async isExistGroupMember(USER_ID, GROUP_ID) {
+    const { sql, params } = await queryBaseSqlBuilder(entity.IDM_GROUP_MEMBERS, {
+      ORG_ID: global.orgid,
+      USER_ID,
+      GROUP_ID,
+    });
+    const result = await sqlExecutor(sql, params);
+    if (result.error) {
+      return null;
+    }
+    return result.results;
+  },
+
+  /* *
+   * 查询部门表
+   * */
+  async getIdmDepts(filter) {
+    let filters = filter || {};
+    filters.ORG_ID = global.orgid;
+    const { sql, params } = await queryBaseSqlBuilder(entity.IDM_DEPTS, filters);
+    const result = await sqlExecutor(sql, params);
+    if (result.error) {
+      return null;
+    }
+    if (result.results.length > 0) {
+      return result.results[0];
+    }
+    return {};
+  },
+
+  /***
+   * 修改部门信息
+   * */
+  async updateIdmDept(body, filter) {
+    let filters = filter || {};
+    filter.ORG_ID = global.orgid;
+    const { sql, params } = await updateSqlBuilder(entity.IDM_DEPTS, body, filters);
+    let result = await sqlExecutor(sql, params);
+    if (result.error) return null;
+    return result;
+  },
+};
+
+module.exports = memberService;

package/backend/routers/team/services/roles.js

@@ -0,0 +1,71 @@
+'use strict';
+const {
+  sqlExecutor,
+  pageQuery,
+  insertSqlBuilder,
+  updateSqlBuilder,
+  deleteSqlBuilder,
+  queryBaseSqlBuilder,
+  queryParamsBuilder,
+} = require('@gingkoo/node-tools');
+const entity = require('../../../common/entity');
+
+const rolesService = {
+  async getRolesLists(pageInfo, searchParam) {
+    let pageSize = pageInfo.pageSize;
+    let pageIndex = pageInfo.pageIndex;
+    let parmas = [global.orgid];
+    let sql = `select * from ${entity.IDM_ROLES} where ORG_ID =? and ROLE_TYPE='MANAGER'`;
+    if (Object.keys(searchParam).length > 0) {
+      let pops = {};
+      for (let v in searchParam) {
+        pops[v] = 'like';
+      }
+      const result = await queryParamsBuilder(searchParam, null, null, pops);
+      sql += ' and ' + result.sql;
+    }
+    let result = await pageQuery(sql, parmas, pageSize, pageIndex);
+    return result;
+  },
+  isExistRoleId: async function (id) {
+    const { sql, params } = await queryBaseSqlBuilder(entity.IDM_ROLES, { ROLE_ID: id });
+    let data = await sqlExecutor(sql, params);
+    return data;
+  },
+
+  async addRoles(param) {
+    let body = {
+      ORG_ID: global.orgid,
+      ROLE_ID: param.ROLE_ID || '',
+      ROLE_NAME: param.ROLE_NAME || '',
+      ROLE_TYPE: 'MANAGER',
+      DEPT_NOS: param.DEPT_NOS || '',
+      REMARKS: param.REMARKS || '',
+    };
+    const { sql, params } = await insertSqlBuilder(entity.IDM_ROLES, body);
+    let result = await sqlExecutor(sql, params);
+    return result;
+  },
+
+  async delRoles(id) {
+    const { sql, params } = await deleteSqlBuilder(entity.IDM_ROLES, { ROLE_ID: id });
+    let data = await sqlExecutor(sql, params);
+    return data;
+  },
+
+  async modifyRoles(param) {
+    let body = {
+      ROLE_NAME: param.ROLE_NAME || '',
+      ROLE_TYPE: 'MANAGER',
+      DEPT_NOS: param.DEPT_NOS || '',
+      REMARKS: param.REMARKS || '',
+    };
+    const { sql, params } = await updateSqlBuilder(entity.IDM_ROLES, body, {
+      ROLE_ID: param.ROLE_ID,
+    });
+    let result = await sqlExecutor(sql, params);
+    return result;
+  },
+};
+
+module.exports = rolesService;