gubersail-platform-ui/src/api/forecast/forecast-summary.js

// @ts-check
import request from '@/router/axios'

/**
 * @typedef {import('./types').ForecastSummaryQueryParams} ForecastSummaryQueryParams
 * @typedef {import('./types').ForecastSummaryForm} ForecastSummaryForm
 * @typedef {import('./types').ForecastSummaryRecord} ForecastSummaryRecord
 * @typedef {import('./types').ForecastSummaryListResponse} ForecastSummaryListResponse
 * @typedef {import('./types').ForecastSummaryOperationResponse} ForecastSummaryOperationResponse
 * @typedef {import('./types').ForecastSummaryBatchOperationResponse} ForecastSummaryBatchOperationResponse
 * @typedef {import('./types').ForecastSummaryItem} ForecastSummaryItem
 * @typedef {import('./types').ForecastSummaryPageResponse} ForecastSummaryPageResponse
 * @typedef {import('./types').ApprovalData} ApprovalData
 * @typedef {import('./types').SalesForecastSummaryBatchSaveRequest} SalesForecastSummaryBatchSaveRequest
 * @typedef {import('./types').SalesForecastSummaryBatchSaveResponse} SalesForecastSummaryBatchSaveResponse
 * @typedef {import('./types').SalesForecastSummaryPageQueryParams} SalesForecastSummaryPageQueryParams
 * @typedef {import('./types').SalesForecastSummaryPageResponse} SalesForecastSummaryPageResponse
 * @typedef {import('./types').SalesForecastMainListQueryParams} SalesForecastMainListQueryParams
 * @typedef {import('./types').SalesForecastMainListResponse} SalesForecastMainListResponse
 * @typedef {import('./types').SalesForecastTemplateResponse} SalesForecastTemplateResponse
 * @typedef {import('./types').SalesForecastMainDetailResponse} SalesForecastMainDetailResponse
 * @typedef {import('./types').SalesForecastMainUpdateRequest} SalesForecastMainUpdateRequest
 * @typedef {import('./types').SalesForecastMainUpdateResponse} SalesForecastMainUpdateResponse
 * @typedef {import('./types').SalesForecastByMonthResponse} SalesForecastByMonthResponse
 * @typedef {import('./types').SalesForecastExportByYearMonthParams} SalesForecastExportByYearMonthParams
 */

/**
 * 获取预测汇总列表
 * @param {number} [current=1] - 当前页码
 * @param {number} [size=10] - 每页数量
 * @param {ForecastSummaryQueryParams} [params={}] - 查询参数
 * @returns {Promise<ForecastSummaryListResponse>} 预测汇总列表响应
 * @description 获取经销商销售预测汇总列表，支持多条件查询和分页
 * @example
 * // 获取第一页10条数据
 * const result = await getForecastSummaryList(1, 10)
 *
 * // 按年月查询
 * const result = await getForecastSummaryList(1, 10, { year: 2023, month: 8 })
 *
 * // 按客户查询
 * const result = await getForecastSummaryList(1, 10, { customerId: 1002 })
 *
 * // 按审批状态查询
 * const result = await getForecastSummaryList(1, 10, { approvalStatus: 2 })
 */
export const getForecastSummaryList = async (current = 1, size = 10, params = {}) => {
  return request({
    url: '/api/blade-factory/api/factory/forecast-summary',
    method: 'get',
    params: {
      current,
      size,
      ...params
    }
  })
}

/**
 * 销售预测汇总分页查询
 * 对应后端：GET /api/blade-factory/api/factory/salesForecastSummary/page
 * @param {number} [current=1] - 当前页码
 * @param {number} [size=10] - 每页数量
 * @param {SalesForecastSummaryPageQueryParams} [params={}] - 查询参数（startMonth、endMonth、brandName、startDate、endDate）
 * @returns {Promise<SalesForecastSummaryPageResponse>} 分页响应
 * @example
 * // 基础分页
 * const res = await getSalesForecastSummaryPage(1, 10)
 * // 条件筛选
 * const res2 = await getSalesForecastSummaryPage(1, 20, { startMonth: '2025-08', endMonth: '2025-12', brandName: '朝阳', startDate: '2025-09-01', endDate: '2025-09-30' })
 */
