service-center/app/service/teaplan.js

'use strict';


const assert = require('assert');
const _ = require('lodash');
const { ObjectId } = require('mongoose').Types;
const { CrudService } = require('naf-framework-mongoose/lib/service');
const { BusinessError, ErrorCode } = require('naf-core').Error;
const moment = require('moment');

class TeaplanService extends CrudService {
  constructor(ctx) {
    super(ctx, 'teaplan');
    this.model = this.ctx.model.Teaplan;
    this.hmodel = this.ctx.model.Headteacher;
    this.tmodel = this.ctx.model.Trainplan;
    this.cmodel = this.ctx.model.Class;
    this.dmodel = this.ctx.model.Department;
  }

  // 查询所有班主任带是否能带班标记
  async findteacher({ planid, termid, batchid }) {
    // 查询所有班主任信息
    const headteachers = await this.hmodel.find();
    // 根据批次id取得当前批次具体信息
    const trainplan = await this.tmodel.findById(planid);
    if (!trainplan) {
      throw new BusinessError(ErrorCode.DATA_NOT_EXIST, '全年计划信息不存在');
    }
    const term = await trainplan.termnum.id(termid);
    if (!term) {
      throw new BusinessError(ErrorCode.DATA_NOT_EXIST, '全年计划内期信息不存在');
    }
    const batch = await term.batchnum.id(batchid);
    if (!batch) {
      throw new BusinessError(ErrorCode.DATA_NOT_EXIST, '全年计划内批次信息不存在');
    }
    const newheadteachers = [];
    // 遍历班主任信息
    for (const headteacher of headteachers) {
      // 查询某班主任对应的班主任全年计划表
      const teaplan = await this.model.findOne({ headteacherid: headteacher.id });
      if (teaplan) {
        // 取得所有不能排班的日期列表
        const nodates = teaplan.nodate;
        const iswork = await this.teacheriswork(nodates, batch.startdate, batch.enddate);
        if (iswork) {
          newheadteachers.push(headteacher);
        } else {
          newheadteachers.push({ ...JSON.parse(JSON.stringify(headteacher)), disabled: true });
        }
      } else {
        newheadteachers.push(headteacher);
      }
    }
    return newheadteachers;
  }

  // 判断当前日期是否在两个日期之间
  async betweendate(curdate, startdate, enddate) {
    // 比较开始日期，如果小于0 为不在此区间
    // 比较结束日期 如果大于0 为不在此区间
    const sres = moment(curdate).diff(moment(startdate), 'days');
    const eres = moment(curdate).diff(moment(enddate), 'days');
    let result = true;
    if (sres < 0 || eres > 0) {
      result = false;
    }
    return result;
  }

  // 判断班主任不能带班日期是否在批次日期里
  async teacheriswork(nodates, startdate, enddate) {
    let result = true;
    for (const nodate of nodates) {
      const res = await this.betweendate(nodate, startdate, enddate);
      if (res) {
        result = false;
        break;
      }
    }
    return result;
  }

