pcwl_yancheng/cheflinkuser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
ISFP_T
2026-02-26 09:32:03 +08:00
commit 36a8e4c51b
845 changed files with 116474 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/service/agreement.ts
+60
View File
@@ -0,0 +1,60 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 获取协议内容 GET /app/agreement/getAgreement/${param0} */
export async function appAgreementGetAgreementCodeGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppAgreementGetAgreementcodeGetParams;
options?: CustomRequestOptions;
}) {
const { code: param0, ...queryParams } = params;
return request<string>(`/app/agreement/getAgreement/${param0}`, {
method: 'GET',
params: { ...queryParams },
...(options || {}),
});
}
/** 获取协议 POST /app/agreement/getByCode */
export async function appAgreementGetByCodePost({
body,
options,
}: {
body: API.GetAgreementBo;
options?: CustomRequestOptions;
}) {
return request<API.RAgreementVo>('/app/agreement/getByCode', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取协议内容 POST /app/agreement/getContentByCode */
export async function appAgreementGetContentByCodePost({
body,
options,
}: {
body: API.GetAgreementBo;
options?: CustomRequestOptions;
}) {
return request<string>('/app/agreement/getContentByCode', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
src/service/appointmentTime.ts
+153
View File
@@ -0,0 +1,153 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 查询用户的预约时间 POST /app/appointmentTime/queryAppointmentTime */
export async function appAppointmentTimeQueryAppointmentTimePost({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RAppointmentTimeVo>(
'/app/appointmentTime/queryAppointmentTime',
{
method: 'POST',
...(options || {}),
}
);
}
/** 修改用户的预约时间 POST /app/appointmentTime/updateAppointmentTime */
export async function appAppointmentTimeUpdateAppointmentTimePost({
body,
options,
}: {
body: API.AppointmentTimeBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/appointmentTime/updateAppointmentTime', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 修改用户预约时间 PUT /xjpmj/appointmentTime */
export async function xjpmjAppointmentTimePut({
body,
options,
}: {
body: API.AppointmentTimeBoEditGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/appointmentTime', {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 新增用户预约时间 POST /xjpmj/appointmentTime */
export async function xjpmjAppointmentTimePost({
body,
options,
}: {
body: API.AppointmentTimeBoAddGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/appointmentTime', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取用户预约时间详细信息 GET /xjpmj/appointmentTime/${param0} */
export async function xjpmjAppointmentTimeIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjAppointmentTimeidGetParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.RAppointmentTimeVo>(`/xjpmj/appointmentTime/${param0}`, {
method: 'GET',
params: { ...queryParams },
...(options || {}),
});
}
/** 删除用户预约时间 DELETE /xjpmj/appointmentTime/${param0} */
export async function xjpmjAppointmentTimeIdsDelete({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjAppointmentTimeidsDeleteParams;
options?: CustomRequestOptions;
}) {
const { ids: param0, ...queryParams } = params;
return request<API.RVoid>(`/xjpmj/appointmentTime/${param0}`, {
method: 'DELETE',
params: { ...queryParams },
...(options || {}),
});
}
/** 导出用户预约时间列表 POST /xjpmj/appointmentTime/export */
export async function xjpmjAppointmentTimeExportPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjAppointmentTimeExportPostParams;
options?: CustomRequestOptions;
}) {
return request<API.XjpmjAppointmentTimeExportPostResponse>(
'/xjpmj/appointmentTime/export',
{
method: 'POST',
params: {
...params,
},
...(options || {}),
}
);
}
/** 查询用户预约时间列表 GET /xjpmj/appointmentTime/list */
export async function xjpmjAppointmentTimeListGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjAppointmentTimeListGetParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoAppointmentTimeVo>(
'/xjpmj/appointmentTime/list',
{
method: 'GET',
params: {
...params,
},
...(options || {}),
}
);
}
src/service/automaticCookingMachine.ts
+72
View File
@@ -0,0 +1,72 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 查询炒菜机详情 GET /app/automaticCookingMachine/detail */
export async function appAutomaticCookingMachineDetailGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RAutomaticCookingMachineVo>(
'/app/automaticCookingMachine/detail',
{
method: 'GET',
...(options || {}),
}
);
}
/** 炒菜机报名 POST /app/automaticCookingMachine/registration */
export async function appAutomaticCookingMachineRegistrationPost({
body,
options,
}: {
body: API.AutomaticCookingMachineRegistrationBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/app/automaticCookingMachine/registration', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 修改炒菜机 PUT /xjpmj/automaticCookingMachine */
export async function xjpmjAutomaticCookingMachinePut({
body,
options,
}: {
body: API.AutomaticCookingMachineBoEditGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/automaticCookingMachine', {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取炒菜机详细信息 GET /xjpmj/automaticCookingMachine/getInfo */
export async function xjpmjAutomaticCookingMachineGetInfoGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RAutomaticCookingMachineVo>(
'/xjpmj/automaticCookingMachine/getInfo',
{
method: 'GET',
...(options || {}),
}
);
}
src/service/automaticCookingMachineRegistration.ts
+93
View File
@@ -0,0 +1,93 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 修改炒菜机报名 PUT /xjpmj/automaticCookingMachineRegistration */
export async function xjpmjAutomaticCookingMachineRegistrationPut({
body,
options,
}: {
body: API.AutomaticCookingMachineRegistrationBoEditGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/automaticCookingMachineRegistration', {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取炒菜机报名详细信息 GET /xjpmj/automaticCookingMachineRegistration/${param0} */
export async function xjpmjAutomaticCookingMachineRegistrationIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjAutomaticCookingMachineRegistrationidGetParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.RAutomaticCookingMachineRegistrationVo>(
`/xjpmj/automaticCookingMachineRegistration/${param0}`,
{
method: 'GET',
params: { ...queryParams },
...(options || {}),
}
);
}
/** 删除炒菜机报名 DELETE /xjpmj/automaticCookingMachineRegistration/${param0} */
export async function xjpmjAutomaticCookingMachineRegistrationIdsDelete({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjAutomaticCookingMachineRegistrationidsDeleteParams;
options?: CustomRequestOptions;
}) {
const { ids: param0, ...queryParams } = params;
return request<API.RVoid>(
`/xjpmj/automaticCookingMachineRegistration/${param0}`,
{
method: 'DELETE',
params: { ...queryParams },
...(options || {}),
}
);
}
/** 查询炒菜机报名列表 POST /xjpmj/automaticCookingMachineRegistration/list */
export async function xjpmjAutomaticCookingMachineRegistrationListPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjAutomaticCookingMachineRegistrationListPostParams;
body: API.AutomaticCookingMachineRegistrationBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoAutomaticCookingMachineRegistrationVo>(
'/xjpmj/automaticCookingMachineRegistration/list',
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
}
);
}
src/service/collect.ts
+48
View File
@@ -0,0 +1,48 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 收藏 POST /app/collect/collect */
export async function appCollectCollectPost({
body,
options,
}: {
body: API.UserCollectBo;
options?: CustomRequestOptions;
}) {
return request<API.RBoolean>('/app/collect/collect', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 收藏列表 POST /app/collect/list */
export async function appCollectListPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppCollectListPostParams;
body: API.UserCollectBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoUserCollectVo>('/app/collect/list', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
});
}
src/service/comment.ts
+90
View File
@@ -0,0 +1,90 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 评论列表 POST /app/comment/commentList */
export async function appCommentCommentListPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppCommentCommentListPostParams;
body: API.CommentPageBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoCommentVo>('/app/comment/commentList', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
});
}
/** 删除评论 DELETE /app/comment/deleteComment/${param0} */
export async function appCommentDeleteCommentIdDelete({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppCommentDeleteCommentidDeleteParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.RVoid>(`/app/comment/deleteComment/${param0}`, {
method: 'DELETE',
params: { ...queryParams },
...(options || {}),
});
}
/** 发布评论/回复 POST /app/comment/publishComment */
export async function appCommentPublishCommentPost({
body,
options,
}: {
body: API.CommentBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/app/comment/publishComment', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 回复列表 POST /app/comment/replyList */
export async function appCommentReplyListPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppCommentReplyListPostParams;
body: API.ReplyPageBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoCommentVo>('/app/comment/replyList', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
});
}
src/service/coupon.ts
+222
View File
@@ -0,0 +1,222 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 新增优惠券 POST /app/coupon/addCoupon */
export async function appCouponAddCouponPost({
body,
options,
}: {
body: API.CouponBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/coupon/addCoupon', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 复制兑换码(指定数量) POST /app/coupon/copyCouponCode */
export async function appCouponCopyCouponCodePost({
body,
options,
}: {
body: API.CouponBo;
options?: CustomRequestOptions;
}) {
return request<API.RListString>('/app/coupon/copyCouponCode', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 创建优惠券需付款金额 如果为0 则免费添加 POST /app/coupon/couponCost */
export async function appCouponCouponCostPost({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RBigDecimal>('/app/coupon/couponCost', {
method: 'POST',
...(options || {}),
});
}
/** 删除优惠券 DELETE /app/coupon/deleteCoupon/${param0} */
export async function appCouponDeleteCouponIdDelete({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppCouponDeleteCouponidDeleteParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.R>(`/app/coupon/deleteCoupon/${param0}`, {
method: 'DELETE',
params: { ...queryParams },
...(options || {}),
});
}
/** 兑换码生成优惠券 POST /app/coupon/exchangeCoupon */
export async function appCouponExchangeCouponPost({
body,
options,
}: {
body: API.CouponCodeBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/coupon/exchangeCoupon', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 商家优惠券列表 POST /app/coupon/merchantCouponList */
export async function appCouponMerchantCouponListPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppCouponMerchantCouponListPostParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoCouponVo>('/app/coupon/merchantCouponList', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 用户优惠券列表 POST /app/coupon/userCouponList */
export async function appCouponUserCouponListPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppCouponUserCouponListPostParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoUserCouponVo>('/app/coupon/userCouponList', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 新增优惠券主 POST /xjpmj/coupon */
export async function xjpmjCouponPost({
body,
options,
}: {
body: API.CouponBoAddGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/coupon', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取优惠券主详细信息 GET /xjpmj/coupon/${param0} */
export async function xjpmjCouponIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjCouponidGetParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.RCouponVo>(`/xjpmj/coupon/${param0}`, {
method: 'GET',
params: { ...queryParams },
...(options || {}),
});
}
/** 删除优惠券主 DELETE /xjpmj/coupon/${param0} */
export async function xjpmjCouponIdsDelete({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjCouponidsDeleteParams;
options?: CustomRequestOptions;
}) {
const { ids: param0, ...queryParams } = params;
return request<API.RVoid>(`/xjpmj/coupon/${param0}`, {
method: 'DELETE',
params: { ...queryParams },
...(options || {}),
});
}
/** 复制兑换码(指定数量) POST /xjpmj/coupon/copyCouponCode */
export async function xjpmjCouponCopyCouponCodePost({
body,
options,
}: {
body: API.CouponBo;
options?: CustomRequestOptions;
}) {
return request<API.RListString>('/xjpmj/coupon/copyCouponCode', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 查询优惠券主列表 POST /xjpmj/coupon/list */
export async function xjpmjCouponListPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjCouponListPostParams;
body: API.CouponBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoCouponVo>('/xjpmj/coupon/list', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
});
}
src/service/customerService.ts
+48
View File
@@ -0,0 +1,48 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 获取筛选条件 GET /app/customerService/getInfo */
export async function appCustomerServiceGetInfoGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RCustomerServiceVo>('/app/customerService/getInfo', {
method: 'GET',
...(options || {}),
});
}
/** 修改客服中心 PUT /xjpmj/customerService */
export async function xjpmjCustomerServicePut({
body,
options,
}: {
body: API.CustomerServiceBoEditGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/customerService', {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取客服中心详细信息 GET /xjpmj/customerService/getInfo */
export async function xjpmjCustomerServiceGetInfoGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RCustomerServiceVo>('/xjpmj/customerService/getInfo', {
method: 'GET',
...(options || {}),
});
}
src/service/displayEnumLabel.ts
+11
View File
@@ -0,0 +1,11 @@
/* eslint-disable */
// @ts-ignore
import * as API from './types';
export function displayTypeEnum(field: API.TypeEnum) {
return {}[field];
}
export function displayTypeEnum2(field: API.TypeEnum2) {
return {}[field];
}
src/service/featuredMerchant.ts
+105
View File
@@ -0,0 +1,105 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 修改精选商家 PUT /xjpmj/featuredMerchant */
export async function xjpmjFeaturedMerchantPut({
body,
options,
}: {
body: API.FeaturedMerchantBoEditGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/featuredMerchant', {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 新增精选商家 POST /xjpmj/featuredMerchant */
export async function xjpmjFeaturedMerchantPost({
body,
options,
}: {
body: API.FeaturedMerchantBoAddGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/featuredMerchant', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取精选商家详细信息 GET /xjpmj/featuredMerchant/${param0} */
export async function xjpmjFeaturedMerchantIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjFeaturedMerchantidGetParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.RFeaturedMerchantVo>(`/xjpmj/featuredMerchant/${param0}`, {
method: 'GET',
params: { ...queryParams },
...(options || {}),
});
}
/** 删除精选商家 DELETE /xjpmj/featuredMerchant/${param0} */
export async function xjpmjFeaturedMerchantIdsDelete({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjFeaturedMerchantidsDeleteParams;
options?: CustomRequestOptions;
}) {
const { ids: param0, ...queryParams } = params;
return request<API.RVoid>(`/xjpmj/featuredMerchant/${param0}`, {
method: 'DELETE',
params: { ...queryParams },
...(options || {}),
});
}
/** 查询精选商家列表 POST /xjpmj/featuredMerchant/list */
export async function xjpmjFeaturedMerchantListPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjFeaturedMerchantListPostParams;
body: API.FeaturedMerchantBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoFeaturedMerchantVo>(
'/xjpmj/featuredMerchant/list',
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
}
);
}
src/service/feedback.ts
+78
View File
@@ -0,0 +1,78 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 添加意见反馈 POST /app/feedback/add */
export async function appFeedbackAddPost({
body,
options,
}: {
body: API.FeedbackBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/app/feedback/add', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取意见反馈详细信息 GET /xjpmj/feedback/${param0} */
export async function xjpmjFeedbackIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjFeedbackidGetParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.RFeedbackVo>(`/xjpmj/feedback/${param0}`, {
method: 'GET',
params: { ...queryParams },
...(options || {}),
});
}
/** 删除意见反馈 DELETE /xjpmj/feedback/${param0} */
export async function xjpmjFeedbackIdsDelete({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjFeedbackidsDeleteParams;
options?: CustomRequestOptions;
}) {
const { ids: param0, ...queryParams } = params;
return request<API.RVoid>(`/xjpmj/feedback/${param0}`, {
method: 'DELETE',
params: { ...queryParams },
...(options || {}),
});
}
/** 查询意见反馈列表 GET /xjpmj/feedback/list */
export async function xjpmjFeedbackListGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjFeedbackListGetParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoFeedbackVo>('/xjpmj/feedback/list', {
method: 'GET',
params: {
...params,
},
...(options || {}),
});
}
src/service/filtersConfig.ts
+18
View File
@@ -0,0 +1,18 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 获取筛选条件 GET /app/filtersConfig/getFilters */
export async function appFiltersConfigGetFiltersGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RMapListFilterConfigVo>('/app/filtersConfig/getFilters', {
method: 'GET',
...(options || {}),
});
}
src/service/helpCenter.ts
+108
View File
@@ -0,0 +1,108 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 帮助中心列表 GET /app/helpCenter/list */
export async function appHelpCenterListGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RListHelpCenterVo>('/app/helpCenter/list', {
method: 'GET',
...(options || {}),
});
}
/** 修改帮助中心 PUT /xjpmj/helpCenter */
export async function xjpmjHelpCenterPut({
body,
options,
}: {
body: API.HelpCenterBoEditGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/helpCenter', {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 新增帮助中心 POST /xjpmj/helpCenter */
export async function xjpmjHelpCenterPost({
body,
options,
}: {
body: API.HelpCenterBoAddGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/helpCenter', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取帮助中心详细信息 GET /xjpmj/helpCenter/${param0} */
export async function xjpmjHelpCenterIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjHelpCenteridGetParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.RHelpCenterVo>(`/xjpmj/helpCenter/${param0}`, {
method: 'GET',
params: { ...queryParams },
...(options || {}),
});
}
/** 删除帮助中心 DELETE /xjpmj/helpCenter/${param0} */
export async function xjpmjHelpCenterIdsDelete({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjHelpCenteridsDeleteParams;
options?: CustomRequestOptions;
}) {
const { ids: param0, ...queryParams } = params;
return request<API.RVoid>(`/xjpmj/helpCenter/${param0}`, {
method: 'DELETE',
params: { ...queryParams },
...(options || {}),
});
}
/** 查询帮助中心列表 GET /xjpmj/helpCenter/list */
export async function xjpmjHelpCenterListGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjHelpCenterListGetParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoHelpCenterVo>('/xjpmj/helpCenter/list', {
method: 'GET',
params: {
...params,
},
...(options || {}),
});
}
src/service/hotSearchWord.ts
+18
View File
@@ -0,0 +1,18 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 查询热门搜索词列表 POST /app/hotSearchWord/list */
export async function appHotSearchWordListPost({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RListString>('/app/hotSearchWord/list', {
method: 'POST',
...(options || {}),
});
}
src/service/index.ts
+44
View File
@@ -0,0 +1,44 @@
/* eslint-disable */
// @ts-ignore
export * from './types';
export * from './displayEnumLabel';
export * from './filtersConfig';
export * from './merchant';
export * from './agreement';
export * from './version';
export * from './preference';
export * from './message';
export * from './user';
export * from './merchantCategory';
export * from './merchantLabel';
export * from './login';
export * from './hotSearchWord';
export * from './comment';
export * from './collect';
export * from './helpCenter';
export * from './shopSettlement';
export * from './appointmentTime';
export * from './recipeCategory';
export * from './merchantRecipe';
export * from './merchantDish';
export * from './merchantMenu';
export * from './membership';
export * from './merchantCart';
export * from './coupon';
export * from './search';
export * from './merchantOrder';
export * from './featuredMerchant';
export * from './feedback';
export * from './membershipConfig';
export * from './customerService';
export * from './userBalanceDetail';
export * from './withdrawalRecord';
export * from './index';
export * from './sms';
export * from './userAddress';
export * from './automaticCookingMachineRegistration';
export * from './automaticCookingMachine';
export * from './userCoupon';
export * from './marketingActivity';
export * from './marketActivity';
src/service/login.ts
+24
View File
@@ -0,0 +1,24 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 登录 POST /app/login */
export async function appLoginPost({
body,
options,
}: {
body: API.LoginBo;
options?: CustomRequestOptions;
}) {
return request<API.RMapObject>('/app/login', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
src/service/marketActivity.ts
+18
View File
@@ -0,0 +1,18 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 获取列表 POST /app/marketActivity/list */
export async function appMarketActivityListPost({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RListMarketingActivityVo>('/app/marketActivity/list', {
method: 'POST',
...(options || {}),
});
}
src/service/marketingActivity.ts
+123
View File
@@ -0,0 +1,123 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 修改营销活动 PUT /xjpmj/marketingActivity */
export async function xjpmjMarketingActivityPut({
body,
options,
}: {
body: API.MarketingActivityBoEditGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/marketingActivity', {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 新增营销活动 POST /xjpmj/marketingActivity */
export async function xjpmjMarketingActivityPost({
body,
options,
}: {
body: API.MarketingActivityBoAddGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/marketingActivity', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取营销活动详细信息 GET /xjpmj/marketingActivity/${param0} */
export async function xjpmjMarketingActivityIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMarketingActivityidGetParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.RMarketingActivityVo>(
`/xjpmj/marketingActivity/${param0}`,
{
method: 'GET',
params: { ...queryParams },
...(options || {}),
}
);
}
/** 删除营销活动 DELETE /xjpmj/marketingActivity/${param0} */
export async function xjpmjMarketingActivityIdsDelete({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMarketingActivityidsDeleteParams;
options?: CustomRequestOptions;
}) {
const { ids: param0, ...queryParams } = params;
return request<API.RVoid>(`/xjpmj/marketingActivity/${param0}`, {
method: 'DELETE',
params: { ...queryParams },
...(options || {}),
});
}
/** 导出营销活动列表 POST /xjpmj/marketingActivity/export */
export async function xjpmjMarketingActivityExportPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMarketingActivityExportPostParams;
options?: CustomRequestOptions;
}) {
return request<API.XjpmjMarketingActivityExportPostResponse>(
'/xjpmj/marketingActivity/export',
{
method: 'POST',
params: {
...params,
},
...(options || {}),
}
);
}
/** 查询营销活动列表 GET /xjpmj/marketingActivity/list */
export async function xjpmjMarketingActivityListGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMarketingActivityListGetParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoMarketingActivityVo>(
'/xjpmj/marketingActivity/list',
{
method: 'GET',
params: {
...params,
},
...(options || {}),
}
);
}
src/service/membership.ts
+51
View File
@@ -0,0 +1,51 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 查询会员配置项 GET /app/membership/config */
export async function appMembershipConfigGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RMembershipConfigVo>('/app/membership/config', {
method: 'GET',
...(options || {}),
});
}
/** 充值会员 POST /app/membership/recharge */
export async function appMembershipRechargePost({
body,
options,
}: {
body: API.RechargeBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/membership/recharge', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 查询会员充值项 GET /app/membership/rechargeItem */
export async function appMembershipRechargeItemGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RListMembershipRechargeItemVo>(
'/app/membership/rechargeItem',
{
method: 'GET',
...(options || {}),
}
);
}
src/service/membershipConfig.ts
+36
View File
@@ -0,0 +1,36 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 修改会员配置 PUT /xjpmj/membershipConfig */
export async function xjpmjMembershipConfigPut({
body,
options,
}: {
body: API.MembershipConfigBoEditGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/membershipConfig', {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取会员配置详细信息 GET /xjpmj/membershipConfig/getInfo */
export async function xjpmjMembershipConfigGetInfoGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RMembershipConfigVo>('/xjpmj/membershipConfig/getInfo', {
method: 'GET',
...(options || {}),
});
}
src/service/merchant.ts
+321
View File
@@ -0,0 +1,321 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 查询商家详情 GET /app/merchant/detail/${param0} */
export async function appMerchantDetailMerchantIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantDetailmerchantIdGetParams;
options?: CustomRequestOptions;
}) {
const { merchantId: param0, ...queryParams } = params;
return request<API.RMerchantVo>(`/app/merchant/detail/${param0}`, {
method: 'GET',
params: { ...queryParams },
...(options || {}),
});
}
/** 商户编辑个人信息 POST /app/merchant/edit */
export async function appMerchantEditPost({
body,
options,
}: {
body: API.MerchantBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchant/edit', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 查询精选商家列表(首页) POST /app/merchant/featuredList */
export async function appMerchantFeaturedListPost({
body,
options,
}: {
body: API.LatLogBo;
options?: CustomRequestOptions;
}) {
return request<API.RListMerchantVo>('/app/merchant/featuredList', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 查询商户用户的第一个入驻信息 GET /app/merchant/getFirstShopSettled */
export async function appMerchantGetFirstShopSettledGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RShopSettlementVo>('/app/merchant/getFirstShopSettled', {
method: 'GET',
...(options || {}),
});
}
/** 获取切换商户信息信息 GET /app/merchant/getLoginMerchant */
export async function appMerchantGetLoginMerchantGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RMerchantVo>('/app/merchant/getLoginMerchant', {
method: 'GET',
...(options || {}),
});
}
/** 查询商户首页数据 GET /app/merchant/indexData */
export async function appMerchantIndexDataGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RMerchantIndexDataVO>('/app/merchant/indexData', {
method: 'GET',
...(options || {}),
});
}
/** 查询附近商家列表(首页) POST /app/merchant/nearbyList */
export async function appMerchantNearbyListPost({
body,
options,
}: {
body: API.LatLogBo;
options?: CustomRequestOptions;
}) {
return request<API.RListMerchantVo>('/app/merchant/nearbyList', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 查询推荐商家列表(首页) POST /app/merchant/recommendList */
export async function appMerchantRecommendListPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantRecommendListPostParams;
body: API.RecommendMerchantBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoMerchantVo>('/app/merchant/recommendList', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
});
}
/** 切换商户 GET /app/merchant/switch/${param0} */
export async function appMerchantSwitchMerchantIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantSwitchmerchantIdGetParams;
options?: CustomRequestOptions;
}) {
const { merchantId: param0, ...queryParams } = params;
return request<API.R>(`/app/merchant/switch/${param0}`, {
method: 'GET',
params: { ...queryParams },
...(options || {}),
});
}
/** 查询当前用户可切换的商户 GET /app/merchant/switch/list */
export async function appMerchantSwitchListGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RListMerchantVo>('/app/merchant/switch/list', {
method: 'GET',
...(options || {}),
});
}
/** 修改商家 PUT /xjpmj/merchant */
export async function xjpmjMerchantPut({
body,
options,
}: {
body: API.MerchantBoEditGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/merchant', {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 新增商家 POST /xjpmj/merchant */
export async function xjpmjMerchantPost({
body,
options,
}: {
body: API.MerchantBoAddGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/merchant', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取商家详细信息 GET /xjpmj/merchant/${param0} */
export async function xjpmjMerchantIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMerchantidGetParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.RMerchantVo>(`/xjpmj/merchant/${param0}`, {
method: 'GET',
params: { ...queryParams },
...(options || {}),
});
}
/** 删除商家 DELETE /xjpmj/merchant/${param0} */
export async function xjpmjMerchantIdsDelete({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMerchantidsDeleteParams;
options?: CustomRequestOptions;
}) {
const { ids: param0, ...queryParams } = params;
return request<API.RVoid>(`/xjpmj/merchant/${param0}`, {
method: 'DELETE',
params: { ...queryParams },
...(options || {}),
});
}
/** 导出商家列表 POST /xjpmj/merchant/export */
export async function xjpmjMerchantExportPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMerchantExportPostParams;
options?: CustomRequestOptions;
}) {
return request<API.XjpmjMerchantExportPostResponse>(
'/xjpmj/merchant/export',
{
method: 'POST',
params: {
...params,
},
...(options || {}),
}
);
}
/** 查询商家列表 POST /xjpmj/merchant/list */
export async function xjpmjMerchantListPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMerchantListPostParams;
body: API.MerchantListBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoMerchantVo>('/xjpmj/merchant/list', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
});
}
/** 设置商家标签 POST /xjpmj/merchant/setMerchantLabel */
export async function xjpmjMerchantSetMerchantLabelPost({
body,
options,
}: {
body: API.MerchantBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/merchant/setMerchantLabel', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 修改用户余额 POST /xjpmj/merchant/updateBalance */
export async function xjpmjMerchantUpdateBalancePost({
body,
options,
}: {
body: API.UpdateUserAmount;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/merchant/updateBalance', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
src/service/merchantCart.ts
+132
View File
@@ -0,0 +1,132 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 加入购物车 POST /app/merchantCart/addCart */
export async function appMerchantCartAddCartPost({
body,
options,
}: {
body: API.MerchantCartBo;
options?: CustomRequestOptions;
}) {
return request<API.RLong>('/app/merchantCart/addCart', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 加入购物车 POST /app/merchantCart/addCartById */
export async function appMerchantCartAddCartByIdPost({
body,
options,
}: {
body: API.MerchantCartBo;
options?: CustomRequestOptions;
}) {
return request<API.RLong>('/app/merchantCart/addCartById', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 计算购物车内会员可以节省多少费用 POST /app/merchantCart/calculateSavings */
export async function appMerchantCartCalculateSavingsPost({
body,
options,
}: {
body: API.AppMerchantCartCalculateSavingsPostBody;
options?: CustomRequestOptions;
}) {
return request<API.RCalculateSavingsVo>(
'/app/merchantCart/calculateSavings',
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
}
);
}
/** 删除某个商户的购物车 POST /app/merchantCart/deleteByMerchantId */
export async function appMerchantCartDeleteByMerchantIdPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantCartDeleteByMerchantIdPostParams;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantCart/deleteByMerchantId', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 删除购物车 POST /app/merchantCart/deleteCart */
export async function appMerchantCartDeleteCartPost({
body,
options,
}: {
body: API.DeleteCartBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantCart/deleteCart', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 查询某个商户下的购物车列表 POST /app/merchantCart/listByMerchantId */
export async function appMerchantCartListByMerchantIdPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantCartListByMerchantIdPostParams;
options?: CustomRequestOptions;
}) {
return request<API.RListMerchantCartVo>(
'/app/merchantCart/listByMerchantId',
{
method: 'POST',
params: {
...params,
},
...(options || {}),
}
);
}
/** 查询购物车的商户列表 根据最新的一个购物车加入时间来排序 POST /app/merchantCart/listMerchant */
export async function appMerchantCartListMerchantPost({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RListMerchantVo>('/app/merchantCart/listMerchant', {
method: 'POST',
...(options || {}),
});
}
src/service/merchantCategory.ts
+18
View File
@@ -0,0 +1,18 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 查询所有商家分类数据 GET /app/merchantCategory/list */
export async function appMerchantCategoryListGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantCategory/list', {
method: 'GET',
...(options || {}),
});
}
src/service/merchantDish.ts
+264
View File
@@ -0,0 +1,264 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 新增菜品 POST /app/merchantDish/addDish */
export async function appMerchantDishAddDishPost({
body,
options,
}: {
body: API.MerchantDishBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantDish/addDish', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 增加菜品浏览量 POST /app/merchantDish/addViewCount */
export async function appMerchantDishAddViewCountPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantDishAddViewCountPostParams;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantDish/addViewCount', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 菜品详情 GET /app/merchantDish/detail */
export async function appMerchantDishDetailGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantDishDetailGetParams;
options?: CustomRequestOptions;
}) {
return request<API.RMerchantDishVo>('/app/merchantDish/detail', {
method: 'GET',
params: {
...params,
},
...(options || {}),
});
}
/** 编辑菜品 POST /app/merchantDish/editDish */
export async function appMerchantDishEditDishPost({
body,
options,
}: {
body: API.MerchantDishBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantDish/editDish', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 修改排序 POST /app/merchantDish/editSort */
export async function appMerchantDishEditSortPost({
body,
options,
}: {
body: API.AppMerchantDishEditSortPostBody;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantDish/editSort', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 商家查询自己的菜品列表 POST /app/merchantDish/list */
export async function appMerchantDishListPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantDishListPostParams;
body: API.MerchantDishBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoMerchantDishVo>('/app/merchantDish/list', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
});
}
/** 查询附近菜品列表 POST /app/merchantDish/nearbyList */
export async function appMerchantDishNearbyListPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantDishNearbyListPostParams;
body: API.LatLogBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoMerchantDishVo>(
'/app/merchantDish/nearbyList',
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
}
);
}
/** 批量删除菜品 POST /app/merchantDish/remove */
export async function appMerchantDishRemovePost({
body,
options,
}: {
body: API.AppMerchantDishRemovePostBody;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantDish/remove', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 查询菜品销售记录 POST /app/merchantDish/saleRecord */
export async function appMerchantDishSaleRecordPost({
body,
options,
}: {
body: API.TimeSearchBo;
options?: CustomRequestOptions;
}) {
return request<API.RSaleRecordVo>('/app/merchantDish/saleRecord', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取商家菜品详细信息 GET /xjpmj/merchantDish/${param0} */
export async function xjpmjMerchantDishIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMerchantDishidGetParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.RMerchantDishVo>(`/xjpmj/merchantDish/${param0}`, {
method: 'GET',
params: { ...queryParams },
...(options || {}),
});
}
/** 删除商家菜品 DELETE /xjpmj/merchantDish/${param0} */
export async function xjpmjMerchantDishIdsDelete({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMerchantDishidsDeleteParams;
options?: CustomRequestOptions;
}) {
const { ids: param0, ...queryParams } = params;
return request<API.RVoid>(`/xjpmj/merchantDish/${param0}`, {
method: 'DELETE',
params: { ...queryParams },
...(options || {}),
});
}
/** 导出商家菜品列表 POST /xjpmj/merchantDish/export */
export async function xjpmjMerchantDishExportPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMerchantDishExportPostParams;
options?: CustomRequestOptions;
}) {
return request<API.XjpmjMerchantDishExportPostResponse>(
'/xjpmj/merchantDish/export',
{
method: 'POST',
params: {
...params,
},
...(options || {}),
}
);
}
/** 查询商家菜品列表 POST /xjpmj/merchantDish/list */
export async function xjpmjMerchantDishListPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMerchantDishListPostParams;
body: API.MerchantDishBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoMerchantDishVo>('/xjpmj/merchantDish/list', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
});
}
src/service/merchantLabel.ts
+18
View File
@@ -0,0 +1,18 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 查询所有商家分类数据 GET /app/merchantLabel/list */
export async function appMerchantLabelListGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantLabel/list', {
method: 'GET',
...(options || {}),
});
}
src/service/merchantMenu.ts
+153
View File
@@ -0,0 +1,153 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 新增菜谱 POST /app/merchantMenu/add */
export async function appMerchantMenuAddPost({
body,
options,
}: {
body: API.MerchantMenuBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantMenu/add', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 修改排序 POST /app/merchantMenu/editSort */
export async function appMerchantMenuEditSortPost({
body,
options,
}: {
body: API.AppMerchantMenuEditSortPostBody;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantMenu/editSort', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 查询菜单详情 POST /app/merchantMenu/menuDetail */
export async function appMerchantMenuMenuDetailPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantMenuMenuDetailPostParams;
options?: CustomRequestOptions;
}) {
return request<API.RMerchantMenuVo>('/app/merchantMenu/menuDetail', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 商家查询菜单列表 POST /app/merchantMenu/menuListByMerchant */
export async function appMerchantMenuMenuListByMerchantPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantMenuMenuListByMerchantPostParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoMerchantMenuVo>(
'/app/merchantMenu/menuListByMerchant',
{
method: 'POST',
params: {
...params,
},
...(options || {}),
}
);
}
/** 用户查询菜单列表 POST /app/merchantMenu/menuListByUser */
export async function appMerchantMenuMenuListByUserPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantMenuMenuListByUserPostParams;
options?: CustomRequestOptions;
}) {
return request<API.RListMerchantMenuVo>('/app/merchantMenu/menuListByUser', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 查询菜单详情 POST /app/merchantMenu/recipeDetail */
export async function appMerchantMenuRecipeDetailPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantMenuRecipeDetailPostParams;
options?: CustomRequestOptions;
}) {
return request<API.RMerchantRecipeVo>('/app/merchantMenu/recipeDetail', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 批量删除菜单 POST /app/merchantMenu/remove */
export async function appMerchantMenuRemovePost({
body,
options,
}: {
body: API.AppMerchantMenuRemovePostBody;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantMenu/remove', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 修改菜单 POST /app/merchantMenu/update */
export async function appMerchantMenuUpdatePost({
body,
options,
}: {
body: API.MerchantMenuBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantMenu/update', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
src/service/merchantOrder.ts
+465
View File
@@ -0,0 +1,465 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 商家同意退款 POST /app/merchantOrder/agreeRefund */
export async function appMerchantOrderAgreeRefundPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantOrderAgreeRefundPostParams;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantOrder/agreeRefund', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 商家点击已送达 POST /app/merchantOrder/arrivedOrder */
export async function appMerchantOrderArrivedOrderPost({
body,
options,
}: {
body: API.ArrivedOrderBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantOrder/arrivedOrder', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 购物车下单 - 计算价格 POST /app/merchantOrder/calculatePriceCart */
export async function appMerchantOrderCalculatePriceCartPost({
body,
options,
}: {
body: API.CalculatePriceCartBo;
options?: CustomRequestOptions;
}) {
return request<API.RCalculatePriceCartVo>(
'/app/merchantOrder/calculatePriceCart',
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
}
);
}
/** 商品下单 - 计算价格 POST /app/merchantOrder/calculatePriceDish */
export async function appMerchantOrderCalculatePriceDishPost({
body,
options,
}: {
body: API.CalculatePriceDishBo;
options?: CustomRequestOptions;
}) {
return request<API.RCalculatePriceDishVo>(
'/app/merchantOrder/calculatePriceDish',
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
}
);
}
/** 用户取消订单(用户申请退款) POST /app/merchantOrder/cancelOrder */
export async function appMerchantOrderCancelOrderPost({
body,
options,
}: {
body: API.CancelOrderBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantOrder/cancelOrder', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 查询可用优惠券 GET /app/merchantOrder/canUseCouponList/${param0} */
export async function appMerchantOrderCanUseCouponListMerchantIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantOrderCanUseCouponListmerchantIdGetParams;
options?: CustomRequestOptions;
}) {
const { merchantId: param0, ...queryParams } = params;
return request<API.RListUserCouponVo>(
`/app/merchantOrder/canUseCouponList/${param0}`,
{
method: 'GET',
params: { ...queryParams },
...(options || {}),
}
);
}
/** 购物车下单 POST /app/merchantOrder/createOrderCart */
export async function appMerchantOrderCreateOrderCartPost({
body,
options,
}: {
body: API.CreateOrderCartBo;
options?: CustomRequestOptions;
}) {
return request<API.RLong>('/app/merchantOrder/createOrderCart', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 菜品下单 POST /app/merchantOrder/createOrderDish */
export async function appMerchantOrderCreateOrderDishPost({
body,
options,
}: {
body: API.CreateOrderDishBo;
options?: CustomRequestOptions;
}) {
return request<API.RLong>('/app/merchantOrder/createOrderDish', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 商家点击配送订单 POST /app/merchantOrder/deliverOrder */
export async function appMerchantOrderDeliverOrderPost({
body,
options,
}: {
body: API.DeliverOrderBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantOrder/deliverOrder', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 查询商家最新配送订单的五个配送员信息，根据创建时间排序排列 POST /app/merchantOrder/deliveryList */
export async function appMerchantOrderDeliveryListPost({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RListMerchantOrderVo>('/app/merchantOrder/deliveryList', {
method: 'POST',
...(options || {}),
});
}
/** 订单详情 POST /app/merchantOrder/detail */
export async function appMerchantOrderDetailPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantOrderDetailPostParams;
options?: CustomRequestOptions;
}) {
return request<API.RMerchantOrderVo>('/app/merchantOrder/detail', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 菜品列表(根据预约时间查询) POST /app/merchantOrder/dishList */
export async function appMerchantOrderDishListPost({
body,
options,
}: {
body: API.TimeSearchBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoMerchantDishVo>(
'/app/merchantOrder/dishList',
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
}
);
}
/** 评价订单 POST /app/merchantOrder/evaluateOrder */
export async function appMerchantOrderEvaluateOrderPost({
body,
options,
}: {
body: API.EvaluateOrderBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantOrder/evaluateOrder', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 订单列表 POST /app/merchantOrder/orderList */
export async function appMerchantOrderOrderListPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantOrderOrderListPostParams;
body: API.MerchantOrderListBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoMerchantOrderVo>(
'/app/merchantOrder/orderList',
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
}
);
}
/** 订单付款 POST /app/merchantOrder/payOrder */
export async function appMerchantOrderPayOrderPost({
body,
options,
}: {
body: API.PayOrderBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantOrder/payOrder', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 商家接单 POST /app/merchantOrder/receiveOrder */
export async function appMerchantOrderReceiveOrderPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantOrderReceiveOrderPostParams;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantOrder/receiveOrder', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 商家拒绝退款 POST /app/merchantOrder/rejectRefund */
export async function appMerchantOrderRejectRefundPost({
body,
options,
}: {
body: API.RejectRefundBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantOrder/rejectRefund', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 用户自取时，商家核销订单 POST /app/merchantOrder/writeOff */
export async function appMerchantOrderWriteOffPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantOrderWriteOffPostParams;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantOrder/writeOff', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 修改商家订单 PUT /xjpmj/merchantOrder */
export async function xjpmjMerchantOrderPut({
body,
options,
}: {
body: API.MerchantOrderBoEditGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/merchantOrder', {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 新增商家订单 POST /xjpmj/merchantOrder */
export async function xjpmjMerchantOrderPost({
body,
options,
}: {
body: API.MerchantOrderBoAddGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/merchantOrder', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取商家订单详细信息 GET /xjpmj/merchantOrder/${param0} */
export async function xjpmjMerchantOrderIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMerchantOrderidGetParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.RMerchantOrderVo>(`/xjpmj/merchantOrder/${param0}`, {
method: 'GET',
params: { ...queryParams },
...(options || {}),
});
}
/** 删除商家订单 DELETE /xjpmj/merchantOrder/${param0} */
export async function xjpmjMerchantOrderIdsDelete({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMerchantOrderidsDeleteParams;
options?: CustomRequestOptions;
}) {
const { ids: param0, ...queryParams } = params;
return request<API.RVoid>(`/xjpmj/merchantOrder/${param0}`, {
method: 'DELETE',
params: { ...queryParams },
...(options || {}),
});
}
/** 导出商家订单列表 POST /xjpmj/merchantOrder/export */
export async function xjpmjMerchantOrderExportPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMerchantOrderExportPostParams;
options?: CustomRequestOptions;
}) {
return request<API.XjpmjMerchantOrderExportPostResponse>(
'/xjpmj/merchantOrder/export',
{
method: 'POST',
params: {
...params,
},
...(options || {}),
}
);
}
/** 查询商家订单列表 POST /xjpmj/merchantOrder/list */
export async function xjpmjMerchantOrderListPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMerchantOrderListPostParams;
body: API.MerchantOrderListBackendBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoMerchantOrderVo>(
'/xjpmj/merchantOrder/list',
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
}
);
}
src/service/merchantRecipe.ts
+234
View File
@@ -0,0 +1,234 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 新增菜谱 POST /app/merchantRecipe/add */
export async function appMerchantRecipeAddPost({
body,
options,
}: {
body: API.MerchantRecipeBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantRecipe/add', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 增加菜谱浏览量 POST /app/merchantRecipe/addViewCount */
export async function appMerchantRecipeAddViewCountPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantRecipeAddViewCountPostParams;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantRecipe/addViewCount', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 查询菜谱详情 POST /app/merchantRecipe/recipeDetail */
export async function appMerchantRecipeRecipeDetailPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantRecipeRecipeDetailPostParams;
options?: CustomRequestOptions;
}) {
return request<API.RMerchantRecipeVo>('/app/merchantRecipe/recipeDetail', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 商家查询菜谱列表 POST /app/merchantRecipe/recipeList */
export async function appMerchantRecipeRecipeListPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantRecipeRecipeListPostParams;
body: API.SearchRecipeBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoMerchantRecipeVo>(
'/app/merchantRecipe/recipeList',
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
}
);
}
/** 批量删除菜谱 POST /app/merchantRecipe/remove */
export async function appMerchantRecipeRemovePost({
body,
options,
}: {
body: API.AppMerchantRecipeRemovePostBody;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantRecipe/remove', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 用户端搜索菜谱 POST /app/merchantRecipe/searchRecipe */
export async function appMerchantRecipeSearchRecipePost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMerchantRecipeSearchRecipePostParams;
body: API.SearchRecipeBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoMerchantRecipeVo>(
'/app/merchantRecipe/searchRecipe',
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
}
);
}
/** 修改菜谱 POST /app/merchantRecipe/update */
export async function appMerchantRecipeUpdatePost({
body,
options,
}: {
body: API.MerchantRecipeBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/merchantRecipe/update', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取商家菜谱详细信息 GET /xjpmj/merchantRecipe/${param0} */
export async function xjpmjMerchantRecipeIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMerchantRecipeidGetParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.RMerchantRecipeVo>(`/xjpmj/merchantRecipe/${param0}`, {
method: 'GET',
params: { ...queryParams },
...(options || {}),
});
}
/** 删除商家菜谱 DELETE /xjpmj/merchantRecipe/${param0} */
export async function xjpmjMerchantRecipeIdsDelete({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMerchantRecipeidsDeleteParams;
options?: CustomRequestOptions;
}) {
const { ids: param0, ...queryParams } = params;
return request<API.RVoid>(`/xjpmj/merchantRecipe/${param0}`, {
method: 'DELETE',
params: { ...queryParams },
...(options || {}),
});
}
/** 导出商家菜谱列表 POST /xjpmj/merchantRecipe/export */
export async function xjpmjMerchantRecipeExportPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMerchantRecipeExportPostParams;
options?: CustomRequestOptions;
}) {
return request<API.XjpmjMerchantRecipeExportPostResponse>(
'/xjpmj/merchantRecipe/export',
{
method: 'POST',
params: {
...params,
},
...(options || {}),
}
);
}
/** 查询商家菜谱列表 POST /xjpmj/merchantRecipe/list */
export async function xjpmjMerchantRecipeListPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjMerchantRecipeListPostParams;
body: API.MerchantRecipeBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoMerchantRecipeVo>(
'/xjpmj/merchantRecipe/list',
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
}
);
}
src/service/message.ts
+66
View File
@@ -0,0 +1,66 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 消息列表 POST /app/message/list */
export async function appMessageListPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppMessageListPostParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoMessageVo>('/app/message/list', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 消息设置为已读 POST /app/message/read */
export async function appMessageReadPost({
body,
options,
}: {
body: API.AppMessageReadPostBody;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/app/message/read', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 消息全部设置为已读 POST /app/message/readAll */
export async function appMessageReadAllPost({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/app/message/readAll', {
method: 'POST',
...(options || {}),
});
}
/** 获取未读消息数量 POST /app/message/unreadCount */
export async function appMessageUnreadCountPost({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RLong>('/app/message/unreadCount', {
method: 'POST',
...(options || {}),
});
}
src/service/preference.ts
+36
View File
@@ -0,0 +1,36 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 用户选择喜好 POST /app/preference/choose */
export async function appPreferenceChoosePost({
body,
options,
}: {
body: API.AppPreferenceChoosePostBody;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/preference/choose', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 查询喜好列表 GET /app/preference/list */
export async function appPreferenceListGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RListPreferenceVo>('/app/preference/list', {
method: 'GET',
...(options || {}),
});
}
src/service/recipeCategory.ts
+147
View File
@@ -0,0 +1,147 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 查询所有菜谱分类数据 GET /app/recipeCategory/list */
export async function appRecipeCategoryListGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RListRecipeCategoryVo>('/app/recipeCategory/list', {
method: 'GET',
...(options || {}),
});
}
/** 商家查询自己有菜谱数据的分类 GET /app/recipeCategory/listOnHasRecipe */
export async function appRecipeCategoryListOnHasRecipeGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RListRecipeCategoryVo>(
'/app/recipeCategory/listOnHasRecipe',
{
method: 'GET',
...(options || {}),
}
);
}
/** 修改菜谱分类 PUT /xjpmj/recipeCategory */
export async function xjpmjRecipeCategoryPut({
body,
options,
}: {
body: API.RecipeCategoryBoEditGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/recipeCategory', {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 新增菜谱分类 POST /xjpmj/recipeCategory */
export async function xjpmjRecipeCategoryPost({
body,
options,
}: {
body: API.RecipeCategoryBoAddGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/recipeCategory', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取菜谱分类详细信息 GET /xjpmj/recipeCategory/${param0} */
export async function xjpmjRecipeCategoryIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjRecipeCategoryidGetParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.RRecipeCategoryVo>(`/xjpmj/recipeCategory/${param0}`, {
method: 'GET',
params: { ...queryParams },
...(options || {}),
});
}
/** 删除菜谱分类 DELETE /xjpmj/recipeCategory/${param0} */
export async function xjpmjRecipeCategoryIdsDelete({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjRecipeCategoryidsDeleteParams;
options?: CustomRequestOptions;
}) {
const { ids: param0, ...queryParams } = params;
return request<API.RVoid>(`/xjpmj/recipeCategory/${param0}`, {
method: 'DELETE',
params: { ...queryParams },
...(options || {}),
});
}
/** 导出菜谱分类列表 POST /xjpmj/recipeCategory/export */
export async function xjpmjRecipeCategoryExportPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjRecipeCategoryExportPostParams;
options?: CustomRequestOptions;
}) {
return request<API.XjpmjRecipeCategoryExportPostResponse>(
'/xjpmj/recipeCategory/export',
{
method: 'POST',
params: {
...params,
},
...(options || {}),
}
);
}
/** 查询菜谱分类列表 GET /xjpmj/recipeCategory/list */
export async function xjpmjRecipeCategoryListGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjRecipeCategoryListGetParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoRecipeCategoryVo>(
'/xjpmj/recipeCategory/list',
{
method: 'GET',
params: {
...params,
},
...(options || {}),
}
);
}
src/service/search.ts
+96
View File
@@ -0,0 +1,96 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 商家内搜索菜品 POST /app/search/dishInMerchant */
export async function appSearchDishInMerchantPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppSearchDishInMerchantPostParams;
body: API.SearchMerchantDishBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoMerchantDishVo>(
'/app/search/dishInMerchant',
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
}
);
}
/** 查询热门搜索词列表 POST /app/search/list */
export async function appSearchListPost({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RListHotSearchWordVo>('/app/search/list', {
method: 'POST',
...(options || {}),
});
}
/** 搜索美食 POST /app/search/merchantByDish */
export async function appSearchMerchantByDishPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppSearchMerchantByDishPostParams;
body: API.RecommendMerchantBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoMerchantVo>('/app/search/merchantByDish', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
});
}
/** 搜索菜谱 POST /app/search/searchRecipe */
export async function appSearchSearchRecipePost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppSearchSearchRecipePostParams;
body: API.SearchRecipeBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoMerchantRecipeVo>(
'/app/search/searchRecipe',
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
}
);
}
src/service/shopSettlement.ts
+138
View File
@@ -0,0 +1,138 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 申请入驻店铺 POST /app/shopSettlement/apply */
export async function appShopSettlementApplyPost({
body,
options,
}: {
body: API.ShopSettlementBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/shopSettlement/apply', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 查询入驻详情 GET /app/shopSettlement/detail */
export async function appShopSettlementDetailGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppShopSettlementDetailGetParams;
options?: CustomRequestOptions;
}) {
return request<API.RShopSettlementVo>('/app/shopSettlement/detail', {
method: 'GET',
params: {
...params,
},
...(options || {}),
});
}
/** 查询入驻列表 GET /app/shopSettlement/list */
export async function appShopSettlementListGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RListShopSettlementVo>('/app/shopSettlement/list', {
method: 'GET',
...(options || {}),
});
}
/** 获取店铺入驻详细信息 GET /xjpmj/shopSettlement/${param0} */
export async function xjpmjShopSettlementIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjShopSettlementidGetParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.RShopSettlementVo>(`/xjpmj/shopSettlement/${param0}`, {
method: 'GET',
params: { ...queryParams },
...(options || {}),
});
}
/** 审核店铺入驻结果 POST /xjpmj/shopSettlement/audit */
export async function xjpmjShopSettlementAuditPost({
body,
options,
}: {
body: API.ShopSettlementBo;
options?: CustomRequestOptions;
}) {
return request<API.RBoolean>('/xjpmj/shopSettlement/audit', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 导出店铺入驻列表 POST /xjpmj/shopSettlement/export */
export async function xjpmjShopSettlementExportPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjShopSettlementExportPostParams;
options?: CustomRequestOptions;
}) {
return request<API.XjpmjShopSettlementExportPostResponse>(
'/xjpmj/shopSettlement/export',
{
method: 'POST',
params: {
...params,
},
...(options || {}),
}
);
}
/** 查询店铺入驻列表 POST /xjpmj/shopSettlement/list */
export async function xjpmjShopSettlementListPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjShopSettlementListPostParams;
body: API.ShopSettlementBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoShopSettlementVo>(
'/xjpmj/shopSettlement/list',
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
}
);
}
src/service/sms.ts
+24
View File
@@ -0,0 +1,24 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 发送验证码 POST /app/sms/send */
export async function appSmsSendPost({
body,
options,
}: {
body: API.SendSmsBo;
options?: CustomRequestOptions;
}) {
return request<API.RString>('/app/sms/send', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
src/service/types.ts
+7450
View File
File diff suppressed because it is too large Load Diff
src/service/user.ts
+843
View File
@@ -0,0 +1,843 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 加入黑名单 POST /app/user/addBlackList */
export async function appUserAddBlackListPost({
body,
options,
}: {
body: API.BlockBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/user/addBlackList', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 新增银行账户 POST /app/user/bank/add */
export async function appUserBankAddPost({
body,
options,
}: {
body: API.AddBankBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/app/user/bank/add', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 删除银行账户 POST /app/user/bank/delete */
export async function appUserBankDeletePost({
body,
options,
}: {
body: API.OnlyIdBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/app/user/bank/delete', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取银行账户详细信息 POST /app/user/bank/detail */
export async function appUserBankDetailPost({
body,
options,
}: {
body: API.OnlyIdBo;
options?: CustomRequestOptions;
}) {
return request<API.RBankVo>('/app/user/bank/detail', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 查询银行账户列表 POST /app/user/bank/list */
export async function appUserBankListPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppUserBankListPostParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoBankVo>('/app/user/bank/list', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 修改银行账户 POST /app/user/bank/update */
export async function appUserBankUpdatePost({
body,
options,
}: {
body: API.UpdateBankBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/app/user/bank/update', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 绑定新邮箱 POST /app/user/bindNewEmail */
export async function appUserBindNewEmailPost({
body,
options,
}: {
body: API.BindEmailBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/app/user/bindNewEmail', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 绑定新手机号 POST /app/user/bindNewPhone */
export async function appUserBindNewPhonePost({
body,
options,
}: {
body: API.BindPhoneBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/app/user/bindNewPhone', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 删除用户卡 POST /app/user/card/delete */
export async function appUserCardDeletePost({
body,
options,
}: {
body: API.AppUserCardBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/app/user/card/delete', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 用户卡列表 POST /app/user/card/list */
export async function appUserCardListPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppUserCardListPostParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoUserCardVo>('/app/user/card/list', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 新增用户卡 POST /app/user/card/save */
export async function appUserCardSavePost({
body,
options,
}: {
body: API.AppUserCardBo;
options?: CustomRequestOptions;
}) {
return request<API.RLong>('/app/user/card/save', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 查询默认 POST /app/user/card/selectDefault */
export async function appUserCardSelectDefaultPost({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RUserCardVo>('/app/user/card/selectDefault', {
method: 'POST',
...(options || {}),
});
}
/** 修改默认 POST /app/user/card/updateDefault */
export async function appUserCardUpdateDefaultPost({
body,
options,
}: {
body: API.AppUserCardBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/app/user/card/updateDefault', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 校验邮箱是否被使用 POST /app/user/checkEmailUnique */
export async function appUserCheckEmailUniquePost({
body,
options,
}: {
body: API.AppUserBo;
options?: CustomRequestOptions;
}) {
return request<API.RBoolean>('/app/user/checkEmailUnique', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 校验旧邮箱(绑定邮箱) POST /app/user/checkOldEmail */
export async function appUserCheckOldEmailPost({
body,
options,
}: {
body: API.BindEmailBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/app/user/checkOldEmail', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 校验旧手机号(绑定新手机号) POST /app/user/checkOldPhone */
export async function appUserCheckOldPhonePost({
body,
options,
}: {
body: API.BindPhoneBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/app/user/checkOldPhone', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 校验手机号是否被使用 POST /app/user/checkPhoneUnique */
export async function appUserCheckPhoneUniquePost({
body,
options,
}: {
body: API.AppUserBo;
options?: CustomRequestOptions;
}) {
return request<API.RBoolean>('/app/user/checkPhoneUnique', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 修改登录密码 POST /app/user/editLoginPwd */
export async function appUserEditLoginPwdPost({
body,
options,
}: {
body: API.AppUserBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/user/editLoginPwd', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 修改支付密码 POST /app/user/editPayPwd */
export async function appUserEditPayPwdPost({
body,
options,
}: {
body: API.AppUserBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/user/editPayPwd', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 修改用户信息 POST /app/user/editUserInfo */
export async function appUserEditUserInfoPost({
body,
options,
}: {
body: API.AppUserBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/user/editUserInfo', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 忘记支付密码 POST /app/user/forgetPayPwd */
export async function appUserForgetPayPwdPost({
body,
options,
}: {
body: API.AppUserBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/user/forgetPayPwd', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 忘记密码/可不传邮箱 POST /app/user/forgetPwd */
export async function appUserForgetPwdPost({
body,
options,
}: {
body: API.AppUserBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/user/forgetPwd', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 忘记密码/可不传邮箱(未登录之前) POST /app/user/forgetPwdNotLogin */
export async function appUserForgetPwdNotLoginPost({
body,
options,
}: {
body: API.AppUserBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/user/forgetPwdNotLogin', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 根据邮箱查询用户信息 POST /app/user/getByEmail */
export async function appUserGetByEmailPost({
body,
options,
}: {
body: API.AppUserBo;
options?: CustomRequestOptions;
}) {
return request<API.RUser>('/app/user/getByEmail', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 根据手机号查询用户信息 POST /app/user/getByPhone */
export async function appUserGetByPhonePost({
body,
options,
}: {
body: API.AppUserBo;
options?: CustomRequestOptions;
}) {
return request<API.RUser>('/app/user/getByPhone', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取登录用户信息 GET /app/user/getLoginUser */
export async function appUserGetLoginUserGet({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RUserVo>('/app/user/getLoginUser', {
method: 'GET',
...(options || {}),
});
}
/** 注销账号 POST /app/user/logOff */
export async function appUserLogOffPost({
body,
options,
}: {
body: API.AppUserBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/user/logOff', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 退出登录 POST /app/user/logout */
export async function appUserLogoutPost({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/user/logout', {
method: 'POST',
...(options || {}),
});
}
/** 谷歌换绑 POST /app/user/rebindGoogle */
export async function appUserRebindGooglePost({
body,
options,
}: {
body: API.AppUserBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/app/user/rebindGoogle', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 邮箱/手机号注册, 手机号注册不传邮箱即可, 手机号校验类型都一样,不用改 POST /app/user/register */
export async function appUserRegisterPost({
body,
options,
}: {
body: API.AppUserBo;
options?: CustomRequestOptions;
}) {
return request<API.RMapObject>('/app/user/register', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 记录新人优惠券弹窗已经弹过了 POST /app/user/setHasPop */
export async function appUserSetHasPopPost({
options,
}: {
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/app/user/setHasPop', {
method: 'POST',
...(options || {}),
});
}
/** 设置支付密码 POST /app/user/setPayPwd */
export async function appUserSetPayPwdPost({
body,
options,
}: {
body: API.AppUserBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/user/setPayPwd', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 余额明细列表 POST /app/user/userBalanceDetail/balanceDetailList */
export async function appUserUserBalanceDetailBalanceDetailListPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppUserUserBalanceDetailBalanceDetailListPostParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoUserBalanceDetailVo>(
'/app/user/userBalanceDetail/balanceDetailList',
{
method: 'POST',
params: {
...params,
},
...(options || {}),
}
);
}
/** 我的邀请列表 type 1:invited 2:completed 3:expired POST /app/user/userInvite/inviteList */
export async function appUserUserInviteInviteListPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppUserUserInviteInviteListPostParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoUserInviteVo>(
'/app/user/userInvite/inviteList',
{
method: 'POST',
params: {
...params,
},
...(options || {}),
}
);
}
/** 申请提现 POST /app/user/withdrawal/applyWithdrawal */
export async function appUserWithdrawalApplyWithdrawalPost({
body,
options,
}: {
body: API.ApplyWithdrawalBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/app/user/withdrawal/applyWithdrawal', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 实时计算到账金额和手续费 POST /app/user/withdrawal/computeAmountFee */
export async function appUserWithdrawalComputeAmountFeePost({
body,
options,
}: {
body: API.ComputeAmountFeeBo;
options?: CustomRequestOptions;
}) {
return request<API.RComputeAmountFeeVo>(
'/app/user/withdrawal/computeAmountFee',
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
}
);
}
/** 提现记录详细信息 POST /app/user/withdrawal/detail */
export async function appUserWithdrawalDetailPost({
body,
options,
}: {
body: API.OnlyIdBo;
options?: CustomRequestOptions;
}) {
return request<API.RWithdrawalRecordVo>('/app/user/withdrawal/detail', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 提现记录列表 POST /app/user/withdrawal/list */
export async function appUserWithdrawalListPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppUserWithdrawalListPostParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoWithdrawalRecordVo>(
'/app/user/withdrawal/list',
{
method: 'POST',
params: {
...params,
},
...(options || {}),
}
);
}
/** 修改用户 PUT /xjpmj/user */
export async function xjpmjUserPut({
body,
options,
}: {
body: API.UserBoEditGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/user', {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 新增用户 POST /xjpmj/user */
export async function xjpmjUserPost({
body,
options,
}: {
body: API.UserBoAddGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/user', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取用户详细信息 GET /xjpmj/user/${param0} */
export async function xjpmjUserIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjUseridGetParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.RUserVo>(`/xjpmj/user/${param0}`, {
method: 'GET',
params: { ...queryParams },
...(options || {}),
});
}
/** 删除用户 DELETE /xjpmj/user/${param0} */
export async function xjpmjUserIdsDelete({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjUseridsDeleteParams;
options?: CustomRequestOptions;
}) {
const { ids: param0, ...queryParams } = params;
return request<API.RVoid>(`/xjpmj/user/${param0}`, {
method: 'DELETE',
params: { ...queryParams },
...(options || {}),
});
}
/** 导出用户列表 POST /xjpmj/user/export */
export async function xjpmjUserExportPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjUserExportPostParams;
options?: CustomRequestOptions;
}) {
return request<API.XjpmjUserExportPostResponse>('/xjpmj/user/export', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 查询用户列表 GET /xjpmj/user/list */
export async function xjpmjUserListGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjUserListGetParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoUserVo>('/xjpmj/user/list', {
method: 'GET',
params: {
// selectEntry has a default value: 1
selectEntry: '1',
...params,
},
...(options || {}),
});
}
/** 会员续期 POST /xjpmj/user/membershipRenewal */
export async function xjpmjUserMembershipRenewalPost({
body,
options,
}: {
body: API.MembershipRenewalBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/user/membershipRenewal', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 重置密码 POST /xjpmj/user/resetPassword */
export async function xjpmjUserResetPasswordPost({
body,
options,
}: {
body: API.ResetPasswordBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/user/resetPassword', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 修改用户余额 POST /xjpmj/user/updateBalance */
export async function xjpmjUserUpdateBalancePost({
body,
options,
}: {
body: API.UpdateUserAmount;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/user/updateBalance', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
src/service/userAddress.ts
+78
View File
@@ -0,0 +1,78 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 新增用户地址 POST /app/userAddress/add */
export async function appUserAddressAddPost({
body,
options,
}: {
body: API.UserAddressBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/userAddress/add', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 编辑用户地址 POST /app/userAddress/edit */
export async function appUserAddressEditPost({
body,
options,
}: {
body: API.UserAddressBo;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/userAddress/edit', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 用户地址列表 POST /app/userAddress/list */
export async function appUserAddressListPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.AppUserAddressListPostParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfo>('/app/userAddress/list', {
method: 'POST',
params: {
...params,
},
...(options || {}),
});
}
/** 批量删除用户地址 POST /app/userAddress/remove */
export async function appUserAddressRemovePost({
body,
options,
}: {
body: API.AppUserAddressRemovePostBody;
options?: CustomRequestOptions;
}) {
return request<API.R>('/app/userAddress/remove', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
src/service/userBalanceDetail.ts
+27
View File
@@ -0,0 +1,27 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 查询用户余额明细列表 GET /xjpmj/userBalanceDetail/list */
export async function xjpmjUserBalanceDetailListGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjUserBalanceDetailListGetParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoUserBalanceDetailVo>(
'/xjpmj/userBalanceDetail/list',
{
method: 'GET',
params: {
...params,
},
...(options || {}),
}
);
}
src/service/userCoupon.ts
+123
View File
@@ -0,0 +1,123 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 修改用户优惠券关联 PUT /xjpmj/userCoupon */
export async function xjpmjUserCouponPut({
body,
options,
}: {
body: API.UserCouponBoEditGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/userCoupon', {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 新增用户优惠券关联 POST /xjpmj/userCoupon */
export async function xjpmjUserCouponPost({
body,
options,
}: {
body: API.UserCouponBoAddGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/userCoupon', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取用户优惠券关联详细信息 GET /xjpmj/userCoupon/${param0} */
export async function xjpmjUserCouponIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjUserCouponidGetParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.RUserCouponVo>(`/xjpmj/userCoupon/${param0}`, {
method: 'GET',
params: { ...queryParams },
...(options || {}),
});
}
/** 删除用户优惠券关联 DELETE /xjpmj/userCoupon/${param0} */
export async function xjpmjUserCouponIdsDelete({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjUserCouponidsDeleteParams;
options?: CustomRequestOptions;
}) {
const { ids: param0, ...queryParams } = params;
return request<API.RVoid>(`/xjpmj/userCoupon/${param0}`, {
method: 'DELETE',
params: { ...queryParams },
...(options || {}),
});
}
/** 导出用户优惠券关联列表 POST /xjpmj/userCoupon/export */
export async function xjpmjUserCouponExportPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjUserCouponExportPostParams;
options?: CustomRequestOptions;
}) {
return request<API.XjpmjUserCouponExportPostResponse>(
'/xjpmj/userCoupon/export',
{
method: 'POST',
params: {
...params,
},
...(options || {}),
}
);
}
/** 查询用户优惠券关联列表 POST /xjpmj/userCoupon/list */
export async function xjpmjUserCouponListPost({
params,
body,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjUserCouponListPostParams;
body: API.UserCouponBo;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoUserCouponVo>('/xjpmj/userCoupon/list', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
params: {
...params,
},
data: body,
...(options || {}),
});
}
src/service/version.ts
+24
View File
@@ -0,0 +1,24 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 版本更新 POST /app/version/isUpdateVersion */
export async function appVersionIsUpdateVersionPost({
body,
options,
}: {
body: API.IsUpdateVersionBo;
options?: CustomRequestOptions;
}) {
return request<API.RAppVersionVo>('/app/version/isUpdateVersion', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
src/service/withdrawalRecord.ts
+138
View File
@@ -0,0 +1,138 @@
/* eslint-disable */
// @ts-ignore
import request from '@/http/vue-query';
import type { CustomRequestOptions } from '@/http/types';
import * as API from './types';
/** 修改钱包提现记录 PUT /xjpmj/withdrawalRecord */
export async function xjpmjWithdrawalRecordPut({
body,
options,
}: {
body: API.WithdrawalRecordBoEditGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/withdrawalRecord', {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 新增钱包提现记录 POST /xjpmj/withdrawalRecord */
export async function xjpmjWithdrawalRecordPost({
body,
options,
}: {
body: API.WithdrawalRecordBoAddGroup;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/withdrawalRecord', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 获取钱包提现记录详细信息 GET /xjpmj/withdrawalRecord/${param0} */
export async function xjpmjWithdrawalRecordIdGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjWithdrawalRecordidGetParams;
options?: CustomRequestOptions;
}) {
const { id: param0, ...queryParams } = params;
return request<API.RWithdrawalRecordVo>(`/xjpmj/withdrawalRecord/${param0}`, {
method: 'GET',
params: { ...queryParams },
...(options || {}),
});
}
/** 删除钱包提现记录 DELETE /xjpmj/withdrawalRecord/${param0} */
export async function xjpmjWithdrawalRecordIdsDelete({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjWithdrawalRecordidsDeleteParams;
options?: CustomRequestOptions;
}) {
const { ids: param0, ...queryParams } = params;
return request<API.RVoid>(`/xjpmj/withdrawalRecord/${param0}`, {
method: 'DELETE',
params: { ...queryParams },
...(options || {}),
});
}
/** 提现审核 POST /xjpmj/withdrawalRecord/audit */
export async function xjpmjWithdrawalRecordAuditPost({
body,
options,
}: {
body: API.AuditBo;
options?: CustomRequestOptions;
}) {
return request<API.RVoid>('/xjpmj/withdrawalRecord/audit', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
data: body,
...(options || {}),
});
}
/** 导出钱包提现记录列表 POST /xjpmj/withdrawalRecord/export */
export async function xjpmjWithdrawalRecordExportPost({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjWithdrawalRecordExportPostParams;
options?: CustomRequestOptions;
}) {
return request<API.XjpmjWithdrawalRecordExportPostResponse>(
'/xjpmj/withdrawalRecord/export',
{
method: 'POST',
params: {
...params,
},
...(options || {}),
}
);
}
/** 查询钱包提现记录列表 GET /xjpmj/withdrawalRecord/list */
export async function xjpmjWithdrawalRecordListGet({
params,
options,
}: {
// 叠加生成的Param类型 (非body参数openapi默认没有生成对象)
params: API.XjpmjWithdrawalRecordListGetParams;
options?: CustomRequestOptions;
}) {
return request<API.TableDataInfoWithdrawalRecordVo>(
'/xjpmj/withdrawalRecord/list',
{
method: 'GET',
params: {
...params,
},
...(options || {}),
}
);
}