import request from "@/utils/request";


/**
 * 数据字典
**/

// 编码规则流水号
export const getCoderuleList = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/code-rule/list`,
  method: 'post',
  data: params
})
// 获取数据类型的接口
export const getDataTypeList = (params) => request({
  url: `${import.meta.env.VITE_APP_API_BASEURL}/data-dict/get-data-list`,
  method: 'post',
  data: params,
})
// 获取数据库列表
export const getDataBaseList = (params) => request({
  url: `${import.meta.env.VITE_APP_API_BASEURL}/data-source/get-source-list`,
  method: 'post',
  data: params,
})

// 新增
export const addDictionary = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-dictionary-general/add`,
  method: 'post',
  data: params
})
// 删除
export const deleteDictionary = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-dictionary-general/del`,
  method: 'delete',
  data: params
})
// 删除数据字典前的校验
export const checkDeleteDictionary = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-dictionary-general/check-del`,
  method: 'delete',
  data: params
})
// 编辑校验数据结构删除的条件
export const checkDeleteDictionaryScheme = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-dictionary-general/check-del/dictionary-scheme`,
  method: 'post',
  data: params
})
// 分页查询
// export const getDictionary = (params) => request({
//   url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-dictionary-general/page-list`,
//   method: 'post',
//   data: params
// })
// 查询数据字典启用状态的数据
export const getDictionaryAll = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-dictionary-general/list-all`,
  method: 'post',
  params
})
// 修改
export const updateDictionary = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-dictionary-general/update`,
  method: 'put',
  data: params
})
// 详情
export const getDictionaryDetail = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-dictionary-general/detail/${params}`,
  method: 'get'
})
// 查看数据字典数据
export const getDictionaryFileds = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-dictionary-general/dictionary-data/${params}`,
  method: 'get'
})
// 数据字典启用停用
export const updateDictionaryState = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-dictionary-general/change-state`,
  method: 'get',
  params
})
// 检验是否存在
export const checkDictionary = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-dictionary-general/check-exist`,
  method: 'get',
  params
})
// 数据字典新增数据时生成编码规则
export const getDictionaryRuleData = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-dictionary-general/generate/code-rule/byGuid`,
  method: 'get',
  params
})
// 数据字典树形数据
export const getDictionaryTree = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-dictionary-general/tree-list`,
  method: 'post',
  params
})
// 保存动态数据字典数据
export const saveDictionaryData = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-dictionary-general/save/dictionary-data`,
  method: 'post',
  data: params
})
// 更新数据字典数据
export const updateDictionaryData = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-dictionary-general/update/dictionary-data`,
  method: 'post',
  data: params
})
// 删除数据字典数据
export const deleteDictionaryData = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-dictionary-general/del/dictionary-data`,
  method: 'delete',
  data: params
})
// 导入数据字典
export const importDictionary = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/import/data-dictionary`,
  method: 'post',
  data: params
})
// 显示导入的数据字典数据
export const showDictionary = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/import/show/data-dictionary`,
  method: 'post',
  data: params,
  headers: {
    'Content-Type': 'multipart/form-data'
  }
})
// 导出数据字典模板
export const exportDictionary = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/export/data-dictionary/schema`,
  method: 'post',
  data: params,
  responseType: 'blob'
})
// 导出数据字典数据
export const exportDictionaryFileds = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/export/data-dictionary/data`,
  method: 'post',
  data: params,
  responseType: 'blob'
})
// 验证数据是否符合标准
export const checkDictionaryData = (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-dictionary-general/check/dictionary-data`,
  method: 'post',
  data: params
})


/**
 * 获取数据级别
 * @param {Object}
 * { paramCode: "DATA-CLASSIFY" }
 * DATA-CLASSIFY 数据类别
 * DATA-GRADE 数据级别
 */
// export const getLargeCategoryList = (data) => request({
//   url:`${import.meta.env.VITE_APP_API_BASEURL}/data-dict/get-data-list`,
//   method: 'post',
//   data
// })
export const getLargeCategoryList = (params) => request({
  url: `${import.meta.env.VITE_APP_CONFIG_URL}/dict/data/get-by-dictType?dictType=${params.dictType}`,
  method: 'get',
})