  async divide({ trainplanid }) {
    const data = [];
    // 根据全年计划表id查出对应的全年计划详细信息
    const trainplan = await this.tmodel.findById(trainplanid);
    // 将全年计划中的批次信息取出放在一个数组中
    const batchList = [];
    for (const term of trainplan.termnum) {
      for (const batch of term.batchnum) {
        batchList.push(batch);
      }
    }
    // 查询本培训计划中班主任全年计划表的全部信息
    const teaplanList = await this.model.find({ trainplanid });
    // 查询所有班主任信息
    const headteacherList = await this.hmodel.find();
    for (const teaplan of teaplanList) {
      // 过滤出班主任信息表中id为此班主任全年计划信息班主任id的数据
      const headteacherInfo = _.filter(headteacherList, item => item.id === teaplan.headteacherid);
      // 如果班主任信息列表中班主任上报了班主任全年计划，将其移除
      if (headteacherInfo.length >= 1) {
        _.remove(headteacherList, item => item.id === teaplan.headteacherid);
        teaplan.department = headteacherInfo[0].department;
      }
    }
    // 遍历班主任信息，将班主任的id放在headteacherid字段中
    for (const headteacher of headteacherList) {
      headteacher.headteacherid = headteacher.id;
    }
    const teaList = _.concat(teaplanList, headteacherList);
    let noteaList = [];
    // 遍历所有批次信息
    for (const batch of batchList) {
      let _teaList = [];
      for (const teaplan of teaList) {
        if (teaplan.nodate && (teaplan.nodate).length > 0) {
          // 遍历班主任全年计划表中的不能上课的日期
          for (const nodate of teaplan.nodate) {
          // 如果不能上课的日期在该批次的开始时间和结束时间中，将该班主任从班主任列表中删除
            if (moment(nodate).isBetween(batch.startdate, batch.enddate, null, '[]')) {
              noteaList.push(teaplan);
            }
          }
        }
        // 过滤出已分配的数据中该班主任的数据
        const teaInfo = _.filter(data, item => item.headteacherid === teaplan.headteacherid);
        // 计算出每个班主任担任过班主任的次数
        teaplan.teacount = await this.cmodel.count({ headteacherid: teaplan.headteacherid }) + teaInfo.length;
        // 如果已分配的数据中该班主任的数据长度大于0
        if (teaInfo.length > 0) {
          // 遍历已分配的数据中该班主任的数据
          for (const _teaInfo of teaInfo) {
            // 查询该班主任已分配的数据中的班级信息
            const _class = await this.cmodel.findById(_teaInfo.classid);
            // 根据班级的批次id查出该班级的开始时间和结束时间
            const batchInfo = _.filter(batchList, item => item.id === _class.batchid);
            // 如果该班级的开始时间和结束时间于当前遍历批次的开始时间和结束时间有重合部分，将该班主任加入不能上课的班主任数组中
            if (await this.isrepeat(batchInfo.startdate, batchInfo.enddate, batch.startdate, batch.enddate)) {
              noteaList.push(teaplan);
            }
          }
        }
        // 将数组去重
        noteaList = _.uniqWith(noteaList, _.isEqual);
        // 将班主任全年计划表过滤，去除在不能上课的班主任数组中已存在的数据
        _teaList = _.difference(teaList, noteaList);
        // 将不能上课的班主任数组清空
        noteaList = [];
        const departmentList = await this.departmentcount(_teaList);
        for (const department of departmentList) {
        // 如果部门中人员的数量减去能部门中上课的班主任数量小于一，那么将能上课的班主任数组中部门为该部门的班主任移除一个
          if ((department.dcount - department.dnum) < 1) {
            let _noteaList = _.filter(_teaList, item => item.deparment === department.deparmentid);
            _noteaList = _.orderBy(_noteaList, [ 'teacount' ], [ 'desc' ]);
            _teaList = _.difference(_teaList, _noteaList[0]);
          }
        }
        // 将该批次最终筛选出的能上课的班主任数组按每个班主任担任过班主任的次数倒序排序
        _teaList = _.orderBy(_teaList, [ 'teacount' ], [ 'asc' ]);

      }
      // 查出该批次下所有的班级
      const classList = await this.cmodel.find({ batchid: batch.id });
      // 循环该批次下所有的班级
      let index = 0;
      for (const _class of classList) {
        if (_teaList.length > 0 && _teaList[index]) {
          data.push({ classid: _class.id, headteacherid: _teaList[index].headteacherid, teacount: _teaList[index].teacount });
        } else {
          data.push({ classid: _class.id, headteacherid: undefined });
        }
        index = index + 1;
      }
    }
    return data;
  }

