import request from '@/utils/request'
const bpmModel = window.context.bpmModel
const bpmRunTime = window.context.bpmRunTime
const portal = window.context.portal
export default {
  //获取分类
  getFlowTree() {
    return request({
      url: `${portal}/sys/sysType/v1/getTypesByKey?typeKey=FLOW_TYPE`,
      method: 'get',
    })
  },
  /* 获取当前用户流程分类 */
  getCurUserFlowType() {
    return request({
      url: `${bpmRunTime}/runtime/instance/v1/getCurUserFlowType`,
      method: 'get',
    })
  },
  getDefaultFlow() {
    return request({
      url: `${bpmRunTime}/runtime/instance/v1/getMyMobileOftenFlow`,
      method: 'get',
    })
  },
  getCategory(type, cb) {
    return new Promise((resolve, reject) => {
      request
        .get(portal + `/sys/sysType/v1/getByGroupKey?groupKey=${type}`)
        .then(
          (resp) => {
            resolve(resp)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },
  relatedProcess(data, cb) {
    //相关流程
    request
      .post(bpmRunTime + `/runtime/instance/v1/relatedProcess`, data)
      .then((response) => {
        cb(response)
      })
  },
  myMobileRequest(queryFilter) {
    //我发起的
    return new Promise((resolve, reject) => {
      request
        .post(bpmRunTime + `/runtime/instance/v1/myMobileRequest`, queryFilter)
        .then(
          (resp) => {
            resolve(resp)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },

  myMobileDraft(queryFilter) {
    //我的草稿
    return new Promise((resolve, reject) => {
      request
        .post(bpmRunTime + `/runtime/instance/v1/myMobileDraft`, queryFilter)
        .then(
          (resp) => {
            resolve(resp)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },

  getMobileDelegate(queryFilter) {
    //转办代理
    return new Promise((resolve, reject) => {
      request
        .post(bpmRunTime + `/runtime/task/v1/getDelegate`, queryFilter)
        .then(
          (resp) => {
            resolve(resp)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },

  getMobileTodoList(queryFilter) {
    //我的待办
    return new Promise((resolve, reject) => {
      queryFilter.params = queryFilter.params || {}
      queryFilter.params.isMobile = 'true'
      request
        .post(bpmRunTime + `/runtime/task/v1/getTodoList`, queryFilter)
        .then(
          (resp) => {
            resolve(resp)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },

  getMobileDoneList(queryFilter) {
    //我的已办
    return new Promise((resolve, reject) => {
      request
        .post(bpmRunTime + `/runtime/instance/v1/getDoneInstList`, queryFilter)
        .then(
          (response) => {
            resolve(response)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },

  myMobileProcess(queryFilter) {
    //流程列表
    return new Promise((resolve, reject) => {
      request
        .post(bpmRunTime + `/runtime/instance/v1/myMobileProcess`, queryFilter)
        .then(
          (resp) => {
            resolve(resp)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },

  getNoticesList(queryFilter, type) {
    //根据类型获取传阅事项
    return new Promise((resolve, reject) => {
      request.post(bpmRunTime + `/runtime/task/v1/` + type, queryFilter).then(
        (resp) => {
          resolve(resp)
        },
        (error) => {
          reject(error)
        }
      )
    })
  },

  getNoticeTodoReadList(queryFilter) {
    //我的待阅
    return new Promise((resolve, reject) => {
      request
        .post(
          bpmRunTime + `/runtime/task/v1/getNoticeTodoReadList`,
          queryFilter
        )
        .then(
          (resp) => {
            resolve(resp.data)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },

  getNoticeDoneReadList(queryFilter) {
    //我的已阅
    return new Promise((resolve, reject) => {
      request
        .post(
          bpmRunTime + `/runtime/task/v1/getNoticeDoneReadList`,
          queryFilter
        )
        .then(
          (resp) => {
            resolve(resp.data)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },

  getMyNoticeReadList(queryFilter) {
    //我的待阅
    return new Promise((resolve, reject) => {
      request
        .post(bpmRunTime + `/runtime/task/v1/getMyNoticeReadList`, queryFilter)
        .then(
          (resp) => {
            resolve(resp.data)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },

  getDefById(defId) {
    //获取流程定义信息
    return new Promise((resolve, reject) => {
      request.get(bpmRunTime + `/flow/def/v1/defGet?defId=` + defId).then(
        (resp) => {
          resolve(resp.data)
        },
        (error) => {
          reject(error)
        }
      )
    })
  },

  getCurNodeProperties(taskId, defId, instId) {
    //获取当前节点信息
    return new Promise((resolve, reject) => {
      request
        .get(
          bpmRunTime +
            `/runtime/task/v1/getCurNodeProperties?taskId=` +
            taskId +
            '&defId=' +
            defId +
            '&instId=' +
            instId
        )
        .then(
          (resp) => {
            resolve(resp.data)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },

  getByRecordInstId(queryFilter) {
    //根据流程实例ID获取阅读记录
    return new Promise((resolve, reject) => {
      request
        .post(
          bpmRunTime + '/runtime/instance/v1/getByRecordInstId',
          queryFilter
        )
        .then(
          (response) => {
            resolve(response.data)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },
  //根据流程实例ID、催办人ID获取催办记录
  getUrgrntById(queryFilter) {
    return new Promise((resolve, reject) => {
      request
        .post(bpmRunTime + '/runtime/instance/v1/getUrgrntById', queryFilter)
        .then(
          (response) => {
            resolve(response.data)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },
  // 根据定义key或者id获取流程的主版本信息
  getMainByDefIdOrKey(defKey, defId) {
    return new Promise((resolve, reject) => {
      request
        .get(
          `${bpmRunTime}/flow/def/v1/getMainByDefIdOrKey?defKey=${
            defKey || ''
          }&=defId${defId || ''}`
        )
        .then(
          (resp) => {
            resolve(resp.data)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },
  // 获取流程实例明细
  instanceFlowImage(data) {
    const { instId, nodeId, type, defId } = data
    return new Promise((resolve, reject) => {
      request
        .get(
          `${bpmRunTime}/runtime/instance/v1/instanceFlowImageMobile?proInstId=${instId}&nodeId=
  ${nodeId || ''}&type=${type || ''}&defId=${defId || ''}`
        )
        .then(
          (resp) => {
            resolve(resp)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },
  // 获取流程图
  getBpmImage(instId, proInstId, defId) {
    return new Promise((resolve, reject) => {
      request
        .get(
          `${bpmRunTime}/runtime/instance/v1/getBpmImage?taskId=&proInstId=${proInstId}&defId=${defId}&bpmnInstId=${instId}`
        )
        .then(
          (resp) => {
            resolve(resp)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },
  // 获取审批意见
  getNodeOpinions(data) {
    const { instId, nodeIds, defId } = data

    return new Promise((resolve, reject) => {
      request
        .get(
          `${bpmRunTime}/runtime/task/v1/nodeOpinion?instId=${instId}&nodeId=${nodeIds}&defId=${defId}`
        )
        .then(
          (resp) => {
            resolve(resp)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },

  // 获取审批意见 预测图  流程图
  getNodeOpinionsPreview(data) {
    const { instId, nodeIds, defId } = data

    return new Promise((resolve, reject) => {
      request
        .get(
          `${bpmRunTime}/runtime/task/v1/nodeOpinionFromPreview?instId=${instId}&nodeId=${nodeIds}&defId=${defId}&isDerive=${data.isDerive}`
        )
        .then(
          (resp) => {
            resolve(resp)
          },
          (error) => {
            reject(error)
          }
        )
    })
  },
}
/* 全部流程不可用流程按钮 */
export function myMobileProcessShowButton(data) {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/myMobileProcessShowButton`,
    method: 'post',
    data,
  })
}
/* 常用流程不可用流程按钮 */
export function getMyMobileOftenFlowShowButton() {
  return request({
    url: `${bpmRunTime}/runtime/instance/v1/getMyMobileOftenFlowShowButton`,
    method: 'get',
  })
}

/* 收藏的流程不可用流程按钮 */
export function myCollectShowButton() {
  return request({
    url: `${bpmRunTime}/bpmFlowCollect/v1/myCollectShowButton`,
    method: 'get',
  })
}

// 根据 taskId 获取任务明细
export function getNotice(taskId) {
  const url = `${bpmRunTime}/runtime/task/v1/getNotice?id=${taskId}`
  return request.get(url)
}
//验证当前用户是否有该任务处理权限
export function checkTaskAuth(taskId, cb) {
  const url = `${bpmRunTime}/runtime/task/v1/checkTaskAuth?taskId=${taskId}`
  return request.get(url)
}
//获取流程状态根据defId 实例id,任务id
export function getFlowStatus(query, cb) {
  const { instId, taskId } = query
  const url = `${bpmRunTime}/runtime/instance/v1/getDefStatus?instId=${instId}&taskId=${taskId}`
  return request.get(url)
}
//获取审批按钮
export function getApprovalButtons(query, cb) {
  const { taskId, leaderId } = query
  const url = `${bpmRunTime}/runtime/task/v1/getButtonsBytaskId?taskId=${taskId}&leaderId=${leaderId}&reqParams=`
  return request.get(url)
}
//审批按钮挂起或者取消挂起
export function hangUpOrCancelHangUp(query, cb) {
  const { instId, type, taskId } = query
  const url =
    `${bpmRunTime}/runtime/instance/v1/${type}?instId=${instId}` +
    (taskId ? `&taskId=${taskId}` : '')
  return request.get(url).then((response) => {
    cb(response)
  })
}
//获取审批意见通过流程实例id和任务id
export function getBpmSaveOpinionByTeam(instId, taskId, cb) {
  const url = `${bpmRunTime}/runtime/task/v1/getBpmSaveOpinionByTeam?instId=${instId}&taskId=${taskId}`
  request.get(url).then((response) => {
    cb(response)
  })
}
//新增，修改或暂存审批意见
export function saveApprovalComments(data) {
  return request({
    url: `${bpmRunTime}/runtime/task/v1/createBpmSaveOpinion`,
    method: 'post',
    data,
  })
}
// 根据当前任务查询是否在第一个节点
export function isTaskFirstNode(taskId) {
  return request.get(
    `${bpmRunTime}/runtime/task/v1/taskIsFirstNode?taskId=${taskId}`
  )
}

//获取流程图人员详情
export function getUserOrgPostPolymer(data) {
  return request({
    url: `${uc}/api/user/v1/user/getUserOrgPostPolymer`,
    method: 'post',
    data,
  })
}

//获取审批常用语
export function getCommonWordsByDefKeyAndTypeId(defKey, cb) {
  const url = `${context.bpmModel}/flow/approvalItem/v1/getApprovalByDefKeyAndTypeId?defKey=${defKey}`
  request.get(url).then((response) => {
    cb(response)
  })
}