/**
 * 获取字段类型
 */
export const getNewDataTypeList = (params) => request({
  url: `${import.meta.env.VITE_APP_CONFIG_URL}/dict/data/get-by-dictType?dictType=${params.dictType}`,
  method: 'get',
})


/** 分类分级模板数据 */
export const getTempleteClassifyData = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-template/page-list`,
  method: 'post',
  data
})


/** 新增分级
 *
 * @param {Object}
 * @path /classify-grade/save
*/

export const saveClassifyGrad = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/classify-grade/save`,
  method: 'post',
  data
})

/** 删除分级
 * @param {Object}
 * @path /classify-grade/delete
 * */

export const deleteClassifyGrad = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/classify-grade/delete`,
  method: 'delete',
  headers: {
    'Content-Type': 'multipart/form-data',
  },
  data
})
/** 修改分级
 * @param {Object}
 * @path /classify-grade/update
 * */

export const updateClassifyGrad = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/classify-grade/update`,
  method: 'post',
  data
})


/**
 * 分级列表
 * @param {Object}
 * @path /classify-grade/page-list
 */

export const getClassifyGradList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/classify-grade/page-list`,
  method: 'post',
  data
})

/**
 * 分级列表详情
 * @param {Object}
 * @path /classify-grade/page-list
 */

export const getClassifyGradDetail = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/classify-grade/detail`,
  method: 'get',
  params: data
})

/**
 * 分级新增
 * @param {Object}
 * @path /grade/save
 */
export const saveGrade = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/grade/save`,
  method: 'post',
  data
})

/**
 * 分级更新
 * @param {Object}
 * @path /grade/update
 * */
export const updateGrade = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/grade/update`,
  method: 'post',
  data
})

/**
 * 分级列表
 * @param {Object}
 * @path /grade/page-list
 */
export const getGradeList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/grade/page-list`,
  method: 'post',
  data
})

/**
 * 批量删除分级
 * @param {Array}
 * @path /grade/delete
 * */
export const deleteGrade = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/grade/delete`,
  method: 'delete',
  data
})


/*---------------------------------分类标准 tab -----------------------------*/

/**
 * 分级树形结构
 * @param no params
 * @path /grade/tree-list
 */
export const getGradeTreeList = () => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/grade/tree-list`,
  method: 'post',
})

/**
 * 分类树形列表
 * @param {Object}
 * @path /classify/tree-list
 * */
export const getClassifyTreeList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/classify/tree-list`,
  method: 'post',
  data
})

/**
 * 分类新增
 * @param {Object}
 * @path /classify/save
 * */

export const saveClassify = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/classify/save`,
  method: 'post',
  data
})

/**
 * 分类更新
 * @param {Object}
 * @path /classify/update
 */

export const updateClassify = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/classify/update`,
  method: 'post',
  data
})

/**删除分类
 * @param {Object}
 * @path /classify/delete
 */
export const deleteClassify = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/classify/delete?guid=${data.guid}`,
  method: 'delete',
})


/** ---------------分类分级模板------------------------ */

/**
 * 分类分级模板新增
 * @param {Object}
 * @path /cg-template/save
 */

export const saveCgTemplate = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-template/save`,
  method: 'post',
  data
})

/**
 * 分类分级模板左侧树形列表
 * @param {Object}
 * @path /cg-template-classify/tree-list
 */
export const getCgTemplateClassifyTreeList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-template-classify/tree-list`,
  method: 'post',
  data
})


/**-------------------------分类分级目录--------------------------------- */
/**
 * 查询执行guid和目录名称
 * @param {no params}
 * @path /cg-dir/get-exec-guid-and-name
 */
export const getExecGuidAndName = () => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-dir/get-exec-guid-and-name`,
  method: 'post',
})




/**
 * 分类分级目录树形列表
 * @param {Object}
 * @path /cg-dir/tree-list
 */

