minnan-collect-web/src/api/collect/AssessmentContent.ts

import { DataModel, transformArrayDataModel, transformDataModel, type KeyValue } from '@imengyu/js-request-transform';
import { AppServerRequestModule } from '../RequestModules';
import { transformSomeToArray } from '../Utils';
import { appendGetUrlParams } from '@imengyu/imengyu-utils';
import { useAuthStore } from '@/stores/auth';
import ApiCofig from '@/common/config/ApiCofig';
import dayjs from 'dayjs';

/**
 * 自查评估 / 传承协议相关接口（ShowDoc）
 * @see https://www.showdoc.com.cn/minnanCE/11559060626966335 列表
 * @see https://www.showdoc.com.cn/minnanCE/11559060626887140 传承协议编辑
 * @see https://www.showdoc.com.cn/minnanCE/11559060626966336 评估表编辑/新增
 * @see https://www.showdoc.com.cn/minnanCE/11559060626966337 详情
 */

/** 计分点项（getCheckItems） */
export class CheckItemInfo extends DataModel<CheckItemInfo> {
  constructor() {
    super(CheckItemInfo, '自查计分项目');
    this.setNameMapperCase('Camel', 'Snake');
    this._convertTable = {
      id: { clientSide: 'number', serverSide: 'number' },
      pid: { clientSide: 'number', serverSide: 'number' },
      level: { clientSide: 'number', serverSide: 'number' },
      points: { clientSide: 'number', serverSide: 'number' },
      isTitle: { clientSide: 'boolean', serverSide: 'number' },
      isMulitCheck: { clientSide: 'boolean', serverSide: 'number' },
    };
  }

  id = 0 as number;
  pid = 0 as number;
  name = '' as string;
  level = 0 as number;
  points = 0 as number;
  isTitle = false;
  isMulitCheck = false;
  /** 1=单选,2=多选,3=次数 */
  checkType = 0 as number;
  children: CheckItemInfo[] = [];
}

/** 自查评估表列表行 */
export class SelfAssessmentListRow extends DataModel<SelfAssessmentListRow> {
  constructor() {
    super(SelfAssessmentListRow, '自查评估表列表项');
    this.setNameMapperCase('Camel', 'Snake');
    this._convertTable = {
      id: { clientSide: 'number', serverSide: 'number' },
      userId: { clientSide: 'number', serverSide: 'number' },
      year: { clientSide: 'number', serverSide: 'number' },
      weigh: { clientSide: 'number', serverSide: 'number' },
      deductPoints: { clientSide: 'number', serverSide: 'number' },
      points: { clientSide: 'number', serverSide: 'number' },
      self: { clientSide: 'number', serverSide: 'number' },
      ichUnit: { clientSide: 'number', serverSide: 'number' },
      unitPoints: { clientSide: 'number', serverSide: 'number' },
      county: { clientSide: 'number', serverSide: 'number' },
      countyPoints: { clientSide: 'number', serverSide: 'number' },
      district: { clientSide: 'number', serverSide: 'number' },
      districtPoints: { clientSide: 'number', serverSide: 'number' },
      province: { clientSide: 'number', serverSide: 'number' },
      provincePoints: { clientSide: 'number', serverSide: 'number' },
      level: { clientSide: 'number', serverSide: 'string' },
      progress: { clientSide: 'number', serverSide: 'number' },
    };
    this._convertKeyType = (key) => {
      if (key.endsWith('Text') || key.endsWith('_text')) {
        return { clientSide: 'string', serverSide: 'undefined' };
      }
      return undefined;
    };
  }

  id = 0 as number;
  userId = 0 as number;
  year = 0 as number;
  inheritor = '' as string|null;
  unit = '' as string|null;
  ichName = '' as string|null;
  mobile = '' as string|null;
  idCard = '' as string|null;
  level = null as number|string|null;
  address = '' as string|null;
  weigh = 0 as number;
  deductPoints = 0 as number;
  points = 0 as number;
  self = null as number|null;
  ichUnit = null as number|null;
  unitPoints = 0 as number;
  county = null as number|null;
  countyPoints = 0 as number;
  district = null as number|null;
  districtPoints = 0 as number;
  province = null as number|null;
  provincePoints = 0 as number;
  createtime = '' as string;
  updatetime = '' as string;
  selfText = '' as string;
  /** -1=未提交,0=草稿,1=已自评,2～5 各级审核完成 */
  progress = null as number|null;
}

/** 传承协议列表行 */
export class AgreementListRow extends DataModel<AgreementListRow> {
  constructor() {
    super(AgreementListRow, '传承协议列表项');
    this.setNameMapperCase('Camel', 'Snake');
    this._convertTable = {
      id: { clientSide: 'number', serverSide: 'number' },
      userId: { clientSide: 'number', serverSide: 'number' },
      year: { clientSide: 'number', serverSide: 'number' },
      apprentice: { clientSide: 'number', serverSide: 'number' },
      activity: { clientSide: 'number', serverSide: 'number' },
      course: { clientSide: 'number', serverSide: 'number' },
      level: { clientSide: 'number', serverSide: 'number' },
    };
  }

  id = 0 as number;
  userId = 0 as number;
  level = null as number|null;
  year = 0 as number;
  partyA = '' as string|null;
  partyB = '' as string|null;
  apprentice = 0 as number;
  activity = 0 as number;
  course = 0 as number;
  mobile = '' as string|null;
  partyAMobile = '' as string|null;
  idCard = '' as string|null;
  health = '' as string|null;
  ich = '' as string|null;
  partyASign = '' as string|null;
  partyBSign = '' as string|null;
  createtime = '' as string;
  updatetime = '' as string;
  deletetime = '' as string|null;
}

/** 保护单位账号：传承人传承协议分页列表行（ich/check/getUserAgreement） */
export class UserAgreementListRow extends DataModel<UserAgreementListRow> {
  constructor() {
    super(UserAgreementListRow, '传承人传承协议列表项');
    this.setNameMapperCase('Camel', 'Snake');
    this._convertTable = {
      id: { clientSide: 'number', serverSide: 'number' },
      sitesId: { clientSide: 'number', serverSide: 'number' },
      batch: { clientSide: 'number', serverSide: 'number' },
      ichId: { clientSide: 'number', serverSide: 'number' },
      agreementId: { clientSide: 'number', serverSide: 'number' },
      userId: { clientSide: 'number', serverSide: 'number' },
      year: { clientSide: 'number', serverSide: 'number' },
      apprentice: { clientSide: 'number', serverSide: 'number' },
      activity: { clientSide: 'number', serverSide: 'number' },
      course: { clientSide: 'number', serverSide: 'number' },
      progress: { clientSide: 'number', serverSide: 'number' },
      level: { clientSide: 'number', serverSide: 'string' },
      rejectType: { clientSide: 'number', serverSide: 'number' },
    };
    this._convertKeyType = (key) => {
      if (key.endsWith('Text') || key.endsWith('_text')) {
        return { clientSide: 'string', serverSide: 'undefined' };
      }
      return undefined;
    };
  }