export const getSalesForecastSummaryPage = async (current = 1, size = 10, params = {}) => {
  return request({
    url: '/api/blade-factory/api/factory/salesForecastSummary/page',
    method: 'get',
    params: {
      current,
      size,
      ...params
    }
  })
}

/**
 * 销售预测主表分页列表
 * 对应后端：GET /api/blade-factory/api/factory/salesForecastSummary/main-list
 * @param {number} [current=1] - 当前页码
 * @param {number} [size=10] - 每页数量
 * @param {SalesForecastMainListQueryParams} [params={}] - 查询参数（year、month、customerName）
 * @returns {Promise<SalesForecastMainListResponse>} 分页响应
 * @example
 * // 基础分页
 * const res = await getSalesForecastMainList(1, 10)
 * // 条件筛选
 * const res2 = await getSalesForecastMainList(1, 10, { year: 2025, month: 9, customerName: '库比森' })
 */
export const getSalesForecastMainList = async (current = 1, size = 10, params = {}) => {
  return request({
    url: '/api/blade-factory/api/factory/salesForecastSummary/main-list',
    method: 'get',
    params: { current, size, ...params }
  })
}

/**
 * 销售预测主表分页（新接口）
 * 对应后端：GET /api/blade-factory/api/factory/sales-forecast-main
 * @param {number} [current=1] - 当前页码
 * @param {number} [size=10] - 每页数量
 * @param {SalesForecastMainListQueryParams} [params={}] - 查询参数（可选）
 * @returns {Promise<SalesForecastMainListResponse>} 分页响应（records 为 SalesForecastMainRecord[]）
 * @example
 * const res = await getSalesForecastMainPage(1, 10)
 */
export const getSalesForecastMainPage = async (current = 1, size = 10, params = {}) => {
  return request({
    url: '/api/blade-factory/api/factory/sales-forecast-main',
    method: 'get',
    params: { current, size, ...params }
  })
}

/**
 * 销售预测主表分页列表（含明细）
 * 对应后端：GET /api/blade-factory/api/factory/salesForecastSummary/forecast/list
 * 说明：返回结构与 main-list 相同，顶层记录为 SalesForecastMainRecord，
 *       明细列表字段为 pcBladeSalesForecastSummaryList，因此直接复用现有类型
 * @param {number} [current=1] - 当前页码
 * @param {number} [size=10] - 每页数量
 * @param {SalesForecastMainListQueryParams} [params={}] - 查询参数（year、month、customerName）
 * @returns {Promise<SalesForecastMainListResponse>} 分页响应
 * @example
 * // 基础分页
 * const res = await getSalesForecastForecastList(1, 10)
 * // 条件筛选
 * const res2 = await getSalesForecastForecastList(1, 10, { year: 2025, month: 10, customerName: '库比森' })
 */
export const getSalesForecastForecastList = async (current = 1, size = 10, params = {}) => {
  return request({
    url: '/api/blade-factory/api/factory/salesForecastSummary/forecast/list',
    method: 'get',
    params: { current, size, ...params }
  })
}

