info_admin/app/service/sysDeptService.js

'use strict';

const Service = require('../service/baseService');

class SysDeptService extends Service {
  tag() {
    return this.ctx.model.SysDeptModel;
  }

  async addDeptAndPerson(data) {
    const { ctx, service } = this;
    const listByCode = await service.sysDeptService.list({ code: data.code });
    if (listByCode.length > 0) {
      return '地区编码已存在';
    }
    const order = await service.sysDeptService.getMaxOrder();
    data.order = order;
    if (data.fid == '0') {
      data.level = '1';
    } else {
      const dept = await service.sysDeptService.one(data.fid);
      data.level = (parseInt(dept.level) + 1) + '';
    }
    const result = await ctx.model.SysDeptModel.create(data);
    const arr = await this.findDept(result._id, data.fid);
    const dept1 = arr[0];
    const dept2 = arr[1];
    const dept3 = arr[2];
    const dept4 = arr[3];
    const dept5 = arr[4];
    const userData = { type: 'admin', deptId: result._id,
      dept1, dept2, dept3, dept4, dept5 };

    await ctx.service.sysUserService.batchAdd(userData);
    return null;
  }

  async updateDeptAndPerson(id, data) {
    const { ctx, service } = this;
    const { model } = ctx;
    const dept = await this.one(id);
    const code = dept ? dept.code : data.code;
    delete data.fid;
    const listByCode = await service.sysDeptService.list({ code: data.code });
    if (listByCode.length > 0 && listByCode[0]._id != id && listByCode[0].code == data.code) {
      return '地区编码已存在';
    }
    await model.SysDeptModel.updateOne({ _id: id }, data);
    if (code != data.code) {
      const codes = await model.SysDeptModel.find({ code: { $regex: '^' + code } });
      for (const c of codes) {
        const replaceName = c.code.replace(code, data.code);
        await model.SysDeptModel.updateOne(
          { _id: c._id },
          { code: replaceName });
      }

      const users = await model.SysUserModel.find({ loginName: { $regex: '^' + code } });
      for (const user of users) {
        const replaceName = user.loginName.replace(code, data.code);
        await model.SysUserModel.updateOne(
          { _id: user._id },
          { loginName: replaceName });
      }
    }
    return null;
  }

  async orderChange(id, type) {
    const { model } = this.ctx;
    const dept = await model.SysDeptModel.findById(id);
    let where = {};
    let sort = {};
    if (type === 'down') {
      where = { order: { $gte: dept.order }, fid: dept.fid };
      sort = { order: 1 };
    }

    if (type === 'up') {
      where = { order: { $lte: dept.order }, fid: dept.fid };
      sort = { order: -1 };
    }

    const result = await model.SysDeptModel.find(where)
      .sort(sort)
      .skip(0)
      .limit(2);
    if (result.length === 2) {
      await model.SysDeptModel.updateOne({ _id: result[0]._id }, { order: result[1].order });
      await model.SysDeptModel.updateOne({ _id: result[1]._id }, { order: result[0].order });
      return null;
    }
    return '更新排序异常';

  }

  async getMaxOrder() {
    const { model } = this.ctx;
    const result = await model.SysDeptModel.find()
      .sort({ order: -1 })
      .skip(0)
      .limit(1);
    let max_order = 0;
    if (result.length > 0 && result[0].order) {
      max_order = result[0].order;
    }
    max_order = max_order + 1;
    return max_order;
  }

  async deleteWithSub(id) {
    const { model } = this.ctx;
    const dbDeptArr = await model.SysDeptModel.find({ fid: id });
    if (dbDeptArr.length > 0) {
      return '删除失败,该地区存在下级地区';
    }
    const dbUserArr = await model.SysUserModel.find({ dept: id });
    if (dbUserArr.length > 0) {
      return '删除失败,该地区下存在人员';
    }
    await model.SysDeptModel.deleteOne({ _id: id });
    return null;
  }

  async listForPageSortWithUser(data) {
    const deptId = data.deptId;
    const roleId = data.roleId;
    const fid = data.fid;
    delete data.deptId;
    delete data.roleId;
    delete data.level;

    // type 代表前端是否需要显示添加按钮 true需要 false 不需要
    let type = true;
    if (fid === '0') {
      if (roleId == this.app.config.defaultUserRoleId) { //  采集员
        data.fid = '-1';
        type = false;
      } else if (roleId == this.app.config.defaultManagerRoleId) { // 地区管理员
        delete data.fid;
        data._id = deptId;
        type = false;
      }
    }
    const result = await super.listForPage(data);
    result.type = type;
    return result;
  }

  async findDept(id, fid) {
    const arr = [ id ];
    while (fid != '0') { // 最多3次 比如是最底层的5级，那么知道5.4，只需要找3次
      const result = await this.one(fid);
      arr.unshift(fid);
      fid = result.fid;
    }
    return arr;
  }

  async findDeptDetail(dept, fid) {
    const arr = [ dept ];
    while (fid != '0') { // 最多3次 比如是最底层的5级，那么知道5.4，只需要找3次
      const result = await this.one(fid);
      arr.unshift(result);
      fid = result.fid;
    }
    return arr;
  }

  async findLink() {
    const result = await this.list({ name: { $regex: this.ctx.query.name } });
    const arr = [];
    for (let i = 0; i < result.length; i++) {
      const deptArr = await this.findDeptDetail(result[i], result[i].fid);
      arr.push(deptArr);
    }
    return arr;
  }
}

module.exports = SysDeptService;