  id = 0 as number;
  title = '' as string;
  associationId = '' as string;
  sitesId = 0 as number;
  level = null as number|string|null;
  batch = 0 as number;
  gender = '' as string;
  basicMobile = '' as string|null;
  basicUnit = '' as string|null;
  ichId = 0 as number;
  ichTitle = '' as string;
  /** 已填写的传承协议记录 ID，未填写时为 null */
  agreementId = null as number|null;
  userId = null as number|null;
  year = null as number|null;
  partyA = '' as string|null;
  partyB = '' as string|null;
  apprentice = null as number|null;
  activity = null as number|null;
  course = null as number|null;
  mobile = '' as string|null;
  partyAMobile = '' as string|null;
  partyAContact = '' as string|null;
  idCard = '' as string|null;
  health = '' as string|null;
  ich = '' as string|null;
  partyASign = '' as string|null;
  partyBSign = '' as string|null;
  /** 进度:0=草稿,
1=已自评,
2=项目保护单位审核完成,
3=县（区）文旅部门审核完成,
4=设区市文旅部门、省非遗中心审核完成,
5=省文化和旅游厅审核完成 */
  progress = null as number|null;
  /** 退回状态: 0=无,1=自评阶段退回,2=项目保护单位退回,3=县(区)文旅部门退回,4=设区市文旅部门/省非遗中心退回,5=省文化和旅游厅退回 */
  rejectType = null as number|null;
  rejectReason = '' as string|null;
  createtime = '' as string|null;
  updatetime = '' as string|null;
  deletetime = '' as string|null;
  batchText = '' as string;
  ichSiteTypeText = '' as string;
}

/** 保护单位账号：传承人列表行（ich/check/getInheritorList） */
export class InheritorCheckListRow extends DataModel<InheritorCheckListRow> {
  constructor() {
    super(InheritorCheckListRow, '传承人列表项');
    this.setNameMapperCase('Camel', 'Snake');
    this._convertTable = {
      id: { clientSide: 'number', serverSide: 'number' },
      sitesId: { clientSide: 'number', serverSide: 'number' },
      batch: { clientSide: 'number', serverSide: 'number' },
      ichId: { clientSide: 'number', serverSide: 'number' },
      checkId: { clientSide: 'number', serverSide: 'number' },
      userId: { clientSide: 'number', serverSide: 'number' },
      year: { clientSide: 'number', serverSide: 'number' },
      weigh: { clientSide: 'number', serverSide: 'number' },
      deductPoints: { clientSide: 'number', serverSide: 'number' },
      points: { clientSide: 'number', serverSide: 'number' },
      self: { clientSide: 'number', serverSide: 'number' },
      ichUnit: { clientSide: 'number', serverSide: 'number' },
      unitPoints: { clientSide: 'number', serverSide: 'number' },
      county: { clientSide: 'number', serverSide: 'number' },
      countyPoints: { clientSide: 'number', serverSide: 'number' },
      district: { clientSide: 'number', serverSide: 'number' },
      districtPoints: { clientSide: 'number', serverSide: 'number' },
      province: { clientSide: 'number', serverSide: 'number' },
      provincePoints: { clientSide: 'number', serverSide: 'number' },
      progress: { clientSide: 'number', serverSide: 'number' },
      level: { clientSide: 'number', serverSide: 'string' },
      rejectType: { clientSide: 'number', serverSide: 'number' },
    };
    this._convertKeyType = (key) => {
      if (key.endsWith('Text') || key.endsWith('_text')) {
        return { clientSide: 'string', serverSide: 'undefined' };
      }
      return undefined;
    };
  }

  id = 0 as number;
  title = '' as string;
  /** 关联项目 ID（接口可能返回字符串数字） */
  associationId = '' as string;
  sitesId = 0 as number;
  level = null as number|string|null;
  batch = 0 as number;
  gender = '' as string;
  basicMobile = '' as string|null;
  basicUnit = '' as string|null;
  ichId = 0 as number;
  ichTitle = '' as string;
  checkId = null as number|null;
  userId = null as number|null;
  year = null as number|null;
  inheritor = '' as string|null;
  unit = '' as string|null;
  ichName = '' as string|null;
  mobile = '' as string|null;
  idCard = '' as string|null;
  address = '' as string|null;
  weigh = null as number|null;
  deductPoints = null as number|null;
  points = null as number|null;
  self = null as number|null;
  ichUnit = null as number|null;
  unitPoints = null as number|null;
  county = null as number|null;
  countyPoints = null as number|null;
  district = null as number|null;
  districtPoints = null as number|null;
  province = null as number|null;
  provincePoints = null as number|null;
  createtime = '' as string|null;
  updatetime = '' as string|null;
  /** -1=未提交,0=草稿,1=已自评,2=项目保护单位审核完成,3=县（区）文旅部门审核完成,4=设区市文旅部门/省非遗中心审核完成,5=省文化和旅游厅审核完成 */
  progress = null as number|null;
  /** 退回状态: 0=无,1=自评阶段退回,2=项目保护单位退回,3=县(区)文旅部门退回,4=设区市文旅部门/省非遗中心退回,5=省文化和旅游厅退回 */
  rejectType = null as number|null;
  rejectReason = '' as string|null;
  flagText = '' as string;
  typeText = '' as string;
  openStatusText = '' as string;
  statusText = '' as string;
  regionText = '' as string;
  levelText = '' as string;
  crTypeText = '' as string;
  ichTypeText = '' as string;
  claimStatusText = '' as string;
  isMultipleClaimsText = '' as string;
  batchText = '' as string;
  ichSiteTypeText = '' as string;
}