/**
 * 新增销售预测主表（main-add）
 * @param {import('./types').SalesForecastMainAddRequest} data - 主表新增请求体（包含年份、月份、审批状态以及子项列表）
 * @returns {Promise<import('./types').SalesForecastMainAddResponse>} 新增主表响应（data 通常为 null，msg 为提示信息）
 * @description 新增销售预测主表记录，提交 pcBladeSalesForecastSummaryList 子项明细；遵循后端通用响应结构 { code, success, data, msg }
 * @example
 * const payload = {
 *   year: 2025,
 *   month: 10,
 *   approvalStatus: 0,
 *   pcBladeSalesForecastSummaryList: [
 *     {
 *       brandId: 101,
 *       brandCode: 'BD-001',
 *       brandName: '品牌A',
 *       itemId: 2001,
 *       itemCode: 'IT-2001',
 *       itemName: '刀片型号A1',
 *       specs: '100x200mm',
 *       pattern: '标准花纹',
 *       forecastQuantity: 500.00,
 *       approvalStatus: 0
 *     }
 *   ]
 * }
 * const res = await addSalesForecastMain(payload)
 */
export const addSalesForecastMain = async (data) => {
  return request({
    url: '/api/blade-factory/api/factory/salesForecastSummary/main-add',
    method: 'post',
    data
  })
}
/**
 * 更新销售预测主表（main-update）
 * 对应后端：PUT /api/blade-factory/api/factory/salesForecastSummary/main-update
 * @param {SalesForecastMainUpdateRequest} data - 更新请求体（包含主表 id、年月、审批状态及明细列表）
 * @returns {Promise<SalesForecastMainUpdateResponse>} 更新响应（data 通常为 null，msg 为提示文本）
 * @example
 * const payload = {
 *   id: 1965692513192693762,
 *   year: 2025,
 *   month: 9,
 *   approvalStatus: 1,
 *   pcBladeSalesForecastSummaryList: [
 *     { id: 1965692513603735554, brandId: 101, brandCode: 'BD-001', brandName: '品牌A1111111111', itemId: 2001, itemCode: 'IT-2001', itemName: '刀片型号A1', specs: '100x200mm', pattern: '标准花纹', forecastQuantity: 500.00, approvalStatus: 0 },
 *     { id: 1965692513633095681, brandId: 101, brandCode: 'BD-001', brandName: '品牌A11111111111', itemId: 2002, itemCode: 'IT-2002', itemName: '刀片型号A2', specs: '150x250mm', pattern: '加强花纹', forecastQuantity: 300.00, approvalStatus: 0 },
 *     { id: 1965692513641484290, brandId: 102, brandCode: 'BD-002', brandName: '品牌B11111111111', itemId: 3001, itemCode: 'IT-3001', itemName: '刀片型号B1', specs: '200x300mm', pattern: '特殊花纹', forecastQuantity: 200.00, approvalStatus: 0 }
 *   ]
 * }
 * const res = await updateSalesForecastMain(payload)
 * // 可能返回：{ code: 400, success: false, data: null, msg: '修改失败，请稍后重试' }
 */
export const updateSalesForecastMain = async (data) => {
  return request({
    url: '/api/blade-factory/api/factory/salesForecastSummary/main-update',
    method: 'put',
    data
  })
}

/**
 * 获取预测汇总详情
 * @param {string|number} forecastSummaryId - 预测汇总ID
 * @returns {Promise<ForecastSummaryOperationResponse>} 预测汇总详情响应
 * @description 根据ID获取预测汇总的详细信息
 * @example
 * const result = await getForecastSummaryDetail('1954819531796865026')
 *
 * // 处理响应数据
 * if (result.success && result.code === 200) {
 *   const summaryData = result.data
 *   console.log('预测汇总详情:', summaryData)
 * }
 */
export const getForecastSummaryDetail = async (forecastSummaryId) => {
  return request({
    url: `/api/blade-factory/api/factory/forecast-summary/${forecastSummaryId}`,
    method: 'get'
  })
}

