front/src/api/interface-trackOrder/trackOrder.ts

// @ts-ignore
/* eslint-disable */
import request from '@/utils/request';

/** 根据轨迹id删除单条轨迹 POST /Track/Order/DeleteTrackById */
export async function trackOrderDeleteTrackByIdPost(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.TrackOrderDeleteTrackByIdPOSTParams,
  options?: { [key: string]: any }
) {
  return request<boolean>(`trackApi/Track/Order/DeleteTrackById`, {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 根据订单id获取轨迹明细列表 POST /Track/Order/GetDetails */
export async function trackOrderGetTracksPost(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.TrackOrderGetTracksPOSTParams,
  options?: { [key: string]: any }
) {
  return request<API.TrackOrderDetailDto[]>(`trackApi/Track/Order/GetDetails`, {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 按时间轴获取轨迹内容 POST /Track/Order/GetDetailTimeline */
export async function trackOrderGetDetailTimelinePost(
  body: API.GetDetailTimelineInput,
  options?: { [key: string]: any }
) {
  return request<API.GetDetailTimelineOutputListUnifyResultDto>(
    `trackApi/Track/Order/GetDetailTimeline`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json-patch+json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 根据订单id查询订单操作记录 GET /Track/Order/GetOrderOperationsById */
export async function trackOrderGetOrderOperationsByIdGet(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.TrackOrderGetOrderOperationsByIdGETParams,
  options?: { [key: string]: any }
) {
  return request<API.OrderOperationRecordIndex[]>(
    `trackApi/Track/Order/GetOrderOperationsById`,
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/**
 * 获取订单类型字典。
 * 轨迹后端无 /Track/Order/GetOrderTypeDict（404），统一走 Dictionary/GetList。
 * 返回形态兼容旧调用方：`{ data: Record<string, string> }`。
 */
export async function trackOrderGetOrderTypeDictGet(options?: {
  [key: string]: any;
}) {
  const list = await request<API.EnumCacheEntry[] | Record<string, any>>(
    `trackApi/Dictionary/GetList`,
    {
      method: 'GET',
      params: {
        type: 'TrackOrderType',
      },
      ...(options || {}),
    },
  );

  if (Array.isArray(list)) {
    const dict: Record<string, string> = {};
    for (const item of list) {
      if (item?.key == null) continue;
      dict[String(item.key)] = String(item.value ?? '');
    }
    return { data: dict };
  }

  if (list && typeof list === 'object' && (list as any).data != null) {
    return list as { data: Record<string, any> };
  }

  return { data: (list as Record<string, any>) || {} };
}

/** 获取分页的轨迹订单 POST /Track/Order/GetTrackOrderList */
export async function trackOrderGetTrackOrderPagedListPost(
  body: API.GetPageTrackOrderInput,
  options?: { [key: string]: any }
) {
  return request<API.TrackOrderDtoUnifyPageResultDto>(
    `trackApi/Track/Order/GetTrackOrderList`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json-patch+json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取轨迹推送记录 GET /Track/Order/GetTrackPushRecords */
export async function trackOrderGetTrackPushRecordsGet(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.TrackOrderGetTrackPushRecordsGETParams,
  options?: { [key: string]: any }
) {
  return request<API.TrackPushRecordOutput[]>(
    `trackApi/Track/Order/GetTrackPushRecords`,
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 更新订单状态 POST /Track/Order/UpdateOrderStatus */
export async function trackOrderUpdateOrderStatusPost(
  body: API.UpdateOrderStatusInput,
  options?: { [key: string]: any }
) {
  return request<boolean>(`trackApi/Track/Order/UpdateOrderStatus`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json-patch+json',
    },
    data: body,
    ...(options || {}),
  });
}