/** 自查表审核日志列表行（checkLogList） */
export class CheckLogListRow extends DataModel<CheckLogListRow> {
  constructor() {
    super(CheckLogListRow, '自查表审核日志');
    this.setNameMapperCase('Camel', 'Snake');
    this._convertTable = {
      id: { clientSide: 'number', serverSide: 'number' },
      checkId: { clientSide: 'number', serverSide: 'number' },
      reviewType: { clientSide: 'number', serverSide: 'number' },
      status: { clientSide: 'number', serverSide: 'number' },
      operator: { clientSide: 'number', serverSide: 'number' },
      progress: { clientSide: 'number', serverSide: 'number' },
      userId: { clientSide: 'number', serverSide: 'number' },
    };
    this._convertKeyType = (key) => {
      if (key.endsWith('Text') || key.endsWith('_text')) {
        return { clientSide: 'string', serverSide: 'undefined' };
      }
      return undefined;
    };
  }

  id = 0 as number;
  checkId = 0 as number;
  /** 审核环节: 1=自评阶段,2=项目保护单位,3=县（区）文旅部门,4=设区市文旅部门、省非遗中心,5=省文化和旅游厅 */
  reviewType = 0 as number;
  /** 状态: 1=通过,2=退回 */
  status = 0 as number;
  reason = '' as string|null;
  operator = 0 as number;
  createtime = '' as string|null;
  progress = 0 as number;
  inheritor = '' as string|null;
  userId = 0 as number;
  reviewTypeText = '' as string;
  statusText = '' as string;
}

/** 传承人基础信息（ich/check/basic） */
export class InheritorCheckBasicInfo extends DataModel<InheritorCheckBasicInfo> {
  constructor() {
    super(InheritorCheckBasicInfo, '传承人自查基础信息');
    this.setNameMapperCase('Camel', 'Snake');
    this._convertTable = {
      userId: { clientSide: 'number', serverSide: 'number' },
      level: { clientSide: 'number', serverSide: 'number' },
      batch: { clientSide: 'number', serverSide: 'number' },
    };
    this._convertKeyType = (key) => {
      if (key.endsWith('Text') || key.endsWith('_text')) {
        return { clientSide: 'string', serverSide: 'undefined' };
      }
      return undefined;
    };
  }

  userId = 0 as number;
  name = '' as string;
  region = '' as string;
  gender = '' as string;
  education = '' as string|null;
  ichName = '' as string;
  unit = '' as string;
  /** 国家级(23), 省级(24), 市级(25) */
  level = 0 as number;
  idCard = '' as string;
  address = '' as string;
  batch = 0 as number;
  mobile = '' as string;
  genderText = '' as string;
  educationText = '' as string;
  levelText = '' as string;
  regionText = '' as string;
  /** 已填写的传承协议ID */
  agreementId = 0 as number;
  /** 已填写的自查表ID */
  checkId = 0 as number;
}

/** 详情中已选计分项 */
export class SelfAssessmentCheckItemAnswer extends DataModel<SelfAssessmentCheckItemAnswer> {
  constructor() {
    super(SelfAssessmentCheckItemAnswer, '自查计分选项');
    this.setNameMapperCase('Camel', 'Snake');
    this._convertTable = {
      id: { clientSide: 'number', serverSide: 'number' },
      points: { clientSide: 'number', serverSide: 'number' },
      count: { clientSide: 'number', serverSide: 'number' },
    };
    this._afterSolveServer = (data) => {
      if (data.itemId)
        data.id = data.itemId;
    }
  }

  id = 0 as number;
  points = 0 as number;
  count = 0 as number;
}

/** 自查评估表详情 */
export class SelfAssessmentDetail extends DataModel<SelfAssessmentDetail> {
  constructor() {
    super(SelfAssessmentDetail, '自查评估表详情');
    this.setNameMapperCase('Camel', 'Snake');
    this._convertTable = {
      id: { clientSide: 'number', serverSide: 'number' },
      userId: { clientSide: 'number', serverSide: 'number' },
      year: { clientSide: 'number', serverSide: 'number' },
      weigh: { clientSide: 'number', serverSide: 'number' },
      deductPoints: { clientSide: 'number', serverSide: 'number' },
      points: { clientSide: 'number', serverSide: 'number' },
      self: { clientSide: 'number', serverSide: 'number' },
      ichUnit: { clientSide: 'number', serverSide: 'number' },
      unitPoints: { clientSide: 'number', serverSide: 'number' },
      county: { clientSide: 'number', serverSide: 'number' },
      countyPoints: { clientSide: 'number', serverSide: 'number' },
      district: { clientSide: 'number', serverSide: 'number' },
      districtPoints: { clientSide: 'number', serverSide: 'number' },
      province: { clientSide: 'number', serverSide: 'number' },
      provincePoints: { clientSide: 'number', serverSide: 'number' },
      districtSt: { clientSide: 'number', serverSide: 'number' },
      districtStPoints: { clientSide: 'number', serverSide: 'number' },
      districtNd: { clientSide: 'number', serverSide: 'number' },
      districtNdPoints: { clientSide: 'number', serverSide: 'number' },
      districtRd: { clientSide: 'number', serverSide: 'number' },
      districtRdPoints: { clientSide: 'number', serverSide: 'number' },
      districtTh: { clientSide: 'number', serverSide: 'number' },
      districtThPoints: { clientSide: 'number', serverSide: 'number' },
      districtFi: { clientSide: 'number', serverSide: 'number' },
      districtFiPoints: { clientSide: 'number', serverSide: 'number' },
      level: { clientSide: 'number', serverSide: 'string' },
      content: {
        customToClientFn: (value) => {
          try {
            if (typeof value === 'object') 
              return value;
            return JSON.parse(value as string);
          } catch {
            return {};
          }
        },
        customToServerFn: (value) => {
          return value;
        },

      },
      awardTime: {
        clientSide: 'dayjs',
        clientSideDateFormat: 'YYYY-MM-DD',
        serverSide: 'dayjsString',
        serverSideDateFormat: 'YYYY-MM-DD',
      },
      checkItems: {
        customToClientFn: (value) => {
          const arr = transformSomeToArray(value);
          for (const item of arr) 
            item.id = item.item_id;
          return transformArrayDataModel(SelfAssessmentCheckItemAnswer, arr, 'data');
        },
        customToServerFn: (value) => {
          return (value as SelfAssessmentCheckItemAnswer[])
            .filter(item => item.count > 0)
            .map((item) => {
              return {
                id: item.id,
                count: item.count,
              };
            });
        },
      },
    };
    this._blackList.toServer = [
      'createtime',
      'updatetime',
      'deletetime',
    ]
    this._convertKeyType = (key) => {
      if (key.endsWith('Text') || key.endsWith('_text')) {
        return { clientSide: 'string', serverSide: 'undefined' };
      }
      return undefined;
    };
    this._beforeSolveClient = (data) => {
      if (data.id == 0)
        delete data.id;
      return data;
    }
  }