  async adivide({ trainplanid }) {
    const data = [];
    // 根据全年计划表id查出对应的全年计划详细信息
    const trainplan = await this.tmodel.findById(trainplanid);
    // 将全年计划中的批次信息取出放在一个数组中
    const batchList = [];
    for (const term of trainplan.termnum) {
      for (const batch of term.batchnum) {
        batchList.push(batch);
      }
    }
    // 查询本培训计划中班主任全年计划表的全部信息
    const teaplanList = await this.model.find({ trainplanid });
    // 查询所有班主任信息
    const headteacherList = await this.hmodel.find();
    let noteaList = [];
    // 遍历所有批次信息
    for (const _batch of batchList) {
      // 遍历班主任全年计划表
      for (const teaplan of teaplanList) {
        if ((teaplan.nodate).length > 0) {
          // 遍历班主任全年计划表中的不能上课的日期
          for (const nodate of teaplan.nodate) {
          // 如果不能上课的日期在该批次的开始时间和结束时间中，将该班主任加入不能上课的班主任数组中
            if (moment(nodate).isBetween(_batch.startdate, _batch.enddate, null, '[]')) {
              noteaList.push(teaplan);
            }
          }
        }
        const headteacherInfo = _.filter(headteacherList, item => item.id === teaplan.headteacherid);
        // 如果班主任信息列表中班主任上报了班主任全年计划，将其移除
        if (headteacherInfo.length >= 1) {
          _.remove(headteacherList, item => item.id === teaplan.headteacherid);
        }
        // 过滤出已分配的数据中该班主任的数据
        const teaInfo = _.filter(data, item => item.headteacherid === teaplan.headteacherid);
        // 计算出每个班主任担任过班主任的次数
        teaplan.teacount = await this.cmodel.count({ headteacherid: teaplan.headteacherid }) + teaInfo.length;
        // 如果已分配的数据中该班主任的数据长度大于0
        if (teaInfo.length > 0) {
          // 遍历已分配的数据中该班主任的数据
          for (const _teaInfo of teaInfo) {
            // 查询该班主任已分配的数据中的班级信息
            const _class = await this.cmodel.findById(_teaInfo.classid);
            // 根据班级的批次id查出该班级的开始时间和结束时间
            const batchInfo = _.filter(batchList, item => item.id === _class.batchid);
            // 如果该班级的开始时间和结束时间于当前遍历批次的开始时间和结束时间有重合部分，将该班主任加入不能上课的班主任数组中
            if (await this.isrepeat(batchInfo.startdate, batchInfo.enddate, _batch.startdate, _batch.enddate)) {
              noteaList.push(teaplan);
            }
          }
        }
      }
      for (const headteacher of headteacherList) {
        headteacher.headteacherid = headteacher.id;
        // 过滤出已分配的数据中该班主任的数据
        const teaInfo = _.filter(data, item => item.headteacherid === headteacher.headteacherid);
        // 计算出每个班主任担任过班主任的次数
        headteacher.teacount = await this.cmodel.count({ headteacherid: headteacher.id }) + teaInfo.length;
        // 如果已分配的数据中该班主任的数据长度大于0
        if (teaInfo.length > 0) {
          // 遍历已分配的数据中该班主任的数据
          for (const _teaInfo of teaInfo) {
            // 查询该班主任已分配的数据中的班级信息
            const _class = await this.cmodel.findById(_teaInfo.classid);
            // 根据班级的批次id查出该班级的开始时间和结束时间
            const batchInfo = _.filter(batchList, item => item.id === _class.batchid);
            // 如果该班级的开始时间和结束时间于当前遍历批次的开始时间和结束时间有重合部分，将该班主任加入不能上课的班主任数组中
            if (await this.isrepeat(batchInfo.startdate, batchInfo.enddate, _batch.startdate, _batch.enddate)) {
              _.remove(headteacherList, item => item.id === headteacher.id);
            }
          }
        }
      }
      // 将数组去重
      noteaList = _.uniqWith(noteaList, _.isEqual);
      // 将班主任全年计划表过滤，去除在不能上课的班主任数组中已存在的数据
      let teaList = _.difference(teaplanList, noteaList);
      teaList = _.concat(teaList, headteacherList);
      // 将不能上课的班主任数组清空
      noteaList = [];
      const departmentList = await this.departmentcount(teaList);
      for (const department of departmentList) {
        // 如果部门中人员的数量减去能部门中上课的班主任数量小于一，那么将能上课的班主任数组中部门为该部门的班主任移除一个
        if ((department.dcount - department.dnum) < 1) {
          let _noteaList = _.filter(teaList, item => item.deparmentid === department.deparmentid);
          _noteaList = _.orderBy(_noteaList, [ 'teacount' ], [ 'desc' ]);
          teaList = _.difference(teaList, _noteaList[0]);
        }
      }
      // 将该批次最终筛选出的能上课的班主任数组按每个班主任担任过班主任的次数倒序排序
      teaList = _.orderBy(teaList, [ 'teacount' ], [ 'asc' ]);
      console.log(teaList);

      // 查出该批次下所有的班级
      const classList = await this.cmodel.find({ batchid: _batch.id });
      // 循环该批次下所有的班级
      let index = 0;
      for (const _class of classList) {
        if (teaList[index]) {
          data.push({ classid: _class.id, headteacherid: teaList[index].headteacherid });
        } else {
          data.push({ classid: _class.id, headteacherid: undefined });
        }
        index = index + 1;
      }
    }
    return data;
  }

  // 判断两个时间段是否有重合部分
  async isrepeat(startdate1, enddate1, startdate2, enddate2) {
    let result = true;
    if (moment(enddate1).isSameOrBefore(startdate2)) {
      result = false;
    }
    if (moment(startdate1).isSameOrAfter(enddate2)) {
      result = false;
    }
    return result;
  }

  // 查询传递的班主任列表中每个部门的人数以及每个部门的总人数
  // teaList 传递的教师列表  dnum 传递的教师列表中各部门的人数  dcount 各部门的总人数
  async departmentcount(teaList) {
    let departmentList = [];
    for (const teaplan of teaList) {
      departmentList.push({ deparmentid: teaplan.department });
    }
    // 将数组去重
    departmentList = _.uniqWith(departmentList, _.isEqual);
    for (const department of departmentList) {
      // 计算出能该批次能上课的班主任中各部门有多少人
      const dnum = _.filter(teaList, item => item.department === department.deparmentid).length;
      department.dnum = dnum;
      // 计算出各部门有多少人
      const dcount = await this.hmodel.count({ department: department.deparmentid });
      department.dcount = dcount;
    }
    return departmentList;
  }
}

module.exports = TeaplanService;