/**
 * 添加预测汇总
 * @param {ForecastSummaryForm} data - 预测汇总表单数据
 * @returns {Promise<ForecastSummaryOperationResponse>} 添加预测汇总响应
 * @description 创建新的销售预测汇总记录
 * @example
 * const formData = {
 *   year: 2023,
 *   month: 8,
 *   customerId: 1001,
 *   customerCode: 'DLR001',
 *   customerName: '上海轮胎经销商',
 *   brandId: 2001,
 *   brandCode: 'BRD001',
 *   brandName: '米其林',
 *   itemId: 3001,
 *   itemCode: 'ITEM001',
 *   itemName: '轮胎A型号',
 *   specs: '225/65R17',
 *   pattern: 'Primacy SUV',
 *   forecastQuantity: 150,
 *   approvalStatus: 0
 * }
 * const result = await addForecastSummary(formData)
 */
export const addForecastSummary = async (data) => {
  return request({
    url: '/api/blade-factory/api/factory/forecast-summary',
    method: 'post',
    data
  })
}

/**
 * 更新预测汇总
 * @param {ForecastSummaryForm} data - 预测汇总表单数据（必须包含id）
 * @returns {Promise<ForecastSummaryOperationResponse>} 更新预测汇总响应
 * @description 更新现有的销售预测汇总记录
 * @example
 * const formData = {
 *   id: '1954819531796865026',
 *   year: 2023,
 *   month: 8,
 *   customerId: 1001,
 *   customerCode: 'DLR001',
 *   customerName: '上海轮胎经销商',
 *   brandId: 2001,
 *   brandCode: 'BRD001',
 *   brandName: '米其林',
 *   itemId: 3001,
 *   itemCode: 'ITEM001',
 *   itemName: '轮胎A型号',
 *   specs: '225/65R17',
 *   pattern: 'Primacy SUV',
 *   forecastQuantity: 180,
 *   approvalStatus: 0
 * }
 * const result = await updateForecastSummary(formData)
 */
export const updateForecastSummary = async (data) => {
  return request({
    url: '/api/blade-factory/api/factory/forecast-summary',
    method: 'put',
    data
  })
}

/**
 * 删除预测汇总
 * @param {string|number} id - 预测汇总ID
 * @returns {Promise<ForecastSummaryOperationResponse>} 删除预测汇总响应
 * @description 根据ID删除销售预测汇总记录
 * @example
 * const result = await removeForecastSummary('1954819531796865026')
 */
export const removeForecastSummary = async (id) => {
  return request({
    url: `/api/blade-factory/api/factory/forecast-summary/${id}`,
    method: 'delete'
  })
}

/**
 * 批量删除预测汇总
 * @param {Array<string|number>} ids - 预测汇总ID数组
 * @returns {Promise<ForecastSummaryBatchOperationResponse>} 批量删除预测汇总响应
 * @description 批量删除多个销售预测汇总记录
 * @example
 * const result = await batchRemoveForecastSummary(['1954819531796865026', '1954819531796865027'])
 */
export const batchRemoveForecastSummary = async (ids) => {
  return request({
    url: '/api/blade-factory/api/factory/forecast-summary/batch',
    method: 'delete',
    data: ids
  })
}

/**
 * 审批预测汇总
 * @param {ApprovalData} data - 审批数据
 * @returns {Promise<ForecastSummaryOperationResponse>} 审批预测汇总响应
 * @description 审批销售预测汇总记录
 * @example
 * // 通过审批
 * await approveForecastSummary({ id: '123', approvalStatus: 1, approvalComment: '同意' })
 * // 拒绝审批
 * await approveForecastSummary({ id: '123', approvalStatus: 2, approvalComment: '不符合要求' })
 */
export const approveForecastSummary = async (data) => {
  return request({
    url: '/api/blade-factory/api/factory/forecast-summary/approve',
    method: 'post',
    data
  })
}

/**
 * 销售预测汇总批量保存
 * 对应后端：POST /api/blade-factory/api/factory/salesForecastSummary/batchSave
 * @param {SalesForecastSummaryBatchSaveRequest} data - 批量保存请求体
 * @returns {Promise<SalesForecastSummaryBatchSaveResponse>} 响应，data 通常为 null，msg 提示文本
 */