  id = 0 as number;
  userId = 0 as number;
  year = 0 as number;
  inheritor = '' as string|null;
  unit = '' as string|null;
  ichName = '' as string|null;
  mobile = '' as string|null;
  idCard = '' as string|null;
  level = null as number|string|null;
  address = '' as string|null;
  content : Record<string, any>|null = null;
  weigh = 0 as number;
  awardTime = dayjs();
  deductContent = '' as string|null;
  deductPoints = 0 as number;
  scan = '' as string|null;
  points = 0 as number;
  /** 进度:
0=草稿,
1=已自评,
2=项目保护单位审核完成,
3=县（区）文旅部门审核完成,
4=设区市文旅部门、省非遗中心审核完成,
5=省文化和旅游厅审核完成 */
  progress = 0;
  /** 自我评估: 1=优秀,2=合格,3=不合格,4=丧失传承能力,5=取消资格 */
  self = null as number|null;
  sign = '' as string|null;
  /** 项目保护单位意见: 1=优秀,2=合格,3=不合格,4=丧失传承能力,5=取消资格 */
  ichUnit = null as number|null;
  /** 项目保护单位评分 */
  unitPoints = 0 as number;
  /** 县（区）文旅部门审核意见: 1=优秀,2=合格,3=不合格,4=丧失传承能力,5=取消资格 */
  county = null as number|null;
  /** 县（区）文旅部门评分 */
  countyPoints = 0 as number;
  /** 设区市文旅部门、省非遗中心审核意见: 1=优秀,2=合格,3=不合格,4=丧失传承能力,5=取消资格 */
  district = null as number|null;
  /** 设区市文旅部门、省非遗中心评分 */
  districtPoints = 0 as number;
  /** 省文化和旅游厅意见: 1=优秀,2=合格,3=不合格,4=丧失传承能力,5=取消资格 */
  province = null as number|null;
  /** 省文化和旅游厅评分 */
  provincePoints = 0 as number;
  /** 项目负责人意见: 0=未审核,1=优秀,2=合格,3=不合格,4=丧失传承能力,5=取消资格 */
  districtSt = null as number|null;
  /** 项目负责人评分 */
  districtStPoints = 0 as number;
  /** 部门主任意见: 0=未审核,1=优秀,2=合格,3=不合格,4=丧失传承能力,5=取消资格 */
  districtNd = null as number|null;
  /** 部门主任评分 */
  districtNdPoints = 0 as number;
  /** 分管领导意见: 0=未审核,1=优秀,2=合格,3=不合格,4=丧失传承能力,5=取消资格 */
  districtRd = null as number|null;
  /** 分管领导评分 */
  districtRdPoints = 0 as number;
  /** 工服处意见: 0=未审核,1=优秀,2=合格,3=不合格,4=丧失传承能力,5=取消资格 */
  districtTh = null as number|null;
  /** 工服处评分 */
  districtThPoints = 0 as number;
  /** 工服处-分管领导意见: 0=未审核,1=优秀,2=合格,3=不合格,4=丧失传承能力,5=取消资格 */
  districtFi = null as number|null;
  /** 工服处-分管领导评分 */
  districtFiPoints = 0 as number;
  createtime = '' as string;
  updatetime = '' as string;
  deletetime = '' as string|null;
  selfText = '' as string;
  checkItems :  SelfAssessmentCheckItemAnswer[] = [];
  /** 退回状态: 0=无,1=自评阶段退回,2=项目保护单位退回,3=县（区）文旅部门退回,4=设区市文旅部门/省非遗中心退回,5=省文化和旅游厅退回 */
  rejectType = 0 as number;
  /** 退回原因 */
  rejectReason = '' as string;
  /** 退回意见 reasons [键值-角色组id : 退回意见] */
  reasons = {} as Record<number, string>;
}

/** 传承协议详情 */
export class AgreementDetail extends DataModel<AgreementDetail> {
  constructor() {
    super(AgreementDetail, '传承协议详情');
    this.setNameMapperCase('Camel', 'Snake');
    this._convertTable = {
      id: { clientSide: 'number', serverSide: 'number' },
      userId: { clientSide: 'number', serverSide: 'number' },
      year: { clientSide: 'number', serverSide: 'number' },
      apprentice: { clientSide: 'number', serverSide: 'number' },
      activity: { clientSide: 'number', serverSide: 'number' },
      course: { clientSide: 'number', serverSide: 'number' },
      level: { clientSide: 'number', serverSide: 'number' },
      updatetime: { clientSide: 'date', serverSide: 'undefined' },
    };
    this._nameMapperClient = {
      partyA: 'party_a',
      partyB: 'party_b',
      partyASign: 'party_a_sign',
      partyBSign: 'party_b_sign',
      partyAMobile: 'party_a_mobile',
    }
    this._blackList.toServer = [
      'createtime',
      'updatetime',
      'deletetime',
    ]
    this._beforeSolveClient = (data) => {
      if (data.id == 0)
        delete data.id;
      return data;
    }
  }

  id = 0 as number;
  userId = 0 as number;
  level = null as number|null;
  year = 0 as number;
  partyA = '' as string|null;
  partyB = '' as string|null;
  apprentice = 0 as number;
  activity = 0 as number;
  course = 0 as number;
  mobile = '' as string|null;
  /** 进度: 0=草稿,1=已自评,2=项目保护单位审核完成,3=县（区）文旅部门审核完成,4=设区市文旅部门、省非遗中心审核完成,5=省文化和旅游厅审核完成 */
  progress: number = 0;
  /** 退回状态: 0=无,1=自评阶段退回,2=项目保护单位退回,3=县（区）文旅部门退回,4=设区市文旅部门、省非遗中心退回,5=省文化和旅游厅退回 */
  rejectType: number = 0;
  /** 退回原因 */
  rejectReason?: string;
  partyAMobile = '' as string|null;
  idCard = '' as string|null;
  health = '' as string|null;
  ich = '' as string|null;
  scan = '' as string|null;
  partyASign = '' as string|null;
  partyBSign = '' as string|null;
  unitSign = '' as string|null;
  updatetime = new Date();
}

