service-center/app/service/apply.js

'use strict';


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

class ApplyService extends CrudService {
  constructor(ctx) {
    super(ctx, 'apply');
    this.model = this.ctx.model.Apply;
    this.tmodel = this.ctx.model.Teacher;
    this.submodel = this.ctx.model.Subject;
    this.trainmodel = this.ctx.model.Trainplan;
    this.dayList = [ '日', '一', '二', '三', '四', '五', '六' ];
  }

  // 查询
  async queryteacher(query) {
    const { termid, subid, date } = query;
    const data = await this.model
      .find({ termid, subid, date })
      .sort({ msscore: -1 });
    const teachers = [];
    for (const _data of data) {
      const teacherid = _data.teacherid;
      const teacher = await this.tmodel.findById(teacherid);
      teachers.push(teacher);
    }
    return teachers;
  }

  // 教师计划初步课表安排,可反复使用
  async arrangeteacher({ planid }) {
    const trainplan = await this.trainmodel.findById(planid);
    if (!trainplan) {
      throw new BusinessError(ErrorCode.DATA_EXISTED, '年度计划不存在');
    }
    // trainplan = JSON.parse(JSON.stringify(trainplan));
    // 查找所有教师列表
    let teacherList = await this.tmodel.find({ xsscore: { $exists: true } });
    teacherList = JSON.parse(JSON.stringify(teacherList));
    // 查找所有教师上报列表
    let teaplanList = await this.model.find();
    teaplanList = JSON.parse(JSON.stringify(teaplanList));
    // 课程
    let subjectList = await this.submodel.find();
    subjectList = JSON.parse(JSON.stringify(subjectList));
    const termList = _.cloneDeep(trainplan);
    let { termnum } = termList;
    if (!termnum) return;
    termnum = JSON.parse(JSON.stringify(termnum));
    // 整理出课表
    const arr = this.setLessonList(termnum);
    // 安排后的课表
    const afterList = [];
    // 排课
    for (const l of arr) {
      const { termid, subid, day: date, teaid, status, batchid } = l;
      if (status && `${status}` === '1') {
        afterList.push(l);
        continue;
      }
      const subject = subjectList.find(f => ObjectId(subid).equals(f._id));
      if (subject.need_teacher !== '0') {
        afterList.push(l);
        continue;
      }

      // 申请该天,该科目的教师,并查出教师的名字,分数;并按分数排序
      let applyList = teaplanList.filter(
        f => f.date === date && f.subid === subid
      );
      // console.log(applyList.length);
      applyList = applyList.map(i => {
        let obj = { ...JSON.parse(JSON.stringify(i)) };
        const r = teacherList.find(f => i.teacherid === f._id);
        if (r) {
          const { name: teaname, xsscore: score } = r;
          i.teaname = teaname;
          i.score = score * 1;
          obj = { ...obj, teaname, score };
        }
        return obj;
      });
      // 过滤出没有分数的,不排
      applyList = applyList.filter(f => f.score);
      // 按成绩排序
      applyList = _.orderBy(applyList, [ 'score' ], [ 'desc' ]);
      // 本期超过2次的教师列表,如果没有人就用这里分最高的排
      const outTwoTimesList = [];
      // 依次循环申请的教师列表,往这个课程安排中放教师
      for (const atea of applyList) {
        // 先查询,该教师,是否在今天有安排
        const tr = afterList.find(
          f => f.teaid === atea.teacherid && f.day === atea.date
        );
        if (tr) continue;
        // 查看这期内,每个申请上课的教师时候超过2天(2条记录),如果超过,则不排,但是如果最后没有人了,就得硬排了
        const r = afterList.filter(
          f => f.termid === termid && f.teaid === atea.teacherid
        );
        if (r.length >= 2) {
          outTwoTimesList.push(atea);
          continue;
        } else {
          l.teaid = atea.teacherid;
          l.teaname = atea.teaname;
          break;
        }
      }
      // 检查,该天,该科的课是否有教师
      const has_teaid = _.has(l, 'teaid');
      if (!has_teaid) {
        // 如果没有教师,就需要在outTowTimesList列表中找分最高的教师
        // const head = _.head();
        // if (head) {
        //   l.teaid = head.teacherid;
        //   l.teaname = head.teaname;
        // }
        const list = _.orderBy(outTwoTimesList, [ 'score' ], [ 'desc' ]);
        for (const i of list) {
          const tr = afterList.find(
            f => f.teaid === i.teacherid && f.day === i.date
          );
          if (tr) continue;
          else {
            l.teaid = i.teacherid;
            l.teaname = i.teaname;
          }
        }
      }
      afterList.push(l);
    }
    // 将afterList还原回正常的termnum;
    const newTermnum = this.returnTermnum(afterList, termnum);
    // 保存至计划
    trainplan.termnum = newTermnum;
    await trainplan.save();
  }

