server-race-v2/app/service/matchSmallGroupSchedule.js

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

//
class MatchSmallGroupScheduleService extends CrudService {
  constructor(ctx) {
    super(ctx, 'matchsmallgroupschedule');
    this.model = this.ctx.model.Race.MatchSmallGroupSchedule;
    this.baseUserModel = this.ctx.model.Base.User;
    this.userModel = this.ctx.model.Race.User;
    this.teamApplyModel = this.ctx.model.Race.TeamApply;
    // 加入框架
    this.defaultModule = this.app.config.defaultModel || 'Race';
  }

  async saveAll(data) {
    for (const i of data) {
      const { _id } = i;
      if (!_id) {
        // TODO: 创建前:需要检查这些人员是否出现在这个项目中的别的组中
        await this.model.create(i);
      } else {
        await this.model.updateOne({ _id }, i);
      }
    }
  }

  async beforeCreate(body) {
    // 检查数据是否有重复,如果符合检查重复条件,就把之前的删了,用新来的
    const { match_id, group_id, project_id, team_id, player_one, player_two } = body;
    const query = {
      match_id,
      group_id,
      project_id,
      team_id,
      $or: [
        { player_one, player_two },
        { player_one: player_two, player_two: player_one },
      ],
    };
    const d = await this.model.findOne(query);
    if (d) await this.model.deleteOne(query);
    return body;
  }

  async beforeQuery(filter) {
    // 可查询自己的赛程-user_id / 某人的赛程
    // const { user_id, user_name } = filter;
    const user_name = _.get(filter, 'user_name');
    let user_id = _.get(filter, 'user_id');
    // 没有user_id就不需要处理查询条件
    if (!user_id && !user_name) return filter;
    const usualCondition = _.pick(filter, [ 'match_id', 'group_id', 'project_id' ]);

    if (user_name) {
      // 要先找比赛用户模块的数据id
      const baseUser = await this.baseUserModel.findOne({ name: new RegExp(user_name) }, { _id: 1 });
      if (!baseUser) delete filter.user_name;
      delete filter.user_name;
      const baseUserId = baseUser._id;
      const raceUser = await this.userModel.findOne({ user_id: baseUserId, type: '0' });
      if (raceUser) user_id = raceUser._id;
    }

    if (user_id) {
      // 需要查:该用户是 单打 和 双打 的情况
      // 单打,直接user_id 为player_one/two 就可以,双打需要查teamApply
      // 所以先把user_id添加进查询范围里
      let probablyList = [ user_id ];
      // 尽可能的缩小查询范围
      // 接着找组队申请中和该用户有关的人
      const teamApplyList = await this.teamApplyModel.find({ ...usualCondition, status: '1', $or: [{ one_member_id: user_id }, { two_member_id: user_id }] }, { _id: 1 });
      const teamApplyIds = teamApplyList.map(i => i._id);
      probablyList.push(...teamApplyIds);
      // 删除user_id.会造成错误
      delete filter.user_id;
      // 添加该用户正确的范围条件
      probablyList = probablyList.map(i => ObjectId(i).toString());
      filter.$or = [{ player_one: { $in: probablyList } }, { player_two: { $in: probablyList } }];
    }
    return filter;
  }

  turnFilter(filter) {
    const str = /^%\S*%$/;
    // $是mongodb固定条件,不用处理;大多为手写特殊处理过的条件
    let keys = Object.keys(filter).filter(f => !f.includes('$'));
    for (const key of keys) {
      const res = key.match(str);
      if (res) {
        const newKey = key.slice(1, key.length - 1);
        if (!ObjectId.isValid(filter[key])) filter[newKey] = new RegExp(filter[key]);
        delete filter[key];
      }
    }
    // 再次过滤数据,将数组的数据都变成{$in:value},因为查询变成了聚合查询
    // $是mongodb固定条件,不用处理;大多为手写特殊处理过的条件
    keys = Object.keys(filter).filter(f => !f.includes('$'));
    for (const key of keys) {
      if (_.isArray(filter[key])) {
        filter[key] = { $in: filter[key] };
      } else if (filter[key] === 'true' || filter[key] === 'false') {
        // 布尔类型的值检查，如果是布尔类型，则将字符串转为布尔
        filter[key] = filter[key] === 'true';
      }
    }
    return filter;
  }