export function getRejectTypeText(d: number) {
  switch (d) {
    case 0: return '无';
    case 1: return '自评阶段退回';
    case 2: return '项目保护单位退回';
    case 3: return '县（区）文旅部门退回';
    case 4: return '设区市文旅部门/省非遗中心退回';
    case 5: return '省文化和旅游厅退回';
    default: return '未知';
  }
}

/** 证明材料附件类型（saveAnnex `type`） */
export const CheckAnnexType = {
  Image: 1,
  Video: 2,
  Audio: 3,
  Document: 4,
  Other: 5,
  ExternalLink: 6,
} as const;

export function getCheckAnnexType(mimetype: string) {
  if (mimetype.startsWith('image/')) return CheckAnnexType.Image;
  if (mimetype.startsWith('video/')) return CheckAnnexType.Video;
  if (mimetype.startsWith('audio/')) return CheckAnnexType.Audio;
  if (mimetype.startsWith('application/pdf')) return CheckAnnexType.Document;
  return CheckAnnexType.Other;
}

export type CheckAnnexTypeValue = (typeof CheckAnnexType)[keyof typeof CheckAnnexType];

/** 传承协议审核提交（POST /ich/check/reviewAgreement） */
export interface AgreementReviewPayload {
  /** 传承协议 ID */
  id: number;
  /** 进度: 0=草稿,1=已自评,2=项目保护单位审核完成,3=县（区）文旅部门审核完成,4=设区市文旅部门、省非遗中心审核完成,5=省文化和旅游厅审核完成 */
  progress: number;
  /** 退回状态: 0=无,1=自评阶段退回,2=项目保护单位退回,3=县（区）文旅部门退回,4=设区市文旅部门、省非遗中心退回,5=省文化和旅游厅退回 */
  rejectType?: number;
  /** 退回原因 */
  rejectReason?: string;
}

/** 自查表审核提交（POST /ich/check/review） */
export interface IchCheckReviewPayload {
  /** 自查表 ID */
  id: number;
  /** 项目保护单位意见: 0=未审核,1=优秀,2=合格,3=不合格,4=丧失传承能力,5=取消资格 */
  ichUnit?: number;
  unitPoints?: number;
  /** 县（区）文旅部门审核意见，取值同 ichUnit */
  county?: number;
  countyPoints?: number;
  /** 设区市文旅部门、省非遗中心审核意见，取值同 ichUnit */
  district?: number;
  districtPoints?: number;
  /** 省文化和旅游厅意见，取值同 ichUnit */
  province?: number;
  provincePoints?: number;
  /** 项目负责人意见，取值同 ichUnit */
  districtSt?: number;
  districtStPoints?: number;
  /** 部门主任意见，取值同 ichUnit */
  districtNd?: number;
  districtNdPoints?: number;
  /** 分管领导意见，取值同 ichUnit */
  districtRd?: number;
  districtRdPoints?: number;
  /** 工服处意见，取值同 ichUnit */
  districtTh?: number;
  districtThPoints?: number;
  /** 工服处-分管领导意见，取值同 ichUnit */
  districtFi?: number;
  districtFiPoints?: number;
  /** 0=草稿,1=已自评,2=项目保护单位审核完成,3=县（区）文旅部门审核完成,4=设区市文旅部门/省非遗中心审核完成,5=省文化和旅游厅审核完成 */
  progress: number;
  /** 退回状态: 0=无,1=自评阶段退回,2=项目保护单位退回,3=县(区)文旅部门退回,4=设区市文旅部门/省非遗中心退回,5=省文化和旅游厅退回 */
  rejectType?: number;
  /** 退回原因 */
  rejectReason?: string;
  /** 退回意见 reasons [键值-角色组id : 退回意见] */
  reasons?:Record<number, string>;

  sendMsg?: boolean;
}

/** 过会后修改分数和意见请求体（POST /ich/check/checkReview） */
export interface CheckReviewPayload {
  checkId: number;
  ichUnit?: number;
  unitPoints?: number;
  county?: number;
  countyPoints?: number;
  district?: number;
  districtPoints?: number;
  province?: number;
  provincePoints?: number;
  progress?: number;
  rejectType?: number;
  rejectReason?: string;
  scan?: string;
}

/** 自查评估表审核（新）请求体（POST /ich/check/reviewOnly） */
export interface SelfAssessmentReviewOnlyPayload {
  /** 自查表 ID */
  checkId: number;
  /** 审核角色组 ID */
  groupId: number;
  /** 退回状态：0=无,1=自评阶段退回,2=项目保护单位退回,3=县（区）文旅部门退回,4=设区市文旅部门、省非遗中心退回,5=省文化和旅游厅退回 */
  rejectType: number;
  /** 审核退回意见 */
  rejectReason?: string;
  /** 评估级别: 1=优秀,2=合格,3=不合格,4=丧失传承能力,5=取消资格 */
  opinion?: number;
  /** 评分 */
  points?: number;
  /** 发送短信:0=否,1=是 */
  sendMsg?: number;
}

/** 自查评估表审核（新）返回结果 */
export interface SelfAssessmentReviewOnlyResult {
  /** 操作级别 */
  operateLevel: number;
  /** 操作角色组ID */
  targetGroupId: string;
  /** 短信内容 */
  smsInfo: string;
  /** 是否退回 */
  isFormalReject: boolean;
  /** 是否改变进度 */
  canChangeProgress: boolean;
  /** 新进度 */
  newProgress: number;
}

/** 证明材料修改与新增请求体（POST /ich/check/saveAnnex） */
export interface SaveCheckAnnexPayload {
  id?: number;
  name: string;
  formId: number;
  itemId?: number;
  url: string;
  type: CheckAnnexTypeValue | number;
  desc?: string;
  mimetype?: string;
  attachId?: number;
  fileSize?: number;
}

/** 证明材料列表项（getAnnexList） */
export class CheckAnnexListItem extends DataModel<CheckAnnexListItem> {
  constructor() {
    super(CheckAnnexListItem, '证明材料列表项');
    this.setNameMapperCase('Camel', 'Snake');
    this._convertTable = {
      id: { clientSide: 'number', serverSide: 'number' },
      formId: { clientSide: 'number', serverSide: 'number' },
      type: { clientSide: 'number', serverSide: 'number' },
      attachId: { clientSide: 'number', serverSide: 'number' },
      fileSize: { clientSide: 'number', serverSide: 'number' },
    };
  }