export const getCgDirTreeList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-dir/tree-list`,
  method: 'post',
  data
})

/**
 * 分类分级目录-分页
 * @param {Object}
 * @path /cg-dir/field/page-list
 */

export const getCgDirFieldPageList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-dir/field/page-list`,
  method: 'post',
  data
})


// 分来分级任务-分页
export const getCgTaskPageList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-task/page-list`,
  method: 'post',
  data
})

// 分来分级任务-详情
export const getCgTaskDetail = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-task/detail`,
  method: 'get',
  params: data
})

// 分来分级任务-新增
export const cgTaskSave = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-task/save`,
  method: 'post',
  data
})

// 分来分级任务-修改
export const cgTaskUpdate = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-task/update`,
  method: 'put',
  data
})

// 分来分级任务-删除
export const cgTaskDelete = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-task/delete`,
  method: 'delete',
  data
})

// 手动执行任务
export const runExecTask = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-task/exec-task`,
  method: 'post',
  params: data
})

// 分类分级任务日志
export const getTaskExecPageList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-task-exec/page-list`,
  method: 'post',
  data
})

// 分类分级任务执行树形数据
export const getTaskExeTreeList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-task-exec/classify/tree-list`,
  method: 'get',
  params: data
})

// 分类分级任务执行字段统计
export const getTaskFieldCount = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-task-exec-result/confirm-field-cnt`,
  method: 'get',
  params: data
})

// 分类分级任务执行数据库信息查询
export const getDbFieldList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-task-exec-result/confirm-query-db-list`,
  method: 'get',
  params: data
})

// 分类分级任务执行字段查询
export const execTaskFieldList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-task-exec-result/confirm-field-list-query`,
  method: 'post',
  data
})
// 分类分级任务执行库表查询
export const execTaskSheetList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-task-exec-result/confirm-db-list-query`,
  method: 'post',
  data
})

// 分类分级任务执行任务确认
export const execTaskConfirm = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-task-exec-result/confirm-task`,
  method: 'post',
  params: data
})

// 分类分级任务执行字段确认
export const execFieldConfirm = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-task-exec-result/confirm-field`,
  method: 'post',
  data
})

// 分类分级任务执行结果确认
export const execTaskStatus = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-task-exec-result/batch-change-status`,
  method: 'post',
  data
})

// 标签规则-分页
export const getCgLabelPageList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-label/page-list`,
  method: 'post',
  data
})

// 元数据采集任务-分页
export const getMetaTableCollectList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/meta-table/meta-table-collect-list`,
  method: 'post',
  data
})

export const filterVal = (val, type) => {
  let status = '--';
  if(type == 'status'){
    switch (val) {
      case 'N':
        status = '未运行';
        break;
      case 'Y':
        status = '成功';
        break;
      case 'E':
        status = '失败';
        break;
      case 'R':
        status = '运行中';
        break;
      default:
        status = '未运行';
        break;
    }
  } else if(type == 'confirmStatus'){
    switch (val) {
      case 'N':
        status = '待确认';
        break;
      case 'Y':
        status = '已确认';
        break;
      default:
        status = '--';
        break;
    }
  } else if(type == 'isCgChange'){
    switch (val) {
      case 'N':
        status = '待确认';
        break;
      case 'Y':
        status = '已确认';
        break;
      default:
        status = '待确认';
        break;
    }
  } else if(type == 'changeStatus'){
    switch (val) {
      case 'N':
        status = '待确认';
        break;
      case 'Y':
        status = '已确认';
        break;
      default:
        status = '--';
        break;
    }
  }
  return status;
}

/** 获取字典列表
 * VITE_APP_PLAN_BASEURL 为环境变量 现在只是mock数据
*/
export const getDictionary = (params) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/data-dictionary-general/list-all?state=1`,
  method: 'post'
})



/** 业务规则配置-新增
 * @param {Object}
 * @path /biz-rule-config/save
*/
export const saveBizRuleConfig = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/biz-rule-config/save-or-update`,
  method: 'post',
  data
})


/**树形目录
 * @param {Object}
 * @path /db-dir/tree-list
*/
export const getDbDirTreeList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/db-dir/tree-list`,
  method: 'post',
  data
})