  async afterQuery(filter, data) {
    data = JSON.parse(JSON.stringify(data));
    for (const d of data) {
      const { player_type, player_one, player_two, referee_id } = d;
      if (player_type === 'User') {
        const pouid = _.get(player_one, 'user_id');
        const user1 = await this.baseUserModel.findById(pouid);
        d.player_one_name = _.get(user1, 'name');
        d.player_one = _.get(d, 'player_one._id');
        const ptuid = _.get(player_two, 'user_id');
        const user2 = await this.baseUserModel.findById(ptuid);
        d.player_two_name = _.get(user2, 'name');
        d.player_two = _.get(d, 'player_two._id');
      } else if (player_type === 'TeamApply') {
        d.player_one_name = `${_.get(d, 'player_one.one_member_name')}-${_.get(d, 'player_one.two_member_name')}`;
        d.player_one = _.get(d, 'player_one._id');
        d.player_two_name = `${_.get(d, 'player_two.one_member_name')}-${_.get(d, 'player_two.two_member_name')}`;
        d.player_two = _.get(d, 'player_two._id');
      }

      const referee = await this.userModel.findById(referee_id).populate({
        path: 'user_id',
        model: this.baseUserModel,
      });
      d.referee_id_name = _.get(referee, 'user_id.name');
    }
    return data;
  }

  async fetch(filter, { sort, desc, projection } = {}) {
    assert(filter);
    filter = await this.beforeFetch(filter);
    const { _id, id } = filter;
    if (_id || id) filter = { _id: ObjectId(_id || id) };

    // 处理排序
    if (sort && _.isString(sort)) {
      sort = { [sort]: desc ? -1 : 1 };
    } else if (sort && _.isArray(sort)) {
      sort = sort.map(f => ({ [f]: desc ? -1 : 1 })).reduce((p, c) => ({ ...p, ...c }), {});
    }
    const { refMods, populate } = this.getRefMods();
    let res = await this.model.findOne(filter, projection).populate(populate).exec();
    res = JSON.parse(JSON.stringify(res));
    for (const obj of refMods) {
      const { col, prop, type } = obj;
      if (!prop) continue;
      if (_.isArray(prop)) {
        for (const p of prop) {
          if (type === 'String') res[`${col}_${p}`] = _.get(res, `${col}.${p}`);
          if (type === 'Array') {
            const list = [];
            const oList = _.get(res, `${col}`);
            for (const d of oList) {
              const obj = { _id: d._id };
              obj[p] = _.get(d, p);
              list.push(obj);
            }
            res[`${col}_${p}`] = list;
          }
        }
        res[col] = _.get(res, `${col}._id`);
      }
    }
    res = await this.afterFetch(filter, res);
    return res;
  }
  async afterFetch(filter, d) {
    const { player_type, player_one, player_two, referee_id } = d;
    if (player_type === 'User') {
      const pouid = _.get(player_one, 'user_id');
      const user1 = await this.baseUserModel.findById(pouid);
      d.player_one_name = _.get(user1, 'name');
      d.player_one = _.get(d, 'player_one._id');
      const ptuid = _.get(player_two, 'user_id');
      const user2 = await this.baseUserModel.findById(ptuid);
      d.player_two_name = _.get(user2, 'name');
      d.player_two = _.get(d, 'player_two._id');
    } else if (player_type === 'TeamApply') {
      d.player_one_name = `${_.get(d, 'player_one.one_member_name')}-${_.get(d, 'player_one.two_member_name')}`;
      d.player_one = _.get(d, 'player_one._id');
      d.player_two_name = `${_.get(d, 'player_two.one_member_name')}-${_.get(d, 'player_two.two_member_name')}`;
      d.player_two = _.get(d, 'player_two._id');
    }
    const referee = await this.userModel.findById(referee_id).populate({
      path: 'user_id',
      model: this.baseUserModel,
    });
    d.referee_id_name = _.get(referee, 'user_id.name');

    return d;
  }

  getRefMods() {
    // 找到该表的schema(表结构)
    const mod = this.getSchema();
    const populate = this.resetPopulate(mod);
    const refMods = [];
    for (const key in mod) {
      if (!mod[key].ref && !mod[key].refPath) continue;
      const obj = { col: key, prop: mod[key].getProp, type: mod[key].type.name };
      refMods.push(obj);
    }
    return { refMods, populate };
  }

  // 针对每个表进行检查
  resetPopulate(schema) {
    const arr = [];
    for (const key in schema) {
      const e = schema[key];
      const { ref } = e;
      if (!ref) continue;
      const obj = { path: key };
      const modelPath = this.formatModelPath(ref);
      const model = this.getModel(modelPath);
      obj.model = model;
      const msch = this.getSchema(modelPath);
      const popu = this.resetPopulate(msch);
      if (popu.length > 0) obj.populate = popu;
      arr.push(obj);
    }
    return arr;
  }

  // 格式化model路径
  formatModelPath(str) {
    let arr = str.split('.');
    arr = arr.map(i => _.upperFirst(i));
    const modelPath = arr.join('.');
    return modelPath;
  }

  // 获取model的模式
  getSchema(path) {
    const model = this.getModel(path);
    return _.get(model, 'prototype.schema.obj');
  }

  // 获取model实例
  getModel(path) {
    if (!path) return this.model;
    let model = _.get(this.ctx.model, path);
    const clients = this.app.mongooseDB.clients;
    if (clients && !model) {
      model = _.get(this.ctx.model, `${this.defaultModule}.${path}`);
    }
    return model;
  }
}

module.exports = MatchSmallGroupScheduleService;