  id = 0 as number;
  name = '' as string;
  formId = 0 as number;
  url = '' as string;
  type = 0 as number;
  desc = '' as string|null;
  mimetype = '' as string|null;
  attachId = null as number|null;
  fileSize = null as number|null;
  createtime = '' as string|null;
  updatetime = '' as string|null;
}

export class DataCountItem extends DataModel<DataCountItem> {
  constructor() {
    super(DataCountItem, '统计条目');
    this.setNameMapperCase('Camel', 'Snake');
    this._convertTable = {
      num: { clientSide: 'number' },
    };
    this._nameMapperServer = {
      progress: 'key',
      reject_type: 'key',
      progress_text: 'title',
      reject_type_text: 'title',
      num: 'value',
    };
  }

  title = '';
  key = 0 as number;
  value = 0 as number;
}

export type IchCheckPaginated<T> = {
  total: number;
  perPage: number;
  currentPage: number;
  lastPage: number;
  data: T[];
};

function normalizePaginated<T extends DataModel>(rowClass: new () => T, raw: KeyValue): IchCheckPaginated<T> {
  return {
    total: Number(raw.total ?? 0),
    perPage: Number(raw.per_page ?? 0),
    currentPage: Number(raw.current_page ?? 0),
    lastPage: Number(raw.last_page ?? 0),
    data: transformArrayDataModel(rowClass, transformSomeToArray(raw.data), 'data'),
  };
}

function buildPdfUrl(baseUrl: string, path: string, id: number) {
  const auth = useAuthStore();
  let url = `${baseUrl}${path}?id=${encodeURIComponent(String(id))}`;
  url = appendGetUrlParams(url, 'main_body_id', ApiCofig.mainBodyId);
  url = appendGetUrlParams(url, 'token', auth.token);
  return url;
}

async function downloadPdfBlob(path: string, id: number, baseUrl: string, defaultFilename: string) {
  const url = buildPdfUrl(baseUrl, path, id);
  const auth = useAuthStore();
  const res = await fetch(url, {
    method: 'GET',
    headers: {
      token: auth.token,
      __token__: auth.token,
    },
  });
  if (!res.ok)
    throw new Error('下载失败，状态码：' + res.status);
  const blob = await res.blob();
  const objectUrl = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = objectUrl;
  a.download = defaultFilename;
  a.rel = 'noopener';
  document.body.appendChild(a);
  a.click();
  document.body.removeChild(a);
  URL.revokeObjectURL(objectUrl);
}

export class AssessmentContentApi extends AppServerRequestModule<DataModel> {

  constructor() {
    super();
  }

  async getDataCount(level?: number) {
    const res = (await this.post<{
      agreement: object;
      agreement_reject: object;
      check: object;
      check_reject: object;
    }>('/ich/check/dataCount', '自查/协议数据统计', {
      level,
    })).requireData();
    return {
      /**自查评估表统计 {进度值progress:数量} */
      check: transformArrayDataModel<DataCountItem>(DataCountItem, transformSomeToArray(res.check), 'data.check'),
      /**自查评估表退回统计 {退回类型reject_type:数量} */
      checkReject: transformArrayDataModel<DataCountItem>(DataCountItem, transformSomeToArray(res.check_reject), 'data.checkReject'),
      /**传承协议统计 {进度值progress:数量} */
      agreement: transformArrayDataModel<DataCountItem>(DataCountItem, transformSomeToArray(res.agreement), 'data.agreement'),
      /**传承协议退回统计 {退回类型reject_type:数量} */
      agreementReject: transformArrayDataModel<DataCountItem>(DataCountItem, transformSomeToArray(res.agreement_reject), 'data.agreementReject'),
    };
  }

  async getCheckItems(level: number) {
    const res = await this.post('/ich/check/getCheckItems', '自查计分项目', { level });
    const list = transformSomeToArray(res.data) as KeyValue[];
    const items = transformArrayDataModel<CheckItemInfo>(CheckItemInfo, list, 'data') as CheckItemInfo[];
    const map = new Map<number, CheckItemInfo>();
    for (const item of items)
      map.set(item.id, item);
    const top = items.filter((item) => item.pid === 0);
    for (const item of items)
      item.children = items.filter((i) => i.pid === item.id);
    return {
      top,
      map,
    };
  }

  async getSelfAssessmentList(data: {
    userId?: number;
    progress?: number;
    level?: number;
    year?: number;
    keywords?: string;
    page?: number;
    pageSize?: number;
  }) {
    const res = await this.post<KeyValue>('/ich/check/getList', '评估表列表', {
      user_id: data.userId,
      progress: data.progress,
      level: data.level,
      year: data.year,
      keywords: data.keywords,
      page: data.page,
      pageSize: data.pageSize,
    });
    return normalizePaginated<SelfAssessmentListRow>(SelfAssessmentListRow, res.requireData());
  }

  async getAgreementList(data: {
    userId?: number;
    level?: number;
    year?: number;
    keywords?: string;
    page?: number;
    pageSize?: number;
  }) {
    const res = await this.post<KeyValue>('/ich/check/getAgreementList', '传承协议列表', {
      user_id: data.userId,
      level: data.level,
      year: data.year,
      keywords: data.keywords,
      page: data.page,
      pageSize: data.pageSize,
    });
    return normalizePaginated<AgreementListRow>(AgreementListRow, res.requireData());
  }

  /**
   * 保护单位账号：传承人传承协议分页列表
   * @param data.progress -1=未提交,0=草稿,1=已自评,2=审核完成
   */
  async getUserAgreementList(data: {
    userId?: number;
    progress?: number;
    level?: number;
    year?: number;
    keywords?: string;
    page?: number;
    pageSize?: number;
  }) {
    const res = await this.post<KeyValue>('/ich/check/getUserAgreement', '传承人传承协议列表', {
      user_id: data.userId,
      progress: data.progress,
      level: data.level,
      year: data.year,
      keywords: data.keywords,
      page: data.page,
      pageSize: data.pageSize,
    });
    return normalizePaginated<UserAgreementListRow>(UserAgreementListRow, res.requireData());
  }