/**
 * 数据库目录-表数据列表查询
 * @param {Object}
 * @path /db-dir/table/page-list
 */
export const getDbDirTablePageList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/db-dir/table/page-list`,
  method: 'post',
  data
})

/**
 * 数据库目录-已有数据库列表
 * @param {no params}
 * @path /db-dir/data-source/list
 */
export const getDbDirDataSourceList = (params) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/db-dir/data-source/list?execGuid=${params.execGuid}`,
  method: 'post',
})

/**
 * 获取列表
 * @param {Object}
 * @path /db-dir/field/page-list
 * @returns
 */
export const getDbDirFieldPageList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/db-dir/field/page-list`,
  method: 'post',
  data
})

/**
 * 数据库目录-表联动查询
 * @param data
 * @returns
 * @path /db-dir/table/select-list
 */
export const getDbDirTableSelectList = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/db-dir/table/select-list`,
  method: 'post',
  data
})



/** 获取已有字段信息 */
export const getDsTableStructure= (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/db-dir/field/list-by-table-guid?tableGuid=${data.tableGuid}&execGuid=${data.execGuid}`,
  method: 'post',
});

/** 获取已有数据库目录字段信息 入参是数组 */
export const getDsTableStructures= (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/db-dir/field/list-by-table-guids`,
    method: 'post',
    data
});

/**
 * 数据库目录-字段查询分类分级
 * @param {Object}
 * @path /db-dir/field/get-classify-and-grade
 */
export const getDbDirFieldClassifyAndGrade = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/db-dir/field/get-classify-and-grade`,
  method: 'post',
  data
})



/** 根据选择的连接池获取表列表 */
export const getDsTableByDs = (params) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/db-dir/table/list-by-datasource-guid`,
  method: 'post',
  data: params
})

/** 根据数据表获取表结构 */
export const  getDsData= (params) => request({
  url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-catalog-subject/table-column-list`,
  method: 'post',
  data: params
});


/**
 * 数据库新建目录表
 * @param {Object}
 * @path /db-dir/table/save
 */
export const saveDbDirTable = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/db-dir/table/save`,
  method: 'post',
  data
})

/**
 * 数据库目录修改表
 * @param {Object}
 * @path /db-dir/table/update
 */
export const updateDbDirTable = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/db-dir/table/update`,
  method: 'post',
  data
})

/**
 * 生成建表sql语句
 * @param {Object}
 * @path /db-dir/table/create-table-sql
 */
export const createTableSql = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/db-dir/table/create-table-sql`,
  method: 'post',
  data
})

/**
 * 导出分类分级目录列表
 * @param {no params}
 * @path /cg-dir/export
 */
export const exportCgDir = () => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-dir/export`,
  method: 'post',
  responseType: 'blob',
})

/**
 * 数据库目录导出
 * @param {no params}
 * @path /db-dir/table/export
 */
export const exportDbDirTable = (params) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/db-dir/table/export?execGuid=${params.execGuid}`,
  method: 'post',
  responseType: 'blob',
})

/**
 * 数据库目录详情
 * @param {query}
 * @path /db-dir/detail
 *
 */
export const getDbDirDetail = (params) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/db-dir/detail?tableGuid=${params.tableGuid}`,
  method: 'get',
})



/*********************业务规则配置 ************数据库目录************************* */

/**
 * 业务规则配置-详情
 * @param {Object}
 * @path /biz-rule-config/detail
 * @returns
 */
export const getBizRuleConfigDetail = (params) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/biz-rule-config/detail?tableGuid=${params.tableGuid}&execGuid=${params.execGuid}`,
  method: 'get',
})



/**-----------------根据文件新建表-------------------------------------- */

/**
 * 根据字段中文名解析字段英文名
 * @param {Object}
 * @path /db-dir/field/get-field-en-name
 */
export const getFidldEnName = (data) => request({
  url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/db-dir/field/get-field-en-name`,
  method: 'post',
  data
})