import Vue from 'vue'
import router from '@/router'
import HotentUi from 'hotent-ui'
import utils from 'hotent-ui/src/utils.js'
import wangeditor from 'hotent-ui/packages/plugins/wangeditor'
import Echarts from 'hotent-ui/packages/plugins/Echarts'
import Map from 'hotent-ui/packages/plugins/Map'
import Qrcode from 'hotent-ui/packages/plugins/Qrcode'
import XLSX from 'hotent-ui/packages/plugins/XLSX'
import 'hotent-ui/lib/hotent-ui.css'
import HotentPortal from 'hotent-portal'
import 'hotent-portal/lib/hotent-portal.css'
import 'hotent-portal/src/icon/index.js'

import request from '@/utils/request.js'
// import i18n from '@/lang/index.js'
import store from '@/store'

const manage = window.context.manage
const front = window.context.front
const mobile = window.context.mobile
const form = window.context.form
const uc = window.context.uc
const flow = window.context.bpmRunTime
const portal = window.context.portal
const model = window.context.bpmModel
const runtime = window.context.bpmRunTime
const version = 'v1'
const type = 'mobile'

const getUserId = () => {
  return store.getters['login/userId']
}

const getAccount = () => {
  const account = store.state.login.account
  return account
}
const getToken = () => {
  const accessToken = store.getters['login/token']
  return accessToken ? `Bearer ${accessToken}` : null
}

const getPostById = (postMap, postId) => {
  let post = null
  if (postMap) {
    for (let k in postMap) {
      if (postMap[k].postId === postId) {
        post = postMap[k]
      }
    }
    if (!post) {
      post = Object.values(postMap)[0]
    }
  }
  return post
}

const getTokenOnly = () => {
  const accessToken = store.getters['login/token']
  return accessToken
}