  /**
   * 自查表审核日志列表
   */
  async getCheckLogList(data: {
    userId?: number;
    reviewType?: number;
    year?: number;
    status?: number;
    operator?: number;
    checkId?: number;
    keywords?: string;
    page?: number;
    pageSize?: number;
  }) {
    const res = await this.post<KeyValue>('/ich/check/checkLogList', '自查表审核日志', {
      user_id: data.userId,
      review_type: data.reviewType,
      year: data.year,
      status: data.status,
      operator: data.operator,
      check_id: data.checkId,
      keywords: data.keywords,
      page: data.page,
      pageSize: data.pageSize,
    });
    return normalizePaginated<CheckLogListRow>(CheckLogListRow, res.requireData());
  }

  /**
   * 保护单位账号：传承人分页列表
   * @param data.progress -1=未提交,0=草稿,1=已自评,2=项目保护单位审核完成,3=县（区）文旅部门审核完成,4=设区市文旅部门/省非遗中心审核完成,5=省文化和旅游厅审核完成
   */
  async getInheritorList(data: {
    userId?: number;
    progress?: number;
    level?: number;
    year?: number;
    keywords?: string;
    page?: number;
    pageSize?: number;
    logStatus?: number;
  }) {
    const res = await this.post<KeyValue>('/ich/check/getInheritorList', '传承人列表', {
      user_id: data.userId,
      progress: data.progress,
      level: data.level,
      year: data.year,
      keywords: data.keywords,
      page: data.page,
      pageSize: data.pageSize,
      log_status: data.logStatus,
    });
    return normalizePaginated<InheritorCheckListRow>(InheritorCheckListRow, res.requireData());
  }

  async saveAgreement(dataModel: AgreementDetail) {
    return this.post('/ich/check/saveAgreement', '传承协议保存', dataModel.toServerSide());
  }

  /**
   * 传承协议审核
   * POST `/ich/check/reviewAgreement`
   */
  async reviewAgreement(payload: AgreementReviewPayload) {
    return this.post('/ich/check/reviewAgreement', '传承协议审核', {
      id: payload.id,
      progress: payload.progress,
      reject_type: payload.rejectType || 0,
      reject_reason: payload.rejectReason,
    });
  }

  async saveSelfAssessment(dataModel: SelfAssessmentDetail, progress?: number) {
    const data = dataModel.toServerSide();
    if (progress !== undefined)
      data.progress = progress;
    return this.post('/ich/check/save', '自查评估表保存', data);
  }

  /**
   * 自查评估表审核
   * POST `/ich/check/review`
   */
  async reviewSelfAssessment(payload: IchCheckReviewPayload) {
    return this.post('/ich/check/review', '自查评估表审核', {
      id: payload.id,
      ich_unit: payload.ichUnit,
      unit_points: payload.unitPoints,
      county: payload.county,
      county_points: payload.countyPoints,
      district: payload.district,
      district_points: payload.districtPoints,
      province: payload.province,
      province_points: payload.provincePoints,
      district_st: payload.districtSt,
      district_st_points: payload.districtStPoints,
      district_nd: payload.districtNd,
      district_nd_points: payload.districtNdPoints,
      district_rd: payload.districtRd,
      district_rd_points: payload.districtRdPoints,
      district_th: payload.districtTh,
      district_th_points: payload.districtThPoints,
      district_fi: payload.districtFi,
      district_fi_points: payload.districtFiPoints,
      progress: payload.progress,
      reject_type: payload.rejectType || 0,
      reject_reason: payload.rejectReason,
      reasons: payload.reasons,
      send_msg: payload.sendMsg === false ? 0 : undefined,
    });
  }

  /**
   * 自查评估表审核（新）
   * POST `/ich/check/reviewOnly`
   */
  async reviewOnly(payload: SelfAssessmentReviewOnlyPayload) {
    return this.post<SelfAssessmentReviewOnlyResult>('/ich/check/reviewOnly', '自查评估表审核（新）', {
      check_id: payload.checkId,
      group_id: payload.groupId,
      reject_type: payload.rejectType,
      reject_reason: payload.rejectReason,
      opinion: payload.opinion,
      points: payload.points,
      send_msg: payload.sendMsg,
    });
  }

  /**
   * 过会后修改分数和意见
   * POST `/ich/check/checkReview`
   */
  async checkReview(payload: CheckReviewPayload) {
    return this.post('/ich/check/checkReview', '过会后修改分数和意见', {
      check_id: payload.checkId,
      ich_unit: payload.ichUnit,
      unit_points: payload.unitPoints,
      county: payload.county,
      county_points: payload.countyPoints,
      district: payload.district,
      district_points: payload.districtPoints,
      province: payload.province,
      province_points: payload.provincePoints,
      progress: payload.progress,
      reject_type: payload.rejectType,
      reject_reason: payload.rejectReason,
      scan: payload.scan,
    });
  }

