LifePaymentFront.git

/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';
 
/** 新增联系记录 POST /api/Order/AddTradeChatRecord */
export async function addTradeChatRecord(
  body: API.AddTradeChatRecordInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Order/AddTradeChatRecord', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 交易申请 POST /api/Order/ApplyMatchMaking */
export async function applyMatchMaking(
  body: API.ApplyMatchMakingInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Order/ApplyMatchMaking', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 此处后端没有提供注释 POST /api/Order/CancelOrderAttention */
export async function cancelOrderAttention(body: API.OrderViewInput, options?: API.RequestConfig) {
  return request<number>('/api/Order/CancelOrderAttention', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 订单审核 POST /api/Order/CheckOrder */
export async function checkOrder(body: API.CreateOrUpdateOrderinput, options?: API.RequestConfig) {
  return request<string>('/api/Order/CheckOrder', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 新增修改订单 POST /api/Order/CreateOrUpdateOrder */
export async function createOrUpdateOrder(
  body: API.CreateOrUpdateOrderinput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Order/CreateOrUpdateOrder', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 删除交易申请 GET /api/Order/DeleteMatchMakingApply */
export async function deleteMatchMakingApply(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteMatchMakingApplyParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Order/DeleteMatchMakingApply', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}
 
/** 删除订单 GET /api/Order/DeleteOrder */
export async function deleteOrder(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteOrderParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Order/DeleteOrder', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}
 
/** 获取甲方公司我要人列表 POST /api/Order/GetFirstPartyCompanyOrderList */
export async function getFirstPartyCompanyOrderList(
  body: API.OrderListInput,
  options?: API.RequestConfig
) {
  return request<API.OrderListDtoPageOutput>('/api/Order/GetFirstPartyCompanyOrderList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 此处后端没有提供注释 POST /api/Order/GetFrontOrderList */
export async function getFrontOrderList(
  body: API.FrontOrderListInput,
  options?: API.RequestConfig
) {
  return request<API.FrontOrderListPageOutput>('/api/Order/GetFrontOrderList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 根据订单获取交易申请分页列表 POST /api/Order/GetMatchMakingApplyByOrderPage */
export async function getMatchMakingApplyByOrderPage(
  body: API.QueryMatchMakingApplyByOrderInput,
  options?: API.RequestConfig
) {
  return request<API.MatchMakingApplyByOrderOutputPageOutput>(
    '/api/Order/GetMatchMakingApplyByOrderPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}
 
/** 获取我的甲方公司我要人列表 POST /api/Order/GetMyFirstPartyCompanyOrderList */
export async function getMyFirstPartyCompanyOrderList(
  body: API.OrderListInput,
  options?: API.RequestConfig
) {
  return request<API.OrderListDtoPageOutput>('/api/Order/GetMyFirstPartyCompanyOrderList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 获取我的交易申请分页列表 POST /api/Order/GetMyMatchMakingApplyPage */
export async function getMyMatchMakingApplyPage(
  body: API.MyMatchMakingApplyInput,
  options?: API.RequestConfig
) {
  return request<API.MyMatchMakingApplyOutputPageOutput>('/api/Order/GetMyMatchMakingApplyPage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 查询我的订单 POST /api/Order/GetMyOrderList */
export async function getMyOrderList(body: API.MyOrderListInput, options?: API.RequestConfig) {
  return request<API.FrontOrderListPageOutput>('/api/Order/GetMyOrderList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 获取订单详情 GET /api/Order/GetOrdeForDetail */
export async function getOrdeForDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetOrdeForDetailParams,
  options?: API.RequestConfig
) {
  return request<API.OrderInfoDto>('/api/Order/GetOrdeForDetail', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}
 
/** 根据UserID获取订单详情 GET /api/Order/GetOrdeForDetailByUserId */
export async function getOrdeForDetailByUserId(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetOrdeForDetailByUserIdParams,
  options?: API.RequestConfig
) {
  return request<API.OrderInfoDto>('/api/Order/GetOrdeForDetailByUserId', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}
 
/** 获取订单列表 POST /api/Order/GetOrderList */
export async function getOrderList(body: API.OrderListInput, options?: API.RequestConfig) {
  return request<API.OrderListDtoPageOutput>('/api/Order/GetOrderList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 获取订单审核列表 POST /api/Order/GetOrderListForCheck */
export async function getOrderListForCheck(body: API.OrderListInput, options?: API.RequestConfig) {
  return request<API.OrderListDtoPageOutput>('/api/Order/GetOrderListForCheck', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 获取订单推荐列表 GET /api/Order/GetOrderListForRecommend */
export async function getOrderListForRecommend(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetOrderListForRecommendParams,
  options?: API.RequestConfig
) {
  return request<API.OrderListDto[]>('/api/Order/GetOrderListForRecommend', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}
 
/** 获取联系记录 POST /api/Order/GetTradeChatRecordPage */
export async function getTradeChatRecordPage(
  body: API.QueryTradeChatRecordInput,
  options?: API.RequestConfig
) {
  return request<API.TradeChatRecordOutputPageOutput>('/api/Order/GetTradeChatRecordPage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 获取他人用户订单列表 POST /api/Order/GetUserOrderList */
export async function getUserOrderList(body: API.UserOrderListInput, options?: API.RequestConfig) {
  return request<API.FrontOrderListPageOutput>('/api/Order/GetUserOrderList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 订单收藏 POST /api/Order/OrderAttention */
export async function orderAttention(body: API.OrderViewInput, options?: API.RequestConfig) {
  return request<number>('/api/Order/OrderAttention', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 订单浏览 POST /api/Order/OrderBrowse */
export async function orderBrowse(body: API.OrderViewInput, options?: API.RequestConfig) {
  return request<number>('/api/Order/OrderBrowse', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 接单未读数 GET /api/Order/OrderTakenNotReadCount */
export async function orderTakenNotReadCount(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIorderTakenNotReadCountParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Order/OrderTakenNotReadCount', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}
 
/** 阅读接单信息 POST /api/Order/ReadOrderTaken */
export async function readOrderTaken(body: API.ReadOrderTakenInput, options?: API.RequestConfig) {
  return request<number>('/api/Order/ReadOrderTaken', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 批量设置order状态 POST /api/Order/SetListOrderStatus */
export async function setListOrderStatus(body: API.ListOrderStatus, options?: API.RequestConfig) {
  return request<number>('/api/Order/SetListOrderStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 设置交易申请状态 POST /api/Order/SetMatchMakingApplyStatus */
export async function setMatchMakingApplyStatus(
  body: API.SetMatchMakingApplyStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Order/SetMatchMakingApplyStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 设置订单推荐 POST /api/Order/SetOrderRecommend */
export async function setOrderRecommend(
  body: API.ResourceRecommendInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Order/SetOrderRecommend', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 订单招聘 上架/下架/修改状态/删除 POST /api/Order/SetOrderStatus */
export async function setOrderStatus(body: API.PutOrOffOrderInput, options?: API.RequestConfig) {
  return request<number>('/api/Order/SetOrderStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}
 
/** 我要接单 GET /api/Order/TakeOrder */
export async function takeOrder(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APItakeOrderParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Order/TakeOrder', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}