front/mock/modules/elective-generation.js

const Mock = require('mockjs')
const Random = Mock['Random']

const mockGeneration = 8 // primary
const mockGroups = [1, 2, 3, 4, 5, 6]
const mockPreferenceCount = 3 // 1 or 3 // 1志愿/3志愿

module.exports = [
  {
    url: '/mock/front/report/getElectiveStatus',
    type: 'get',
    response: config => {
      return {
        code: 200,
        msg: 'success',
        data: {
          year: 2021,
          roundId: 1,
          roundName: '第X次选科',
          groupIds: mockGroups.toString(),
          roundGroups: mockGroups.map(groupId => ({
            groupId: groupId,
            classCount: Random.integer(2, 6),
            personCount: function() {
              return this.classCount * 50
            },
            limitPerson: false,
            rankOut: false
          })),
          allMatched: Random.boolean(1, 10, 8),
          currentGeneration: mockGeneration,

          // +
          disenrollCount: Random.integer(20, 100), // 未录人数
          enablePushNextDMGeneration: Random.boolean(1, 10, 8),
          allowDMAlgorithm: true,
          doneDMAlgorithm: Random.boolean(1, 10, 8),
          allowForce: Random.boolean(1, 10, 8)
        }
      }
    }
  },
  {
    url: '/mock/front/report/getElectiveSummary',
    type: 'get',
    response: config => {
      const results = []
      for (let generation = 1; generation <= mockGeneration; generation++) {
        const copyGeneration = generation
        switch (generation) {
          case 1:
            // primary
            const allPreferences = []
            for (let pref = 0; pref < mockPreferenceCount; pref++) {
              const preferences = []
              const groupDefines = [
                {
                  category: 'actualCount',
                  queryCode: Random.cname(),
                  displayName: '已报名',
                  values: mockGroups.map(groupId => ({
                    groupId: groupId,
                    value: Random.integer(120, 400),
                    color: 'B',
                    bold: false,
                    star: false,
                    disabled: false
                  }))
                }
              ]
              const nonGroupDefines = [
                {
                  category: 'unfinishedCount',
                  queryCode: Random.cname(),
                  displayName: '未报名',
                  values: [{
                    groupId: 0,
                    value: Random.integer(0, 10),
                    color: '',
                    bold: false,
                    star: false,
                    disabled: false
                  }]
                }
              ]
              preferences.push(...groupDefines)
              preferences.push(...nonGroupDefines)
              allPreferences.push(preferences)
            }
            const primary = {
              roundId: 1,
              generation: copyGeneration,
              categories: allPreferences
            }
            results.push(primary)
            break
          default:
            const accumulateDefine = {
              generations: [2, 4, 6, 7],
              factory: () => [
                {
                  category: 'approvedCount',
                  queryCode: Random.cname(),
                  displayName: '正常录取',
                  values: mockGroups.map(groupId => ({
                    groupId: groupId,
                    value: Random.integer(120, 300),
                    color: '',
                    bold: false,
                    star: false,
                    disabled: false
                  }))
                },
                {
                  category: 'forcedCount',
                  queryCode: Random.cname(),
                  displayName: '调剂录取',
                  values: mockGroups.map(groupId => ({
                    groupId: groupId,
                    value: Random.integer(0, 10),
                    color: '',
                    bold: false,
                    star: false,
                    disabled: false
                  }))
                }
              ]
            }
            const commonDefines = [
              {
                generations: [2],
                factory: () => [
                  {
                    category: 'indicateCount',
                    displayName: '指标',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: true,
                      queryCode: 'abc',
                      disabled: false
                    }))
                  },
                  {
                    category: 'approvedCount',
                    queryCode: Random.cname(),
                    displayName: '录取人数',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  },
                  {
                    category: 'adjustCount',
                    queryCode: Random.cname(),
                    displayName: '调剂人数',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  },
                  {
                    category: 'matchedCount',
                    queryCode: Random.cname(),
                    displayName: '专业符合',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  },
                  {
                    category: 'nonmatchedCount',
                    queryCode: Random.cname(),
                    displayName: '专业不符',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  }
                ]
              },
              {
                generations: [3, 5],
                factory: () => [
                  {
                    category: 'matchedApproved',
                    queryCode: Random.cname(),
                    displayName: '专业符合同意',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  },
                  {
                    category: 'matchedNotOptional',
                    queryCode: Random.cname(),
                    displayName: '专业符合改选',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  },
                  {
                    category: 'matchedRejected',
                    queryCode: Random.cname(),
                    displayName: '专业符合拒绝',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  },
                  {
                    category: 'matchedNonaction',
                    queryCode: Random.cname(),
                    displayName: '专业符合未填',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  },
                  {
                    category: 'matchedRankout',
                    queryCode: Random.cname(),
                    displayName: '专业符合被挤出',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  },
                  {
                    category: 'nonmatchedApproved',
                    queryCode: Random.cname(),
                    displayName: '专业符合已填',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  },
                  {
                    category: 'nonmatchedRejected',
                    queryCode: Random.cname(),
                    displayName: '不可调剂拒绝',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  },
                  {
                    category: 'nonmatchedNonaction',
                    queryCode: Random.cname(),
                    displayName: '不可调剂未填',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  }
                ]
              },
              {
                generations: [4],
                factory: () => [
                  {
                    category: 'approvedCount',
                    queryCode: Random.cname(),
                    displayName: '补录录取',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  },
                  {
                    category: 'forcedCount',
                    queryCode: Random.cname(),
                    displayName: '调剂录取',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  },
                  {
                    category: 'matchedCount',
                    queryCode: Random.cname(),
                    displayName: '可调剂人数',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  },
                  {
                    category: 'nonmatchedCount',
                    queryCode: Random.cname(),
                    displayName: '不可调剂人数',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  }
                ]
              },
              {
                generations: [6],
                factory: () => [
                  {
                    category: 'approvedCount',
                    queryCode: Random.cname(),
                    displayName: '补录录取',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  },
                  {
                    category: 'forcedCount',
                    queryCode: Random.cname(),
                    displayName: '调剂录取',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  }
                ]
              },
              {
                generations: [7],
                factory: () => [
                  {
                    category: 'forcedCount',
                    queryCode: Random.cname(),
                    displayName: '调剂录取',
                    values: mockGroups.map(groupId => ({
                      groupId: groupId,
                      value: Random.integer(120, 400),
                      color: '',
                      bold: false,
                      star: false,
                      disabled: false
                    }))
                  }
                ]
              }
            ]
            const defines = commonDefines.find(d => d.generations.includes(generation))
            const inAccDef = accumulateDefine.generations.includes(generation)
            if (defines) {
              results.push({
                roundId: 1,
                generation: copyGeneration,
                categories: defines.factory(),
                accumulates: inAccDef ? accumulateDefine.factory() : undefined
              })
            }
            break
        }
      }

      return {
        code: 200,
        msg: 'success',
        data: results
      }
    }
  }
]