  async downloadSelfAssessmentPdf(id: number) {
    await downloadPdfBlob('/pdf/create', id, this.config.baseUrl, `self-assessment-${id}.pdf`);
  }
  /**
   * 预览自查评估表 PDF
   */
  async previewSelfAssessmentPdf(id: number) {
    const url = `${this.config.baseUrl}/pdf/create/${id}?main_body_id=${ApiCofig.mainBodyId}`;
    const auth = useAuthStore();
    const res = await fetch(url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        token: auth.token,
        __token__: auth.token,
      },
      body: JSON.stringify({ id }),
    });
    if (!res.ok)
      throw new Error('预览失败，状态码：' + res.status);
    const blob = await res.blob();
    return URL.createObjectURL(blob);
  }

  async downloadAgreementPdf(id: number) {
    await downloadPdfBlob('/pdf/nationalContract', id, this.config.baseUrl, `agreement-${id}.pdf`);
  }
  /**
   * 预览传承协议 PDF
   */
  async previewAgreementPdf(id: number) {
    const url = `${this.config.baseUrl}/pdf/nationalContract/?id=${id}&main_body_id=${ApiCofig.mainBodyId}`;
    const auth = useAuthStore();
    const res = await fetch(url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        token: auth.token,
        __token__: auth.token,
      },
    });
    if (!res.ok)
      throw new Error('预览失败，状态码：' + res.status);
    const blob = await res.blob();
    return URL.createObjectURL(blob);
  }

  async saveAnnex(payload: SaveCheckAnnexPayload) {
    return this.post('/ich/check/saveAnnex', '证明材料保存', {
      id: payload.id,
      name: payload.name,
      form_id: payload.formId,
      item_id: payload.itemId,
      url: payload.url,
      type: payload.type,
      desc: payload.desc,
      mimetype: payload.mimetype,
      attach_id: payload.attachId,
      filesize: payload.fileSize,
    });
  }

  async getAnnexList(formId: number, itemId?: number) {
    const res = await this.post<KeyValue>('/ich/check/getAnnexList', '证明材料列表', {
      form_id: formId,
      item_id: itemId,
    });
    return normalizePaginated<CheckAnnexListItem>(CheckAnnexListItem, res.requireData());
  }

  async delAnnex(id: number) {
    return this.post('/ich/check/delAnnex', '删除证明材料', { id });
  }

  async getInheritorBasic(userId?: number) {
    const res = await this.post<KeyValue>('/ich/check/basic', '传承人自查基础信息', {
      user_id: userId,
    });
    return transformDataModel<InheritorCheckBasicInfo>(InheritorCheckBasicInfo, res.requireData());
  }

  async getSelfAssessmentDetail(id: number, userId?: number) {
    const res = await this.post<KeyValue>('/ich/check/detail', '评估表详情', { id, user_id: userId });
    return transformDataModel<SelfAssessmentDetail>(SelfAssessmentDetail, res.requireData());
  }

  async getAgreementDetail(id: number, userId?: number) {
    const res = await this.post<KeyValue>('/ich/check/agreementDetail', '传承协议详情', { id, user_id: userId });
    return transformDataModel<AgreementDetail>(AgreementDetail, res.requireData());
  }

  /**
   * 自查表汇总excel导出
   */
  async exportCheckExcel(data: { level?: number; year?: number; progress?: number }) {
    const auth = useAuthStore();
    let url = `${this.config.baseUrl}/pdf/exportCheckExcel`;
    url = appendGetUrlParams(url, 'main_body_id', ApiCofig.mainBodyId);
    url = appendGetUrlParams(url, 'token', auth.token);
    if (data.level !== undefined) url = appendGetUrlParams(url, 'level', String(data.level));
    if (data.year) url = appendGetUrlParams(url, 'year', String(data.year));
    if (data.progress !== undefined) url = appendGetUrlParams(url, 'progress', String(data.progress));
    const res = await fetch(url, {
      method: 'POST',
      headers: {
        token: auth.token,
        __token__: auth.token,
      },
    });
    if (!res.ok)
      throw new Error('导出失败，状态码：' + res.status);
    const blob = await res.blob();
    const objectUrl = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = objectUrl;
    a.download = `自查表汇总-${data.year || '全部'}.xlsx`;
    a.rel = 'noopener';
    document.body.appendChild(a);
    a.click();
    document.body.removeChild(a);
    URL.revokeObjectURL(objectUrl);
  }

  /**
   * 打包传承人自查表、汇总表zip下载
   * @see https://www.showdoc.com.cn/minnanCE/11559060626887137
   */
  async downloadCheckZip(data: { 
    year?: number; 
    level?: number;
    progress?: number 
  }) {
    const auth = useAuthStore();
    let url = `${this.config.baseUrl}/inheritor_check_download/index`;
    url = appendGetUrlParams(url, 'main_body_id', ApiCofig.mainBodyId);
    url = appendGetUrlParams(url, 'token', auth.token);
    if (data.year) url = appendGetUrlParams(url, 'year', String(data.year));
    if (data.level !== undefined) url = appendGetUrlParams(url, 'level', String(data.level));
    if (data.progress !== undefined) url = appendGetUrlParams(url, 'progress', String(data.progress));
    const res = await fetch(url, {
      method: 'POST',
      headers: {
        token: auth.token,
        __token__: auth.token,
      },
    });
    if (!res.ok)
      throw new Error('下载失败，状态码：' + res.status);
    const blob = await res.blob();
    const objectUrl = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = objectUrl;
    a.download = `自查表汇总-${data.year || '全部'}.zip`;
    a.rel = 'noopener';
    document.body.appendChild(a);
    a.click();
    document.body.removeChild(a);
    URL.revokeObjectURL(objectUrl);
  }

  /**
   * 审核结果建议汇总 PDF 导出
   * @see pdf/exportSummaryPdf
   */
  private buildSummaryPdfUrl(data: { year?: number; level?: string; region?: string }) {
    const auth = useAuthStore();
    let url = `${this.config.baseUrl}/pdf/exportSummaryPdf`;
    url = appendGetUrlParams(url, 'main_body_id', ApiCofig.mainBodyId);
    url = appendGetUrlParams(url, 'token', auth.token);
    if (data.year) url = appendGetUrlParams(url, 'year', String(data.year));
    if (data.level !== undefined && data.level !== '') url = appendGetUrlParams(url, 'level', data.level);
    if (data.region !== undefined && data.region !== '') url = appendGetUrlParams(url, 'region', data.region);
    return url;
  }

  /**
   * 预览审核结果建议汇总 PDF
   * @returns PDF Blob URL
   */
  async previewSummaryPdf(data: { year?: number; level?: string; region?: string }) {
    const url = this.buildSummaryPdfUrl(data);
    const auth = useAuthStore();
    const res = await fetch(url, {
      method: 'POST',
      headers: {
        token: auth.token,
        __token__: auth.token,
      },
    });
    if (!res.ok)
      throw new Error('预览失败，状态码：' + res.status);
    const blob = await res.blob();
    return URL.createObjectURL(blob);
  }

  /**
   * 下载审核结果建议汇总 PDF
   */
  async downloadSummaryPdf(data: { year?: number; level?: string; region?: string }) {
    const url = this.buildSummaryPdfUrl(data);
    const auth = useAuthStore();
    const res = await fetch(url, {
      method: 'POST',
      headers: {
        token: auth.token,
        __token__: auth.token,
      },
    });
    if (!res.ok)
      throw new Error('下载失败，状态码：' + res.status);
    const blob = await res.blob();
    const objectUrl = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = objectUrl;
    a.download = `审核结果建议汇总-${data.year || '全部'}.pdf`;
    a.rel = 'noopener';
    document.body.appendChild(a);
    a.click();
    document.body.removeChild(a);
    URL.revokeObjectURL(objectUrl);
  }
}

export default new AssessmentContentApi();