service-center/app/service/student.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 StudentService extends CrudService {
  constructor(ctx) {
    super(ctx, 'student');
    this.model = this.ctx.model.Student;
    this.umodel = this.ctx.model.User;
    this.tmodel = this.ctx.model.Trainplan;
    this.clamodel = this.ctx.model.Class;
    this.upmodel = this.ctx.model.Uploadtask;
    this.gmodel = this.ctx.model.Group;
    this.psmodel = this.ctx.model.Personalscore;
    this.gsmodel = this.ctx.model.Groupscore;
    this.uqmodel = this.ctx.model.Uploadquestion;
    this.scoremodel = this.ctx.model.Score;
    this.leavemodel = this.ctx.model.Leave;
    this.attendmodel = this.ctx.model.Attendance;
    const { baseUrl } = _.get(this.ctx.app.config, 'mission');
    if (baseUrl) this.missionBase = baseUrl;
  }

  async create(data) {
    const { name, phone: mobile, gender } = data;
    const res = await this.model.create(data);
    if (res) {
      const obj = {
        name,
        mobile,
        gender,
        type: '4',
        passwd: '12345678',
        uid: res._id,
      };
      const user = await this.ctx.service.user.create(obj);
    }
    return res;
  }

  async delete({ id }) {
    // 删除小组中的这个人,作业表,问卷表,评分,考勤,用户表,学生表
    await this.gmodel.update(
      { 'students.stuid': id },
      { $pull: { students: { stuid: id } } }
    );
    await this.upmodel.deleteMany({ studentid: id });
    await this.uqmodel.deleteMany({ studentid: id });
    await this.scoremodel.deleteMany({ stuid: id });
    await this.attendmodel.deleteMany({ studentid: id });
    await this.umodel.deleteOne({ uid: id });
    await this.model.deleteOne({ _id: ObjectId(id) });
  }
  async update({ id }, data) {
    const student = await this.model.findByIdAndUpdate(id, data);
    if (student) {
      const { phone, name } = data;
      if (phone && name) {
        await this.umodel.findOneAndUpdate(
          { uid: id },
          { mobile: phone, name }
        );
      }
    }
    return student;
  }

  // 查询
  async query({ name, ...info } = {}, { skip = 0, limit = 0 } = {}) {
    const query = { ...info };
    if (name) {
      query.name = { $regex: name };
    }
    let data = await this.model
      .find(query)
      .populate([
        {
          path: 'classid',
          model: 'Class',
          select: 'name',
        },
      ])
      .skip(parseInt(skip))
      .limit(parseInt(limit));
    const planids = _.uniq(data.map(i => ObjectId(i.planid)));
    const plan = await this.ctx.model.Trainplan.find({ _id: planids });
    data = JSON.parse(JSON.stringify(data));
    data = data.map(i => {
      if (i.classid && _.isObject(i.classid)) {
        i.classname = _.get(i.classid, 'name');
        i.classid = _.get(i.classid, '_id');
      }
      const p = plan.find(f => ObjectId(f._id).equals(i.planid));
      if (p) {
        const { termnum } = p;
        const tr = termnum.id(i.termid);
        if (tr) {
          i.termname = _.get(tr, 'term');
          const br = tr.batchnum.id(i.batchid);
          if (br) {
            i.batchname = _.get(br, 'batch');
          }
        }
      }
      return i;
    });
    return data;
  }

  async count({ name, ...info } = {}) {
    const query = { ...info };
    if (name) {
      query.name = { $regex: name };
    }
    return await this.model.count(query);
  }

  // 查询
  async seek({ termid, type, batchid, skip, limit }) {
    const total = await this.model.count({
      termid,
      type,
      batchid,
      $or: [{ classid: null }, { classid: '' }],
    });
    const data = await this.model
      .find({
        termid,
        type,
        batchid,
        $or: [{ classid: null }, { classid: '' }],
      })
      .skip(Number(skip))
      .limit(Number(limit));
    const result = { total, data };
    return result;
  }

  async findbedroom(data) {
    const { batchid, classid } = data;
    const result = [];
    // 如果传的是批次id
    if (batchid) {
      // 查询该批次下的所有学生
      const students = await this.model.find({ batchid });
      const bedroomList = new Set();
      // 查询该批次的所有寝室号
      for (const student of students) {
        bedroomList.add(student.bedroom);
      }
      let studentList = [];
      // 查询该批次所有寝室下的学生名单
      for (const bedroom of bedroomList) {
        const newstudents = await this.model.find({ bedroom });
        for (const newstudent of newstudents) {
          studentList.push(newstudent.name);
        }
        result.push({ bedroom, studentList });
        studentList = [];
      }
    }
    // 如果传的是班级id
    if (classid) {
      // 查询该班级所有学生
      const students = await this.model.find({ classid });
      const bedroomList = new Set();
      // 查询该班级所有寝室号
      for (const student of students) {
        bedroomList.add(student.bedroom);
      }
      let studentList = [];
      // 查询该班级所有寝室的学生名单
      for (const bedroom of bedroomList) {
        const newstudents = await this.model.find({ bedroom });
        for (const newstudent of newstudents) {
          // 如果寝室中有非本班级学生（混寝），则过滤掉不予显示
          if (newstudent.classid === classid) {
            studentList.push(newstudent.name);
          }
        }
        result.push({ bedroom, studentList });
        studentList = [];
      }
    }
    return result;
  }

  async upjob(data) {
    const { stuid, job } = data;
    const student = await this.model.findById(stuid);
    student.job = job;
    if (job === '班长' || job === '学委') {
      const user = await this.umodel.findOne({ uid: stuid, type: '4' });
      const date = await this.ctx.service.util.updatedate();
      const openid = user.openid;
      const detail = '你已被班主任设置为' + job + ',请及时登录查看';
      const remark = '感谢您的使用';
      if (openid) {
        this.ctx.service.weixin.sendTemplateMsg(
          this.ctx.app.config.REVIEW_TEMPLATE_ID,
          openid,
          '您有一个新的通知',
          detail,
          date,
          remark
        );
      }
    }
    return await student.save();
  }

  // 根据学生id删除班级
  async deleteclass(data) {
    for (const el of data) {
      const student = await this.model.findById(el);
      if (student) {
        student.classid = '';
        await student.save();
      }
    }
  }

  // 根据班级id查出班级各个学生的分数
  async findscore({ skip, limit, ...info }) {
    const { classid } = info;
    const total = await this.model.count(info);
    const students = await this.model
      .find(info)
      .skip(Number(skip))
      .limit(Number(limit));
    const data = [];
    const groups = await this.gmodel.find({ classid });
    for (const student of students) {
      const _student = JSON.parse(JSON.stringify(student));
      const group = groups.find(item =>
        item.students.find(stuinfo => stuinfo.stuid === _student.id)
      );
      if (group) {
        _student.groupscore = group.score;
      }
      const tasks = await this.upmodel.find({ studentid: _student.id });
      _student.tasks = tasks;
      data.push(_student);
    }

    return { total, data };
  }

  async findbystuids({ data }) {
    const res = [];
    for (const stuid of data) {
      const stu = await this.model.findById(stuid);
      if (stu) res.push(stu);
    }
    return res;
  }

  // 根据学生id删除学生
  async deletestus(data) {
    throw new BusinessError(
      ErrorCode.BUSINESS,
      '此功能暂不开放,待确定好会出现的以外情况后,再次开放'
    );
    // for (const id of data) {
    //   await this.model.deleteOne({ _id: ObjectId(id) });
    //   await this.umodel.deleteOne({ uid: id });
    //   await this.upmodel.deleteMany({ studentid: id });
    //   await this.uqmodel.deleteMany({ studentid: id });
    //   await this.scoremodel.deleteMany({ stuid: id });
    //   await this.attendmodel.deleteMany({ studentid: id });
    // }
  }

  // 批量更新寝室号
  async updatabedroom(data) {
    for (const el of data) {
      const student = await this.model.findById(el.id);
      if (student) {
        student.bedroom = el.bedroom;
        await student.save();
      }
    }
  }

  /**
   * 计算班级的优秀学生
   * 规则:班级干部(学生的job!=='普通学生'),检查是否有评优资格(is_fine_status==='0'可以评优),全部评优;
   *     普通学生取总成绩前10的人评优(非10位并列时,名额该占用就占用;第10名若有并列,就全都要)
   * @param {String} param0 {id=>班级id}
   */
  async getFineStudent({ id: classid }) {
    // 获取班级学生列表
    let studentList = await this.model.find({ classid });
    // 重置评优,干部全优秀
    studentList = studentList.map(i => {
      if (i.job.includes('普通')) i.is_fine = '0';
      else i.is_fine = '1';
      return i;
    });
    // 初始化后取出不需要算的人,他们就这样,没必要算
    const reverseList = studentList.filter(
      f => !(f.is_fine !== '2' && f.job.includes('普通'))
    );
    // 过滤出取消评优资格的学生和干部;干部就是优秀;被取消资格就别凑热闹了
    studentList = studentList.filter(
      f => f.is_fine !== '2' && f.job.includes('普通')
    );
    // 获取平时分
    let dailyScoreList = await this.psmodel.find({ classid });
    // 去重复
    dailyScoreList = this.getDailyScore(dailyScoreList);
    studentList = this.dealScoreList(dailyScoreList, studentList, 'daily');
    // 获取作业分
    let taskScoreList = await this.upmodel.find({ classid });
    taskScoreList = this.getTaskScore(taskScoreList);
    studentList = this.dealScoreList(taskScoreList, studentList, 'task');
    // 获取小组分,小组
    const groupList = await this.gmodel.find({ classid });
    const groupScoreList = await this.gsmodel.find({ classid });
    studentList = this.dealGroupScoreList(
      groupList,
      groupScoreList,
      studentList
    );
    studentList = studentList.map(i => {
      i.score = _.round(
        (i.daily || 0) + (i.task || 0) + (i.groupscore || 0),
        2
      );
      return i;
    });
    studentList = studentList.sort(
      (a, b) => (b.score * 1 || 0) - (a.score * 1 || 0)
    );
    // 排名
    // eslint-disable-next-line no-unused-vars
    let num = 0;
    for (const student of studentList) {
      // 先判断是否超过第10位,超过就跳出
      if (num >= 10) break;
      const { score, is_fine, job, name, _id } = student;
      // 最开始初始化过所有人的状态,并且将干部和不能评优的人都过滤出去,所以正常学生应该都是没有评优,如果此处已经是优秀,那么就是和前人同分改的,直接跳过就好
      if (is_fine === '1') continue;
      // 没有分凑什么热闹
      if (!score) continue;
      let plus = 1; // 这轮有多少人,到这了,这个人肯定是要改了,所以默认1
      // 评优
      student.is_fine = '1';
      const rlist = studentList.filter(
        f => f.score === score && !ObjectId(f._id).equals(_id)
      );
      // 处理同分的人也都变成is_fine
      for (const stud of rlist) {
        stud.is_fine = '1';
        const sindex = studentList.findIndex(f =>
          ObjectId(stud._id).equals(f._id)
        );
        if (sindex >= 0) {
          studentList[sindex] = stud;
          plus++;
        }
      }
      // num+plus,算下num
      num = num + plus;
    }
    // 算完的和不用算的合并,提交
    const lastList = [ ...studentList, ...reverseList ];
    for (const student of lastList) {
      // const res = await student.save();
      // const { meta, ...data } = student;
      const r = await this.model.findByIdAndUpdate(
        { _id: ObjectId(student._id) },
        { score: student.score, is_fine: student.is_fine }
      );
    }
  }
  /**
   * 将分数放到学生身上
   * @param {Array} scoreList 班级的分数列表
   * @param {Array} studentList 学生列表
   * @param {String} type 分数类型
   */
  dealScoreList(scoreList, studentList, type) {
    scoreList = JSON.parse(JSON.stringify(scoreList));
    studentList = JSON.parse(JSON.stringify(studentList));
    scoreList = _.groupBy(scoreList, 'studentid');
    const arr = [];
    for (let i of studentList) {
      const slist = scoreList[i._id];
      const obj = {};
      if (slist) {
        const score = slist.reduce((p, n) => p + (n.score * 1 || 0), 0);
        obj[type] = score;
      } else {
        obj[type] = 0;
      }
      i = Object.assign(i, obj);
      arr.push(i);
    }

    return arr;
  }
  /**
   * 将 学生所在 组的 团队平均分 + 到学生身上
   * @param {Array} groupList 班级的小组的列表
   * @param {Array} scoreList 所有小组的分数列表
   * @param {Array} studentList 学生列表
   */
  dealGroupScoreList(groupList, scoreList, studentList) {
    scoreList = _.groupBy(scoreList, 'groupid');
    // 算出每组的平均分,之后加给学生
    groupList = groupList.map(i => {
      const { students } = i;
      if (students.length > 0) {
        const slist = scoreList[i._id];
        if (slist) {
          i.score = slist.reduce((p, n) => p + (n.score * 1 || 0), 0);
          i.score = _.floor(_.divide(i.score, students.length), 2);
        }
      }

      return i;
    });
    // 每个学生加自己的组的平均分
    studentList = studentList.map(i => {
      const r = groupList.find(f =>
        f.students.find(sf => ObjectId(sf.stuid).equals(i._id))
      );
      if (r) {
        // i.score = _.round((i.score * 1 || 0) + (r.score * 1 || 0), 2);
        i.groupscore = r.score * 1 || 0;
      } else {
        i.groupscore = 0;
      }
      return i;
    });
    return studentList;
  }

  // 平时分去重处理
  getDailyScore(list) {
    const arr = [];
    const mid1 = _.groupBy(list, 'studentid');
    const keys = Object.keys(mid1);
    for (const key of keys) {
      const mid2 = _.uniqBy(mid1[key], 'subid');
      arr.push(...mid2);
    }
    return arr;
  }
  // 作业分去重处理
  getTaskScore(list) {
    const arr = [];
    const mid1 = _.groupBy(list, 'studentid');
    const keys = Object.keys(mid1);
    for (const key of keys) {
      const mid2 = _.uniqBy(mid1[key], 'lessonid');
      arr.push(...mid2);
    }
    return arr;
  }

  // 将学生排号
  async arrangeNumber({ classid }) {
    const studList = await this.model.find({ classid });
    let number = 1;
    // 查每个学生的编号,如果没有,就给赋上值;有,就给number赋上值,然后继续下一位
    for (const stu of studList) {
      if (!stu.number) {
        if (number * 1 < 10) stu.number = `0${number}`;
        else stu.number = number;
        await stu.save();
      } else {
        number = stu.number * 1;
      }
      number = number * 1 + 1;
    }
    number = 1;
  }
  // 建立导出学生名单的任务
  async toExport(body) {
    const { planid, termid, batchid, classid } = body;
    const trainPlan = await this.ctx.model.Trainplan.findById(planid);
    let fn = '学生名单';
    if (termid && termid.length > 0) {
      if (classid) {
        const cla = await this.ctx.model.Class.findById(classid);
        if (cla) {
          const { name } = cla;
          if (name) {
            fn = `${name.includes('班') ? name : `${name}班`}${fn}`;
          }
        }
      }
      if (termid.length === 1) {
        const tid = _.head(termid);
        const { termnum } = trainPlan;
        const t = termnum.id(tid);
        if (t) {
          const { term, batchnum } = t;
          if (batchid) {
            const b = batchnum.id(batchid);
            if (b) {
              const { batch } = b;
              if (b) fn = `第${batch}批${fn}`;
            }
          }
          if (term) fn = `第${term}期${fn}`;
        }
      } else if (termid.length > 1) {
        const { termnum } = trainPlan;
        let str = '第';
        for (const tid of termid) {
          const t = termnum.id(tid);
          if (t) {
            const { term } = t;
            str = `${str}${term} `;
          }
        }
        fn = `${str}期${fn}`;
      }
    } else {
      const { title } = trainPlan;
      fn = `${title}${fn}`;
    }
    const data = {
      title: fn,
      params: {
        project: 'center',
        // router: '/api/train/mission/student/export',
        service: 'student',
        method: 'exportStudent',
        body,
      },
    };
    if (this.missionBase) {
      const url = `${this.missionBase}/api/mission`;
      const res = await this.ctx.curl(url, {
        method: 'post',
        headers: {
          'content-type': 'application/json',
        },
        data,
        dataType: 'json',
      });
      if (res.status !== 200 || res.data.errcode !== 0) {
        throw new BusinessError(ErrorCode.SERVICE_FAULT, '创建任务失败');
      }
    } else {
      throw new BusinessError(ErrorCode.SERVICE_FAULT, '未找到任务项目设置');
    }
  }
  // 导出学生
  async exportStudent(body) {
    let { missionid, model, ...data } = body;
    assert(missionid, '缺少任务信息,无法执行任务');
    try {
      // 整理model
      model = model.map(i => {
        const { zh, model } = i;
        if (zh && model) {
          const obj = {};
          obj.header = zh;
          if (model === 'termid') obj.key = 'termname';
          else if (model === 'batchid') obj.key = 'batchname';
          else if (model === 'classid') obj.key = 'classname';
          else obj.key = model;
          obj.width = 20;
          return obj;
        }
      });
      model = _.compact(model);
      // 请求数据
      // 修改条件,termid变成数组了,需要一个一个查出来
      const { planid, termid, batchid, classid, isComming } = data;
      const queryObject = {};
      if (planid) queryObject.planid = planid;
      if (batchid) queryObject.batchid = batchid;
      if (classid) queryObject.classid = classid;
      if (isComming) {
        // 因为isComming有3种,0=>没来;1=>来了;2=>来了又退了.而已参培的类型应该是不为0,而不是单纯的1,只管来没来,不管走没走,毕竟吃饭了,得交钱
        if (isComming !== '0') queryObject.isComming = { $ne: '0' };
        else queryObject.isComming = isComming;
      }
      let studentList = [];
      console.log(queryObject);
      if (termid && termid.length > 0) {
        for (const t of termid) {
          queryObject.termid = t;
          const stuList = await this.query(queryObject);
          studentList.push(...stuList);
        }
      } else {
        studentList = await this.query(queryObject);
      }
      console.log(studentList.length);
      // 获取学生,4分之1
      this.ctx.service.util.updateProcess(missionid, '25');
      console.log('学生导出=>25%');
      studentList = JSON.parse(JSON.stringify(studentList));
      let ids = studentList.map(i => i.classid);
      ids = _.uniq(ids);
      ids = _.compact(ids);
      ids = ids.map(i => ObjectId(i));
      const classList = await this.ctx.model.Class.find({
        _id: { $in: ids },
      });
      for (const stu of studentList) {
        // 转换是否参培
        const { classid, isComming } = stu;
        if (!classid) continue;
        const cla = await this.ctx.service.class.fetch({ id: classid });
        if (!cla) continue;
        const { startdate } = cla;
        if (!startdate) continue;
        stu.insurance = moment(startdate).add(1, 'd').format('YYYY-MM-DD');
        if (isComming) {
          if (isComming === '0') stu.isComming = '否';
          if (isComming === '1') stu.isComming = '是';
        }
      }
      // 整理完数据,4分之2
      this.ctx.service.util.updateProcess(missionid, '50');
      console.log('学生导出=>50%');
      let fn = '学生名单';
      // 因为是递进下来, batchid和classid并列,并非递进
      // 获取fn
      if (classid) {
        // 文件名称: 期, 班
        // 班级名上面有直接拽来
        const cla = classList.find(f => ObjectId(classid).equals(f._id));
        if (cla) {
          const { name, termid } = cla;
          if (name) fn = `${name.includes('班') ? name : `${name}班`}${fn}`;
          if (termid) {
            const obj = await this.toGetFn(termid);
            if (obj) {
              const { term } = obj;
              fn = `第${term}期${fn}`;
            }
          }
        }
      } else if (batchid) {
        // 文件名称,期,批
        const tid = _.head(termid);
        const obj = await this.toGetFn(tid, batchid);
        if (obj) {
          const { term, batch } = obj;
          if (batch) fn = `第${batch}批${fn}`;
          if (term) fn = `第${term}期${fn}`;
        }
      } else if (termid) {
        // 文件名称: 期
        if (termid.length === 1) {
          const obj = await this.toGetFn(_.head(termid));
          if (obj) {
            const { term } = obj;
            if (term) fn = `第${term}期${fn}`;
          }
        } else {
          let tStr = '';
          for (let i = 0; i < termid.length; i++) {
            const tid = termid[i];
            const obj = await this.toGetFn(tid);
            if (obj) {
              const { term } = obj;
              if (term) {
                if (i === 0) {
                  tStr += `${term}期`;
                } else {
                  tStr += `,${term}期`;
                }
              }
            }
          }
          fn = `${tStr}${fn}`;
        }
      } else if (planid) {
        // 文件名称:该计划标题
        const trainPlan = await this.ctx.model.Trainplan.findById(planid);
        if (trainPlan) {
          const { title } = trainPlan;
          if (title) fn = `${title}${fn}`;
        }
      }
      // 获取文件名,60%
      this.ctx.service.util.updateProcess(missionid, '60');
      console.log('学生导出=>60%');
      const res = await this.ctx.service.util.toExcel(studentList, model, fn);
      if (!res) {
        console.error(
          `${moment().format('YYYY-MM-DD HH:SS:mm')} ${fn} 导出失败`
        );
        throw new BusinessError(ErrorCode.SERVICE_FAULT, `${fn}导出失败`);
      }
      this.ctx.service.util.updateProcess(missionid, '100', '2', {
        uri: res,
      });
      console.log('学生导出=>100%');
    } catch (error) {
      this.ctx.service.util.updateProcess(missionid, undefined, '3');
    }
  }

  async toGetFn(termid, batchid) {
    const trainPlan = await this.ctx.model.Trainplan.findOne({
      'termnum._id': ObjectId(termid),
    });
    if (!trainPlan) {
      throw new BusinessError(ErrorCode.DATA_NOT_EXIST, '未找到年度计划信息');
    }
    const { termnum } = trainPlan;
    if (!termnum) {
      throw new BusinessError(
        ErrorCode.DATA_NOT_EXIST,
        '未找到年度计划的期信息'
      );
    }
    const obj = {};
    if (termid) {
      const term = termnum.id(termid);
      if (term) obj.term = term.term;
      if (batchid) {
        const { batchnum } = term;
        const batch = batchnum.id(batchid);
        if (batch) obj.batch = batch.batch;
      }
    }
    return obj;
  }

  // 确认学生打印证书
  async printCert({ ids }) {
    const res = await this.model.updateMany(
      { _id: { $in: ids.map(i => ObjectId(i)) } },
      { cert: '1' }
    );
    return res;
  }

  // 根据计划id找到学校是否上传学生
  async getSchoolStudent({ planid }) {
    const res = await this.model.aggregate([
      { $match: { planid } },
      { $group: { _id: '$schid', sum: { $sum: 1 } } },
      { $project: { _id: 0, schid: '$_id', schnum: '$sum' } },
    ]);
    return res;
  }

  // excel导出表头设置
  metaBx(type) {
    const header = [
      {
        header: '姓名',
        key: 'name',
        width: 20,
      },
    ];
    return header;
  }
}

module.exports = StudentService;