export const batchSaveSalesForecastSummary = async (data) => {
  return request({
    url: '/api/blade-factory/api/factory/salesForecastSummary/batchSave',
    method: 'post',
    data
  })
}

/**
 * 销售预测模板下载
 * 对应后端：GET /api/blade-factory/api/factory/salesForecastSummary/exportTemplate
 * @param {number} [current=1] - 当前页码
 * @param {number} [size=10] - 每页数量
 * @param {SalesForecastSummaryPageQueryParams} [params={}] - 查询参数（用于与分页检索保持一致，便于后端构造模板）
 * @returns {Promise<SalesForecastTemplateResponse>} 模板下载响应（Blob 数据 + 响应头）
 */
export const exportSalesForecastTemplate = async (current = 1, size = 10, params = {}) => {
  return request({
    url: '/api/blade-factory/api/factory/salesForecastSummary/exportTemplate',
    method: 'get',
    responseType: 'blob',
    params: { current, size, ...params }
  })
}

/**
 * 销售预测数据导出（按年月）
 * 对应后端：GET /api/blade-factory/api/factory/salesForecastSummary/export/{year}/{month}
 * @param {number|string} year - 年份，如 2025
 * @param {number|string} month - 月份，1-12 或 '01'-'12'
 * @returns {Promise<SalesForecastTemplateResponse>} 导出响应（Blob 数据 + 响应头）
 * @example
 * const res = await exportSalesForecastByMonth(2025, 10)
 * // 文件名可从 res.headers['content-disposition'] 中解析
 */
export const exportSalesForecastByMonth = async (year, month) => {
  return request({
    url: `/api/blade-factory/api/factory/salesForecastSummary/export/${year}/${month}`,
    method: 'get',
    responseType: 'blob'
  })
}

/**
 * 销售预测数据导出（按年月：query参数）
 * 对应后端：GET /api/blade-factory/api/factory/salesForecastSummary/exportByYearMonth?year=2025&month=10
 * @param {SalesForecastExportByYearMonthParams['year']} year - 年份，如 2025
 * @param {SalesForecastExportByYearMonthParams['month']} month - 月份，1-12 或 '01'-'12'
 * @returns {Promise<SalesForecastTemplateResponse>} 导出响应（Blob 数据 + 响应头）
 * @example
 * const res = await exportSalesForecastByYearMonthQuery(2025, 10)
 * // 文件名可从 res.headers['content-disposition'] 中解析
 */
export const exportSalesForecastByYearMonthQuery = async (year, month) => {
  return request({
    url: '/api/blade-factory/api/factory/salesForecastSummary/exportByYearMonth',
    method: 'get',
    responseType: 'blob',
    params: { year, month }
  })
}

/**
 * 销售预测数据导出（用户维度，按年月）
 * 对应后端：GET /api/blade-factory/api/factory/salesForecastSummary/user/export/{year}/{month}
 * @param {number|string} year - 年份，如 2025
 * @param {number|string} month - 月份，1-12 或 '01'-'12'
 * @returns {Promise<SalesForecastTemplateResponse>} 导出响应（Blob 数据 + 响应头）
 * @example
 * const res = await exportUserSalesForecastByMonth(2025, 10)
 * // 文件名可从 res.headers['content-disposition'] 中解析
 */
export const exportUserSalesForecastByMonth = async (year, month) => {
  return request({
    url: `/api/blade-factory/api/factory/salesForecastSummary/user/export/${year}/${month}`,
    method: 'get',
    responseType: 'blob'
  })
}

/**
 * 销售预测数据导出（按主表ID）
 * 对应后端：GET /api/blade-factory/api/factory/salesForecastSummary/exportByMainId/{mainId}
 * @param {number|string} mainId - 主表ID
 * @returns {Promise<SalesForecastTemplateResponse>} 导出响应（Blob 数据 + 响应头）
 * @example
 * const res = await exportSalesForecastByMainId('1966517943156121601')
 * // 文件名可从 res.headers['content-disposition'] 中解析
 */