const requestConfig = {
  /**1.全局设置 start ****************************************************************/
  baseUrl: form,
  // 管理端地址
  manageUrl: manage,
  // 应用端地址
  frontUrl: front,
  // 移动端地址
  mobileUrl: mobile,
  // 流程建模地址
  bpmModelUrl: model,
  // 表单地址
  formUrl: form,
  // 用户中心地址
  ucUrl: uc,
  // 流程运行时地址
  flowUrl: flow,
  // 门户地址
  portalUrl: portal,
  // 客户端类型
  type: type,

  /** 用户信息获取 start */
  getToken,
  getTokenOnly,
  getUserId,
  getAccount,
  /** 用户信息获取 end */

  // 附件处理的头部信息
  header: () => {
    return {
      Authorization: getToken(),
    }
  },
  // 通用查询
  request: (params) => {
    params.url = utils.parseExp(params.url, { form, uc, flow, portal, model })
    return request(params)
  },

  // 获取服务器当前时间
  getCurrentServerTime: (format) => {
    return request({
      url: `${form}/base/tools/v1/getCurrentDate?valFormat=${format}`,
    }).then((resp) => {
      return resp.value
    })
  },
  // 通用返回事件
  goBack: () => {
    Vue.prototype.$tabs.close()
  },
  //通用获取图片地址
  getImgSrc: (fileId) => {
    return `${portal}/system/file/v1/downloadFile?fileId=${fileId}`
  },
  /**全局设置 end ********************************************************************/

  /**2.表单设置 start ****************************************************************/
  // 获取关联查询定义
  getCustomQuery: (alias) => {
    return request({
      url: `${form}/form/customQuery/v1/getByAlias`,
      method: 'post',
      data: alias,
    })
  },
  // 通过表单ID获取表单数据（包括bpmForm,permission,data)
  getFormById: (formId) => {
    return request({
      url: `${form}/form/form/v1/previewDesignVue?formId=${formId}`,
    })
  },
  // 通过id获取图表
  getChartById: (id) => {
    return request({
      url: `${form}/form/customChart/v1/get/${id}`,
    })
  },
  // 通过别名获取图表
  getChartByAlias: (alias) => {
    return request({
      url: `${form}/form/customChart/v1/getByAlias?alias=${alias}`,
    })
  },
  // 获取图表的列表数据
  getChartListData: (alias, params) => {
    return request({
      url: `${form}/form/customChart/v1/getListData?alias=${alias}`,
      method: 'post',
      data: params,
    })
  },
  //获取业务数据模板信息
  getBpmDataTemplateInfo(data) {
    return request({
      url: `${form}/form/dataTemplate/v1/getBpmDataTemplateInfo?alias=${
        data.templateKey
      }&needDisplayFileds=${data.needDisplayFileds ? true : false}`,
      method: 'get',
    })
  },
  //获取业务数据模板列表模板html
  getTemplateDataListForm(data) {
    return request({
      url: `${form}/form/dataTemplate/v1/dataList_${data}?isMobile=true`,
      method: 'post',
      data: {},
    })
  },
  //根据别名获取树形自定义对话框数据
  getCustomDialogTreeData(alias) {
    return request({
      url: `${form}/form/customDialog/v1/getTreeData?alias=${alias}&mapParam=`,
      method: 'get',
    })
  },
  //获取业务数据模板子表信息
  getSubEntsByFormKey(formKey) {
    return request({
      url: `${form}/form/form/v1/getSubEntsByFormKey?formKey=${formKey}`,
      method: 'get',
    })
  },
  //导入主表数据
  dataTemplateMainImport(data) {
    return request({
      url: `${form}/form/dataTemplate/v1/newImport?alias=${
        data.alias
      }&bindFilld=${data.bindFilld || ''}&fillValue=${
        data.fillValue || ''
      }&refIdValue=${data.refIdValue || ''}`,
      data: data.data,
      method: 'post',
    })
  },
  //导出子表数据
  dataTemplateSubExport(data) {
    return request({
      url: `${form}/form/dataTemplate/v1/exportSub`,
      method: 'post',
      data: data,
      responseType: 'arraybuffer',
    })
  },
  //根据别名获取自定义对话框
  getCustomDialogByAlias(alias) {
    return request({
      url: `${form}/form/customDialog/v1/getByAlias?alias=${alias}`,
      method: 'get',
    })
  },
  //表单列表子表导入
  dataTemplateSubImport(data) {
    return request({
      url: `${form}/form/dataTemplate/v1/importSub?refId=${data.refId}&alias=${
        data.alias
      }&formKey=${data.formKey || ''}`,
      method: 'post',
      data: data.data,
    })
  },
  //根据表单ID获取流程实例对象
  getDataTemplateDataList(param) {
    return request({
      url: `${form}/form/dataTemplate/v1/listJson`,
      method: 'post',
      data: param,
    })
  },
  //删除表单列表的bo数据
  deleteTemplateDataById(data) {
    return request({
      url: `${form}/form/dataTemplate/v1/boDel/${data.boAlias}?ids=${
        data.ids
      }&formKey=${data.formKey || ''}`,
      method: 'delete',
    })
  },
  //表单列表下载导入模板
  downloadTempFile(data) {
    return request({
      url: `${form}/form/dataTemplate/v1/downloadTempFile/${data}`,
      method: 'post',
      responseType: 'arraybuffer',
    })
  },
  //业务数据模板导出
  templateExport(data) {
    return request({
      url: `${form}/form/dataTemplate/v1/export?formKey=${data.boAlias}&getType=${data.getType}&filterKey=${data.filterKey}&expField=${data.expField}`,
      method: 'post',
      data: data.query,
      responseType: 'arraybuffer',
    })
  },
  //业务数据模板导出
  exportByBtnSetting(data) {
    return request({
      url: `${form}/form/dataTemplate/v1/exportByBtnSetting?id=${data.id}`,
      method: 'post',
      data: data.params,
      timeout: 30000,
      responseType: 'arraybuffer',
    })
  },
  //获取表单列表的子表数据
  getDataTemplateSubData(data) {
    return request({
      url: `${form}/form/dataTemplate/v1/getSubDataPagination?alias=${data.name}&refId=${data.refId}`,
      method: 'post',
      data: data.pagination,
    })
  },
  //保存表单bo数据
  boSave(data) {
    return request({
      url: `${form}/form/dataTemplate/v1/boSave/${data.templateKey}/${
        data.boAlias
      }?delDraftId=${data.delDraftId || ''}`,
      method: 'post',
      data: data.boData,
    })
  },
  boSaveDraft(data) {
    return request({
      url: `${form}/form/dataTemplate/v1/boSaveDraft`,
      method: 'post',
      data: data,
    })
  },
  boCopy(data) {
    return request({
      url: `${form}/form/dataTemplate/v1/boCopy`,
      method: 'post',
      data: data,
    })
  },
  //获取业务数据模板信息
  batchUpdateTemplateData(data) {
    return request({
      url: `${form}/form/dataTemplate/v1/boBatchUpdate/${data.boAlias}`,
      method: 'post',
      data: data.boData,
      timeout: 120000,
    })
  },
  batchUpdateTemplateRowData(data) {
    return request({
      url: `${form}/form/dataTemplate/v1/boBatchUpdate/${data.boAlias}`,
      method: 'post',
      data: data.boData,
    })
  },
  //获取表单列表导入后的日志列表
  getDataTemplateImportLogData(param) {
    return request({
      url: `${form}/form/formDataImportLog/v1/listJson`,
      method: 'post',
      data: param,
    })
  },
  //根据表单列表别名获取导入日志
  getImportLogData(data) {
    return request({
      url: `${form}/form/formDataTemplateImportLog/v1/listJson`,
      method: 'post',
      data,
    })
  },
  getImportErrorInfoById(id) {
    return request({
      url: `${form}/form/formDataTemplateImportLog/v1/getDetail?id=${id}`,
      method: 'get',
    })
  },
  //根据表单Key, boAlias 获取表单html， 权限， bo数据结构
  getDataTemplateForm(
    formAlias,
    dataDefAlias,
    pkVal,
    action,
    recordId,
    dataKey
  ) {
    return request({
      url: `${form}/form/dataTemplate/v1/getForm/${formAlias}/${dataDefAlias}?id=${pkVal}&action=${
        action || 'get'
      }&recordId=${recordId || ''}&dataKey=${dataKey || ''}`,
      method: 'get',
    })
  },
  //获取业务数据模板表单草稿数据
  getTempDraftData(data) {
    return request({
      url: `${form}/form/dataTemplate/v1/getTempDraftData/${data}`,
      method: 'get',
    })
  },
  // 下载子表导入模板
  downloadSubtableTemplate: (subDesc, columns) => {
    return request({
      url: encodeURI(`${form}/form/form/v1/exportFormSub?subDesc=${subDesc}`),
      method: 'post',
      data: columns,
      responseType: 'arraybuffer',
    })
  },
  //获取自定义sql视图定义
  getQuerySqlView(viewId) {
    return request({
      url: `${form}/form/query/queryView/getJson?id=${viewId}`,
      method: 'get',
    })
  },
  //获取数据列表的数据
  getQueryViewDataList(param) {
    return request({
      url: `${form}/form/query/queryView/data_${param.sqlAlias}/${param.alias}`,
      data: param.param,
      method: 'post',
    })
  },
  //自定义sql查询视图数据导出
  querySqlViewExport(data) {
    return request({
      url: `${form}/form/query/queryView/export?sqlAlias=${data.sqlAlias}&alias=${data.alias}&getType=${data.getType}&expField=${data.expField}`,
      method: 'post',
      data: data.query,
      responseType: 'arraybuffer',
    })
  },
  getTemplateImportResult(cacheKey, data) {
    return request({
      url: `${form}/form/dataTemplate/v1/getImportCache?cacheKey=${cacheKey}`,
      method: 'post',
      data,
    })
  },
  getBoDefinition(id) {
    return request({
      url: `${form}/bo/def/v1/getJson?id=${id}`,
      method: 'get',
    })
  },
  saveImportResult(cacheKey, templateKey) {
    return request({
      url: `${form}/form/dataTemplate/v1/saveImportResult?templateAlias=${templateKey}`,
      data: cacheKey,
      method: 'post',
    })
  },
  /**表单设置 end ********************************************************************/

  /**3.用户中心设置 start ************************************************************/
  // 获取当前登录用户
  getCurrentUser: (type) => {
    const account = getAccount()
    type = type || 'user'
    return request({
      url: `${uc}/api/user/v1/user/getDetailByAccountOrId`,
      data: { accountOrId: account },
      method: 'post',
    }).then((data) => {
      const result = data[type]
      const postId = sessionStorage.getItem('currentPostId')

      if (['org', 'post'].includes(type)) {
        if (postId) {
          return getPostById(data['post'], postId)
        }
        return result ? Object.values(result)[0] : null
      }
      return result && result.constructor == Array ? result[0] : result
    })
  },

  // 获取用户列表数据
  getUserList: (params) => {
    const url = utils.isMobile()
      ? `${uc}/api/user/v1/users/queryUserWithMainOrgPost?isMobile=true`
      : `${uc}/api/user/v1/users/queryUserWithMainOrgPost`
    return request({
      url: url,
      method: 'post',
      data: params,
    })
  },

  // 查询组织下的岗位及子组织
  getByParentAndPostPage: (params) => {
    return request({
      url: `${uc}/api/org/v1/orgs/getByParentAndPostPage`,
      method: 'post',
      data: params,
    })
  },

  //[移动端]获取用户接口，需要在url携带isMobile=true
  getMobileUserList: (params) => {
    return request({
      url: `${uc}/api/user/v1/users/queryUserWithMainOrgPost?isMobile=true`,
      method: 'post',
      data: params,
    })
  },

  //查询组织下的用户及子组织
  getByParentAndUserPage(params) {
    return request({
      url: `${uc}/api/org/v1/orgs/getByParentAndUserPage`,
      method: 'post',
      data: params,
    })
  },

  // 获取组织列表数据 移动端的时候需要在url携带isMobile=true
  getOrgList: (params) => {
    const url = utils.isMobile()
      ? `${uc}/api/org/v1/orgs/getOrgPage?isMobile=true`
      : `${uc}/api/org/v1/orgs/getOrgPage`
    return request({
      url: url,
      method: 'post',
      data: params,
    })
  },

  // 获取角色列表数据
  getRoleList: (params) => {
    return request({
      url: `${uc}/api/role/v1/roles/getRolePage`,
      method: 'post',
      data: params,
    })
  },
  // 获取岗位列表数据
  getPostList: (params) => {
    return request({
      url: `${uc}/api/org/v1/orgPosts/getOrgPostPage`,
      method: 'post',
      data: params,
    })
  },
  // 获取职务列表数据
  getJobList: (params) => {
    return request({
      url: `${uc}/api/job/v1/jobs/getJobPage`,
      method: 'post',
      data: params,
    })
  },
  // 获取所有维度
  getAllDemensions: () => {
    return request({
      url: `${uc}/api/demension/v1/dems/getAll`,
    })
  },
  //获取维度列表数据
  getDimensionList: (params) => {
    return request({
      url: `${uc}/api/demension/v1/dems/getDemListAll`,
      method: 'post',
      data: params,
    })
  },
  // 获取组织树
  getOrgTree: (params) => {
    return request({
      url: `${uc}/api/org/v1/orgs/getByParentAndDem`,
      method: 'post',
      data: params,
    })
  },
  // 获取用户的权限配置
  getUserRightMapByIds(data) {
    return request({
      url: `${uc}/api/user/v1/user/getUserRightMapByIds?ids=${data}`,
      method: 'get',
    })
  },
  // 获取常用联系人群组
  getContactGroup(data) {
    return request({
      url: `${uc}/uc/ucGroup/v1/query`,
      method: 'post',
      data,
    })
  },

  // 获取常用联系人
  getContactUser(data, contactGroupId) {
    let url = utils.isMobile()
      ? `${uc}/uc/ucGroupUser/v1/loadUserByGroupId?isMobile=true`
      : `${uc}/uc/ucGroupUser/v1/loadUserByGroupId`
    if (contactGroupId) {
      if (utils.isMobile()) {
        url = `${url}&groupIds=${contactGroupId}`
      } else {
        url = `${url}?groupIds=${contactGroupId}`
      }
    }
    return request({
      url,
      method: 'post',
      data,
    })
  },

  // 获取指定用户所属组织列表
  getOrgListByUserId(userId) {
    const url = `${uc}/api/org/v1/orgs/getOrgListByUserId?userId=${userId}`
    return request({ url, method: 'get' })
  },
  //根据组织code获取组织path
  getOrgPathByCodes(data) {
    return request({
      url: `${uc}/api/org/v1/org/getOrgPathByCodes`,
      method: 'post',
      data,
    })
  },
  getRoleIds(data) {
    return request({
      url: `${uc}/api/role/v1/role/getRoleIdByCodes`,
      method: 'post',
      data,
    })
  },
  //获取当前默认维度下的主组织
  getMasterOrgByDefaultDimension() {
    return request({
      url: `${uc}/api/org/v1/orgs/getUserOrgsByDefaultDemension`,
      method: 'get',
    })
  },
  getAvatarsByUserId(userId) {
    return request({
      url: `${uc}/api/user/v1/user/getUsersPhotoByAccounts?ids=${userId}`,
      method: 'post',
    })
  },
  getOrgAndPostByUserId(userIds) {
    return request({
      url: `${uc}/api/org/v1/org/getOrgAndPostByUserIds?userIds=${userIds}`,
      method: 'get',
    })
  },
  /**用户中心设置 end ****************************************************************/

  /**4.流程设置 start ****************************************************************/

  // 处理相关流程中点击某个流程的事件
  handleRelevantFlowClick: (flow) => {
    router.push({
      path: '/matter/approvalForm',
      query: {
        instId: flow.id,
        isReadonly: true,
        isRelevantFlow: true,
        type: 'done',
      },
    })
  },
  //根据表单ID获取流程实例对象
  getInstanceByPks(pks, boDefAlias, flowKey) {
    return request({
      url: `${flow}/runtime/instance/v1/getInstanceByPks?boDefAlias=${boDefAlias}&flowKey=${flowKey}`,
      method: 'post',
      data: pks,
    })
  },
  //通过bo数据发起流程
  startForm(data) {
    return request({
      url: `${flow}/runtime/instance/v1/startForm?defKey=${data.defKey}&businessKey=${data.businessKey}&boAlias=${data.boAlias}&templateAlias=${data.templateAlias}`,
      method: 'post',
      data: {},
    })
  },
  //异步执行-通过bo数据发起流程
  startFormPromise(data) {
    return new Promise((resolve) => {
      return request({
        url: `${flow}/runtime/instance/v1/startForm?defKey=${data.defKey}&businessKey=${data.businessKey}&boAlias=${data.boAlias}&templateAlias=${data.templateAlias}`,
        method: 'post',
        data: {},
      }).then((response) => {
        resolve(response)
      })
    })
  },
  // 获取相关流程
  getRelevantFlow: (query) => {
    return request({
      url: `${flow}/runtime/instance/v1/relatedProcess`,
      method: 'post',
      data: query,
    })
  },
  //根据流程实例Id获取代办任务
  getBpmTaskByInstId(instId) {
    return request({
      url: `${flow}/runtime/task/v1/getBpmTaskByInstId?instId=${instId}`,
      method: 'get',
    })
  },
  //获取待阅
  getNoticeTodoReadList(param) {
    return request({
      url: `${flow}/runtime/task/v1/getNoticeTodoReadList`,
      method: 'post',
      data: param,
    })
  },
  //获取已阅
  getNoticeDoneReadList(param) {
    return request({
      url: `${flow}/runtime/task/v1/getNoticeDoneReadList`,
      method: 'post',
      data: param,
    })
  },
  //获取已阅沟通
  getMyNoticeReadList(param) {
    return request({
      url: `${flow}/runtime/task/v1/getNoticeDoneReadList`,
      method: 'post',
      data: param,
    })
  },
  //流程表单数据修改记录列表地址
  boDataModifyRecord(param) {
    return request({
      url: `${flow}/bpm/boDataModifyRecord/v1/listJsonQuery`,
      method: 'post',
      data: param,
    })
  },
    //根据id查询流程表单数据修改记录详情
  boDataModifyRecordById(id) {
  return request({
    url: `${flow}/bpm/boDataModifyRecord/v1/${id}`,
    method: 'get',
  })
  },
  //启动流程
  start(data) {
    return request({
      url: `${flow}/runtime/instance/v1/start`,
      method: 'post',
      data: data,
    })
  },
  //获取表单列表相关权限
  getDataTemplateButtonPermission(instIds, types) {
    return request({
      url: `${flow}/runtime/instance/v1/getDataTemplateButtonPermission?permissionTypes=${types}`,
      data: instIds,
      method: 'post',
    })
  },
  //获取流程实例明细
  instanceFlowImage(data, cb) {
    request({
      url: `${flow}/runtime/instance/v1/instanceFlowImage?proInstId=${
        data.instId
      }&nodeId=${data.nodeId || ''}&type=${data.type || ''}&defId=${
        data.defId || ''
      }&scalePrcent=1.5`,
      method: 'get',
    }).then((response) => {
      cb(response)
    })
  },
  //流程图
  getBpmImage(id, proInstId, defId, cb) {
    request({
      url: `${flow}/runtime/instance/v1/getBpmImage?taskId=&proInstId=${proInstId}&defId=${defId}&bpmnInstId=${id}&scalePrcent=1.5`,
    }).then((response) => {
      cb(response)
    })
  },
  //获取审批意见
  getNodeOpinions(data, cb) {
    request({
      url: `${flow}/runtime/task/v1/nodeOpinion?instId=${data.instId}&nodeId=${data.nodeIds}&defId=${data.defId}`,
    }).then((response) => {
      cb(response)
    })
  },
  //获取处理记录列表
  getOpinionsById(data) {
    return request({
      url: `${flow}/runtime/instance/v1/instanceFlowOpinions`,
      method: 'get',
      params: data,
    })
  },
  //删除流程实例
  removeFlowById(id) {
    return new Promise((resolve) => {
      request({
        url: `${flow}/runtime/instance/v1/remove?ids=${id}`,
        method: 'delete',
      }).then((response) => {
        resolve(response)
      })
    })
  },
  saveRevoke(data) {
    return new Promise((resolve) => {
      request({
        url: `${flow}/runtime/instance/v1/revokeInstance`,
        method: 'post',
        data,
      }).then((response) => {
        resolve(response)
      })
    })
  },
  //获取审批常用语
  getCommonWordsByDefKeyAndTypeId(defKey) {
    const url = `${model}/flow/approvalItem/v1/getApprovalByDefKeyAndTypeId?defKey=${defKey}`
    return request({
      url,
      method: 'get',
    })
  },
  //保存常用语
  savaCommonWords(data) {
    return request({
      url: `${model}/flow/approvalItem/v1/save`,
      method: 'post',
      data,
    })
  },
  transToMore(data) {
    return request({
      url: `${flow}/runtime/instance/v1/transToMore`,
      method: 'post',
      data,
    })
  },
  /**流程设置 end ********************************************************************/

  /**5.门户设置 start ****************************************************************/
  // 附件上传地址
  uploadUrl: `${portal}/system/file/v1/upload`,
  // 附件下载处理
  download: (fileId) => {
    return request({
      url: `${portal}/system/file/v1/downloadFile?fileId=${fileId}`,
      method: 'get',
      responseType: 'arraybuffer',
    })
  },
  // 获取数据字典
  getDictionaryByKey: (key) => {
    return request({
      url: `${portal}/sys/dataDict/v1/getByTypeKeyForComBo?typeKey=${key}`,
      method: 'post',
    })
  },
  // 获取标签数据
  getTagList: (params) => {
    return request({
      url: `${portal}/portal/sysTag/v1/query`,
      method: 'post',
      data: params,
    })
  },
  // 添加标签
  saveTag: (params) => {
    return request({
      url: `${portal}/portal/sysTag/v1/save`,
      method: 'post',
      data: params,
    })
  },
  getNextIdByAlias: (alias) => {
    return request({
      url: `${portal}/sys/identity/v1/getNextIdByAlias?alias=${alias}`,
      method: 'get',
    })
  },
  // 获取我的常用流程
  getMyOftenFlow(alias) {
    return request({
      url: `${runtime}/runtime/instance/${version}/getMyOftenFlow?columnAlias=${alias}`,
      method: 'get',
    })
  },
  //获取布局
  getIndexColumnPage(param) {
    return request({
      url: `${portal}/portal/sysIndexColumn/sysIndexColumn/${version}/listJson`,
      method: 'post',
      data: param,
    })
  },
  getProcessData(queryFilter = {}) {
    const url = `${runtime}/runtime/instance/${version}/getHasAuthFlowList`
    return request.post(url, queryFilter)
  },
  //获取流程图表数据
  getEchartsData(id) {
    return request({
      url: `${runtime}/runtime/report/${version}/getEchartsData?reportId=${id}`,
      method: 'get',
    })
  },
  //获取数据图表数据
  getCustomChartById(id) {
    return request({
      url: `${form}/form/customChart/${version}/get/${id}`,
      method: 'get',
    })
  },
  //数据图标的列表数据
  getListData(alias, params) {
    return request({
      url: `${form}/form/customChart/${version}/getListData?alias=${alias}`,
      method: 'post',
      data: params,
    })
  },
  savaCommonProcess(data) {
    const url = `${model}/bpmModel/BpmOftenFlow/${version}/saveMyOftenFlow`
    return request.post(url, data)
  },
  //待办列表
  getTodoData(data) {
    const url = `${runtime}/runtime/task/${version}/getTodoList`
    return request.post(url, data)
  },
  //已办列表
  getDoneData(data) {
    const url = `${runtime}/runtime/instance/${version}/getDoneInstList`
    return request.post(url, data)
  },
  //我的请求
  getMyRequestList(data) {
    const url = `${runtime}/runtime/instance/${version}/myRequest`
    return request.post(url, data)
  },

  //待阅事项
  getReceivedList(data) {
    const url = `${runtime}/runtime/task/${version}/getNoticeTodoReadList`
    return request.post(url, data)
  },

  //我传阅的
  getCirculatedList(data) {
    const url = `${runtime}/runtime/task/${version}/getMyNoticeReadList`
    return request.post(url, data)
  },

  //我转办的
  getDelegateData(data) {
    const url = `${runtime}/runtime/task/${version}/getDelegate`
    return request.post(url, data)
  },
  getProcessOverviewList(data) {
    const url = `${runtime}/runtime/instance/${version}/newProcess`
    return request.post(url, data)
  },
  getCollectionList(data) {
    const url = `${runtime}/bpmFlowCollect/${version}/myCollect`
    return request.post(url, data)
  },
  getTaskInfo(procIds) {
    const url = `${runtime}/runtime/task/${version}/instanceDetail`
    return request.post(url, procIds)
  },
  getCandidatesListByTaskId(taskId) {
    const url = `${runtime}/runtime/task/${version}/getCandidatesListByTaskId?taskId=${taskId}`
    return request.get(url)
  },
  getColumnByAlias(alias) {
    const url = `${portal}/portal/sysIndexColumn/sysIndexColumn/${version}/getByAlias?alias=${alias}`
    return request.get(url)
  },

  // 获取新闻列表, 轮播图id
  getListAndImg(params) {
    return request({
      url: `${portal}/portalNewsNotice/${version}/listNewsCurrentUserAuth`,
      method: 'post',
      data: params,
    })
  },
  // 获取新闻.轮播图详情
  getNewsOrPictureDetailById(param) {
    return request({
      url: `${portal}/portalNewsNotice/${version}/getNewsById?id=${
        param.id
      }&isRead=${param.read || ''}`,
      method: 'get',
    })
  },

  // 获取轮播图 rotatingDisplayPictures
  rotatingPictures(id) {
    const url = `${portal}/portalNewsNotice/${version}/${id}`
    return request.get(url)
  },

  // 获取图片地址
  downloadImg(fileId) {
    return new Promise((resolve) => {
      const url = `${portal}/system/file/${version}/preview?fileId=${fileId}`
      request({
        url: url,
        method: 'get',
        responseType: 'blob',
      }).then((response) => {
        if (response && response.size > 0) {
          var blob = response
          var reader = new FileReader()
          reader.readAsDataURL(blob)
          reader.onload = function (e) {
            resolve(e.target.result)
          }
        } else {
          resolve('')
        }
      })
    })
  },

  // 日程获取
  getCurrentUserSchedule() {
    const url = `${portal}/portalAgendaDay/${version}/getByUserId`
    return request.get(url)
  },

  // 日程新建
  saveSchedule(data) {
    const url = `${portal}/portalAgendaDay/${version}/save`
    return request.post(url, data)
  },

  // 日程删除
  deleteSchedule(data) {
    const url = `${portal}/portalAgendaDay/${version}/${data.id}`
    return request.delete(url, data)
  },

  // 会议
  meetingQuery(params) {
    const url = `${portal}/portalMeetingRoom/${version}/query`
    return request.post(url, params)
  },

  //获取会议室配置信息
  getConfig() {
    const url = `${portal}/portalMeetingConfig/${version}/getConfig`
    return request.get(url)
  },

  //获取
  getByTypeKey(key) {
    const url = `${portal}/sys/dataDict/${version}/getByTypeKey?typeKey=${key}`
    return request.get(url)
  },
  //获取当前用户下已申请会议室
  getApplyByTime() {
    const url = `${portal}/portalMeetingApply/${version}/getApplyByTime?endDate=&startDate=&userId=`
    return request.get(url)
  },

  //获取申请会议室数量
  getApplyCount() {
    const url = `${portal}/portalMeetingApply/${version}/getApplyCount?ownerId=&roomId=`
    return request.get(url)
  },

  //获取申请会议室数量
  applySubmit(params) {
    const url = `${portal}/portalMeetingApply/${version}/apply`
    return request.post(url, params)
  },

  //获取已预约,待进行,已完成
  getApplyPageByType(urlItem, params) {
    const url = `${portal}/portalMeetingApply/${version}/getApplyPageByType?type=${urlItem}`
    return request.post(url, params)
  },

  //附件在线预览
  onlinePreview(id) {
    const url = `${portal}/file/onlinePreviewController/${version}/onlinePreview?fileId=${id}`
    return request.get(url)
  },

  // 返回的预览url
  getFileById(url, param) {
    return request.get(url, param)
  },

  //
  getVideoSrc(fileId, type) {
    return request({
      url: `${portal}/file/onlinePreviewController/${version}/getFileById_${fileId}`,
      method: 'get',
      responseType: type,
    })
  },

  /* 处理当前点击流程*/
  handleClickProcessName(row) {
    Vue.prototype.$message.success(`查看id为${row.id}的流程实例`)
  },
  //获取栏目布局
  getColumnLayout(alias) {
    return request({
      url: `${portal}/portal/sysIndexLayoutManage/sysIndexLayoutManage/${version}/getByAlias?alias=${alias}`,
      method: 'get',
    })
  },
  getColumns(alias) {
    return request({
      url: `${portal}/portal/sysIndexColumn/sysIndexColumn/${version}/getDatasByAlias`,
      method: 'post',
      data: alias,
    })
  },
  //保存当前栏目布局
  savaCurrentColumnLayout(data) {
    return request({
      url: `${portal}/portalUserLayoutConfig/${version}/save`,
      method: 'post',
      data,
    })
  },
  //当前账号是否有启动该流程的权限
  flowHasStartRights(defKey) {
    return request({
      url: `${model}/flow/def/${version}/flowHasStartRights?defKey=${defKey}`,
      method: 'get',
    })
  },
  //获取当前用户有权限的栏目 isPublic：0-管理端，1-手机端，2-应用端
  getColumn() {
    return request({
      url: `${portal}/portal/sysIndexColumn/sysIndexColumn/${version}/getCurrentUserColumn?isPublic=2`,
      method: 'get',
    })
  },
  getEndTask(data) {
    return request({
      url: `${runtime}/runtime/instance/${version}/getInstDetailList`,
      method: 'post',
      data,
    })
  },
  //仅流程公示栏目，调用接口 查看时记录查看记录，实例id入参
  setReaded(data) {
    return request({
      url: `${runtime}/runtime/bpmProPublicityRead/${version}/readed`,
      method: 'post',
      data,
    })
  },
  //获取公示查看记录，传入实例id数组查询
  getIsReadByProcInstIds(data) {
    return request({
      url: `${runtime}/runtime/bpmProPublicityRead/${version}/getIsReadByProcInstIds`,
      method: 'post',
      data,
    })
  },
  getViewList(param, alias) {
    return request({
      url: `${form}/form/query/queryView/listJson?sqlAlias=${alias}`,
      method: 'post',
      data: param,
    })
  },
  //重置常用流程
  resetCurUserOftenFlow() {
    return request({
      url: `${model}/bpmModel/BpmOftenFlow/${version}/resetCurUserOftenFlow`,
      method: 'get',
    })
  },
  /**门户设置 end ********************************************************************/

  /**6.前端跳转 start ****************************************************************/
  // 二维码组件获取当前流程实例、任务的页面地址
  getQrcodeUrl: (instId) => {
    return request({
      url: `${portal}/portal/shorturlManage/v1/getShortUrlByLong`,
      method: 'post',
      data: { url: `/shareInst/${instId}/true?token=${getTokenOnly()}` },
    })
  },
  //获取当前移动端地址
  getBaseMobileUrl: () => {
    return mobile
  },
  // 根据token接口的入参获取票据
  getUrlTicket: (tokenApi) => {
    return request({
      url: `${portal}/portal/portalRestfulInterface/v1/urlTicket`,
      method: 'post',
      data: tokenApi,
    })
  },
  openUrl: (param) => {
    // bizType:业务类型,openType:打开方式,parameters:参数(json格式)
    const { bizType, openType, parameters } = param

    let path = ''
    if (bizType == 'searchData') {
      //表单列表预览中的查询数据按钮功能
      const previewTemplateAlias = parameters.previewTemplateAlias
      const data = parameters.data
      const key =
        Date.parse(new Date()) + '_' + Math.ceil(Math.random() * 99999)
      path = `${front}/templatePreview/${previewTemplateAlias}/${data}/${key}`
    } else if (bizType == 'startFlow') {
      const data = parameters.data
      let token = ''
      const authToken = getToken()
      if (authToken && authToken.indexOf(' ') > -1) {
        token = authToken.split(' ')[1]
      }
      path = `${front}/matter/startProcess?token=${token}&defId=${parameters.defId}&data=${data}`
    } else if (bizType == 'addData') {
      //表单列表预览中的查询数据按钮功能
      const previewTemplateAlias = parameters.previewTemplateAlias
      const data = parameters.data
      path = `${manage}/templateForm/${previewTemplateAlias}/add?data=${data}`
    }

    if (openType == 'new') {
      window.open(path, '_blank')
    } else {
      window.location.href = path
    }
  },
  // 跳转其他表单列表页面的地址构建
  viewReportURLHandler: ({ item }) => {
    return new Promise((resolve, reject) => {
      request({
        url: `${portal}/sys/sysMenu/v1/getFirstMenuRouterPathByTemplateAlias?templateAlias=${item.alias}`,
      })
        .then((result) => {
          if (result.state) {
            resolve(result.value)
          } else {
            reject(result.message)
          }
        })
        .catch((err) => reject(err))
    })
  },
  /**前端跳转 end *******************************************************************/
  // 后端校验发送请求
  backendValidate: (data) => {
    let params = {}
    if (data.submitFormData == 'true') {
      let formElementAry = document.getElementsByName('online-form')
      if (formElementAry && formElementAry.length == 1) {
        let frmInst = formElementAry[0].__vue__
        params = frmInst.data
      }
    }
    data.url = utils.parseUrl(data.url)
    return new Promise((resolve) => {
      request({
        url: data.url + encodeURIComponent(data.param),
        data: params,
        method: 'post',
      }).then((response) => {
        resolve(response)
      })
    })
  },
  //附件预览
  filePreview: (fileId) => {
    return `${portal}/onlinePreview?fileId=${fileId}&token=${getTokenOnly()}`
  },
  //执行后端脚本
  executeScript: (params) => {
    return request({
      url: `${runtime}/runtime/script/v1/executeScript`,
      method: 'post',
      data: params,
    })
  },
  //公众号
  portalWeixinMaterial(data) {
    return request({
      url: `${portal}/portalWeixinMaterial/${version}/listJson`,
      method: 'post',
      data,
    })
  },
  weixinMaterialDetail(data) {
    return request({
      url: `${portal}/portalWeixinMaterial/${version}/{id}`,
      method: 'post',
      data,
    })
  },
  // 查询用户自定义个人事项列表
  getUserMatters(param = {}) {
    return request.post(
      `${portal}/portal/portalCustomTodo/${version}/listJson`,
      param
    )
  },

  deleteUserMatters(id) {
    return request.delete(`${portal}/portal/portalCustomTodo/${version}/${id}`)
  },

  // 新增个人事项
  addUserMatters(param = {}) {
    return request.post(`${portal}/portal/portalCustomTodo/v1/save`, param)
  },

  // 修改个人事项待办排序
  updateMattersOrder(param = {}) {
    return request.post(
      `${portal}/portal/portalCustomTodo/v1/batchUpdateSn`,
      param
    )
  },

  //获取审批意见
  getNodeOpinionsPreview(data, cb) {
    request({
      url: `${flow}/runtime/task/v1/nodeOpinionFromPreview?instId=${data.instId}&nodeId=${data.nodeIds}&defId=${data.defId}&isDerive=${data.isDerive}`,
    }).then((response) => {
      cb(response)
    })
  },
  //获取子流程实例列表
  getSubInstanceList(parentInstId, nodeId) {
    const url = `${flow}/runtime/instance/v1/getSubInstanceList?parentInstId=${parentInstId}&nodeId=${nodeId}`
    return request.get(url)
  },
  //获取子流程定义id
  getSubDefId(parentDefId, parentInstId, nodeId) {
    const url = `${flow}/runtime/instance/v1/getSubDefId?parentInstId=${parentInstId}&nodeId=${nodeId}&parentDefId=${parentDefId}`
    return request.get(url)
  },
  //获取流程图人员详情
  getUserOrgPostPolymer(data) {
    return request({
      url: `${uc}/api/user/v1/user/getUserOrgPostPolymer`,
      method: 'post',
      data,
    })
  },
  // //通用获取图片地址
  // getImgSrc(fileId) {
  //   return request.get(`${portal}/system/file/v1/downloadFile?fileId=${fileId}`)
  // },
  //跳转到表单列表
  goToFormList: (config) => {
    router.push({
      path: '/worker/formList',
      query: {
        alias: config.alias,
        name: config.name,
        dataView: config.dataView,
        from: 'more',
      },
    })
  },
}

Vue.use(HotentUi, {
  // i18n: (key, value) => i18n.t(key, value),
  requestConfig,
  paginationBackground: true,
})

Vue.use(wangeditor, {
  uploadImgServer: `${portal}/system/file/v1/editor/fileUpload`,
  uploadImgHeaders: {
    Authorization: getToken,
  },
  uploadImgHooks: {
    customInsert: function (insertImgFn, result) {
      result.data &&
        result.data.forEach((data) => {
          let src = data.url
          if (src && !src.startsWith('http')) {
            src = `${portal}/system/file/v1/downloadFile?fileId=${src}`
          }
          insertImgFn(src)
        })
    },
  },
  menuTooltipPosition: 'down',
})
Vue.use(Echarts)
Vue.use(Map)
Vue.use(Qrcode)
Vue.use(XLSX)

Vue.use(HotentPortal)