  /**
   * 拍平了的课表=>termnum
   * @param {Array} list 拍平了的课表,详情参考页面的初步课表的数据
   * @param {Array} termnum 原termnum
   */
  returnTermnum(list, termnum) {
    let newTermnum = [];
    for (const l of list) {
      const { termid, batchid, classid, ...info } = l;
      const updata = _.pick(info, [
        'day',
        'subid',
        'subname',
        'teaid',
        'teaname',
        'time',
        'status',
      ]);
      newTermnum = termnum.map(t => {
        // 找到期
        if (termid === t._id) {
          t.batchnum = t.batchnum.map(b => {
            if (batchid === b._id) {
              // 找到批次
              b.class = b.class.map(c => {
                if (classid === c._id) {
                  if (c.lessons) {
                    // 说明有课程安排,找有没有重复的,没有就推进去,有就更改,subid查
                    const r = c.lessons.find(f => f.subid === updata.subid);
                    if (r) {
                      const rindex = c.lessons.findIndex(
                        f => f.subid === updata.subid
                      );
                      c.lessons[rindex] = updata;
                    } else {
                      c.lessons.push(updata);
                    }
                  } else {
                    // 说明没有课程安排,放进去一条保存
                    c.lessons = [ updata ];
                  }
                }
                return c;
              });
            }
            return b;
          });
        }
        return t;
      });
    }
    return newTermnum;
  }

  /**
   * 将课表拍平了,从多维=>一维
   * @param {Array} termnum 计划的termnum
   */
  setLessonList(termnum) {
    const arr = [];
    for (const t of termnum) {
      const { batchnum, term, _id: termid } = t;
      // 班级和课程一一匹
      for (const b of batchnum) {
        const { class: classes, lessons, _id: batchid } = b;
        const claslesList = this.setList(
          term,
          termid,
          batchid,
          classes,
          lessons
        );
        arr.push(...claslesList);
      }
    }
    return arr;
  }
  /**
   * 将课表模板和班级整理成一维数组
   * @param {String} term 期数
   * @param {String} termid 期id
   * @param {String} batchid 批id
   * @param {Array} classes 班级列表
   * @param {Array} lessonTemplate 课表模板
   */
  setList(term, termid, batchid, classes, lessonTemplate) {
    const arr = [];
    // 班级和课程匹配
    for (const cla of classes) {
      let { lessons } = cla;
      if (!lessons) lessons = lessonTemplate;
      for (const i of lessons) {
        let nobj = {};
        nobj.term = term;
        nobj.termid = termid;
        nobj.batchid = batchid;
        const obj = _.omit(cla, [ 'lessons' ]);
        nobj.classid = _.clone(cla._id);
        nobj = _.assign(nobj, obj);
        nobj = _.assign(nobj, i);
        arr.push(nobj);
      }
    }
    return arr;
  }

  async arrangeSendMsg({ planid, ids }) {
    const trainplan = await this.trainmodel.findById(planid);
    if (!trainplan) {
      throw new BusinessError(ErrorCode.DATA_EXISTED, '年度计划不存在');
    }
    const plan = _.cloneDeep(trainplan);
    let { termnum } = plan;
    if (!termnum) return;
    termnum = JSON.parse(JSON.stringify(termnum));
    // 整理出课表
    let arr = this.setLessonList(termnum);
    // 过滤出需要发送的教师
    arr = arr.filter(f => ids.find(id => f.termid === id) && f.teaid);
    // && f.status !== '1'
    // 整理出要发送的教师列表
    let teaids = arr.map(i => i.teaid);
    teaids = _.uniq(teaids);
    // 找到教师信息
    let teaList = await this.tmodel.find({ _id: teaids });
    if (teaList) teaList = JSON.parse(JSON.stringify(teaList));
    // 发送,此处是根据安排,给教师发.还有一种方案是根据教师,整理安排一起发送
    for (const l of arr) {
      // 教师id,期数,班级名,上课的日期,课程名
      const { teaid, term, name, day, subname } = l;
      const tea = teaList.find(f => f._id === teaid);
      // 文案
      const msg = `${_.get(tea, 'name', '')}老师您好:
      吉林省高等学校毕业生就业指导中心-双困生培训系统提醒您:
      ${term}期-${name.includes('班') ? name : `${name}班`}
      ${day}(星期${this.dayList[moment(day).days()]})
      有您的课程安排:${subname}`;
      // 邮箱与微信都发送
      const { openid, email } = tea;
      if (email) {
        this.toSendEmail('402788946@qq.com', msg, tea.name);
      }
      if (openid) this.toSendWxMsg('ocPqjswkUejZHq2ANriNrFFC7A3I', msg, tea.name);
    }
  }
  /**
   * 计划-教师初步课表发送邮件
   * @param {String} email 邮件
   * @param {String} content 内容
   * @param {String} teaname 教师姓名
   */
  async toSendEmail(email, content, teaname) {
    if (!email) {
      console.error(`计划教师发送通知:${teaname}没有email`);
      return;
    }
    const subject = '吉林省高等学校毕业生就业指导中心通知(测试)'; //
    this.ctx.service.util.sendMail(email, subject, content);
  }
  /**
   * 计划-教师初步课表发送微信推送
   * @param {String} openid 微信公众号的openid
   * @param {String} content 内容
   * @param {String} teaname 教师姓名
   */
  async toSendWxMsg(openid, content, teaname) {
    if (!openid) {
      console.error(`计划教师发送微信推送:${teaname}没有openid`);
      return;
    }
    // TODO or notTODO 发送微信推送记录
    // const tourl = this.ctx.app.config.baseUrl + '/msgconfirm/?userid=' + teacherUser.uid + '&noticeid=' + nresid;
    await this.ctx.service.weixin.sendTemplateDesign(
      this.ctx.app.config.REVIEW_TEMPLATE_ID,
      openid,
      // '您有一个新的通知',
      '测试信息推送',
      '您有新的安排',
      content,
      '感谢您的使用'
      // tourl
    );
  }
}

module.exports = ApplyService;