export const exportSalesForecastByMainId = async (mainId) => {
  return request({
    url: `/api/blade-factory/api/factory/salesForecastSummary/exportByMainId/${mainId}`,
    method: 'get',
    responseType: 'blob'
  })
}

/**
 * 获取销售预测主表详情
 * 对应后端：GET /api/blade-factory/api/factory/salesForecastSummary/forecast/detail
 * @param {string|number} id - 主表ID
 * @returns {Promise<SalesForecastMainDetailResponse>} 详情响应（data: SalesForecastMainRecord）
 * @description 根据 ID 查询销售预测主表详情，包含 pcBladeSalesForecastSummaryList 子项
 * @example
 * const { data } = await getSalesForecastForecastDetail('1966138542639833089')
 * if (data.success && data.code === 200) {
 *   const detail = data.data
 *   console.log('主表详情', detail)
 * }
 */
export const getSalesForecastForecastDetail = async (id) => {
  return request({
    url: '/api/blade-factory/api/factory/salesForecastSummary/forecast/detail',
    method: 'get',
    params: { id }
  })
}

/**
 * 销售预测汇总审批
 * 对应后端：POST /api/blade-factory/api/factory/salesForecastSummary/approve
 * @param {{ id: string|number, approvalStatus: number, remark?: string, approvalComment?: string }} data - 审批参数
 * @returns {Promise<SalesForecastSummaryBatchSaveResponse>} 操作响应（data: null，msg 提示信息）
 * @description 入参支持 remark 或 approvalComment，内部统一映射为 remark
 * @example
 * await approveSalesForecastSummary({ id: 1965692513192693762, approvalStatus: 1, remark: '' })
 */
export const approveSalesForecastSummary = async (data) => {
  const { id, approvalStatus, remark, approvalComment } = data || {}
  return request({
    url: '/api/blade-factory/api/factory/salesForecastSummary/approve',
    method: 'post',
    data: { id, approvalStatus, remark: remark ?? approvalComment ?? '' }
  })
}

/**
 * 销售预测明细审批
 * 对应后端：POST /api/blade-factory/api/factory/salesForecastSummary/particulars
 * @param {{ id: string|number, forecastMainId: string|number, approvalStatus: number, remark?: string, approvalComment?: string }} data - 审批参数
 * @returns {Promise<SalesForecastSummaryBatchSaveResponse>} 操作响应（data: null，msg 提示信息）
 * @description 入参支持 remark 或 approvalComment，内部统一映射为 remark
 * @example
 * await approveSalesForecastSummaryParticulars({ id: 1966138542895685633, forecastMainId: 1966138542639833089, approvalStatus: 1, remark: '' })
 */
export const approveSalesForecastSummaryParticulars = async (data) => {
  const { id, forecastMainId, approvalStatus, remark, approvalComment } = data || {}
  return request({
    url: '/api/blade-factory/api/factory/salesForecastSummary/particulars',
    method: 'post',
    data: { id, forecastMainId, approvalStatus, remark: remark ?? approvalComment ?? '' }
  })
}

/**
 * 按年月查询销售预测汇总明细
 * 对应后端：GET /api/blade-factory/api/factory/salesForecastSummary/byMonth
 * @param {number|string} year - 年份，例如 2025
 * @param {number|string} month - 月份，1-12 或 '01'-'12'
 * @returns {Promise<SalesForecastByMonthResponse>} 响应（data: ForecastSummaryRecord[]）
 * @example
 * const res = await getSalesForecastSummaryByMonth(2025, 12)
 */
export const getSalesForecastSummaryByMonth = async (year, month) => {
  return request({
    url: '/api/blade-factory/api/factory/salesForecastSummary/byMonth',
    method: 'get',
    params: { year, month }
  })
}