清除历史版本

This commit is contained in:
luob
2025-12-23 17:08:57 +08:00
parent ae70d34cd0
commit f57c6ec302
3575 changed files with 0 additions and 387534 deletions

View File

@@ -1,220 +0,0 @@
/**
* 通用组件共同的使用的基础组件,原先放在 adapter/form 内部,限制了使用范围,这里提取出来,方便其他地方使用
* 可用于 vben-form、vben-modal、vben-drawer 等组件使用,
*/
import type { Component } from 'vue';
import type { BaseFormComponentType } from '@vben/common-ui';
import type { Recordable } from '@vben/types';
import { defineAsyncComponent, defineComponent, h, ref } from 'vue';
import { ApiComponent, globalShareState, IconPicker } from '@vben/common-ui';
import { $t } from '@vben/locales';
import { notification } from 'ant-design-vue';
import { Tinymce as RichTextarea } from '#/components/tinymce';
import { FileUpload, ImageUpload } from '#/components/upload';
const AutoComplete = defineAsyncComponent(
() => import('ant-design-vue/es/auto-complete'),
);
const Button = defineAsyncComponent(() => import('ant-design-vue/es/button'));
const Checkbox = defineAsyncComponent(
() => import('ant-design-vue/es/checkbox'),
);
const CheckboxGroup = defineAsyncComponent(() =>
import('ant-design-vue/es/checkbox').then((res) => res.CheckboxGroup),
);
const DatePicker = defineAsyncComponent(
() => import('ant-design-vue/es/date-picker'),
);
const Divider = defineAsyncComponent(() => import('ant-design-vue/es/divider'));
const Input = defineAsyncComponent(() => import('ant-design-vue/es/input'));
const InputNumber = defineAsyncComponent(
() => import('ant-design-vue/es/input-number'),
);
const InputPassword = defineAsyncComponent(() =>
import('ant-design-vue/es/input').then((res) => res.InputPassword),
);
const Mentions = defineAsyncComponent(
() => import('ant-design-vue/es/mentions'),
);
const Radio = defineAsyncComponent(() => import('ant-design-vue/es/radio'));
const RadioGroup = defineAsyncComponent(() =>
import('ant-design-vue/es/radio').then((res) => res.RadioGroup),
);
const RangePicker = defineAsyncComponent(() =>
import('ant-design-vue/es/date-picker').then((res) => res.RangePicker),
);
const Rate = defineAsyncComponent(() => import('ant-design-vue/es/rate'));
const Select = defineAsyncComponent(() => import('ant-design-vue/es/select'));
const Space = defineAsyncComponent(() => import('ant-design-vue/es/space'));
const Switch = defineAsyncComponent(() => import('ant-design-vue/es/switch'));
const Textarea = defineAsyncComponent(() =>
import('ant-design-vue/es/input').then((res) => res.Textarea),
);
const TimePicker = defineAsyncComponent(
() => import('ant-design-vue/es/time-picker'),
);
const TreeSelect = defineAsyncComponent(
() => import('ant-design-vue/es/tree-select'),
);
const Upload = defineAsyncComponent(() => import('ant-design-vue/es/upload'));
const withDefaultPlaceholder = <T extends Component>(
component: T,
type: 'input' | 'select',
componentProps: Recordable<any> = {},
) => {
return defineComponent({
name: component.name,
inheritAttrs: false,
setup: (props: any, { attrs, expose, slots }) => {
const placeholder =
props?.placeholder ||
attrs?.placeholder ||
$t(`ui.placeholder.${type}`);
// 透传组件暴露的方法
const innerRef = ref();
expose(
new Proxy(
{},
{
get: (_target, key) => innerRef.value?.[key],
has: (_target, key) => key in (innerRef.value || {}),
},
),
);
return () =>
h(
component,
{ ...componentProps, placeholder, ...props, ...attrs, ref: innerRef },
slots,
);
},
});
};
// 这里需要自行根据业务组件库进行适配,需要用到的组件都需要在这里类型说明
export type ComponentType =
| 'ApiSelect'
| 'ApiTreeSelect'
| 'AutoComplete'
| 'Checkbox'
| 'CheckboxGroup'
| 'DatePicker'
| 'DefaultButton'
| 'Divider'
| 'FileUpload'
| 'IconPicker'
| 'ImageUpload'
| 'Input'
| 'InputNumber'
| 'InputPassword'
| 'Mentions'
| 'PrimaryButton'
| 'Radio'
| 'RadioGroup'
| 'RangePicker'
| 'Rate'
| 'RichTextarea'
| 'Select'
| 'Space'
| 'Switch'
| 'Textarea'
| 'TimePicker'
| 'TreeSelect'
| 'Upload'
| BaseFormComponentType;
async function initComponentAdapter() {
const components: Partial<Record<ComponentType, Component>> = {
// 如果你的组件体积比较大,可以使用异步加载
// Button: () =>
// import('xxx').then((res) => res.Button),
ApiSelect: withDefaultPlaceholder(
{
...ApiComponent,
name: 'ApiSelect',
},
'select',
{
component: Select,
loadingSlot: 'suffixIcon',
visibleEvent: 'onDropdownVisibleChange',
modelPropName: 'value',
},
),
ApiTreeSelect: withDefaultPlaceholder(
{
...ApiComponent,
name: 'ApiTreeSelect',
},
'select',
{
component: TreeSelect,
fieldNames: { label: 'label', value: 'value', children: 'children' },
loadingSlot: 'suffixIcon',
modelPropName: 'value',
optionsPropName: 'treeData',
visibleEvent: 'onVisibleChange',
},
),
AutoComplete,
Checkbox,
CheckboxGroup,
DatePicker,
// 自定义默认按钮
DefaultButton: (props, { attrs, slots }) => {
return h(Button, { ...props, attrs, type: 'default' }, slots);
},
Divider,
IconPicker: withDefaultPlaceholder(IconPicker, 'select', {
iconSlot: 'addonAfter',
inputComponent: Input,
modelValueProp: 'value',
}),
Input: withDefaultPlaceholder(Input, 'input'),
InputNumber: withDefaultPlaceholder(InputNumber, 'input'),
InputPassword: withDefaultPlaceholder(InputPassword, 'input'),
Mentions: withDefaultPlaceholder(Mentions, 'input'),
// 自定义主要按钮
PrimaryButton: (props, { attrs, slots }) => {
return h(Button, { ...props, attrs, type: 'primary' }, slots);
},
Radio,
RadioGroup,
RangePicker,
Rate,
Select: withDefaultPlaceholder(Select, 'select'),
Space,
Switch,
Textarea: withDefaultPlaceholder(Textarea, 'input'),
RichTextarea,
TimePicker,
TreeSelect: withDefaultPlaceholder(TreeSelect, 'select'),
Upload,
FileUpload,
ImageUpload,
};
// 将组件注册到全局共享状态中
globalShareState.setComponents(components);
// 定义全局共享状态中的消息提示
globalShareState.defineMessage({
// 复制成功消息提示
copyPreferencesSuccess: (title, content) => {
notification.success({
description: content,
message: title,
placement: 'bottomRight',
});
},
});
}
export { initComponentAdapter };

View File

@@ -1,71 +0,0 @@
import type {
VbenFormSchema as FormSchema,
VbenFormProps,
} from '@vben/common-ui';
import type { ComponentType } from './component';
import { setupVbenForm, useVbenForm as useForm, z } from '@vben/common-ui';
import { $t } from '@vben/locales';
/** 手机号正则表达式(中国) */
const MOBILE_REGEX = /(?:0|86|\+86)?1[3-9]\d{9}/;
async function initSetupVbenForm() {
setupVbenForm<ComponentType>({
config: {
// ant design vue组件库默认都是 v-model:value
baseModelPropName: 'value',
// 一些组件是 v-model:checked 或者 v-model:fileList
modelPropNameMap: {
Checkbox: 'checked',
Radio: 'checked',
Switch: 'checked',
Upload: 'fileList',
},
},
defineRules: {
// 输入项目必填国际化适配
required: (value, _params, ctx) => {
if (value === undefined || value === null || value.length === 0) {
return $t('ui.formRules.required', [ctx.label]);
}
return true;
},
// 选择项目必填国际化适配
selectRequired: (value, _params, ctx) => {
if (value === undefined || value === null) {
return $t('ui.formRules.selectRequired', [ctx.label]);
}
return true;
},
// 手机号非必填
mobile: (value, _params, ctx) => {
if (value === undefined || value === null || value.length === 0) {
return true;
} else if (!MOBILE_REGEX.test(value)) {
return $t('ui.formRules.mobile', [ctx.label]);
}
return true;
},
// 手机号必填
mobileRequired: (value, _params, ctx) => {
if (value === undefined || value === null || value.length === 0) {
return $t('ui.formRules.required', [ctx.label]);
}
if (!MOBILE_REGEX.test(value)) {
return $t('ui.formRules.mobile', [ctx.label]);
}
return true;
},
},
});
}
const useVbenForm = useForm<ComponentType>;
export { initSetupVbenForm, useVbenForm, z };
export type VbenFormSchema = FormSchema<ComponentType>;
export type { VbenFormProps };

View File

@@ -1,79 +0,0 @@
/* 来自 @vben/plugins/vxe-table style.css覆盖 vxe-table 原有的样式定义,使用 vben 的样式主题 */
:root {
--vxe-ui-font-color: hsl(var(--foreground));
--vxe-ui-font-primary-color: hsl(var(--primary));
/* --vxe-ui-font-lighten-color: #babdc0;
--vxe-ui-font-darken-color: #86898e; */
--vxe-ui-font-disabled-color: hsl(var(--foreground) / 50%);
/* base */
--vxe-ui-base-popup-border-color: hsl(var(--border));
--vxe-ui-input-disabled-color: hsl(var(--border) / 60%);
/* --vxe-ui-base-popup-box-shadow: 0px 12px 30px 8px rgb(0 0 0 / 50%); */
/* layout */
--vxe-ui-layout-background-color: hsl(var(--background));
--vxe-ui-table-resizable-line-color: hsl(var(--heavy));
/* --vxe-ui-table-fixed-left-scrolling-box-shadow: 8px 0px 10px -5px hsl(var(--accent));
--vxe-ui-table-fixed-right-scrolling-box-shadow: -8px 0px 10px -5px hsl(var(--accent)); */
/* input */
--vxe-ui-input-border-color: hsl(var(--border));
/* --vxe-ui-input-placeholder-color: #8d9095; */
/* --vxe-ui-input-disabled-background-color: #262727; */
/* loading */
--vxe-ui-loading-background-color: hsl(var(--overlay-content));
/* table */
--vxe-ui-table-header-background-color: hsl(var(--accent));
--vxe-ui-table-border-color: hsl(var(--border));
--vxe-ui-table-row-hover-background-color: hsl(var(--accent-hover));
--vxe-ui-table-row-striped-background-color: hsl(var(--accent) / 60%);
--vxe-ui-table-row-hover-striped-background-color: hsl(var(--accent));
--vxe-ui-table-row-radio-checked-background-color: hsl(var(--accent));
--vxe-ui-table-row-hover-radio-checked-background-color: hsl(
var(--accent-hover)
);
--vxe-ui-table-row-checkbox-checked-background-color: hsl(var(--accent));
--vxe-ui-table-row-hover-checkbox-checked-background-color: hsl(
var(--accent-hover)
);
--vxe-ui-table-row-current-background-color: hsl(var(--accent));
--vxe-ui-table-row-hover-current-background-color: hsl(var(--accent-hover));
--vxe-ui-font-primary-tinge-color: hsl(var(--primary));
--vxe-ui-font-primary-lighten-color: hsl(var(--primary) / 60%);
--vxe-ui-font-primary-darken-color: hsl(var(--primary));
/* height: auto !important; */
/* --vxe-ui-table-fixed-scrolling-box-shadow-color: rgb(0 0 0 / 80%); */
}
.vxe-tools--operate {
margin-right: 0.25rem;
margin-left: 0.75rem;
}
.vxe-table-custom--checkbox-option:hover {
background: none !important;
}
.vxe-toolbar {
padding: 0;
}
.vxe-buttons--wrapper:not(:empty),
.vxe-tools--operate:not(:empty),
.vxe-tools--wrapper:not(:empty) {
padding: 0.6em 0;
}
.vxe-tools--operate:not(:has(button)) {
margin-left: 0;
}

View File

@@ -1,371 +0,0 @@
import type { VxeTableGridOptions } from '@vben/plugins/vxe-table';
import type { Recordable } from '@vben/types';
import { h } from 'vue';
import { IconifyIcon } from '@vben/icons';
import { $te } from '@vben/locales';
import {
AsyncComponents,
setupVbenVxeTable,
useVbenVxeGrid,
} from '@vben/plugins/vxe-table';
import {
erpCountInputFormatter,
erpNumberFormatter,
fenToYuan,
formatPast2,
isFunction,
isString,
} from '@vben/utils';
import {
Button,
Image,
ImagePreviewGroup,
Popconfirm,
Switch,
Tag,
} from 'ant-design-vue';
import { DictTag } from '#/components/dict-tag';
import { $t } from '#/locales';
import { useVbenForm } from './form';
import '#/adapter/style.css';
setupVbenVxeTable({
configVxeTable: (vxeUI) => {
vxeUI.setConfig({
grid: {
align: 'center',
border: false,
columnConfig: {
resizable: true,
},
minHeight: 180,
formConfig: {
// 全局禁用vxe-table的表单配置使用formOptions
enabled: false,
},
toolbarConfig: {
import: false, // 是否导入
export: false, // 是否导出
refresh: true, // 是否刷新
print: false, // 是否打印
zoom: true, // 是否缩放
custom: true, // 是否自定义配置
},
customConfig: {
mode: 'modal',
},
proxyConfig: {
autoLoad: true,
response: {
result: 'list',
total: 'total',
},
showActiveMsg: true,
showResponseMsg: false,
},
pagerConfig: {
enabled: true,
},
sortConfig: {
multiple: true,
},
round: true,
showOverflow: true,
size: 'small',
} as VxeTableGridOptions,
});
// 表格配置项可以用 cellRender: { name: 'CellImage' },
vxeUI.renderer.add('CellImage', {
renderTableDefault(_renderOpts, params) {
const { column, row } = params;
return h(Image, { src: row[column.field] });
},
});
vxeUI.renderer.add('CellImages', {
renderTableDefault(_renderOpts, params) {
const { column, row } = params;
if (column && column.field && row[column.field]) {
return h(ImagePreviewGroup, {}, () => {
return row[column.field].map((item: any) =>
h(Image, { src: item }),
);
});
}
return '';
},
});
// 表格配置项可以用 cellRender: { name: 'CellLink' },
vxeUI.renderer.add('CellLink', {
renderTableDefault(renderOpts) {
const { props } = renderOpts;
return h(
Button,
{ size: 'small', type: 'link' },
{ default: () => props?.text },
);
},
});
// 表格配置项可以用 cellRender: { name: 'CellTag' },
vxeUI.renderer.add('CellTag', {
renderTableDefault(renderOpts, params) {
const { props } = renderOpts;
const { column, row } = params;
return h(Tag, { color: props?.color }, () => row[column.field]);
},
});
vxeUI.renderer.add('CellTags', {
renderTableDefault(renderOpts, params) {
const { props } = renderOpts;
const { column, row } = params;
if (!row[column.field] || row[column.field].length === 0) {
return '';
}
return h(
'div',
{ class: 'flex items-center justify-center' },
{
default: () =>
row[column.field].map((item: any) =>
h(Tag, { color: props?.color }, { default: () => item }),
),
},
);
},
});
// 表格配置项可以用 cellRender: { name: 'CellDict', props:{dictType: ''} },
vxeUI.renderer.add('CellDict', {
renderTableDefault(renderOpts, params) {
const { props } = renderOpts;
const { column, row } = params;
if (!props) {
return '';
}
// 使用 DictTag 组件替代原来的实现
return h(DictTag, {
type: props.type,
value: row[column.field]?.toString(),
});
},
});
// 表格配置项可以用 cellRender: { name: 'CellSwitch', props: { beforeChange: () => {} } },
// add by 芋艿from https://github.com/vbenjs/vue-vben-admin/blob/main/playground/src/adapter/vxe-table.ts#L97-L123
vxeUI.renderer.add('CellSwitch', {
renderTableDefault({ attrs, props }, { column, row }) {
const loadingKey = `__loading_${column.field}`;
const finallyProps = {
checkedChildren: $t('common.enabled'),
checkedValue: 1,
unCheckedChildren: $t('common.disabled'),
unCheckedValue: 0,
...props,
checked: row[column.field],
loading: row[loadingKey] ?? false,
'onUpdate:checked': onChange,
};
async function onChange(newVal: any) {
row[loadingKey] = true;
try {
const result = await attrs?.beforeChange?.(newVal, row);
if (result !== false) {
row[column.field] = newVal;
}
} finally {
row[loadingKey] = false;
}
}
return h(Switch, finallyProps);
},
});
// 注册表格的操作按钮渲染器 cellRender: { name: 'CellOperation', options: ['edit', 'delete'] }
// add by 芋艿from https://github.com/vbenjs/vue-vben-admin/blob/main/playground/src/adapter/vxe-table.ts#L125-L255
vxeUI.renderer.add('CellOperation', {
renderTableDefault({ attrs, options, props }, { column, row }) {
const defaultProps = { size: 'small', type: 'link', ...props };
let align = 'end';
switch (column.align) {
case 'center': {
align = 'center';
break;
}
case 'left': {
align = 'start';
break;
}
default: {
align = 'end';
break;
}
}
const presets: Recordable<Recordable<any>> = {
delete: {
danger: true,
text: $t('common.delete'),
},
edit: {
text: $t('common.edit'),
},
};
const operations: Array<Recordable<any>> = (
options || ['edit', 'delete']
)
.map((opt) => {
if (isString(opt)) {
return presets[opt]
? { code: opt, ...presets[opt], ...defaultProps }
: {
code: opt,
text: $te(`common.${opt}`) ? $t(`common.${opt}`) : opt,
...defaultProps,
};
} else {
return { ...defaultProps, ...presets[opt.code], ...opt };
}
})
.map((opt) => {
const optBtn: Recordable<any> = {};
Object.keys(opt).forEach((key) => {
optBtn[key] = isFunction(opt[key]) ? opt[key](row) : opt[key];
});
return optBtn;
})
.filter((opt) => opt.show !== false);
function renderBtn(opt: Recordable<any>, listen = true) {
return h(
Button,
{
...props,
...opt,
icon: undefined,
onClick: listen
? () =>
attrs?.onClick?.({
code: opt.code,
row,
})
: undefined,
},
{
default: () => {
const content = [];
if (opt.icon) {
content.push(
h(IconifyIcon, { class: 'size-5', icon: opt.icon }),
);
}
content.push(opt.text);
return content;
},
},
);
}
function renderConfirm(opt: Recordable<any>) {
return h(
Popconfirm,
{
getPopupContainer(el) {
return el.closest('tbody') || document.body;
},
placement: 'topLeft',
title: $t('ui.actionTitle.delete', [attrs?.nameTitle || '']),
...props,
...opt,
icon: undefined,
onConfirm: () => {
attrs?.onClick?.({
code: opt.code,
row,
});
},
},
{
default: () => renderBtn({ ...opt }, false),
description: () =>
h(
'div',
{ class: 'truncate' },
$t('ui.actionMessage.deleteConfirm', [
row[attrs?.nameField || 'name'],
]),
),
},
);
}
const btns = operations.map((opt) =>
opt.code === 'delete' ? renderConfirm(opt) : renderBtn(opt),
);
return h(
'div',
{
class: 'flex table-operations',
style: { justifyContent: align },
},
btns,
);
},
});
// 这里可以自行扩展 vxe-table 的全局配置,比如自定义格式化
// vxeUI.formats.add
vxeUI.formats.add('formatPast2', {
tableCellFormatMethod({ cellValue }) {
return formatPast2(cellValue);
},
});
// add by 星语:数量格式化,例如说:金额
vxeUI.formats.add('formatNumber', {
tableCellFormatMethod({ cellValue }) {
return erpCountInputFormatter(cellValue);
},
});
vxeUI.formats.add('formatAmount2', {
tableCellFormatMethod({ cellValue }, digits = 2) {
return `${erpNumberFormatter(cellValue, digits)}`;
},
});
vxeUI.formats.add('formatFenToYuanAmount', {
tableCellFormatMethod({ cellValue }, digits = 2) {
return `${erpNumberFormatter(fenToYuan(cellValue), digits)}`;
},
});
},
useVbenForm,
});
export { useVbenVxeGrid };
const [VxeTable, VxeColumn, VxeToolbar] = AsyncComponents;
export { VxeColumn, VxeTable, VxeToolbar };
// add by 芋艿from https://github.com/vbenjs/vue-vben-admin/blob/main/playground/src/adapter/vxe-table.ts#L264-L270
export type OnActionClickParams<T = Recordable<any>> = {
code: string;
row: T;
};
export type OnActionClickFn<T = Recordable<any>> = (
params: OnActionClickParams<T>,
) => void;
export * from '#/components/table-action';
export type * from '@vben/plugins/vxe-table';

View File

@@ -1,75 +0,0 @@
import type { PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace AiChatConversationApi {
export interface ChatConversation {
id: number; // ID 编号
userId: number; // 用户编号
title: string; // 对话标题
pinned: boolean; // 是否置顶
roleId: number; // 角色编号
modelId: number; // 模型编号
model: string; // 模型标志
temperature: number; // 温度参数
maxTokens: number; // 单条回复的最大 Token 数量
maxContexts: number; // 上下文的最大 Message 数量
createTime?: Date; // 创建时间
// 额外字段
systemMessage?: string; // 角色设定
modelName?: string; // 模型名字
roleAvatar?: string; // 角色头像
modelMaxTokens?: string; // 模型的单条回复的最大 Token 数量
modelMaxContexts?: string; // 模型的上下文的最大 Message 数量
}
}
// 获得【我的】聊天对话
export function getChatConversationMy(id: number) {
return requestClient.get<AiChatConversationApi.ChatConversation>(
`/ai/chat/conversation/get-my?id=${id}`,
);
}
// 新增【我的】聊天对话
export function createChatConversationMy(
data: AiChatConversationApi.ChatConversation,
) {
return requestClient.post('/ai/chat/conversation/create-my', data);
}
// 更新【我的】聊天对话
export function updateChatConversationMy(
data: AiChatConversationApi.ChatConversation,
) {
return requestClient.put(`/ai/chat/conversation/update-my`, data);
}
// 删除【我的】聊天对话
export function deleteChatConversationMy(id: number) {
return requestClient.delete(`/ai/chat/conversation/delete-my?id=${id}`);
}
// 删除【我的】所有对话,置顶除外
export function deleteChatConversationMyByUnpinned() {
return requestClient.delete(`/ai/chat/conversation/delete-by-unpinned`);
}
// 获得【我的】聊天对话列表
export function getChatConversationMyList() {
return requestClient.get<AiChatConversationApi.ChatConversation[]>(
`/ai/chat/conversation/my-list`,
);
}
// 获得【我的】聊天对话列表
export function getChatConversationPage(params: any) {
return requestClient.get<
PageResult<AiChatConversationApi.ChatConversation[]>
>(`/ai/chat/conversation/page`, { params });
}
// 管理员删除消息
export function deleteChatConversationByAdmin(id: number) {
return requestClient.delete(`/ai/chat/conversation/delete-by-admin?id=${id}`);
}

View File

@@ -1,95 +0,0 @@
import type { PageResult } from '@vben/request';
import { useAppConfig } from '@vben/hooks';
import { fetchEventSource } from '@vben/request';
import { useAccessStore } from '@vben/stores';
import { requestClient } from '#/api/request';
const { apiURL } = useAppConfig(import.meta.env, import.meta.env.PROD);
const accessStore = useAccessStore();
export namespace AiChatMessageApi {
export interface ChatMessage {
id: number; // 编号
conversationId: number; // 对话编号
type: string; // 消息类型
userId: string; // 用户编号
roleId: string; // 角色编号
model: number; // 模型标志
modelId: number; // 模型编号
content: string; // 聊天内容
tokens: number; // 消耗 Token 数量
segmentIds?: number[]; // 段落编号
segments?: {
content: string; // 段落内容
documentId: number; // 文档编号
documentName: string; // 文档名称
id: number; // 段落编号
}[];
createTime: Date; // 创建时间
roleAvatar: string; // 角色头像
userAvatar: string; // 用户头像
}
}
// 消息列表
export function getChatMessageListByConversationId(
conversationId: null | number,
) {
return requestClient.get<AiChatMessageApi.ChatMessage[]>(
`/ai/chat/message/list-by-conversation-id?conversationId=${conversationId}`,
);
}
// 发送 Stream 消息
export function sendChatMessageStream(
conversationId: number,
content: string,
ctrl: any,
enableContext: boolean,
onMessage: any,
onError: any,
onClose: any,
) {
const token = accessStore.accessToken;
return fetchEventSource(`${apiURL}/ai/chat/message/send-stream`, {
method: 'post',
headers: {
'Content-Type': 'application/json',
Authorization: `Bearer ${token}`,
},
openWhenHidden: true,
body: JSON.stringify({
conversationId,
content,
useContext: enableContext,
}),
onmessage: onMessage,
onerror: onError,
onclose: onClose,
signal: ctrl.signal,
});
}
// 删除消息
export function deleteChatMessage(id: number) {
return requestClient.delete(`/ai/chat/message/delete?id=${id}`);
}
// 删除指定对话的消息
export function deleteByConversationId(conversationId: number) {
return requestClient.delete(
`/ai/chat/message/delete-by-conversation-id?conversationId=${conversationId}`,
);
}
// 获得消息分页
export function getChatMessagePage(params: any) {
return requestClient.get<PageResult<AiChatMessageApi.ChatMessage>>(
'/ai/chat/message/page',
{ params },
);
}
// 管理员删除消息
export function deleteChatMessageByAdmin(id: number) {
return requestClient.delete(`/ai/chat/message/delete-by-admin?id=${id}`);
}

View File

@@ -1,109 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace AiImageApi {
export interface ImageMidjourneyButtons {
customId: string; // MJ::JOB::upsample::1::85a4b4c1-8835-46c5-a15c-aea34fad1862 动作标识
emoji: string; // 图标 emoji
label: string; // Make Variations 文本
style: number; // 样式: 2Primary、3Green
}
// AI 绘图
export interface Image {
id: number; // 编号
platform: string; // 平台
model: string; // 模型
prompt: string; // 提示词
width: number; // 图片宽度
height: number; // 图片高度
status: number; // 状态
publicStatus: boolean; // 公开状态
picUrl: string; // 任务地址
errorMessage: string; // 错误信息
options: any; // 配置 Map<string, string>
taskId: number; // 任务编号
buttons: ImageMidjourneyButtons[]; // mj 操作按钮
createTime: Date; // 创建时间
finishTime: Date; // 完成时间
}
export interface ImageDrawReq {
prompt: string; // 提示词
modelId: number; // 模型
style: string; // 图像生成的风格
width: string; // 图片宽度
height: string; // 图片高度
options: object; // 绘制参数Map<String, String>
}
export interface ImageMidjourneyImagineReq {
prompt: string; // 提示词
modelId: number; // 模型
base64Array?: string[]; // size不能为空
width: string; // 图片宽度
height: string; // 图片高度
version: string; // 版本
}
export interface ImageMidjourneyAction {
id: number; // 图片编号
customId: string; // MJ::JOB::upsample::1::85a4b4c1-8835-46c5-a15c-aea34fad1862 动作标识
}
}
// 获取【我的】绘图分页
export function getImagePageMy(params: PageParam) {
return requestClient.get<PageResult<AiImageApi.Image>>('/ai/image/my-page', {
params,
});
}
// 获取【我的】绘图记录
export function getImageMy(id: number) {
return requestClient.get<AiImageApi.Image>(`/ai/image/get-my?id=${id}`);
}
// 获取【我的】绘图记录列表
export function getImageListMyByIds(ids: number[]) {
return requestClient.get<AiImageApi.Image[]>(`/ai/image/my-list-by-ids`, {
params: { ids: ids.join(',') },
});
}
// 生成图片
export function drawImage(data: AiImageApi.ImageDrawReq) {
return requestClient.post(`/ai/image/draw`, data);
}
// 删除【我的】绘画记录
export function deleteImageMy(id: number) {
return requestClient.delete(`/ai/image/delete-my?id=${id}`);
}
// ================ midjourney 专属 ================
// 【Midjourney】生成图片
export function midjourneyImagine(data: AiImageApi.ImageMidjourneyImagineReq) {
return requestClient.post(`/ai/image/midjourney/imagine`, data);
}
// 【Midjourney】Action 操作(二次生成图片)
export function midjourneyAction(data: AiImageApi.ImageMidjourneyAction) {
return requestClient.post(`/ai/image/midjourney/action`, data);
}
// ================ 绘图管理 ================
// 查询绘画分页
export function getImagePage(params: any) {
return requestClient.get<AiImageApi.Image[]>(`/ai/image/page`, { params });
}
// 更新绘画发布状态
export function updateImage(data: any) {
return requestClient.put(`/ai/image/update`, data);
}
// 删除绘画
export function deleteImage(id: number) {
return requestClient.delete(`/ai/image/delete?id=${id}`);
}

View File

@@ -1,50 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace AiKnowledgeDocumentApi {
export interface KnowledgeDocument {
id: number; // 编号
knowledgeId: number; // 知识库编号
name: string; // 文档名称
contentLength: number; // 字符数
tokens: number; // token 数
segmentMaxTokens: number; // 分片最大 token 数
retrievalCount: number; // 召回次数
status: number; // 是否启用
}
}
// 查询知识库文档分页
export function getKnowledgeDocumentPage(params: PageParam) {
return requestClient.get<
PageResult<AiKnowledgeDocumentApi.KnowledgeDocument>
>('/ai/knowledge/document/page', { params });
}
// 查询知识库文档详情
export function getKnowledgeDocument(id: number) {
return requestClient.get(`/ai/knowledge/document/get?id=${id}`);
}
// 新增知识库文档(单个)
export function createKnowledge(data: any) {
return requestClient.post('/ai/knowledge/document/create', data);
}
// 新增知识库文档(多个)
export function createKnowledgeDocumentList(data: any) {
return requestClient.post('/ai/knowledge/document/create-list', data);
}
// 修改知识库文档
export function updateKnowledgeDocument(data: any) {
return requestClient.put('/ai/knowledge/document/update', data);
}
// 修改知识库文档状态
export function updateKnowledgeDocumentStatus(data: any) {
return requestClient.put('/ai/knowledge/document/update-status', data);
}
// 删除知识库文档
export function deleteKnowledgeDocument(id: number) {
return requestClient.delete(`/ai/knowledge/document/delete?id=${id}`);
}

View File

@@ -1,50 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace AiKnowledgeKnowledgeApi {
export interface Knowledge {
id: number; // 编号
name: string; // 知识库名称
description: string; // 知识库描述
embeddingModelId: number; // 嵌入模型编号,高质量模式时维护
topK: number; // topK
similarityThreshold: number; // 相似度阈值
}
}
// 查询知识库分页
export function getKnowledgePage(params: PageParam) {
return requestClient.get<PageResult<AiKnowledgeKnowledgeApi.Knowledge>>(
'/ai/knowledge/page',
{ params },
);
}
// 查询知识库详情
export function getKnowledge(id: number) {
return requestClient.get<AiKnowledgeKnowledgeApi.Knowledge>(
`/ai/knowledge/get?id=${id}`,
);
}
// 新增知识库
export function createKnowledge(data: AiKnowledgeKnowledgeApi.Knowledge) {
return requestClient.post('/ai/knowledge/create', data);
}
// 修改知识库
export function updateKnowledge(data: AiKnowledgeKnowledgeApi.Knowledge) {
return requestClient.put('/ai/knowledge/update', data);
}
// 删除知识库
export function deleteKnowledge(id: number) {
return requestClient.delete(`/ai/knowledge/delete?id=${id}`);
}
// 获取知识库简单列表
export function getSimpleKnowledgeList() {
return requestClient.get<AiKnowledgeKnowledgeApi.Knowledge[]>(
'/ai/knowledge/simple-list',
);
}

View File

@@ -1,77 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace AiKnowledgeSegmentApi {
// AI 知识库分段
export interface KnowledgeSegment {
id: number; // 编号
documentId: number; // 文档编号
knowledgeId: number; // 知识库编号
vectorId: string; // 向量库编号
content: string; // 切片内容
contentLength: number; // 切片内容长度
tokens: number; // token 数量
retrievalCount: number; // 召回次数
status: number; // 文档状态
createTime: number; // 创建时间
}
}
// 查询知识库分段分页
export function getKnowledgeSegmentPage(params: PageParam) {
return requestClient.get<PageResult<AiKnowledgeSegmentApi.KnowledgeSegment>>(
'/ai/knowledge/segment/page',
{ params },
);
}
// 查询知识库分段详情
export function getKnowledgeSegment(id: number) {
return requestClient.get<AiKnowledgeSegmentApi.KnowledgeSegment>(
`/ai/knowledge/segment/get?id=${id}`,
);
}
// 新增知识库分段
export function createKnowledgeSegment(
data: AiKnowledgeSegmentApi.KnowledgeSegment,
) {
return requestClient.post('/ai/knowledge/segment/create', data);
}
// 修改知识库分段
export function updateKnowledgeSegment(
data: AiKnowledgeSegmentApi.KnowledgeSegment,
) {
return requestClient.put('/ai/knowledge/segment/update', data);
}
// 修改知识库分段状态
export function updateKnowledgeSegmentStatus(data: any) {
return requestClient.put('/ai/knowledge/segment/update-status', data);
}
// 删除知识库分段
export function deleteKnowledgeSegment(id: number) {
return requestClient.delete(`/ai/knowledge/segment/delete?id=${id}`);
}
// 切片内容
export function splitContent(url: string, segmentMaxTokens: number) {
return requestClient.get('/ai/knowledge/segment/split', {
params: { url, segmentMaxTokens },
});
}
// 获取文档处理列表
export function getKnowledgeSegmentProcessList(documentIds: number[]) {
return requestClient.get('/ai/knowledge/segment/get-process-list', {
params: { documentIds: documentIds.join(',') },
});
}
// 搜索知识库分段
export function searchKnowledgeSegment(params: any) {
return requestClient.get('/ai/knowledge/segment/search', {
params,
});
}

View File

@@ -1,64 +0,0 @@
import { useAppConfig } from '@vben/hooks';
import { fetchEventSource } from '@vben/request';
import { useAccessStore } from '@vben/stores';
import { requestClient } from '#/api/request';
const { apiURL } = useAppConfig(import.meta.env, import.meta.env.PROD);
const accessStore = useAccessStore();
export namespace AiMindmapApi {
// AI 思维导图
export interface MindMap {
id: number; // 编号
userId: number; // 用户编号
prompt: string; // 生成内容提示
generatedContent: string; // 生成的思维导图内容
platform: string; // 平台
model: string; // 模型
errorMessage: string; // 错误信息
}
// AI 思维导图生成
export interface AiMindMapGenerateReq {
prompt: string;
}
}
export function generateMindMap({
data,
onClose,
onMessage,
onError,
ctrl,
}: {
ctrl: AbortController;
data: AiMindmapApi.AiMindMapGenerateReq;
onClose?: (...args: any[]) => void;
onError?: (...args: any[]) => void;
onMessage?: (res: any) => void;
}) {
const token = accessStore.accessToken;
return fetchEventSource(`${apiURL}/ai/mind-map/generate-stream`, {
method: 'post',
headers: {
'Content-Type': 'application/json',
Authorization: `Bearer ${token}`,
},
openWhenHidden: true,
body: JSON.stringify(data),
onmessage: onMessage,
onerror: onError,
onclose: onClose,
signal: ctrl.signal,
});
}
// 查询思维导图分页
export function getMindMapPage(params: any) {
return requestClient.get(`/ai/mind-map/page`, { params });
}
// 删除思维导图
export function deleteMindMap(id: number) {
return requestClient.delete(`/ai/mind-map/delete?id=${id}`);
}

View File

@@ -1,48 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace AiModelApiKeyApi {
export interface ApiKey {
id: number; // 编号
name: string; // 名称
apiKey: string; // 密钥
platform: string; // 平台
url: string; // 自定义 API 地址
status: number; // 状态
}
}
// 查询 API 密钥分页
export function getApiKeyPage(params: PageParam) {
return requestClient.get<PageResult<AiModelApiKeyApi.ApiKey>>(
'/ai/api-key/page',
{ params },
);
}
// 获得 API 密钥列表
export function getApiKeySimpleList() {
return requestClient.get<AiModelApiKeyApi.ApiKey[]>(
'/ai/api-key/simple-list',
);
}
// 查询 API 密钥详情
export function getApiKey(id: number) {
return requestClient.get<AiModelApiKeyApi.ApiKey>(`/ai/api-key/get?id=${id}`);
}
// 新增 API 密钥
export function createApiKey(data: AiModelApiKeyApi.ApiKey) {
return requestClient.post('/ai/api-key/create', data);
}
// 修改 API 密钥
export function updateApiKey(data: AiModelApiKeyApi.ApiKey) {
return requestClient.put('/ai/api-key/update', data);
}
// 删除 API 密钥
export function deleteApiKey(id: number) {
return requestClient.delete(`/ai/api-key/delete?id=${id}`);
}

View File

@@ -1,85 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace AiModelChatRoleApi {
export interface ChatRole {
id: number; // 角色编号
modelId: number; // 模型编号
name: string; // 角色名称
avatar: string; // 角色头像
category: string; // 角色类别
sort: number; // 角色排序
description: string; // 角色描述
systemMessage: string; // 角色设定
welcomeMessage: string; // 角色设定
publicStatus: boolean; // 是否公开
status: number; // 状态
knowledgeIds?: number[]; // 引用的知识库 ID 列表
toolIds?: number[]; // 引用的工具 ID 列表
}
// AI 聊天角色 分页请求
export interface ChatRolePageReq {
name?: string; // 角色名称
category?: string; // 角色类别
publicStatus: boolean; // 是否公开
pageNo: number; // 是否公开
pageSize: number; // 是否公开
}
}
// 查询聊天角色分页
export function getChatRolePage(params: PageParam) {
return requestClient.get<PageResult<AiModelChatRoleApi.ChatRole>>(
'/ai/chat-role/page',
{ params },
);
}
// 查询聊天角色详情
export function getChatRole(id: number) {
return requestClient.get<AiModelChatRoleApi.ChatRole>(
`/ai/chat-role/get?id=${id}`,
);
}
// 新增聊天角色
export function createChatRole(data: AiModelChatRoleApi.ChatRole) {
return requestClient.post('/ai/chat-role/create', data);
}
// 修改聊天角色
export function updateChatRole(data: AiModelChatRoleApi.ChatRole) {
return requestClient.put('/ai/chat-role/update', data);
}
// 删除聊天角色
export function deleteChatRole(id: number) {
return requestClient.delete(`/ai/chat-role/delete?id=${id}`);
}
// ======= chat 聊天
// 获取 my role
export function getMyPage(params: AiModelChatRoleApi.ChatRolePageReq) {
return requestClient.get('/ai/chat-role/my-page', { params });
}
// 获取角色分类
export function getCategoryList() {
return requestClient.get('/ai/chat-role/category-list');
}
// 创建角色
export function createMy(data: AiModelChatRoleApi.ChatRole) {
return requestClient.post('/ai/chat-role/create-my', data);
}
// 更新角色
export function updateMy(data: AiModelChatRoleApi.ChatRole) {
return requestClient.put('/ai/chat-role/update', data);
}
// 删除角色 my
export function deleteMy(id: number) {
return requestClient.delete(`/ai/chat-role/delete-my?id=${id}`);
}

View File

@@ -1,55 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace AiModelModelApi {
export interface Model {
id: number; // 编号
keyId: number; // API 秘钥编号
name: string; // 模型名字
model: string; // 模型标识
platform: string; // 模型平台
type: number; // 模型类型
sort: number; // 排序
status: number; // 状态
temperature?: number; // 温度参数
maxTokens?: number; // 单条回复的最大 Token 数量
maxContexts?: number; // 上下文的最大 Message 数量
}
}
// 查询模型分页
export function getModelPage(params: PageParam) {
return requestClient.get<PageResult<AiModelModelApi.Model>>(
'/ai/model/page',
{ params },
);
}
// 获得模型列表
export function getModelSimpleList(type?: number) {
return requestClient.get<AiModelModelApi.Model[]>('/ai/model/simple-list', {
params: {
type,
},
});
}
// 查询模型详情
export function getModel(id: number) {
return requestClient.get<AiModelModelApi.Model>(`/ai/model/get?id=${id}`);
}
// 新增模型
export function createModel(data: AiModelModelApi.Model) {
return requestClient.post('/ai/model/create', data);
}
// 修改模型
export function updateModel(data: AiModelModelApi.Model) {
return requestClient.put('/ai/model/update', data);
}
// 删除模型
export function deleteModel(id: number) {
return requestClient.delete(`/ai/model/delete?id=${id}`);
}

View File

@@ -1,43 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace AiModelToolApi {
export interface Tool {
id: number; // 工具编号
name: string; // 工具名称
description: string; // 工具描述
status: number; // 状态
}
}
// 查询工具分页
export function getToolPage(params: PageParam) {
return requestClient.get<PageResult<AiModelToolApi.Tool>>('/ai/tool/page', {
params,
});
}
// 查询工具详情
export function getTool(id: number) {
return requestClient.get<AiModelToolApi.Tool>(`/ai/tool/get?id=${id}`);
}
// 新增工具
export function createTool(data: AiModelToolApi.Tool) {
return requestClient.post('/ai/tool/create', data);
}
// 修改工具
export function updateTool(data: AiModelToolApi.Tool) {
return requestClient.put('/ai/tool/update', data);
}
// 删除工具
export function deleteTool(id: number) {
return requestClient.delete(`/ai/tool/delete?id=${id}`);
}
// 获取工具简单列表
export function getToolSimpleList() {
return requestClient.get<AiModelToolApi.Tool[]>('/ai/tool/simple-list');
}

View File

@@ -1,44 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace AiMusicApi {
// AI 音乐
export interface Music {
id: number; // 编号
userId: number; // 用户编号
title: string; // 音乐名称
lyric: string; // 歌词
imageUrl: string; // 图片地址
audioUrl: string; // 音频地址
videoUrl: string; // 视频地址
status: number; // 音乐状态
gptDescriptionPrompt: string; // 描述词
prompt: string; // 提示词
platform: string; // 模型平台
model: string; // 模型
generateMode: number; // 生成模式
tags: string; // 音乐风格标签
duration: number; // 音乐时长
publicStatus: boolean; // 是否发布
taskId: string; // 任务id
errorMessage: string; // 错误信息
}
}
// 查询音乐分页
export function getMusicPage(params: PageParam) {
return requestClient.get<PageResult<AiMusicApi.Music>>(`/ai/music/page`, {
params,
});
}
// 更新音乐
export function updateMusic(data: any) {
return requestClient.put('/ai/music/update', data);
}
// 删除音乐
export function deleteMusic(id: number) {
return requestClient.delete(`/ai/music/delete?id=${id}`);
}

View File

@@ -1,29 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export function getWorkflowPage(params: PageParam) {
return requestClient.get<PageResult<any>>('/ai/workflow/page', {
params,
});
}
export const getWorkflow = (id: number | string) => {
return requestClient.get(`/ai/workflow/get?id=${id}`);
};
export const createWorkflow = (data: any) => {
return requestClient.post('/ai/workflow/create', data);
};
export const updateWorkflow = (data: any) => {
return requestClient.put('/ai/workflow/update', data);
};
export const deleteWorkflow = (id: number | string) => {
return requestClient.delete(`/ai/workflow/delete?id=${id}`);
};
export const testWorkflow = (data: any) => {
return requestClient.post('/ai/workflow/test', data);
};

View File

@@ -1,95 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import type { AiWriteTypeEnum } from '#/utils';
import { useAppConfig } from '@vben/hooks';
import { fetchEventSource } from '@vben/request';
import { useAccessStore } from '@vben/stores';
import { requestClient } from '#/api/request';
const { apiURL } = useAppConfig(import.meta.env, import.meta.env.PROD);
const accessStore = useAccessStore();
export namespace AiWriteApi {
export interface Write {
type: AiWriteTypeEnum.REPLY | AiWriteTypeEnum.WRITING; // 1:撰写 2:回复
prompt: string; // 写作内容提示 1。撰写 2回复
originalContent: string; // 原文
length: number; // 长度
format: number; // 格式
tone: number; // 语气
language: number; // 语言
userId?: number; // 用户编号
platform?: string; // 平台
model?: string; // 模型
generatedContent?: string; // 生成的内容
errorMessage?: string; // 错误信息
createTime?: Date; // 创建时间
}
export interface AiWritePageReq extends PageParam {
userId?: number; // 用户编号
type?: AiWriteTypeEnum; // 写作类型
platform?: string; // 平台
createTime?: [string, string]; // 创建时间
}
export interface AiWriteResp {
id: number;
userId: number;
type: number;
platform: string;
model: string;
prompt: string;
generatedContent: string;
originalContent: string;
length: number;
format: number;
tone: number;
language: number;
errorMessage: string;
createTime: string;
}
}
export function writeStream({
data,
onClose,
onMessage,
onError,
ctrl,
}: {
ctrl: AbortController;
data: Partial<AiWriteApi.Write>;
onClose?: (...args: any[]) => void;
onError?: (...args: any[]) => void;
onMessage?: (res: any) => void;
}) {
const token = accessStore.accessToken;
return fetchEventSource(`${apiURL}/ai/write/generate-stream`, {
method: 'post',
headers: {
'Content-Type': 'application/json',
Authorization: `Bearer ${token}`,
},
openWhenHidden: true,
body: JSON.stringify(data),
onmessage: onMessage,
onerror: onError,
onclose: onClose,
signal: ctrl.signal,
});
}
// 获取写作列表
export function getWritePage(params: any) {
return requestClient.get<PageResult<AiWriteApi.AiWritePageReq>>(
`/ai/write/page`,
{ params },
);
}
// 删除音乐
export function deleteWrite(id: number) {
return requestClient.delete(`/ai/write/delete`, { params: { id } });
}

View File

@@ -1,57 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace ProductUnitApi {
/** 产品单位信息 */
export interface ProductUnit {
id: number; // 编号
groupId?: number; // 分组编号
name?: string; // 单位名称
basic?: number; // 基础单位
number?: number; // 单位数量/相对于基础单位
usageType: number; // 用途
}
}
/** 查询产品单位分页 */
export function getProductUnitPage(params: PageParam) {
return requestClient.get<PageResult<ProductUnitApi.ProductUnit>>(
'/basic/product-unit/page',
{ params },
);
}
/** 查询产品单位详情 */
export function getProductUnit(id: number) {
return requestClient.get<ProductUnitApi.ProductUnit>(
`/basic/product-unit/get?id=${id}`,
);
}
/** 新增产品单位 */
export function createProductUnit(data: ProductUnitApi.ProductUnit) {
return requestClient.post('/basic/product-unit/create', data);
}
/** 修改产品单位 */
export function updateProductUnit(data: ProductUnitApi.ProductUnit) {
return requestClient.put('/basic/product-unit/update', data);
}
/** 删除产品单位 */
export function deleteProductUnit(id: number) {
return requestClient.delete(`/basic/product-unit/delete?id=${id}`);
}
/** 批量删除产品单位 */
export function deleteProductUnitListByIds(ids: number[]) {
return requestClient.delete(
`/basic/product-unit/delete-list?ids=${ids.join(',')}`,
);
}
/** 导出产品单位 */
export function exportProductUnit(params: any) {
return requestClient.download('/basic/product-unit/export-excel', params);
}

View File

@@ -1,61 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace ProductUnitGroupApi {
/** 产品单位组信息 */
export interface ProductUnitGroup {
id: number; // 编号
name?: string; // 产品单位组名称
status?: number; // 开启状态
}
}
/** 查询产品单位组分页 */
export function getProductUnitGroupPage(params: PageParam) {
return requestClient.get<PageResult<ProductUnitGroupApi.ProductUnitGroup>>(
'/basic/product-unit-group/page',
{ params },
);
}
/** 查询产品单位组详情 */
export function getProductUnitGroup(id: number) {
return requestClient.get<ProductUnitGroupApi.ProductUnitGroup>(
`/basic/product-unit-group/get?id=${id}`,
);
}
/** 新增产品单位组 */
export function createProductUnitGroup(
data: ProductUnitGroupApi.ProductUnitGroup,
) {
return requestClient.post('/basic/product-unit-group/create', data);
}
/** 修改产品单位组 */
export function updateProductUnitGroup(
data: ProductUnitGroupApi.ProductUnitGroup,
) {
return requestClient.put('/basic/product-unit-group/update', data);
}
/** 删除产品单位组 */
export function deleteProductUnitGroup(id: number) {
return requestClient.delete(`/basic/product-unit-group/delete?id=${id}`);
}
/** 批量删除产品单位组 */
export function deleteProductUnitGroupListByIds(ids: number[]) {
return requestClient.delete(
`/basic/product-unit-group/delete-list?ids=${ids.join(',')}`,
);
}
/** 导出产品单位组 */
export function exportProductUnitGroup(params: any) {
return requestClient.download(
'/basic/product-unit-group/export-excel',
params,
);
}

View File

@@ -1,60 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace BpmCategoryApi {
/** 流程分类 */
export interface Category {
id: number;
name: string;
code: string;
status: number;
description?: string;
sort: number; // 分类排序
}
}
/** 查询流程分类分页 */
export async function getCategoryPage(params: PageParam) {
return requestClient.get<PageResult<BpmCategoryApi.Category>>(
'/bpm/category/page',
{ params },
);
}
/** 查询流程分类详情 */
export async function getCategory(id: number) {
return requestClient.get<BpmCategoryApi.Category>(
`/bpm/category/get?id=${id}`,
);
}
/** 新增流程分类 */
export async function createCategory(data: BpmCategoryApi.Category) {
return requestClient.post<number>('/bpm/category/create', data);
}
/** 修改流程分类 */
export async function updateCategory(data: BpmCategoryApi.Category) {
return requestClient.put<boolean>('/bpm/category/update', data);
}
/** 删除流程分类 */
export async function deleteCategory(id: number) {
return requestClient.delete<boolean>(`/bpm/category/delete?id=${id}`);
}
/** 查询流程分类列表 */
export async function getCategorySimpleList() {
return requestClient.get<BpmCategoryApi.Category[]>(
`/bpm/category/simple-list`,
);
}
/** 批量修改流程分类的排序 */
export async function updateCategorySortBatch(ids: number[]) {
const params = ids.join(',');
return requestClient.put<boolean>(
`/bpm/category/update-sort-batch?ids=${params}`,
);
}

View File

@@ -1,56 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace BpmProcessDefinitionApi {
/** 流程定义 */
export interface ProcessDefinition {
id: string;
version: number;
name: string;
description: string;
deploymentTime: number;
suspensionState: number;
modelType: number;
modelId: string;
formType?: number;
bpmnXml?: string;
simpleModel?: string;
formFields?: string[];
icon?: string;
}
}
/** 查询流程定义 */
export async function getProcessDefinition(id?: string, key?: string) {
return requestClient.get<BpmProcessDefinitionApi.ProcessDefinition>(
'/bpm/process-definition/get',
{
params: { id, key },
},
);
}
/** 分页查询流程定义 */
export async function getProcessDefinitionPage(params: PageParam) {
return requestClient.get<
PageResult<BpmProcessDefinitionApi.ProcessDefinition>
>('/bpm/process-definition/page', { params });
}
/** 查询流程定义列表 */
export async function getProcessDefinitionList(params: any) {
return requestClient.get<BpmProcessDefinitionApi.ProcessDefinition[]>(
'/bpm/process-definition/list',
{
params,
},
);
}
/** 查询流程定义列表(简单列表) */
export async function getSimpleProcessDefinitionList() {
return requestClient.get<
PageResult<BpmProcessDefinitionApi.ProcessDefinition>
>('/bpm/process-definition/simple-list');
}

View File

@@ -1,48 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace BpmFormApi {
/** 流程表单 */
export interface Form {
id?: number | undefined;
name: string;
conf: string;
fields: string[];
status: number;
remark: string;
createTime: number;
}
}
/** 获取表单分页列表 */
export async function getFormPage(params: PageParam) {
return requestClient.get<PageResult<BpmFormApi.Form>>('/bpm/form/page', {
params,
});
}
/** 获取表单详情 */
export async function getFormDetail(id: number) {
return requestClient.get<BpmFormApi.Form>(`/bpm/form/get?id=${id}`);
}
/** 创建表单 */
export async function createForm(data: BpmFormApi.Form) {
return requestClient.post('/bpm/form/create', data);
}
/** 更新表单 */
export async function updateForm(data: BpmFormApi.Form) {
return requestClient.put('/bpm/form/update', data);
}
/** 删除表单 */
export async function deleteForm(id: number) {
return requestClient.delete(`/bpm/form/delete?id=${id}`);
}
/** 获取表单简单列表 */
export async function getFormSimpleList() {
return requestClient.get<BpmFormApi.Form[]>('/bpm/form/simple-list');
}

View File

@@ -1,111 +0,0 @@
import { requestClient } from '#/api/request';
export namespace BpmModelApi {
/** 用户信息 TODO 这个是不是可以抽取出来定义在公共模块 */
// TODO @芋艿:一起看看。
export interface UserInfo {
id: number;
nickname: string;
avatar?: string;
deptId?: number;
deptName?: string;
}
/** 流程定义 */
export interface ProcessDefinition {
id: string;
key?: string;
version: number;
deploymentTime: number;
suspensionState: number;
formType?: number;
formCustomViewPath?: string;
}
/** 流程模型 */
export interface Model {
id: number;
key: string;
name: string;
icon?: string;
description: string;
category: string;
formName: string;
formType: number;
formId: number;
formCustomCreatePath: string;
formCustomViewPath: string;
processDefinition: ProcessDefinition;
status: number;
remark: string;
createTime: string;
bpmnXml: string;
startUsers?: UserInfo[];
}
}
/** 模型分类信息 */
export interface ModelCategoryInfo {
id: number;
name: string;
modelList: BpmModelApi.Model[];
}
/** 获取流程模型列表 */
export async function getModelList(name: string | undefined) {
return requestClient.get<BpmModelApi.Model[]>('/bpm/model/list', {
params: { name },
});
}
/** 获取流程模型详情 */
export async function getModel(id: string) {
return requestClient.get<BpmModelApi.Model>(`/bpm/model/get?id=${id}`);
}
/** 更新流程模型 */
export async function updateModel(data: BpmModelApi.Model) {
return requestClient.put('/bpm/model/update', data);
}
/** 批量修改流程模型排序 */
export async function updateModelSortBatch(ids: number[]) {
const params = ids.join(',');
return requestClient.put<boolean>(
`/bpm/model/update-sort-batch?ids=${params}`,
);
}
/** 更新流程模型的 BPMN XML */
export async function updateModelBpmn(data: BpmModelApi.Model) {
return requestClient.put('/bpm/model/update-bpmn', data);
}
/** 更新流程模型状态 */
export async function updateModelState(id: number, state: number) {
const data = {
id,
state,
};
return requestClient.put('/bpm/model/update-state', data);
}
/** 创建流程模型 */
export async function createModel(data: BpmModelApi.Model) {
return requestClient.post('/bpm/model/create', data);
}
/** 删除流程模型 */
export async function deleteModel(id: number) {
return requestClient.delete(`/bpm/model/delete?id=${id}`);
}
/** 部署流程模型 */
export async function deployModel(id: number) {
return requestClient.post(`/bpm/model/deploy?id=${id}`);
}
/** 清理流程模型 */
export async function cleanModel(id: number) {
return requestClient.delete(`/bpm/model/clean?id=${id}`);
}

View File

@@ -1,40 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace BpmOALeaveApi {
export interface Leave {
id: number;
status: number;
type: number;
reason: string;
processInstanceId: string;
startTime: number;
endTime: number;
createTime: Date;
startUserSelectAssignees?: Record<string, string[]>;
}
}
/** 创建请假申请 */
export async function createLeave(data: BpmOALeaveApi.Leave) {
return requestClient.post('/bpm/oa/leave/create', data);
}
/** 更新请假申请 */
export async function updateLeave(data: BpmOALeaveApi.Leave) {
return requestClient.post('/bpm/oa/leave/update', data);
}
/** 获得请假申请 */
export async function getLeave(id: number) {
return requestClient.get<BpmOALeaveApi.Leave>(`/bpm/oa/leave/get?id=${id}`);
}
/** 获得请假申请分页 */
export async function getLeavePage(params: PageParam) {
return requestClient.get<PageResult<BpmOALeaveApi.Leave>>(
'/bpm/oa/leave/page',
{ params },
);
}

View File

@@ -1,53 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace BpmProcessExpressionApi {
/** 流程表达式 */
export interface ProcessExpression {
id: number; // 编号
name: string; // 表达式名字
status: number; // 表达式状态
expression: string; // 表达式
}
}
/** 查询流程表达式分页 */
export async function getProcessExpressionPage(params: PageParam) {
return requestClient.get<
PageResult<BpmProcessExpressionApi.ProcessExpression>
>('/bpm/process-expression/page', { params });
}
/** 查询流程表达式详情 */
export async function getProcessExpression(id: number) {
return requestClient.get<BpmProcessExpressionApi.ProcessExpression>(
`/bpm/process-expression/get?id=${id}`,
);
}
/** 新增流程表达式 */
export async function createProcessExpression(
data: BpmProcessExpressionApi.ProcessExpression,
) {
return requestClient.post<number>('/bpm/process-expression/create', data);
}
/** 修改流程表达式 */
export async function updateProcessExpression(
data: BpmProcessExpressionApi.ProcessExpression,
) {
return requestClient.put<boolean>('/bpm/process-expression/update', data);
}
/** 删除流程表达式 */
export async function deleteProcessExpression(id: number) {
return requestClient.delete<boolean>(
`/bpm/process-expression/delete?id=${id}`,
);
}
/** 导出流程表达式 */
export async function exportProcessExpression(params: any) {
return requestClient.download('/bpm/process-expression/export-excel', params);
}

View File

@@ -1,197 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import type { BpmTaskApi } from '../task';
import type { BpmModelApi } from '#/api/bpm/model';
import type { BpmCandidateStrategyEnum, BpmNodeTypeEnum } from '#/utils';
import { requestClient } from '#/api/request';
export namespace BpmProcessInstanceApi {
// TODO @芋艿:一些注释缺少或者不对;
export interface Task {
id: number;
name: string;
}
export interface User {
avatar: string;
id: number;
nickname: string;
}
// 审批任务信息
export interface ApprovalTaskInfo {
assigneeUser: User;
id: number;
ownerUser: User;
reason: string;
signPicUrl: string;
status: number;
}
// 审批节点信息
export interface ApprovalNodeInfo {
candidateStrategy?: BpmCandidateStrategyEnum;
candidateUsers?: User[];
endTime?: Date;
id: string;
name: string;
nodeType: BpmNodeTypeEnum;
startTime?: Date;
status: number;
tasks: ApprovalTaskInfo[];
}
/** 流程实例 */
export interface ProcessInstance {
businessKey: string;
category: string;
createTime: string;
endTime: string;
fields: string[];
formVariables: Record<string, any>;
id: number;
name: string;
processDefinition?: BpmModelApi.ProcessDefinition;
processDefinitionId: string;
remark: string;
result: number;
startTime?: Date;
startUser?: User;
status: number;
tasks?: BpmProcessInstanceApi.Task[];
}
// 审批详情
export interface ApprovalDetail {
activityNodes: BpmProcessInstanceApi.ApprovalNodeInfo[];
formFieldsPermission: any;
processDefinition: BpmModelApi.ProcessDefinition;
processInstance: BpmProcessInstanceApi.ProcessInstance;
status: number;
todoTask: BpmTaskApi.Task;
}
// 抄送流程实例
export interface Copy {
activityId: string;
activityName: string;
createTime: number;
createUser: User;
id: number;
processInstanceId: string;
processInstanceName: string;
processInstanceStartTime: number;
reason: string;
startUser: User;
summary: {
key: string;
value: string;
}[];
taskId: string;
}
}
/** 查询我的流程实例分页 */
export async function getProcessInstanceMyPage(params: PageParam) {
return requestClient.get<PageResult<BpmProcessInstanceApi.ProcessInstance>>(
'/bpm/process-instance/my-page',
{ params },
);
}
/** 查询管理员流程实例分页 */
export async function getProcessInstanceManagerPage(params: PageParam) {
return requestClient.get<PageResult<BpmProcessInstanceApi.ProcessInstance>>(
'/bpm/process-instance/manager-page',
{ params },
);
}
/** 新增流程实例 */
export async function createProcessInstance(data: any) {
return requestClient.post<BpmProcessInstanceApi.ProcessInstance>(
'/bpm/process-instance/create',
data,
);
}
/** 申请人主动取消流程实例 */
export async function cancelProcessInstanceByStartUser(
id: number,
reason: string,
) {
return requestClient.delete<boolean>(
'/bpm/process-instance/cancel-by-start-user',
{
data: { id, reason },
},
);
}
/** 管理员取消流程实例 */
export async function cancelProcessInstanceByAdmin(id: number, reason: string) {
return requestClient.delete<boolean>(
'/bpm/process-instance/cancel-by-admin',
{
data: { id, reason },
},
);
}
/** 查询流程实例详情 */
export async function getProcessInstance(id: number) {
return requestClient.get<BpmProcessInstanceApi.ProcessInstance>(
`/bpm/process-instance/get?id=${id}`,
);
}
/** 查询复制流程实例分页 */
export async function getProcessInstanceCopyPage(params: PageParam) {
return requestClient.get<PageResult<BpmProcessInstanceApi.ProcessInstance>>(
'/bpm/process-instance/copy/page',
{ params },
);
}
/** 更新流程实例 */
export async function updateProcessInstance(
data: BpmProcessInstanceApi.ProcessInstance,
) {
return requestClient.put<BpmProcessInstanceApi.ProcessInstance>(
'/bpm/process-instance/update',
data,
);
}
/** 获取审批详情 */
export async function getApprovalDetail(params: any) {
return requestClient.get<BpmProcessInstanceApi.ApprovalDetail>(
`/bpm/process-instance/get-approval-detail`,
{ params },
);
}
/** 获取下一个执行的流程节点 */
export async function getNextApprovalNodes(params: any) {
return requestClient.get<BpmProcessInstanceApi.ApprovalNodeInfo[]>(
`/bpm/process-instance/get-next-approval-nodes`,
{ params },
);
}
/** 获取表单字段权限 */
export async function getFormFieldsPermission(params: any) {
return requestClient.get<BpmProcessInstanceApi.ProcessInstance>(
`/bpm/process-instance/get-form-fields-permission`,
{ params },
);
}
/** 获取流程实例 BPMN 模型视图 */
export async function getProcessInstanceBpmnModelView(id: string) {
return requestClient.get<BpmProcessInstanceApi.ProcessInstance>(
`/bpm/process-instance/get-bpmn-model-view?id=${id}`,
);
}

View File

@@ -1,50 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace BpmProcessListenerApi {
/** BPM 流程监听器 */
export interface ProcessListener {
id: number; // 编号
name: string; // 监听器名字
type: string; // 监听器类型
status: number; // 监听器状态
event: string; // 监听事件
valueType: string; // 监听器值类型
value: string; // 监听器值
}
}
/** 查询流程监听器分页 */
export async function getProcessListenerPage(params: PageParam) {
return requestClient.get<PageResult<BpmProcessListenerApi.ProcessListener>>(
'/bpm/process-listener/page',
{ params },
);
}
/** 查询流程监听器详情 */
export async function getProcessListener(id: number) {
return requestClient.get<BpmProcessListenerApi.ProcessListener>(
`/bpm/process-listener/get?id=${id}`,
);
}
/** 新增流程监听器 */
export async function createProcessListener(
data: BpmProcessListenerApi.ProcessListener,
) {
return requestClient.post<number>('/bpm/process-listener/create', data);
}
/** 修改流程监听器 */
export async function updateProcessListener(
data: BpmProcessListenerApi.ProcessListener,
) {
return requestClient.put<boolean>('/bpm/process-listener/update', data);
}
/** 删除流程监听器 */
export async function deleteProcessListener(id: number) {
return requestClient.delete<boolean>(`/bpm/process-listener/delete?id=${id}`);
}

View File

@@ -1,132 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import type { BpmProcessInstanceApi } from '../processInstance';
import { requestClient } from '#/api/request';
export namespace BpmTaskApi {
/** BPM 流程监听器 */
export interface Task {
id: number; // 编号
name: string; // 监听器名字
type: string; // 监听器类型
status: number; // 监听器状态
event: string; // 监听事件
valueType: string; // 监听器值类型
}
// 流程任务
export interface TaskManager {
id: string; // 编号
name: string; // 任务名称
createTime: number; // 创建时间
endTime: number; // 结束时间
durationInMillis: number; // 持续时间
status: number; // 状态
reason: string; // 原因
ownerUser: any; // 负责人
assigneeUser: any; // 处理人
taskDefinitionKey: string; // 任务定义key
processInstanceId: string; // 流程实例id
processInstance: BpmProcessInstanceApi.ProcessInstance; // 流程实例
parentTaskId: any; // 父任务id
children: any; // 子任务
formId: any; // 表单id
formName: any; // 表单名称
formConf: any; // 表单配置
formFields: any; // 表单字段
formVariables: any; // 表单变量
buttonsSetting: any; // 按钮设置
signEnable: any; // 签名设置
reasonRequire: any; // 原因设置
nodeType: any; // 节点类型
}
}
/** 查询待办任务分页 */
export async function getTaskTodoPage(params: PageParam) {
return requestClient.get<PageResult<BpmTaskApi.Task>>('/bpm/task/todo-page', {
params,
});
}
/** 查询已办任务分页 */
export async function getTaskDonePage(params: PageParam) {
return requestClient.get<PageResult<BpmTaskApi.Task>>('/bpm/task/done-page', {
params,
});
}
/** 查询任务管理分页 */
export async function getTaskManagerPage(params: PageParam) {
return requestClient.get<PageResult<BpmTaskApi.Task>>(
'/bpm/task/manager-page',
{ params },
);
}
/** 审批任务 */
export const approveTask = async (data: any) => {
return await requestClient.put('/bpm/task/approve', data);
};
/** 驳回任务 */
export const rejectTask = async (data: any) => {
return await requestClient.put('/bpm/task/reject', data);
};
/** 根据流程实例 ID 查询任务列表 */
export const getTaskListByProcessInstanceId = async (id: string) => {
return await requestClient.get(
`/bpm/task/list-by-process-instance-id?processInstanceId=${id}`,
);
};
/** 获取所有可退回的节点 */
export const getTaskListByReturn = async (id: string) => {
return await requestClient.get(`/bpm/task/list-by-return?id=${id}`);
};
/** 退回 */
export const returnTask = async (data: any) => {
return await requestClient.put('/bpm/task/return', data);
};
// 委派
export const delegateTask = async (data: any) => {
return await requestClient.put('/bpm/task/delegate', data);
};
// 转派
export const transferTask = async (data: any) => {
return await requestClient.put('/bpm/task/transfer', data);
};
// 加签
export const signCreateTask = async (data: any) => {
return await requestClient.put('/bpm/task/create-sign', data);
};
// 减签
export const signDeleteTask = async (data: any) => {
return await requestClient.delete('/bpm/task/delete-sign', data);
};
// 抄送
export const copyTask = async (data: any) => {
return await requestClient.put('/bpm/task/copy', data);
};
// 获取我的待办任务
export const myTodoTask = async (processInstanceId: string) => {
return await requestClient.get(
`/bpm/task/my-todo?processInstanceId=${processInstanceId}`,
);
};
// 获取加签任务列表
export const getChildrenTaskList = async (id: string) => {
return await requestClient.get(
`/bpm/task/list-by-parent-task-id?parentTaskId=${id}`,
);
};

View File

@@ -1,53 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace BpmUserGroupApi {
/** BPM 用户组 */
export interface UserGroup {
id: number;
name: string;
description: string;
userIds: number[];
status: number;
remark: string;
createTime: string;
}
}
/** 查询用户组分页 */
export async function getUserGroupPage(params: PageParam) {
return requestClient.get<PageResult<BpmUserGroupApi.UserGroup>>(
'/bpm/user-group/page',
{ params },
);
}
/** 查询用户组详情 */
export async function getUserGroup(id: number) {
return requestClient.get<BpmUserGroupApi.UserGroup>(
`/bpm/user-group/get?id=${id}`,
);
}
/** 新增用户组 */
export async function createUserGroup(data: BpmUserGroupApi.UserGroup) {
return requestClient.post<number>('/bpm/user-group/create', data);
}
/** 修改用户组 */
export async function updateUserGroup(data: BpmUserGroupApi.UserGroup) {
return requestClient.put<boolean>('/bpm/user-group/update', data);
}
/** 删除用户组 */
export async function deleteUserGroup(id: number) {
return requestClient.delete<boolean>(`/bpm/user-group/delete?id=${id}`);
}
/** 查询用户组列表 */
export async function getUserGroupSimpleList() {
return requestClient.get<BpmUserGroupApi.UserGroup[]>(
`/bpm/user-group/simple-list`,
);
}

View File

@@ -1,157 +0,0 @@
import type { AuthPermissionInfo } from '@vben/types';
import { baseRequestClient, requestClient } from '#/api/request';
export namespace AuthApi {
/** 登录接口参数 */
export interface LoginParams {
password?: string;
username?: string;
captchaVerification?: string;
// 绑定社交登录时,需要传递如下参数
socialType?: number;
socialCode?: string;
socialState?: string;
}
/** 登录接口返回值 */
export interface LoginResult {
accessToken: string;
refreshToken: string;
userId: number;
expiresTime: number;
}
/** 租户信息返回值 */
export interface TenantResult {
id: number;
name: string;
}
/** 手机验证码获取接口参数 */
export interface SmsCodeParams {
mobile: string;
scene: number;
}
/** 手机验证码登录接口参数 */
export interface SmsLoginParams {
mobile: string;
code: string;
}
/** 注册接口参数 */
export interface RegisterParams {
username: string;
password: string;
captchaVerification: string;
}
/** 重置密码接口参数 */
export interface ResetPasswordParams {
password: string;
mobile: string;
code: string;
}
/** 社交快捷登录接口参数 */
export interface SocialLoginParams {
type: number;
code: string;
state: string;
}
}
/** 登录 */
export async function loginApi(data: AuthApi.LoginParams) {
return requestClient.post<AuthApi.LoginResult>('/system/auth/login', data);
}
/** 刷新 accessToken */
export async function refreshTokenApi(refreshToken: string) {
return baseRequestClient.post(
`/system/auth/refresh-token?refreshToken=${refreshToken}`,
);
}
/** 退出登录 */
export async function logoutApi(accessToken: string) {
return baseRequestClient.post(
'/system/auth/logout',
{},
{
headers: {
Authorization: `Bearer ${accessToken}`,
},
},
);
}
/** 获取权限信息 */
export async function getAuthPermissionInfoApi() {
return requestClient.get<AuthPermissionInfo>(
'/system/auth/get-permission-info',
);
}
/** 获取租户列表 */
export async function getTenantSimpleList() {
return requestClient.get<AuthApi.TenantResult[]>(
`/system/tenant/simple-list`,
);
}
/** 使用租户域名,获得租户信息 */
export async function getTenantByWebsite(website: string) {
return requestClient.get<AuthApi.TenantResult>(
`/system/tenant/get-by-website?website=${website}`,
);
}
/** 获取验证码 */
export async function getCaptcha(data: any) {
return baseRequestClient.post('/system/captcha/get', data);
}
/** 校验验证码 */
export async function checkCaptcha(data: any) {
return baseRequestClient.post('/system/captcha/check', data);
}
/** 获取登录验证码 */
export async function sendSmsCode(data: AuthApi.SmsCodeParams) {
return requestClient.post('/system/auth/send-sms-code', data);
}
/** 短信验证码登录 */
export async function smsLogin(data: AuthApi.SmsLoginParams) {
return requestClient.post('/system/auth/sms-login', data);
}
/** 注册 */
export async function register(data: AuthApi.RegisterParams) {
return requestClient.post('/system/auth/register', data);
}
/** 通过短信重置密码 */
export async function smsResetPassword(data: AuthApi.ResetPasswordParams) {
return requestClient.post('/system/auth/reset-password', data);
}
/** 社交授权的跳转 */
export async function socialAuthRedirect(type: number, redirectUri: string) {
return requestClient.get('/system/auth/social-auth-redirect', {
params: {
type,
redirectUri,
},
});
}
/** 社交快捷登录 */
export async function socialLogin(data: AuthApi.SocialLoginParams) {
return requestClient.post<AuthApi.LoginResult>(
'/system/auth/social-login',
data,
);
}

View File

@@ -1 +0,0 @@
export * from './auth';

View File

@@ -1,125 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import type { CrmPermissionApi } from '#/api/crm/permission';
import { requestClient } from '#/api/request';
export namespace CrmBusinessApi {
/** 商机产品信息 */
export interface BusinessProduct {
id: number;
productId: number;
productName: string;
productNo: string;
productUnit: number;
productPrice: number;
businessPrice: number;
count: number;
totalPrice: number;
}
/** 商机信息 */
export interface Business {
id: number;
name: string;
customerId: number;
customerName?: string;
followUpStatus: boolean;
contactLastTime: Date;
contactNextTime: Date;
ownerUserId: number;
ownerUserName?: string; // 负责人的用户名称
ownerUserDept?: string; // 负责人的部门名称
statusTypeId: number;
statusTypeName?: string;
statusId: number;
statusName?: string;
endStatus: number;
endRemark: string;
dealTime: Date;
totalProductPrice: number;
totalPrice: number;
discountPercent: number;
status?: number;
remark: string;
creator: string; // 创建人
creatorName?: string; // 创建人名称
createTime: Date; // 创建时间
updateTime: Date; // 更新时间
products?: BusinessProduct[];
}
export interface BusinessStatus {
id: number;
statusId: number | undefined;
endStatus: number | undefined;
}
}
/** 查询商机列表 */
export function getBusinessPage(params: PageParam) {
return requestClient.get<PageResult<CrmBusinessApi.Business>>(
'/crm/business/page',
{ params },
);
}
/** 查询商机列表,基于指定客户 */
export function getBusinessPageByCustomer(params: PageParam) {
return requestClient.get<PageResult<CrmBusinessApi.Business>>(
'/crm/business/page-by-customer',
{ params },
);
}
/** 查询商机详情 */
export function getBusiness(id: number) {
return requestClient.get<CrmBusinessApi.Business>(
`/crm/business/get?id=${id}`,
);
}
/** 获得商机列表(精简) */
export function getSimpleBusinessList() {
return requestClient.get<CrmBusinessApi.Business[]>(
'/crm/business/simple-all-list',
);
}
/** 新增商机 */
export function createBusiness(data: CrmBusinessApi.Business) {
return requestClient.post('/crm/business/create', data);
}
/** 修改商机 */
export function updateBusiness(data: CrmBusinessApi.Business) {
return requestClient.put('/crm/business/update', data);
}
/** 修改商机状态 */
export function updateBusinessStatus(data: CrmBusinessApi.BusinessStatus) {
return requestClient.put('/crm/business/update-status', data);
}
/** 删除商机 */
export function deleteBusiness(id: number) {
return requestClient.delete(`/crm/business/delete?id=${id}`);
}
/** 导出商机 */
export function exportBusiness(params: any) {
return requestClient.download('/crm/business/export-excel', params);
}
/** 联系人关联商机列表 */
export function getBusinessPageByContact(params: PageParam) {
return requestClient.get<PageResult<CrmBusinessApi.Business>>(
'/crm/business/page-by-contact',
{ params },
);
}
/** 商机转移 */
export function transferBusiness(data: CrmPermissionApi.TransferReq) {
return requestClient.put('/crm/business/transfer', data);
}

View File

@@ -1,95 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace CrmBusinessStatusApi {
/** 商机状态信息 */
export interface BusinessStatusType {
[x: string]: any;
id?: number;
name: string;
percent: number;
}
/** 商机状态组信息 */
export interface BusinessStatus {
id?: number;
name: string;
deptIds?: number[];
deptNames?: string[];
creator?: string;
createTime?: Date;
statuses?: BusinessStatusType[];
}
}
/** 默认商机状态 */
export const DEFAULT_STATUSES = [
{
endStatus: 1,
key: '结束',
name: '赢单',
percent: 100,
},
{
endStatus: 2,
key: '结束',
name: '输单',
percent: 0,
},
{
endStatus: 3,
key: '结束',
name: '无效',
percent: 0,
},
];
/** 查询商机状态组列表 */
export function getBusinessStatusPage(params: PageParam) {
return requestClient.get<PageResult<CrmBusinessStatusApi.BusinessStatus>>(
'/crm/business-status/page',
{ params },
);
}
/** 新增商机状态组 */
export function createBusinessStatus(
data: CrmBusinessStatusApi.BusinessStatus,
) {
return requestClient.post('/crm/business-status/create', data);
}
/** 修改商机状态组 */
export function updateBusinessStatus(
data: CrmBusinessStatusApi.BusinessStatus,
) {
return requestClient.put('/crm/business-status/update', data);
}
/** 查询商机状态类型详情 */
export function getBusinessStatus(id: number) {
return requestClient.get<CrmBusinessStatusApi.BusinessStatus>(
`/crm/business-status/get?id=${id}`,
);
}
/** 删除商机状态 */
export function deleteBusinessStatus(id: number) {
return requestClient.delete(`/crm/business-status/delete?id=${id}`);
}
/** 获得商机状态组列表 */
export function getBusinessStatusTypeSimpleList() {
return requestClient.get<CrmBusinessStatusApi.BusinessStatus[]>(
'/crm/business-status/type-simple-list',
);
}
/** 获得商机阶段列表 */
export function getBusinessStatusSimpleList(typeId: number) {
return requestClient.get<CrmBusinessStatusApi.BusinessStatusType[]>(
'/crm/business-status/status-simple-list',
{ params: { typeId } },
);
}

View File

@@ -1,86 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import type { CrmPermissionApi } from '#/api/crm/permission';
import { requestClient } from '#/api/request';
export namespace CrmClueApi {
/** 线索信息 */
export interface Clue {
id: number; // 编号
name: string; // 线索名称
followUpStatus: boolean; // 跟进状态
contactLastTime: Date; // 最后跟进时间
contactLastContent: string; // 最后跟进内容
contactNextTime: Date; // 下次联系时间
ownerUserId: number; // 负责人的用户编号
ownerUserName?: string; // 负责人的用户名称
ownerUserDept?: string; // 负责人的部门名称
transformStatus: boolean; // 转化状态
customerId: number; // 客户编号
customerName?: string; // 客户名称
mobile: string; // 手机号
telephone: string; // 电话
qq: string; // QQ
wechat: string; // wechat
email: string; // email
areaId: number; // 所在地
areaName?: string; // 所在地名称
detailAddress: string; // 详细地址
industryId: number; // 所属行业
level: number; // 客户等级
source: number; // 客户来源
remark: string; // 备注
creator: string; // 创建人
creatorName?: string; // 创建人名称
createTime: Date; // 创建时间
updateTime: Date; // 更新时间
}
}
/** 查询线索列表 */
export function getCluePage(params: PageParam) {
return requestClient.get<PageResult<CrmClueApi.Clue>>('/crm/clue/page', {
params,
});
}
/** 查询线索详情 */
export function getClue(id: number) {
return requestClient.get<CrmClueApi.Clue>(`/crm/clue/get?id=${id}`);
}
/** 新增线索 */
export function createClue(data: CrmClueApi.Clue) {
return requestClient.post('/crm/clue/create', data);
}
/** 修改线索 */
export function updateClue(data: CrmClueApi.Clue) {
return requestClient.put('/crm/clue/update', data);
}
/** 删除线索 */
export function deleteClue(id: number) {
return requestClient.delete(`/crm/clue/delete?id=${id}`);
}
/** 导出线索 */
export function exportClue(params: any) {
return requestClient.download('/crm/clue/export-excel', params);
}
/** 线索转移 */
export function transferClue(data: CrmPermissionApi.TransferReq) {
return requestClient.put('/crm/clue/transfer', data);
}
/** 线索转化为客户 */
export function transformClue(id: number) {
return requestClient.put(`/crm/clue/transform?id=${id}`);
}
/** 获得分配给我的、待跟进的线索数量 */
export function getFollowClueCount() {
return requestClient.get<number>('/crm/clue/follow-count');
}

View File

@@ -1,140 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import type { CrmPermissionApi } from '#/api/crm/permission';
import { requestClient } from '#/api/request';
export namespace CrmContactApi {
/** 联系人信息 */
export interface Contact {
id: number; // 编号
name: string; // 联系人名称
customerId: number; // 客户编号
customerName?: string; // 客户名称
contactLastTime: Date; // 最后跟进时间
contactLastContent: string; // 最后跟进内容
contactNextTime: Date; // 下次联系时间
ownerUserId: number; // 负责人的用户编号
ownerUserName?: string; // 负责人的用户名称
ownerUserDept?: string; // 负责人的部门名称
mobile: string; // 手机号
telephone: string; // 电话
qq: string; // QQ
wechat: string; // wechat
email: string; // email
areaId: number; // 所在地
areaName?: string; // 所在地名称
detailAddress: string; // 详细地址
sex: number; // 性别
master: boolean; // 是否主联系人
post: string; // 职务
parentId: number; // 上级联系人编号
parentName?: string; // 上级联系人名称
remark: string; // 备注
creator: string; // 创建人
creatorName?: string; // 创建人名称
createTime: Date; // 创建时间
updateTime: Date; // 更新时间
}
/** 联系人商机关联请求 */
export interface ContactBusinessReq {
contactId: number;
businessIds: number[];
}
/** 商机联系人关联请求 */
export interface BusinessContactReq {
businessId: number;
contactIds: number[];
}
}
/** 查询联系人列表 */
export function getContactPage(params: PageParam) {
return requestClient.get<PageResult<CrmContactApi.Contact>>(
'/crm/contact/page',
{ params },
);
}
/** 查询联系人列表,基于指定客户 */
export function getContactPageByCustomer(params: PageParam) {
return requestClient.get<PageResult<CrmContactApi.Contact>>(
'/crm/contact/page-by-customer',
{ params },
);
}
/** 查询联系人列表,基于指定商机 */
export function getContactPageByBusiness(params: PageParam) {
return requestClient.get<PageResult<CrmContactApi.Contact>>(
'/crm/contact/page-by-business',
{ params },
);
}
/** 查询联系人详情 */
export function getContact(id: number) {
return requestClient.get<CrmContactApi.Contact>(`/crm/contact/get?id=${id}`);
}
/** 新增联系人 */
export function createContact(data: CrmContactApi.Contact) {
return requestClient.post('/crm/contact/create', data);
}
/** 修改联系人 */
export function updateContact(data: CrmContactApi.Contact) {
return requestClient.put('/crm/contact/update', data);
}
/** 删除联系人 */
export function deleteContact(id: number) {
return requestClient.delete(`/crm/contact/delete?id=${id}`);
}
/** 导出联系人 */
export function exportContact(params: any) {
return requestClient.download('/crm/contact/export-excel', params);
}
/** 获得联系人列表(精简) */
export function getSimpleContactList() {
return requestClient.get<CrmContactApi.Contact[]>(
'/crm/contact/simple-all-list',
);
}
/** 批量新增联系人商机关联 */
export function createContactBusinessList(
data: CrmContactApi.ContactBusinessReq,
) {
return requestClient.post('/crm/contact/create-business-list', data);
}
/** 批量新增商机联系人关联 */
export function createBusinessContactList(
data: CrmContactApi.BusinessContactReq,
) {
return requestClient.post('/crm/contact/create-business-list2', data);
}
/** 解除联系人商机关联 */
export function deleteContactBusinessList(
data: CrmContactApi.ContactBusinessReq,
) {
return requestClient.delete('/crm/contact/delete-business-list', { data });
}
/** 解除商机联系人关联 */
export function deleteBusinessContactList(
data: CrmContactApi.BusinessContactReq,
) {
return requestClient.delete('/crm/contact/delete-business-list2', { data });
}
/** 联系人转移 */
export function transferContact(data: CrmPermissionApi.TransferReq) {
return requestClient.put('/crm/contact/transfer', data);
}

View File

@@ -1,21 +0,0 @@
import { requestClient } from '#/api/request';
export namespace CrmContractConfigApi {
/** 合同配置信息 */
export interface Config {
notifyEnabled?: boolean;
notifyDays?: number;
}
}
/** 获取合同配置 */
export function getContractConfig() {
return requestClient.get<CrmContractConfigApi.Config>(
'/crm/contract-config/get',
);
}
/** 更新合同配置 */
export function saveContractConfig(data: CrmContractConfigApi.Config) {
return requestClient.put('/crm/contract-config/save', data);
}

View File

@@ -1,132 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import type { CrmPermissionApi } from '#/api/crm/permission';
import { requestClient } from '#/api/request';
export namespace CrmContractApi {
/** 合同产品信息 */
export interface ContractProduct {
id: number;
productId: number;
productName: string;
productNo: string;
productUnit: number;
productPrice: number;
contractPrice: number;
count: number;
totalPrice: number;
}
/** 合同信息 */
export interface Contract {
id: number;
name: string;
no: string;
customerId: number;
customerName?: string;
businessId: number;
businessName: string;
contactLastTime: Date;
ownerUserId: number;
ownerUserName?: string;
ownerUserDeptName?: string;
processInstanceId: number;
auditStatus: number;
orderDate: Date;
startTime: Date;
endTime: Date;
totalProductPrice: number;
discountPercent: number;
totalPrice: number;
totalReceivablePrice: number;
signContactId: number;
signContactName?: string;
signUserId: number;
signUserName: string;
remark: string;
createTime?: Date;
creator: string;
creatorName: string;
updateTime?: Date;
products?: ContractProduct[];
}
}
/** 查询合同列表 */
export function getContractPage(params: PageParam) {
return requestClient.get<PageResult<CrmContractApi.Contract>>(
'/crm/contract/page',
{ params },
);
}
/** 查询合同列表,基于指定客户 */
export function getContractPageByCustomer(params: PageParam) {
return requestClient.get<PageResult<CrmContractApi.Contract>>(
'/crm/contract/page-by-customer',
{ params },
);
}
/** 查询合同列表,基于指定商机 */
export function getContractPageByBusiness(params: PageParam) {
return requestClient.get<PageResult<CrmContractApi.Contract>>(
'/crm/contract/page-by-business',
{ params },
);
}
/** 查询合同详情 */
export function getContract(id: number) {
return requestClient.get<CrmContractApi.Contract>(
`/crm/contract/get?id=${id}`,
);
}
/** 查询合同下拉列表 */
export function getContractSimpleList(customerId: number) {
return requestClient.get<CrmContractApi.Contract[]>(
`/crm/contract/simple-list?customerId=${customerId}`,
);
}
/** 新增合同 */
export function createContract(data: CrmContractApi.Contract) {
return requestClient.post('/crm/contract/create', data);
}
/** 修改合同 */
export function updateContract(data: CrmContractApi.Contract) {
return requestClient.put('/crm/contract/update', data);
}
/** 删除合同 */
export function deleteContract(id: number) {
return requestClient.delete(`/crm/contract/delete?id=${id}`);
}
/** 导出合同 */
export function exportContract(params: any) {
return requestClient.download('/crm/contract/export-excel', params);
}
/** 提交审核 */
export function submitContract(id: number) {
return requestClient.put(`/crm/contract/submit?id=${id}`);
}
/** 合同转移 */
export function transferContract(data: CrmPermissionApi.TransferReq) {
return requestClient.put('/crm/contract/transfer', data);
}
/** 获得待审核合同数量 */
export function getAuditContractCount() {
return requestClient.get<number>('/crm/contract/audit-count');
}
/** 获得即将到期(提醒)的合同数量 */
export function getRemindContractCount() {
return requestClient.get<number>('/crm/contract/remind-count');
}

View File

@@ -1,150 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import type { CrmPermissionApi } from '#/api/crm/permission';
import { requestClient } from '#/api/request';
export namespace CrmCustomerApi {
/** 客户信息 */
export interface Customer {
id: number; // 编号
name: string; // 客户名称
followUpStatus: boolean; // 跟进状态
contactLastTime: Date; // 最后跟进时间
contactLastContent: string; // 最后跟进内容
contactNextTime: Date; // 下次联系时间
ownerUserId: number; // 负责人的用户编号
ownerUserName?: string; // 负责人的用户名称
ownerUserDept?: string; // 负责人的部门名称
lockStatus?: boolean;
dealStatus?: boolean;
mobile: string; // 手机号
telephone: string; // 电话
qq: string; // QQ
wechat: string; // wechat
email: string; // email
areaId: number; // 所在地
areaName?: string; // 所在地名称
detailAddress: string; // 详细地址
industryId: number; // 所属行业
level: number; // 客户等级
source: number; // 客户来源
remark: string; // 备注
creator: string; // 创建人
creatorName?: string; // 创建人名称
createTime: Date; // 创建时间
updateTime: Date; // 更新时间
}
export interface CustomerImport {
ownerUserId: number;
file: File;
updateSupport: boolean;
}
}
/** 查询客户列表 */
export function getCustomerPage(params: PageParam) {
return requestClient.get<PageResult<CrmCustomerApi.Customer>>(
'/crm/customer/page',
{ params },
);
}
/** 查询客户详情 */
export function getCustomer(id: number) {
return requestClient.get<CrmCustomerApi.Customer>(
`/crm/customer/get?id=${id}`,
);
}
/** 新增客户 */
export function createCustomer(data: CrmCustomerApi.Customer) {
return requestClient.post('/crm/customer/create', data);
}
/** 修改客户 */
export function updateCustomer(data: CrmCustomerApi.Customer) {
return requestClient.put('/crm/customer/update', data);
}
/** 删除客户 */
export function deleteCustomer(id: number) {
return requestClient.delete(`/crm/customer/delete?id=${id}`);
}
/** 导出客户 */
export function exportCustomer(params: any) {
return requestClient.download('/crm/customer/export-excel', params);
}
/** 下载客户导入模板 */
export function importCustomerTemplate() {
return requestClient.download('/crm/customer/get-import-template');
}
/** 导入客户 */
export function importCustomer(data: CrmCustomerApi.CustomerImport) {
return requestClient.upload('/crm/customer/import', data);
}
/** 获取客户精简信息列表 */
export function getCustomerSimpleList() {
return requestClient.get<CrmCustomerApi.Customer[]>(
'/crm/customer/simple-list',
);
}
/** 客户转移 */
export function transferCustomer(data: CrmPermissionApi.TransferReq) {
return requestClient.put('/crm/customer/transfer', data);
}
/** 锁定/解锁客户 */
export function lockCustomer(id: number, lockStatus: boolean) {
return requestClient.put('/crm/customer/lock', { id, lockStatus });
}
/** 领取公海客户 */
export function receiveCustomer(ids: number[]) {
return requestClient.put('/crm/customer/receive', { ids: ids.join(',') });
}
/** 分配公海给对应负责人 */
export function distributeCustomer(ids: number[], ownerUserId: number) {
return requestClient.put('/crm/customer/distribute', { ids, ownerUserId });
}
/** 客户放入公海 */
export function putCustomerPool(id: number) {
return requestClient.put(`/crm/customer/put-pool?id=${id}`);
}
/** 更新客户的成交状态 */
export function updateCustomerDealStatus(id: number, dealStatus: boolean) {
return requestClient.put(
`/crm/customer/update-deal-status?id=${id}&dealStatus=${dealStatus}`,
);
}
/** 进入公海客户提醒的客户列表 */
export function getPutPoolRemindCustomerPage(params: PageParam) {
return requestClient.get<PageResult<CrmCustomerApi.Customer>>(
'/crm/customer/put-pool-remind-page',
{ params },
);
}
/** 获得待进入公海客户数量 */
export function getPutPoolRemindCustomerCount() {
return requestClient.get<number>('/crm/customer/put-pool-remind-count');
}
/** 获得今日需联系客户数量 */
export function getTodayContactCustomerCount() {
return requestClient.get<number>('/crm/customer/today-contact-count');
}
/** 获得分配给我、待跟进的线索数量的客户数量 */
export function getFollowCustomerCount() {
return requestClient.get<number>('/crm/customer/follow-count');
}

View File

@@ -1,56 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace CrmCustomerLimitConfigApi {
/** 客户限制配置 */
export interface CustomerLimitConfig {
id?: number;
type?: number;
userIds?: string;
deptIds?: string;
maxCount?: number;
dealCountEnabled?: boolean;
}
}
/** 客户限制配置类型 */
export enum LimitConfType {
/** 锁定客户数限制 */
CUSTOMER_LOCK_LIMIT = 2,
/** 拥有客户数限制 */
CUSTOMER_QUANTITY_LIMIT = 1,
}
/** 查询客户限制配置列表 */
export function getCustomerLimitConfigPage(params: PageParam) {
return requestClient.get<
PageResult<CrmCustomerLimitConfigApi.CustomerLimitConfig>
>('/crm/customer-limit-config/page', { params });
}
/** 查询客户限制配置详情 */
export function getCustomerLimitConfig(id: number) {
return requestClient.get<CrmCustomerLimitConfigApi.CustomerLimitConfig>(
`/crm/customer-limit-config/get?id=${id}`,
);
}
/** 新增客户限制配置 */
export function createCustomerLimitConfig(
data: CrmCustomerLimitConfigApi.CustomerLimitConfig,
) {
return requestClient.post('/crm/customer-limit-config/create', data);
}
/** 修改客户限制配置 */
export function updateCustomerLimitConfig(
data: CrmCustomerLimitConfigApi.CustomerLimitConfig,
) {
return requestClient.put('/crm/customer-limit-config/update', data);
}
/** 删除客户限制配置 */
export function deleteCustomerLimitConfig(id: number) {
return requestClient.delete(`/crm/customer-limit-config/delete?id=${id}`);
}

View File

@@ -1,26 +0,0 @@
import { requestClient } from '#/api/request';
export namespace CrmCustomerPoolConfigApi {
/** 客户公海规则设置 */
export interface CustomerPoolConfig {
enabled?: boolean;
contactExpireDays?: number;
dealExpireDays?: number;
notifyEnabled?: boolean;
notifyDays?: number;
}
}
/** 获取客户公海规则设置 */
export function getCustomerPoolConfig() {
return requestClient.get<CrmCustomerPoolConfigApi.CustomerPoolConfig>(
'/crm/customer-pool-config/get',
);
}
/** 更新客户公海规则设置 */
export function saveCustomerPoolConfig(
data: CrmCustomerPoolConfigApi.CustomerPoolConfig,
) {
return requestClient.put('/crm/customer-pool-config/save', data);
}

View File

@@ -1,53 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace CrmFollowUpApi {
/** 关联商机信息 */
export interface Business {
id: number;
name: string;
}
/** 关联联系人信息 */
export interface Contact {
id: number;
name: string;
}
/** 跟进记录信息 */
export interface FollowUpRecord {
id: number; // 编号
bizType: number; // 数据类型
bizId: number; // 数据编号
type: number; // 跟进类型
content: string; // 跟进内容
picUrls: string[]; // 图片
fileUrls: string[]; // 附件
nextTime: Date; // 下次联系时间
businessIds: number[]; // 关联的商机编号数组
businesses: Business[]; // 关联的商机数组
contactIds: number[]; // 关联的联系人编号数组
contacts: Contact[]; // 关联的联系人数组
creator: string;
creatorName?: string;
}
}
/** 查询跟进记录分页 */
export function getFollowUpRecordPage(params: PageParam) {
return requestClient.get<PageResult<CrmFollowUpApi.FollowUpRecord>>(
'/crm/follow-up-record/page',
{ params },
);
}
/** 新增跟进记录 */
export function createFollowUpRecord(data: CrmFollowUpApi.FollowUpRecord) {
return requestClient.post('/crm/follow-up-record/create', data);
}
/** 删除跟进记录 */
export function deleteFollowUpRecord(id: number) {
return requestClient.delete(`/crm/follow-up-record/delete?id=${id}`);
}

View File

@@ -1,33 +0,0 @@
import type { PageResult } from '@vben/request';
import type { SystemOperateLogApi } from '#/api/system/operate-log';
import { requestClient } from '#/api/request';
export namespace CrmOperateLogApi {
/** 操作日志查询参数 */
export interface OperateLogQuery {
bizType: number;
bizId: number;
}
/** 操作日志信息 */
export interface OperateLog {
id: number;
bizType: number;
bizId: number;
type: number;
content: string;
creator: string;
creatorName?: string;
createTime: Date;
}
}
/** 获得操作日志 */
export function getOperateLogPage(params: CrmOperateLogApi.OperateLogQuery) {
return requestClient.get<PageResult<SystemOperateLogApi.OperateLog>>(
'/crm/operate-log/page',
{ params },
);
}

View File

@@ -1,82 +0,0 @@
import { requestClient } from '#/api/request';
export namespace CrmPermissionApi {
/** 数据权限信息 */
export interface Permission {
id?: number; // 数据权限编号
ids?: number[];
userId?: number; // 用户编号
bizType: number; // Crm 类型
bizId: number; // Crm 类型数据编号
level: number; // 权限级别
toBizTypes?: number[]; // 同时添加至
deptName?: string; // 部门名称
nickname?: string; // 用户昵称
postNames?: string[]; // 岗位名称数组
createTime?: Date;
}
/** 数据权限转移请求 */
export interface TransferReq {
id: number; // 模块编号
newOwnerUserId: number; // 新负责人的用户编号
oldOwnerPermissionLevel?: number; // 老负责人加入团队后的权限级别
toBizTypes?: number[]; // 转移客户时,需要额外有【联系人】【商机】【合同】的 checkbox 选择
}
export interface PermissionListReq {
bizId: number; // 模块数据编号
bizType: number; // 模块类型
}
}
/**
* CRM 业务类型枚举
*/
export enum BizTypeEnum {
CRM_BUSINESS = 4, // 商机
CRM_CLUE = 1, // 线索
CRM_CONTACT = 3, // 联系人
CRM_CONTRACT = 5, // 合同
CRM_CUSTOMER = 2, // 客户
CRM_PRODUCT = 6, // 产品
CRM_RECEIVABLE = 7, // 回款
CRM_RECEIVABLE_PLAN = 8, // 回款计划
}
/**
* CRM 数据权限级别枚举
*/
export enum PermissionLevelEnum {
OWNER = 1, // 负责人
READ = 2, // 只读
WRITE = 3, // 读写
}
/** 获得数据权限列表(查询团队成员列表) */
export function getPermissionList(params: CrmPermissionApi.PermissionListReq) {
return requestClient.get<CrmPermissionApi.Permission[]>(
'/crm/permission/list',
{ params },
);
}
/** 创建数据权限(新增团队成员) */
export function createPermission(data: CrmPermissionApi.Permission) {
return requestClient.post('/crm/permission/create', data);
}
/** 编辑数据权限(修改团队成员权限级别) */
export function updatePermission(data: CrmPermissionApi.Permission) {
return requestClient.put('/crm/permission/update', data);
}
/** 删除数据权限(删除团队成员) */
export function deletePermissionBatch(ids: number[]) {
return requestClient.delete(`/crm/permission/delete?ids=${ids.join(',')}`);
}
/** 删除自己的数据权限(退出团队) */
export function deleteSelfPermission(id: number) {
return requestClient.delete(`/crm/permission/delete-self?id=${id}`);
}

View File

@@ -1,44 +0,0 @@
import { requestClient } from '#/api/request';
export namespace CrmProductCategoryApi {
/** 产品分类信息 */
export interface ProductCategory {
id: number;
name: string;
parentId: number;
}
}
/** 查询产品分类详情 */
export function getProductCategory(id: number) {
return requestClient.get<CrmProductCategoryApi.ProductCategory>(
`/crm/product-category/get?id=${id}`,
);
}
/** 新增产品分类 */
export function createProductCategory(
data: CrmProductCategoryApi.ProductCategory,
) {
return requestClient.post('/crm/product-category/create', data);
}
/** 修改产品分类 */
export function updateProductCategory(
data: CrmProductCategoryApi.ProductCategory,
) {
return requestClient.put('/crm/product-category/update', data);
}
/** 删除产品分类 */
export function deleteProductCategory(id: number) {
return requestClient.delete(`/crm/product-category/delete?id=${id}`);
}
/** 产品分类列表 */
export function getProductCategoryList(params?: any) {
return requestClient.get<CrmProductCategoryApi.ProductCategory[]>(
'/crm/product-category/list',
{ params },
);
}

View File

@@ -1,57 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace CrmProductApi {
/** 产品信息 */
export interface Product {
id: number;
name: string;
no: string;
unit: number;
price: number;
status: number;
categoryId: number;
categoryName?: string;
description: string;
ownerUserId: number;
}
}
/** 查询产品列表 */
export function getProductPage(params: PageParam) {
return requestClient.get<PageResult<CrmProductApi.Product>>(
'/crm/product/page',
{ params },
);
}
/** 获得产品精简列表 */
export function getProductSimpleList() {
return requestClient.get<CrmProductApi.Product[]>('/crm/product/simple-list');
}
/** 查询产品详情 */
export function getProduct(id: number) {
return requestClient.get<CrmProductApi.Product>(`/crm/product/get?id=${id}`);
}
/** 新增产品 */
export function createProduct(data: CrmProductApi.Product) {
return requestClient.post('/crm/product/create', data);
}
/** 修改产品 */
export function updateProduct(data: CrmProductApi.Product) {
return requestClient.put('/crm/product/update', data);
}
/** 删除产品 */
export function deleteProduct(id: number) {
return requestClient.delete(`/crm/product/delete?id=${id}`);
}
/** 导出产品 */
export function exportProduct(params: any) {
return requestClient.download('/crm/product/export-excel', params);
}

View File

@@ -1,103 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace CrmReceivableApi {
/** 合同信息 */
export interface Contract {
id?: number;
name?: string;
no: string;
totalPrice: number;
}
/** 回款信息 */
export interface Receivable {
id: number;
no: string;
planId?: number;
period?: number;
customerId?: number;
customerName?: string;
contractId?: number;
contract?: Contract;
auditStatus: number;
processInstanceId: number;
returnTime: Date;
returnType: number;
price: number;
ownerUserId: number;
ownerUserName?: string;
remark: string;
creator: string; // 创建人
creatorName?: string; // 创建人名称
createTime: Date; // 创建时间
updateTime: Date; // 更新时间
}
export interface ReceivablePageParam extends PageParam {
no?: string;
planId?: number;
customerId?: number;
contractId?: number;
sceneType?: number;
auditStatus?: number;
}
}
/** 查询回款列表 */
export function getReceivablePage(
params: CrmReceivableApi.ReceivablePageParam,
) {
return requestClient.get<PageResult<CrmReceivableApi.Receivable>>(
'/crm/receivable/page',
{ params },
);
}
/** 查询回款列表,基于指定客户 */
export function getReceivablePageByCustomer(
params: CrmReceivableApi.ReceivablePageParam,
) {
return requestClient.get<PageResult<CrmReceivableApi.Receivable>>(
'/crm/receivable/page-by-customer',
{ params },
);
}
/** 查询回款详情 */
export function getReceivable(id: number) {
return requestClient.get<CrmReceivableApi.Receivable>(
`/crm/receivable/get?id=${id}`,
);
}
/** 新增回款 */
export function createReceivable(data: CrmReceivableApi.Receivable) {
return requestClient.post('/crm/receivable/create', data);
}
/** 修改回款 */
export function updateReceivable(data: CrmReceivableApi.Receivable) {
return requestClient.put('/crm/receivable/update', data);
}
/** 删除回款 */
export function deleteReceivable(id: number) {
return requestClient.delete(`/crm/receivable/delete?id=${id}`);
}
/** 导出回款 */
export function exportReceivable(params: any) {
return requestClient.download('/crm/receivable/export-excel', params);
}
/** 提交审核 */
export function submitReceivable(id: number) {
return requestClient.put(`/crm/receivable/submit?id=${id}`);
}
/** 获得待审核回款数量 */
export function getAuditReceivableCount() {
return requestClient.get<number>('/crm/receivable/audit-count');
}

View File

@@ -1,110 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace CrmReceivablePlanApi {
/** 回款计划信息 */
export interface Plan {
id: number;
period: number;
receivableId: number;
price: number;
returnTime: Date;
remindDays: number;
returnType: number;
remindTime: Date;
customerId: number;
customerName?: string;
contractId?: number;
contractNo?: string;
ownerUserId: number;
ownerUserName?: string;
remark: string;
creator: string;
creatorName?: string;
createTime: Date;
updateTime: Date;
receivable?: {
price: number;
returnTime: Date;
};
}
export interface PlanPageParam extends PageParam {
customerId?: number;
contractId?: number;
contractNo?: string;
sceneType?: number;
remindType?: number;
}
}
/** 查询回款计划列表 */
export function getReceivablePlanPage(
params: CrmReceivablePlanApi.PlanPageParam,
) {
return requestClient.get<PageResult<CrmReceivablePlanApi.Plan>>(
'/crm/receivable-plan/page',
{ params },
);
}
/** 查询回款计划列表(按客户) */
export function getReceivablePlanPageByCustomer(
params: CrmReceivablePlanApi.PlanPageParam,
) {
return requestClient.get<PageResult<CrmReceivablePlanApi.Plan>>(
'/crm/receivable-plan/page-by-customer',
{ params },
);
}
/** 查询回款计划详情 */
export function getReceivablePlan(id: number) {
return requestClient.get<CrmReceivablePlanApi.Plan>(
'/crm/receivable-plan/get',
{ params: { id } },
);
}
/** 查询回款计划下拉数据 */
export function getReceivablePlanSimpleList(
customerId: number,
contractId: number,
) {
return requestClient.get<CrmReceivablePlanApi.Plan[]>(
'/crm/receivable-plan/simple-list',
{
params: { customerId, contractId },
},
);
}
/** 新增回款计划 */
export function createReceivablePlan(data: CrmReceivablePlanApi.Plan) {
return requestClient.post('/crm/receivable-plan/create', data);
}
/** 修改回款计划 */
export function updateReceivablePlan(data: CrmReceivablePlanApi.Plan) {
return requestClient.put('/crm/receivable-plan/update', data);
}
/** 删除回款计划 */
export function deleteReceivablePlan(id: number) {
return requestClient.delete('/crm/receivable-plan/delete', {
params: { id },
});
}
/** 导出回款计划 Excel */
export function exportReceivablePlan(params: PageParam) {
return requestClient.download('/crm/receivable-plan/export-excel', {
params,
});
}
/** 获得待回款提醒数量 */
export function getReceivablePlanRemindCount() {
return requestClient.get<number>('/crm/receivable-plan/remind-count');
}

View File

@@ -1,285 +0,0 @@
import { requestClient } from '#/api/request';
export namespace CrmStatisticsCustomerApi {
/** 客户总量分析(按日期) */
export interface CustomerSummaryByDate {
time: string;
customerCreateCount: number;
customerDealCount: number;
}
/** 客户总量分析(按用户) */
export interface CustomerSummaryByUser {
ownerUserName: string;
customerCreateCount: number;
customerDealCount: number;
contractPrice: number;
receivablePrice: number;
}
/** 客户跟进次数分析(按日期) */
export interface FollowUpSummaryByDate {
time: string;
followUpRecordCount: number;
followUpCustomerCount: number;
}
/** 客户跟进次数分析(按用户) */
export interface FollowUpSummaryByUser {
ownerUserName: string;
followupRecordCount: number;
followupCustomerCount: number;
}
/** 客户跟进方式统计 */
export interface FollowUpSummaryByType {
followUpType: string;
followUpRecordCount: number;
}
/** 合同摘要信息 */
export interface CustomerContractSummary {
customerName: string;
contractName: string;
totalPrice: number;
receivablePrice: number;
customerType: string;
customerSource: string;
ownerUserName: string;
creatorUserName: string;
createTime: Date;
orderDate: Date;
}
/** 客户公海分析(按日期) */
export interface PoolSummaryByDate {
time: string;
customerPutCount: number;
customerTakeCount: number;
}
/** 客户公海分析(按用户) */
export interface PoolSummaryByUser {
ownerUserName: string;
customerPutCount: number;
customerTakeCount: number;
}
/** 客户成交周期(按日期) */
export interface CustomerDealCycleByDate {
time: string;
customerDealCycle: number;
}
/** 客户成交周期(按用户) */
export interface CustomerDealCycleByUser {
ownerUserName: string;
customerDealCycle: number;
customerDealCount: number;
}
/** 客户成交周期(按地区) */
export interface CustomerDealCycleByArea {
areaName: string;
customerDealCycle: number;
customerDealCount: number;
}
/** 客户成交周期(按产品) */
export interface CustomerDealCycleByProduct {
productName: string;
customerDealCycle: number;
customerDealCount: number;
}
export interface CustomerSummaryParams {
times: string[];
interval: number;
deptId: number;
userId: number;
userIds: number[];
}
}
export function getDatas(activeTabName: any, params: any) {
switch (activeTabName) {
case 'conversionStat': {
return getContractSummary(params);
}
case 'customerSummary': {
return getCustomerSummaryByUser(params);
}
case 'dealCycleByArea': {
return getCustomerDealCycleByArea(params);
}
case 'dealCycleByProduct': {
return getCustomerDealCycleByProduct(params);
}
case 'dealCycleByUser': {
return getCustomerDealCycleByUser(params);
}
case 'followUpSummary': {
return getFollowUpSummaryByUser(params);
}
case 'followUpType': {
return getFollowUpSummaryByType(params);
}
case 'poolSummary': {
return getPoolSummaryByUser(params);
}
default: {
return [];
}
}
}
export function getChartDatas(activeTabName: any, params: any) {
switch (activeTabName) {
case 'conversionStat': {
return getCustomerSummaryByDate(params);
}
case 'customerSummary': {
return getCustomerSummaryByDate(params);
}
case 'dealCycleByArea': {
return getCustomerDealCycleByArea(params);
}
case 'dealCycleByProduct': {
return getCustomerDealCycleByProduct(params);
}
case 'dealCycleByUser': {
return getCustomerDealCycleByUser(params);
}
case 'followUpSummary': {
return getFollowUpSummaryByDate(params);
}
case 'followUpType': {
return getFollowUpSummaryByType(params);
}
case 'poolSummary': {
return getPoolSummaryByDate(params);
}
default: {
return [];
}
}
}
/** 客户总量分析(按日期) */
export function getCustomerSummaryByDate(
params: CrmStatisticsCustomerApi.CustomerSummaryParams,
) {
return requestClient.get<CrmStatisticsCustomerApi.CustomerSummaryByDate[]>(
'/crm/statistics-customer/get-customer-summary-by-date',
{ params },
);
}
/** 客户总量分析(按用户) */
export function getCustomerSummaryByUser(
params: CrmStatisticsCustomerApi.CustomerSummaryParams,
) {
return requestClient.get<CrmStatisticsCustomerApi.CustomerSummaryByUser[]>(
'/crm/statistics-customer/get-customer-summary-by-user',
{ params },
);
}
/** 客户跟进次数分析(按日期) */
export function getFollowUpSummaryByDate(
params: CrmStatisticsCustomerApi.CustomerSummaryParams,
) {
return requestClient.get<CrmStatisticsCustomerApi.FollowUpSummaryByDate[]>(
'/crm/statistics-customer/get-follow-up-summary-by-date',
{ params },
);
}
/** 客户跟进次数分析(按用户) */
export function getFollowUpSummaryByUser(
params: CrmStatisticsCustomerApi.CustomerSummaryParams,
) {
return requestClient.get<CrmStatisticsCustomerApi.FollowUpSummaryByUser[]>(
'/crm/statistics-customer/get-follow-up-summary-by-user',
{ params },
);
}
/** 获取客户跟进方式统计数 */
export function getFollowUpSummaryByType(
params: CrmStatisticsCustomerApi.CustomerSummaryParams,
) {
return requestClient.get<CrmStatisticsCustomerApi.FollowUpSummaryByType[]>(
'/crm/statistics-customer/get-follow-up-summary-by-type',
{ params },
);
}
/** 合同摘要信息(客户转化率页面) */
export function getContractSummary(
params: CrmStatisticsCustomerApi.CustomerSummaryParams,
) {
return requestClient.get<CrmStatisticsCustomerApi.CustomerContractSummary[]>(
'/crm/statistics-customer/get-contract-summary',
{ params },
);
}
/** 获取客户公海分析(按日期) */
export function getPoolSummaryByDate(
params: CrmStatisticsCustomerApi.CustomerSummaryParams,
) {
return requestClient.get<CrmStatisticsCustomerApi.PoolSummaryByDate[]>(
'/crm/statistics-customer/get-pool-summary-by-date',
{ params },
);
}
/** 获取客户公海分析(按用户) */
export function getPoolSummaryByUser(
params: CrmStatisticsCustomerApi.CustomerSummaryParams,
) {
return requestClient.get<CrmStatisticsCustomerApi.PoolSummaryByUser[]>(
'/crm/statistics-customer/get-pool-summary-by-user',
{ params },
);
}
/** 获取客户成交周期(按日期) */
export function getCustomerDealCycleByDate(
params: CrmStatisticsCustomerApi.CustomerSummaryParams,
) {
return requestClient.get<CrmStatisticsCustomerApi.CustomerDealCycleByDate[]>(
'/crm/statistics-customer/get-customer-deal-cycle-by-date',
{ params },
);
}
/** 获取客户成交周期(按用户) */
export function getCustomerDealCycleByUser(
params: CrmStatisticsCustomerApi.CustomerSummaryParams,
) {
return requestClient.get<CrmStatisticsCustomerApi.CustomerDealCycleByUser[]>(
'/crm/statistics-customer/get-customer-deal-cycle-by-user',
{ params },
);
}
/** 获取客户成交周期(按地区) */
export function getCustomerDealCycleByArea(
params: CrmStatisticsCustomerApi.CustomerSummaryParams,
) {
return requestClient.get<CrmStatisticsCustomerApi.CustomerDealCycleByArea[]>(
'/crm/statistics-customer/get-customer-deal-cycle-by-area',
{ params },
);
}
/** 获取客户成交周期(按产品) */
export function getCustomerDealCycleByProduct(
params: CrmStatisticsCustomerApi.CustomerSummaryParams,
) {
return requestClient.get<
CrmStatisticsCustomerApi.CustomerDealCycleByProduct[]
>('/crm/statistics-customer/get-customer-deal-cycle-by-product', { params });
}

View File

@@ -1,101 +0,0 @@
import type { PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace CrmStatisticsFunnelApi {
/** 销售漏斗统计数据 */
export interface FunnelSummary {
customerCount: number; // 客户数
businessCount: number; // 商机数
businessWinCount: number; // 赢单数
}
/** 商机分析(按日期) */
export interface BusinessSummaryByDate {
time: string; // 时间
businessCreateCount: number; // 商机数
totalPrice: number | string; // 商机金额
}
/** 商机转化率分析(按日期) */
export interface BusinessInversionRateSummaryByDate {
time: string; // 时间
businessCount: number; // 商机数量
businessWinCount: number; // 赢单商机数
}
}
export function getDatas(activeTabName: any, params: any) {
switch (activeTabName) {
case 'businessInversionRateSummary': {
return getBusinessPageByDate(params);
}
case 'businessSummary': {
return getBusinessPageByDate(params);
}
case 'funnel': {
return getBusinessSummaryByEndStatus(params);
}
default: {
return [];
}
}
}
export function getChartDatas(activeTabName: any, params: any) {
switch (activeTabName) {
case 'businessInversionRateSummary': {
return getBusinessInversionRateSummaryByDate(params);
}
case 'businessSummary': {
return getBusinessSummaryByDate(params);
}
case 'funnel': {
return getFunnelSummary(params);
}
default: {
return [];
}
}
}
/** 获取销售漏斗统计数据 */
export function getFunnelSummary(params: any) {
return requestClient.get<CrmStatisticsFunnelApi.FunnelSummary>(
'/crm/statistics-funnel/get-funnel-summary',
{ params },
);
}
/** 获取商机结束状态统计 */
export function getBusinessSummaryByEndStatus(params: any) {
return requestClient.get<Record<string, number>>(
'/crm/statistics-funnel/get-business-summary-by-end-status',
{ params },
);
}
/** 获取新增商机分析(按日期) */
export function getBusinessSummaryByDate(params: any) {
return requestClient.get<CrmStatisticsFunnelApi.BusinessSummaryByDate[]>(
'/crm/statistics-funnel/get-business-summary-by-date',
{ params },
);
}
/** 获取商机转化率分析(按日期) */
export function getBusinessInversionRateSummaryByDate(params: any) {
return requestClient.get<
CrmStatisticsFunnelApi.BusinessInversionRateSummaryByDate[]
>('/crm/statistics-funnel/get-business-inversion-rate-summary-by-date', {
params,
});
}
/** 获取商机列表(按日期) */
export function getBusinessPageByDate(params: any) {
return requestClient.get<PageResult<any>>(
'/crm/statistics-funnel/get-business-page-by-date',
{ params },
);
}

View File

@@ -1,46 +0,0 @@
import { requestClient } from '#/api/request';
export namespace CrmStatisticsPerformanceApi {
/** 员工业绩统计 */
export interface Performance {
time: string;
currentMonthCount: number;
lastMonthCount: number;
lastYearCount: number;
}
export interface PerformanceParams {
times: string[];
deptId: number;
userId: number;
}
}
/** 员工获得合同金额统计 */
export function getContractPricePerformance(
params: CrmStatisticsPerformanceApi.PerformanceParams,
) {
return requestClient.get<CrmStatisticsPerformanceApi.Performance[]>(
'/crm/statistics-performance/get-contract-price-performance',
{ params },
);
}
/** 员工获得回款统计 */
export function getReceivablePricePerformance(
params: CrmStatisticsPerformanceApi.PerformanceParams,
) {
return requestClient.get<CrmStatisticsPerformanceApi.Performance[]>(
'/crm/statistics-performance/get-receivable-price-performance',
{ params },
);
}
/** 员工获得签约合同数量统计 */
export function getContractCountPerformance(
params: CrmStatisticsPerformanceApi.PerformanceParams,
) {
return requestClient.get<CrmStatisticsPerformanceApi.Performance[]>(
'/crm/statistics-performance/get-contract-count-performance',
{ params },
);
}

View File

@@ -1,89 +0,0 @@
import type { PageParam } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace CrmStatisticsPortraitApi {
/** 客户基础统计信息 */
export interface CustomerBase {
customerCount: number;
dealCount: number;
dealPortion: number | string;
}
/** 客户行业统计信息 */
export interface CustomerIndustry extends CustomerBase {
industryId: number;
industryPortion: number | string;
}
/** 客户来源统计信息 */
export interface CustomerSource extends CustomerBase {
source: number;
sourcePortion: number | string;
}
/** 客户级别统计信息 */
export interface CustomerLevel extends CustomerBase {
level: number;
levelPortion: number | string;
}
/** 客户地区统计信息 */
export interface CustomerArea extends CustomerBase {
areaId: number;
areaName: string;
areaPortion: number | string;
}
}
export function getDatas(activeTabName: any, params: any) {
switch (activeTabName) {
case 'area': {
return getCustomerArea(params);
}
case 'industry': {
return getCustomerIndustry(params);
}
case 'level': {
return getCustomerLevel(params);
}
case 'source': {
return getCustomerSource(params);
}
default: {
return [];
}
}
}
/** 获取客户行业统计数据 */
export function getCustomerIndustry(params: PageParam) {
return requestClient.get<CrmStatisticsPortraitApi.CustomerIndustry[]>(
'/crm/statistics-portrait/get-customer-industry-summary',
{ params },
);
}
/** 获取客户来源统计数据 */
export function getCustomerSource(params: PageParam) {
return requestClient.get<CrmStatisticsPortraitApi.CustomerSource[]>(
'/crm/statistics-portrait/get-customer-source-summary',
{ params },
);
}
/** 获取客户级别统计数据 */
export function getCustomerLevel(params: PageParam) {
return requestClient.get<CrmStatisticsPortraitApi.CustomerLevel[]>(
'/crm/statistics-portrait/get-customer-level-summary',
{ params },
);
}
/** 获取客户地区统计数据 */
export function getCustomerArea(params: PageParam) {
return requestClient.get<CrmStatisticsPortraitApi.CustomerArea[]>(
'/crm/statistics-portrait/get-customer-area-summary',
{ params },
);
}

View File

@@ -1,108 +0,0 @@
import type { PageParam } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace CrmStatisticsRankApi {
/** 排行统计数据 */
export interface Rank {
count: number;
nickname: string;
deptName: string;
}
}
export function getDatas(activeTabName: any, params: any) {
switch (activeTabName) {
case 'contactCountRank': {
return getContactsCountRank(params);
}
case 'contractCountRank': {
return getContractCountRank(params);
}
case 'contractPriceRank': {
return getContractPriceRank(params);
}
case 'customerCountRank': {
return getCustomerCountRank(params);
}
case 'followCountRank': {
return getFollowCountRank(params);
}
case 'followCustomerCountRank': {
return getFollowCustomerCountRank(params);
}
case 'productSalesRank': {
return getProductSalesRank(params);
}
case 'receivablePriceRank': {
return getReceivablePriceRank(params);
}
default: {
return [];
}
}
}
/** 获得合同排行榜 */
export function getContractPriceRank(params: PageParam) {
return requestClient.get<CrmStatisticsRankApi.Rank[]>(
'/crm/statistics-rank/get-contract-price-rank',
{ params },
);
}
/** 获得回款排行榜 */
export function getReceivablePriceRank(params: PageParam) {
return requestClient.get<CrmStatisticsRankApi.Rank[]>(
'/crm/statistics-rank/get-receivable-price-rank',
{ params },
);
}
/** 签约合同排行 */
export function getContractCountRank(params: PageParam) {
return requestClient.get<CrmStatisticsRankApi.Rank[]>(
'/crm/statistics-rank/get-contract-count-rank',
{ params },
);
}
/** 产品销量排行 */
export function getProductSalesRank(params: PageParam) {
return requestClient.get<CrmStatisticsRankApi.Rank[]>(
'/crm/statistics-rank/get-product-sales-rank',
{ params },
);
}
/** 新增客户数排行 */
export function getCustomerCountRank(params: PageParam) {
return requestClient.get<CrmStatisticsRankApi.Rank[]>(
'/crm/statistics-rank/get-customer-count-rank',
{ params },
);
}
/** 新增联系人数排行 */
export function getContactsCountRank(params: PageParam) {
return requestClient.get<CrmStatisticsRankApi.Rank[]>(
'/crm/statistics-rank/get-contacts-count-rank',
{ params },
);
}
/** 跟进次数排行 */
export function getFollowCountRank(params: PageParam) {
return requestClient.get<CrmStatisticsRankApi.Rank[]>(
'/crm/statistics-rank/get-follow-count-rank',
{ params },
);
}
/** 跟进客户数排行 */
export function getFollowCustomerCountRank(params: PageParam) {
return requestClient.get<CrmStatisticsRankApi.Rank[]>(
'/crm/statistics-rank/get-follow-customer-count-rank',
{ params },
);
}

View File

@@ -1 +0,0 @@
export * from './core';

View File

@@ -1,44 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace InfraApiAccessLogApi {
/** API 访问日志信息 */
export interface ApiAccessLog {
id: number;
traceId: string;
userId: number;
userType: number;
applicationName: string;
requestMethod: string;
requestParams: string;
responseBody: string;
requestUrl: string;
userIp: string;
userAgent: string;
operateModule: string;
operateName: string;
operateType: number;
beginTime: string;
endTime: string;
duration: number;
resultCode: number;
resultMsg: string;
createTime: string;
}
}
/** 查询 API 访问日志列表 */
export function getApiAccessLogPage(params: PageParam) {
return requestClient.get<PageResult<InfraApiAccessLogApi.ApiAccessLog>>(
'/infra/api-access-log/page',
{ params },
);
}
/** 导出 API 访问日志 */
export function exportApiAccessLog(params: any) {
return requestClient.download('/infra/api-access-log/export-excel', {
params,
});
}

View File

@@ -1,55 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace InfraApiErrorLogApi {
/** API 错误日志信息 */
export interface ApiErrorLog {
id: number;
traceId: string;
userId: number;
userType: number;
applicationName: string;
requestMethod: string;
requestParams: string;
requestUrl: string;
userIp: string;
userAgent: string;
exceptionTime: string;
exceptionName: string;
exceptionMessage: string;
exceptionRootCauseMessage: string;
exceptionStackTrace: string;
exceptionClassName: string;
exceptionFileName: string;
exceptionMethodName: string;
exceptionLineNumber: number;
processUserId: number;
processStatus: number;
processTime: string;
resultCode: number;
createTime: string;
}
}
/** 查询 API 错误日志列表 */
export function getApiErrorLogPage(params: PageParam) {
return requestClient.get<PageResult<InfraApiErrorLogApi.ApiErrorLog>>(
'/infra/api-error-log/page',
{ params },
);
}
/** 更新 API 错误日志的处理状态 */
export function updateApiErrorLogStatus(id: number, processStatus: number) {
return requestClient.put(
`/infra/api-error-log/update-status?id=${id}&processStatus=${processStatus}`,
);
}
/** 导出 API 错误日志 */
export function exportApiErrorLog(params: any) {
return requestClient.download('/infra/api-error-log/export-excel', {
params,
});
}

View File

@@ -1,155 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace InfraCodegenApi {
/** 代码生成表定义 */
export interface CodegenTable {
id: number;
tableId: number;
isParentMenuIdValid: boolean;
dataSourceConfigId: number;
scene: number;
tableName: string;
tableComment: string;
remark: string;
moduleName: string;
businessName: string;
className: string;
classComment: string;
author: string;
createTime: Date;
updateTime: Date;
templateType: number;
parentMenuId: number;
}
/** 代码生成字段定义 */
export interface CodegenColumn {
id: number;
tableId: number;
columnName: string;
dataType: string;
columnComment: string;
nullable: number;
primaryKey: number;
ordinalPosition: number;
javaType: string;
javaField: string;
dictType: string;
example: string;
createOperation: number;
updateOperation: number;
listOperation: number;
listOperationCondition: string;
listOperationResult: number;
htmlType: string;
}
/** 数据库表定义 */
export interface DatabaseTable {
name: string;
comment: string;
}
/** 代码生成详情 */
export interface CodegenDetail {
table: CodegenTable;
columns: CodegenColumn[];
}
/** 代码预览 */
export interface CodegenPreview {
filePath: string;
code: string;
}
/** 更新代码生成请求 */
export interface CodegenUpdateReq {
table: any | CodegenTable;
columns: CodegenColumn[];
}
/** 创建代码生成请求 */
export interface CodegenCreateListReq {
dataSourceConfigId?: number;
tableNames: string[];
}
}
/** 查询列表代码生成表定义 */
export function getCodegenTableList(dataSourceConfigId: number) {
return requestClient.get<InfraCodegenApi.CodegenTable[]>(
'/infra/codegen/table/list?',
{
params: { dataSourceConfigId },
},
);
}
/** 查询列表代码生成表定义 */
export function getCodegenTablePage(params: PageParam) {
return requestClient.get<PageResult<InfraCodegenApi.CodegenTable>>(
'/infra/codegen/table/page',
{ params },
);
}
/** 查询详情代码生成表定义 */
export function getCodegenTable(tableId: number) {
return requestClient.get<InfraCodegenApi.CodegenDetail>(
'/infra/codegen/detail',
{
params: { tableId },
},
);
}
/** 修改代码生成表定义 */
export function updateCodegenTable(data: InfraCodegenApi.CodegenUpdateReq) {
return requestClient.put('/infra/codegen/update', data);
}
/** 基于数据库的表结构,同步数据库的表和字段定义 */
export function syncCodegenFromDB(tableId: number) {
return requestClient.put(`/infra/codegen/sync-from-db?tableId=${tableId}`);
}
/** 预览生成代码 */
export function previewCodegen(tableId: number) {
return requestClient.get<InfraCodegenApi.CodegenPreview[]>(
`/infra/codegen/preview?tableId=${tableId}`,
);
}
/** 下载生成代码 */
export function downloadCodegen(tableId: number) {
return requestClient.download(`/infra/codegen/download?tableId=${tableId}`);
}
/** 获得表定义 */
export function getSchemaTableList(params: any) {
return requestClient.get<InfraCodegenApi.DatabaseTable[]>(
'/infra/codegen/db/table/list',
{ params },
);
}
/** 基于数据库的表结构,创建代码生成器的表定义 */
export function createCodegenList(data: InfraCodegenApi.CodegenCreateListReq) {
return requestClient.post('/infra/codegen/create-list', data);
}
/** 删除代码生成表定义 */
export function deleteCodegenTable(tableId: number) {
return requestClient.delete('/infra/codegen/delete', {
params: { tableId },
});
}
/** 批量删除代码生成表定义 */
export function deleteCodegenTableList(tableIds: number[]) {
return requestClient.delete(
`/infra/codegen/delete-list?tableIds=${tableIds.join(',')}`,
);
}

View File

@@ -1,67 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace InfraConfigApi {
/** 参数配置信息 */
export interface Config {
id?: number;
category: string;
name: string;
key: string;
value: string;
type: number;
visible: boolean;
remark: string;
createTime?: Date;
}
}
/** 查询参数列表 */
export function getConfigPage(params: PageParam) {
return requestClient.get<PageResult<InfraConfigApi.Config>>(
'/infra/config/page',
{
params,
},
);
}
/** 查询参数详情 */
export function getConfig(id: number) {
return requestClient.get<InfraConfigApi.Config>(`/infra/config/get?id=${id}`);
}
/** 根据参数键名查询参数值 */
export function getConfigKey(configKey: string) {
return requestClient.get<string>(
`/infra/config/get-value-by-key?key=${configKey}`,
);
}
/** 新增参数 */
export function createConfig(data: InfraConfigApi.Config) {
return requestClient.post('/infra/config/create', data);
}
/** 修改参数 */
export function updateConfig(data: InfraConfigApi.Config) {
return requestClient.put('/infra/config/update', data);
}
/** 删除参数 */
export function deleteConfig(id: number) {
return requestClient.delete(`/infra/config/delete?id=${id}`);
}
/** 批量删除参数 */
export function deleteConfigList(ids: number[]) {
return requestClient.delete(`/infra/config/delete-list?ids=${ids.join(',')}`);
}
/** 导出参数 */
export function exportConfig(params: any) {
return requestClient.download('/infra/config/export-excel', {
params,
});
}

View File

@@ -1,46 +0,0 @@
import { requestClient } from '#/api/request';
export namespace InfraDataSourceConfigApi {
/** 数据源配置信息 */
export interface DataSourceConfig {
id?: number;
name: string;
url: string;
username: string;
password: string;
createTime?: Date;
}
}
/** 查询数据源配置列表 */
export function getDataSourceConfigList() {
return requestClient.get<InfraDataSourceConfigApi.DataSourceConfig[]>(
'/infra/data-source-config/list',
);
}
/** 查询数据源配置详情 */
export function getDataSourceConfig(id: number) {
return requestClient.get<InfraDataSourceConfigApi.DataSourceConfig>(
`/infra/data-source-config/get?id=${id}`,
);
}
/** 新增数据源配置 */
export function createDataSourceConfig(
data: InfraDataSourceConfigApi.DataSourceConfig,
) {
return requestClient.post('/infra/data-source-config/create', data);
}
/** 修改数据源配置 */
export function updateDataSourceConfig(
data: InfraDataSourceConfigApi.DataSourceConfig,
) {
return requestClient.put('/infra/data-source-config/update', data);
}
/** 删除数据源配置 */
export function deleteDataSourceConfig(id: number) {
return requestClient.delete(`/infra/data-source-config/delete?id=${id}`);
}

View File

@@ -1,59 +0,0 @@
import type { Dayjs } from 'dayjs';
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace Demo01ContactApi {
/** 示例联系人信息 */
export interface Demo01Contact {
id: number; // 编号
name?: string; // 名字
sex?: number; // 性别
birthday?: Dayjs | string; // 出生年
description?: string; // 简介
avatar: string; // 头像
}
}
/** 查询示例联系人分页 */
export function getDemo01ContactPage(params: PageParam) {
return requestClient.get<PageResult<Demo01ContactApi.Demo01Contact>>(
'/infra/demo01-contact/page',
{ params },
);
}
/** 查询示例联系人详情 */
export function getDemo01Contact(id: number) {
return requestClient.get<Demo01ContactApi.Demo01Contact>(
`/infra/demo01-contact/get?id=${id}`,
);
}
/** 新增示例联系人 */
export function createDemo01Contact(data: Demo01ContactApi.Demo01Contact) {
return requestClient.post('/infra/demo01-contact/create', data);
}
/** 修改示例联系人 */
export function updateDemo01Contact(data: Demo01ContactApi.Demo01Contact) {
return requestClient.put('/infra/demo01-contact/update', data);
}
/** 删除示例联系人 */
export function deleteDemo01Contact(id: number) {
return requestClient.delete(`/infra/demo01-contact/delete?id=${id}`);
}
/** 批量删除示例联系人 */
export function deleteDemo01ContactList(ids: number[]) {
return requestClient.delete(
`/infra/demo01-contact/delete-list?ids=${ids.join(',')}`,
);
}
/** 导出示例联系人 */
export function exportDemo01Contact(params: any) {
return requestClient.download('/infra/demo01-contact/export-excel', params);
}

View File

@@ -1,46 +0,0 @@
import { requestClient } from '#/api/request';
export namespace Demo02CategoryApi {
/** 示例分类信息 */
export interface Demo02Category {
id: number; // 编号
name?: string; // 名字
parentId?: number; // 父级编号
children?: Demo02Category[];
}
}
/** 查询示例分类列表 */
export function getDemo02CategoryList(params: any) {
return requestClient.get<Demo02CategoryApi.Demo02Category[]>(
'/infra/demo02-category/list',
{ params },
);
}
/** 查询示例分类详情 */
export function getDemo02Category(id: number) {
return requestClient.get<Demo02CategoryApi.Demo02Category>(
`/infra/demo02-category/get?id=${id}`,
);
}
/** 新增示例分类 */
export function createDemo02Category(data: Demo02CategoryApi.Demo02Category) {
return requestClient.post('/infra/demo02-category/create', data);
}
/** 修改示例分类 */
export function updateDemo02Category(data: Demo02CategoryApi.Demo02Category) {
return requestClient.put('/infra/demo02-category/update', data);
}
/** 删除示例分类 */
export function deleteDemo02Category(id: number) {
return requestClient.delete(`/infra/demo02-category/delete?id=${id}`);
}
/** 导出示例分类 */
export function exportDemo02Category(params: any) {
return requestClient.download('/infra/demo02-category/export-excel', params);
}

View File

@@ -1,169 +0,0 @@
import type { Dayjs } from 'dayjs';
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace Demo03StudentApi {
/** 学生课程信息 */
export interface Demo03Course {
id: number; // 编号
studentId?: number; // 学生编号
name?: string; // 名字
score?: number; // 分数
}
/** 学生班级信息 */
export interface Demo03Grade {
id: number; // 编号
studentId?: number; // 学生编号
name?: string; // 名字
teacher?: string; // 班主任
}
/** 学生信息 */
export interface Demo03Student {
id: number; // 编号
name?: string; // 名字
sex?: number; // 性别
birthday?: Dayjs | string; // 出生日期
description?: string; // 简介
}
}
/** 查询学生分页 */
export function getDemo03StudentPage(params: PageParam) {
return requestClient.get<PageResult<Demo03StudentApi.Demo03Student>>(
'/infra/demo03-student-erp/page',
{ params },
);
}
/** 查询学生详情 */
export function getDemo03Student(id: number) {
return requestClient.get<Demo03StudentApi.Demo03Student>(
`/infra/demo03-student-erp/get?id=${id}`,
);
}
/** 新增学生 */
export function createDemo03Student(data: Demo03StudentApi.Demo03Student) {
return requestClient.post('/infra/demo03-student-erp/create', data);
}
/** 修改学生 */
export function updateDemo03Student(data: Demo03StudentApi.Demo03Student) {
return requestClient.put('/infra/demo03-student-erp/update', data);
}
/** 删除学生 */
export function deleteDemo03Student(id: number) {
return requestClient.delete(`/infra/demo03-student-erp/delete?id=${id}`);
}
/** 批量删除学生 */
export function deleteDemo03StudentList(ids: number[]) {
return requestClient.delete(
`/infra/demo03-student-erp/delete-list?ids=${ids.join(',')}`,
);
}
/** 导出学生 */
export function exportDemo03Student(params: any) {
return requestClient.download(
'/infra/demo03-student-erp/export-excel',
params,
);
}
// ==================== 子表(学生课程) ====================
/** 获得学生课程分页 */
export function getDemo03CoursePage(params: PageParam) {
return requestClient.get<PageResult<Demo03StudentApi.Demo03Course>>(
`/infra/demo03-student-erp/demo03-course/page`,
{ params },
);
}
/** 新增学生课程 */
export function createDemo03Course(data: Demo03StudentApi.Demo03Course) {
return requestClient.post(
`/infra/demo03-student-erp/demo03-course/create`,
data,
);
}
/** 修改学生课程 */
export function updateDemo03Course(data: Demo03StudentApi.Demo03Course) {
return requestClient.put(
`/infra/demo03-student-erp/demo03-course/update`,
data,
);
}
/** 删除学生课程 */
export function deleteDemo03Course(id: number) {
return requestClient.delete(
`/infra/demo03-student-erp/demo03-course/delete?id=${id}`,
);
}
/** 批量删除学生课程 */
export function deleteDemo03CourseList(ids: number[]) {
return requestClient.delete(
`/infra/demo03-student-erp/demo03-course/delete-list?ids=${ids.join(',')}`,
);
}
/** 获得学生课程 */
export function getDemo03Course(id: number) {
return requestClient.get<Demo03StudentApi.Demo03Course>(
`/infra/demo03-student-erp/demo03-course/get?id=${id}`,
);
}
// ==================== 子表(学生班级) ====================
/** 获得学生班级分页 */
export function getDemo03GradePage(params: PageParam) {
return requestClient.get<PageResult<Demo03StudentApi.Demo03Grade>>(
`/infra/demo03-student-erp/demo03-grade/page`,
{ params },
);
}
/** 新增学生班级 */
export function createDemo03Grade(data: Demo03StudentApi.Demo03Grade) {
return requestClient.post(
`/infra/demo03-student-erp/demo03-grade/create`,
data,
);
}
/** 修改学生班级 */
export function updateDemo03Grade(data: Demo03StudentApi.Demo03Grade) {
return requestClient.put(
`/infra/demo03-student-erp/demo03-grade/update`,
data,
);
}
/** 删除学生班级 */
export function deleteDemo03Grade(id: number) {
return requestClient.delete(
`/infra/demo03-student-erp/demo03-grade/delete?id=${id}`,
);
}
/** 批量删除学生班级 */
export function deleteDemo03GradeList(ids: number[]) {
return requestClient.delete(
`/infra/demo03-student-erp/demo03-grade/delete-list?ids=${ids.join(',')}`,
);
}
/** 获得学生班级 */
export function getDemo03Grade(id: number) {
return requestClient.get<Demo03StudentApi.Demo03Grade>(
`/infra/demo03-student-erp/demo03-grade/get?id=${id}`,
);
}

View File

@@ -1,97 +0,0 @@
import type { Dayjs } from 'dayjs';
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace Demo03StudentApi {
/** 学生课程信息 */
export interface Demo03Course {
id: number; // 编号
studentId?: number; // 学生编号
name?: string; // 名字
score?: number; // 分数
}
/** 学生班级信息 */
export interface Demo03Grade {
id: number; // 编号
studentId?: number; // 学生编号
name?: string; // 名字
teacher?: string; // 班主任
}
/** 学生信息 */
export interface Demo03Student {
id: number; // 编号
name?: string; // 名字
sex?: number; // 性别
birthday?: Dayjs | string; // 出生日期
description?: string; // 简介
demo03courses?: Demo03Course[];
demo03grade?: Demo03Grade;
}
}
/** 查询学生分页 */
export function getDemo03StudentPage(params: PageParam) {
return requestClient.get<PageResult<Demo03StudentApi.Demo03Student>>(
'/infra/demo03-student-inner/page',
{ params },
);
}
/** 查询学生详情 */
export function getDemo03Student(id: number) {
return requestClient.get<Demo03StudentApi.Demo03Student>(
`/infra/demo03-student-inner/get?id=${id}`,
);
}
/** 新增学生 */
export function createDemo03Student(data: Demo03StudentApi.Demo03Student) {
return requestClient.post('/infra/demo03-student-inner/create', data);
}
/** 修改学生 */
export function updateDemo03Student(data: Demo03StudentApi.Demo03Student) {
return requestClient.put('/infra/demo03-student-inner/update', data);
}
/** 删除学生 */
export function deleteDemo03Student(id: number) {
return requestClient.delete(`/infra/demo03-student-inner/delete?id=${id}`);
}
/** 批量删除学生 */
export function deleteDemo03StudentList(ids: number[]) {
return requestClient.delete(
`/infra/demo03-student-inner/delete-list?ids=${ids.join(',')}`,
);
}
/** 导出学生 */
export function exportDemo03Student(params: any) {
return requestClient.download(
'/infra/demo03-student-inner/export-excel',
params,
);
}
// ==================== 子表(学生课程) ====================
/** 获得学生课程列表 */
export function getDemo03CourseListByStudentId(studentId: number) {
return requestClient.get<Demo03StudentApi.Demo03Course[]>(
`/infra/demo03-student-inner/demo03-course/list-by-student-id?studentId=${studentId}`,
);
}
// ==================== 子表(学生班级) ====================
/** 获得学生班级 */
export function getDemo03GradeByStudentId(studentId: number) {
return requestClient.get<Demo03StudentApi.Demo03Grade>(
`/infra/demo03-student-inner/demo03-grade/get-by-student-id?studentId=${studentId}`,
);
}

View File

@@ -1,97 +0,0 @@
import type { Dayjs } from 'dayjs';
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace Demo03StudentApi {
/** 学生课程信息 */
export interface Demo03Course {
id: number; // 编号
studentId?: number; // 学生编号
name?: string; // 名字
score?: number; // 分数
}
/** 学生班级信息 */
export interface Demo03Grade {
id: number; // 编号
studentId?: number; // 学生编号
name?: string; // 名字
teacher?: string; // 班主任
}
/** 学生信息 */
export interface Demo03Student {
id: number; // 编号
name?: string; // 名字
sex?: number; // 性别
birthday?: Dayjs | string; // 出生日期
description?: string; // 简介
demo03courses?: Demo03Course[];
demo03grade?: Demo03Grade;
}
}
/** 查询学生分页 */
export function getDemo03StudentPage(params: PageParam) {
return requestClient.get<PageResult<Demo03StudentApi.Demo03Student>>(
'/infra/demo03-student-normal/page',
{ params },
);
}
/** 查询学生详情 */
export function getDemo03Student(id: number) {
return requestClient.get<Demo03StudentApi.Demo03Student>(
`/infra/demo03-student-normal/get?id=${id}`,
);
}
/** 新增学生 */
export function createDemo03Student(data: Demo03StudentApi.Demo03Student) {
return requestClient.post('/infra/demo03-student-normal/create', data);
}
/** 修改学生 */
export function updateDemo03Student(data: Demo03StudentApi.Demo03Student) {
return requestClient.put('/infra/demo03-student-normal/update', data);
}
/** 删除学生 */
export function deleteDemo03Student(id: number) {
return requestClient.delete(`/infra/demo03-student-normal/delete?id=${id}`);
}
/** 批量删除学生 */
export function deleteDemo03StudentList(ids: number[]) {
return requestClient.delete(
`/infra/demo03-student-normal/delete-list?ids=${ids.join(',')}`,
);
}
/** 导出学生 */
export function exportDemo03Student(params: any) {
return requestClient.download(
'/infra/demo03-student-normal/export-excel',
params,
);
}
// ==================== 子表(学生课程) ====================
/** 获得学生课程列表 */
export function getDemo03CourseListByStudentId(studentId: number) {
return requestClient.get<Demo03StudentApi.Demo03Course[]>(
`/infra/demo03-student-normal/demo03-course/list-by-student-id?studentId=${studentId}`,
);
}
// ==================== 子表(学生班级) ====================
/** 获得学生班级 */
export function getDemo03GradeByStudentId(studentId: number) {
return requestClient.get<Demo03StudentApi.Demo03Grade>(
`/infra/demo03-student-normal/demo03-grade/get-by-student-id?studentId=${studentId}`,
);
}

View File

@@ -1,82 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace InfraFileConfigApi {
/** 文件客户端配置 */
export interface FileClientConfig {
basePath: string;
host?: string;
port?: number;
username?: string;
password?: string;
mode?: string;
endpoint?: string;
bucket?: string;
accessKey?: string;
accessSecret?: string;
pathStyle?: boolean;
domain: string;
}
/** 文件配置信息 */
export interface FileConfig {
id?: number;
name: string;
storage?: number;
master: boolean;
visible: boolean;
config: FileClientConfig;
remark: string;
createTime?: Date;
}
}
/** 查询文件配置列表 */
export function getFileConfigPage(params: PageParam) {
return requestClient.get<PageResult<InfraFileConfigApi.FileConfig>>(
'/infra/file-config/page',
{
params,
},
);
}
/** 查询文件配置详情 */
export function getFileConfig(id: number) {
return requestClient.get<InfraFileConfigApi.FileConfig>(
`/infra/file-config/get?id=${id}`,
);
}
/** 更新文件配置为主配置 */
export function updateFileConfigMaster(id: number) {
return requestClient.put(`/infra/file-config/update-master?id=${id}`);
}
/** 新增文件配置 */
export function createFileConfig(data: InfraFileConfigApi.FileConfig) {
return requestClient.post('/infra/file-config/create', data);
}
/** 修改文件配置 */
export function updateFileConfig(data: InfraFileConfigApi.FileConfig) {
return requestClient.put('/infra/file-config/update', data);
}
/** 删除文件配置 */
export function deleteFileConfig(id: number) {
return requestClient.delete(`/infra/file-config/delete?id=${id}`);
}
/** 批量删除文件配置 */
export function deleteFileConfigList(ids: number[]) {
return requestClient.delete(
`/infra/file-config/delete-list?ids=${ids.join(',')}`,
);
}
/** 测试文件配置 */
export function testFileConfig(id: number) {
return requestClient.get(`/infra/file-config/test?id=${id}`);
}

View File

@@ -1,78 +0,0 @@
import type { AxiosRequestConfig, PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
/** Axios 上传进度事件 */
export type AxiosProgressEvent = AxiosRequestConfig['onUploadProgress'];
export namespace InfraFileApi {
/** 文件信息 */
export interface File {
id?: number;
configId?: number;
path: string;
name?: string;
url?: string;
size?: number;
type?: string;
createTime?: Date;
}
/** 文件预签名地址 */
export interface FilePresignedUrlResp {
configId: number; // 文件配置编号
uploadUrl: string; // 文件上传 URL
url: string; // 文件 URL
path: string; // 文件路径
}
/** 上传文件 */
export interface FileUploadReq {
file: globalThis.File;
directory?: string;
}
}
/** 查询文件列表 */
export function getFilePage(params: PageParam) {
return requestClient.get<PageResult<InfraFileApi.File>>('/infra/file/page', {
params,
});
}
/** 删除文件 */
export function deleteFile(id: number) {
return requestClient.delete(`/infra/file/delete?id=${id}`);
}
/** 批量删除文件 */
export function deleteFileList(ids: number[]) {
return requestClient.delete(`/infra/file/delete-list?ids=${ids.join(',')}`);
}
/** 获取文件预签名地址 */
export function getFilePresignedUrl(name: string, directory?: string) {
return requestClient.get<InfraFileApi.FilePresignedUrlResp>(
'/infra/file/presigned-url',
{
params: { name, directory },
},
);
}
/** 创建文件 */
export function createFile(data: InfraFileApi.File) {
return requestClient.post('/infra/file/create', data);
}
/** 上传文件 */
export function uploadFile(
data: InfraFileApi.FileUploadReq,
onUploadProgress?: AxiosProgressEvent,
) {
// 特殊:由于 upload 内部封装,即使 directory 为 undefined也会传递给后端
if (!data.directory) {
delete data.directory;
}
return requestClient.upload('/infra/file/upload', data, { onUploadProgress });
}

View File

@@ -1,41 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace InfraJobLogApi {
/** 任务日志信息 */
export interface JobLog {
id?: number;
jobId: number;
handlerName: string;
handlerParam: string;
cronExpression: string;
executeIndex: string;
beginTime: Date;
endTime: Date;
duration: string;
status: number;
createTime?: string;
result: string;
}
}
/** 查询任务日志列表 */
export function getJobLogPage(params: PageParam) {
return requestClient.get<PageResult<InfraJobLogApi.JobLog>>(
'/infra/job-log/page',
{ params },
);
}
/** 查询任务日志详情 */
export function getJobLog(id: number) {
return requestClient.get<InfraJobLogApi.JobLog>(
`/infra/job-log/get?id=${id}`,
);
}
/** 导出定时任务日志 */
export function exportJobLog(params: any) {
return requestClient.download('/infra/job-log/export-excel', { params });
}

View File

@@ -1,76 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace InfraJobApi {
/** 任务信息 */
export interface Job {
id?: number;
name: string;
status: number;
handlerName: string;
handlerParam: string;
cronExpression: string;
retryCount: number;
retryInterval: number;
monitorTimeout: number;
createTime?: Date;
nextTimes?: Date[];
}
}
/** 查询任务列表 */
export function getJobPage(params: PageParam) {
return requestClient.get<PageResult<InfraJobApi.Job>>('/infra/job/page', {
params,
});
}
/** 查询任务详情 */
export function getJob(id: number) {
return requestClient.get<InfraJobApi.Job>(`/infra/job/get?id=${id}`);
}
/** 新增任务 */
export function createJob(data: InfraJobApi.Job) {
return requestClient.post('/infra/job/create', data);
}
/** 修改定时任务调度 */
export function updateJob(data: InfraJobApi.Job) {
return requestClient.put('/infra/job/update', data);
}
/** 删除定时任务调度 */
export function deleteJob(id: number) {
return requestClient.delete(`/infra/job/delete?id=${id}`);
}
/** 批量删除定时任务调度 */
export function deleteJobList(ids: number[]) {
return requestClient.delete(`/infra/job/delete-list?ids=${ids.join(',')}`);
}
/** 导出定时任务调度 */
export function exportJob(params: any) {
return requestClient.download('/infra/job/export-excel', { params });
}
/** 任务状态修改 */
export function updateJobStatus(id: number, status: number) {
const params = {
id,
status,
};
return requestClient.put('/infra/job/update-status', {}, { params });
}
/** 定时任务立即执行一次 */
export function runJob(id: number) {
return requestClient.put(`/infra/job/trigger?id=${id}`);
}
/** 获得定时任务的下 n 次执行时间 */
export function getJobNextTimes(id: number) {
return requestClient.get(`/infra/job/get_next_times?id=${id}`);
}

View File

@@ -1,190 +0,0 @@
import { requestClient } from '#/api/request';
export namespace InfraRedisApi {
/** Redis 信息 */
export interface RedisInfo {
io_threaded_reads_processed: string;
tracking_clients: string;
uptime_in_seconds: string;
cluster_connections: string;
current_cow_size: string;
maxmemory_human: string;
aof_last_cow_size: string;
master_replid2: string;
mem_replication_backlog: string;
aof_rewrite_scheduled: string;
total_net_input_bytes: string;
rss_overhead_ratio: string;
hz: string;
current_cow_size_age: string;
redis_build_id: string;
errorstat_BUSYGROUP: string;
aof_last_bgrewrite_status: string;
multiplexing_api: string;
client_recent_max_output_buffer: string;
allocator_resident: string;
mem_fragmentation_bytes: string;
aof_current_size: string;
repl_backlog_first_byte_offset: string;
tracking_total_prefixes: string;
redis_mode: string;
redis_git_dirty: string;
aof_delayed_fsync: string;
allocator_rss_bytes: string;
repl_backlog_histlen: string;
io_threads_active: string;
rss_overhead_bytes: string;
total_system_memory: string;
loading: string;
evicted_keys: string;
maxclients: string;
cluster_enabled: string;
redis_version: string;
repl_backlog_active: string;
mem_aof_buffer: string;
allocator_frag_bytes: string;
io_threaded_writes_processed: string;
instantaneous_ops_per_sec: string;
used_memory_human: string;
total_error_replies: string;
role: string;
maxmemory: string;
used_memory_lua: string;
rdb_current_bgsave_time_sec: string;
used_memory_startup: string;
used_cpu_sys_main_thread: string;
lazyfree_pending_objects: string;
aof_pending_bio_fsync: string;
used_memory_dataset_perc: string;
allocator_frag_ratio: string;
arch_bits: string;
used_cpu_user_main_thread: string;
mem_clients_normal: string;
expired_time_cap_reached_count: string;
unexpected_error_replies: string;
mem_fragmentation_ratio: string;
aof_last_rewrite_time_sec: string;
master_replid: string;
aof_rewrite_in_progress: string;
lru_clock: string;
maxmemory_policy: string;
run_id: string;
latest_fork_usec: string;
tracking_total_items: string;
total_commands_processed: string;
expired_keys: string;
errorstat_ERR: string;
used_memory: string;
module_fork_in_progress: string;
errorstat_WRONGPASS: string;
aof_buffer_length: string;
dump_payload_sanitizations: string;
mem_clients_slaves: string;
keyspace_misses: string;
server_time_usec: string;
executable: string;
lazyfreed_objects: string;
db0: string;
used_memory_peak_human: string;
keyspace_hits: string;
rdb_last_cow_size: string;
aof_pending_rewrite: string;
used_memory_overhead: string;
active_defrag_hits: string;
tcp_port: string;
uptime_in_days: string;
used_memory_peak_perc: string;
current_save_keys_processed: string;
blocked_clients: string;
total_reads_processed: string;
expire_cycle_cpu_milliseconds: string;
sync_partial_err: string;
used_memory_scripts_human: string;
aof_current_rewrite_time_sec: string;
aof_enabled: string;
process_supervised: string;
master_repl_offset: string;
used_memory_dataset: string;
used_cpu_user: string;
rdb_last_bgsave_status: string;
tracking_total_keys: string;
atomicvar_api: string;
allocator_rss_ratio: string;
client_recent_max_input_buffer: string;
clients_in_timeout_table: string;
aof_last_write_status: string;
mem_allocator: string;
used_memory_scripts: string;
used_memory_peak: string;
process_id: string;
master_failover_state: string;
errorstat_NOAUTH: string;
used_cpu_sys: string;
repl_backlog_size: string;
connected_slaves: string;
current_save_keys_total: string;
gcc_version: string;
total_system_memory_human: string;
sync_full: string;
connected_clients: string;
module_fork_last_cow_size: string;
total_writes_processed: string;
allocator_active: string;
total_net_output_bytes: string;
pubsub_channels: string;
current_fork_perc: string;
active_defrag_key_hits: string;
rdb_changes_since_last_save: string;
instantaneous_input_kbps: string;
used_memory_rss_human: string;
configured_hz: string;
expired_stale_perc: string;
active_defrag_misses: string;
used_cpu_sys_children: string;
number_of_cached_scripts: string;
sync_partial_ok: string;
used_memory_lua_human: string;
rdb_last_save_time: string;
pubsub_patterns: string;
slave_expires_tracked_keys: string;
redis_git_sha1: string;
used_memory_rss: string;
rdb_last_bgsave_time_sec: string;
os: string;
mem_not_counted_for_evict: string;
active_defrag_running: string;
rejected_connections: string;
aof_rewrite_buffer_length: string;
total_forks: string;
active_defrag_key_misses: string;
allocator_allocated: string;
aof_base_size: string;
instantaneous_output_kbps: string;
second_repl_offset: string;
rdb_bgsave_in_progress: string;
used_cpu_user_children: string;
total_connections_received: string;
migrate_cached_sockets: string;
}
/** Redis 命令统计 */
export interface RedisCommandStats {
command: string;
calls: number;
usec: number;
}
/** Redis 监控信息 */
export interface RedisMonitorInfo {
info: RedisInfo;
dbSize: number;
commandStats: RedisCommandStats[];
}
}
/** 获取 Redis 监控信息 */
export function getRedisMonitorInfo() {
return requestClient.get<InfraRedisApi.RedisMonitorInfo>(
'/infra/redis/get-monitor-info',
);
}

View File

@@ -1,47 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallBannerApi {
/** Banner 信息 */
export interface Banner {
id: number;
title: string;
picUrl: string;
status: number;
url: string;
position: number;
sort: number;
memo: string;
}
}
/** 查询Banner管理列表 */
export function getBannerPage(params: PageParam) {
return requestClient.get<PageResult<MallBannerApi.Banner>>(
'/promotion/banner/page',
{ params },
);
}
/** 查询Banner管理详情 */
export function getBanner(id: number) {
return requestClient.get<MallBannerApi.Banner>(
`/promotion/banner/get?id=${id}`,
);
}
/** 新增Banner管理 */
export function createBanner(data: MallBannerApi.Banner) {
return requestClient.post('/promotion/banner/create', data);
}
/** 修改Banner管理 */
export function updateBanner(data: MallBannerApi.Banner) {
return requestClient.put('/promotion/banner/update', data);
}
/** 删除Banner管理 */
export function deleteBanner(id: number) {
return requestClient.delete(`/promotion/banner/delete?id=${id}`);
}

View File

@@ -1,58 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallBrandApi {
/** 商品品牌 */
export interface Brand {
/** 品牌编号 */
id?: number;
/** 品牌名称 */
name: string;
/** 品牌图片 */
picUrl: string;
/** 品牌排序 */
sort?: number;
/** 品牌描述 */
description?: string;
/** 开启状态 */
status: number;
}
}
/** 创建商品品牌 */
export function createBrand(data: MallBrandApi.Brand) {
return requestClient.post('/product/brand/create', data);
}
/** 更新商品品牌 */
export function updateBrand(data: MallBrandApi.Brand) {
return requestClient.put('/product/brand/update', data);
}
/** 删除商品品牌 */
export function deleteBrand(id: number) {
return requestClient.delete(`/product/brand/delete?id=${id}`);
}
/** 获得商品品牌 */
export function getBrand(id: number) {
return requestClient.get<MallBrandApi.Brand>(`/product/brand/get?id=${id}`);
}
/** 获得商品品牌列表 */
export function getBrandPage(params: PageParam) {
return requestClient.get<PageResult<MallBrandApi.Brand>>(
'/product/brand/page',
{
params,
},
);
}
/** 获得商品品牌精简信息列表 */
export function getSimpleBrandList() {
return requestClient.get<MallBrandApi.Brand[]>(
'/product/brand/list-all-simple',
);
}

View File

@@ -1,51 +0,0 @@
import { requestClient } from '#/api/request';
export namespace MallCategoryApi {
/** 产品分类 */
export interface Category {
/** 分类编号 */
id?: number;
/** 父分类编号 */
parentId?: number;
/** 分类名称 */
name: string;
/** 移动端分类图 */
picUrl: string;
/** 分类排序 */
sort: number;
/** 开启状态 */
status: number;
}
}
/** 创建商品分类 */
export function createCategory(data: MallCategoryApi.Category) {
return requestClient.post('/product/category/create', data);
}
/** 更新商品分类 */
export function updateCategory(data: MallCategoryApi.Category) {
return requestClient.put('/product/category/update', data);
}
/** 删除商品分类 */
export function deleteCategory(id: number) {
return requestClient.delete(`/product/category/delete?id=${id}`);
}
/** 获得商品分类 */
export function getCategory(id: number) {
return requestClient.get<MallCategoryApi.Category>(
`/product/category/get?id=${id}`,
);
}
/** 获得商品分类列表 */
export function getCategoryList(params: any) {
return requestClient.get<MallCategoryApi.Category[]>(
'/product/category/list',
{
params,
},
);
}

View File

@@ -1,81 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallCommentApi {
export interface Property {
propertyId: number;
propertyName: string;
valueId: number;
valueName: string;
}
/** 商品评论 */
export interface Comment {
id: number;
userId: number;
userNickname: string;
userAvatar: string;
anonymous: boolean;
orderId: number;
orderItemId: number;
spuId: number;
spuName: string;
skuId: number;
visible: boolean;
scores: number;
descriptionScores: number;
benefitScores: number;
content: string;
picUrls: string[];
replyStatus: boolean;
replyUserId: number;
replyContent: string;
replyTime: Date;
createTime: Date;
skuProperties: Property[];
}
/** 评论可见性更新 */
export interface CommentVisibleUpdate {
id: number;
visible: boolean;
}
/** 评论回复 */
export interface CommentReply {
id: number;
replyContent: string;
}
}
/** 查询商品评论列表 */
export function getCommentPage(params: PageParam) {
return requestClient.get<PageResult<MallCommentApi.Comment>>(
'/product/comment/page',
{ params },
);
}
/** 查询商品评论详情 */
export function getComment(id: number) {
return requestClient.get<MallCommentApi.Comment>(
`/product/comment/get?id=${id}`,
);
}
/** 添加自评 */
export function createComment(data: MallCommentApi.Comment) {
return requestClient.post('/product/comment/create', data);
}
/** 显示 / 隐藏评论 */
export function updateCommentVisible(
data: MallCommentApi.CommentVisibleUpdate,
) {
return requestClient.put('/product/comment/update-visible', data);
}
/** 商家回复 */
export function replyComment(data: MallCommentApi.CommentReply) {
return requestClient.put('/product/comment/reply', data);
}

View File

@@ -1,23 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallFavoriteApi {
/** 商品收藏 */
export interface Favorite {
/** 收藏编号 */
id?: number;
/** 用户编号 */
userId?: string;
/** 商品 SPU 编号 */
spuId?: null | number;
}
}
/** 获得商品收藏列表 */
export function getFavoritePage(params: PageParam) {
return requestClient.get<PageResult<MallFavoriteApi.Favorite>>(
'/product/favorite/page',
{ params },
);
}

View File

@@ -1,29 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallHistoryApi {
/** 商品浏览记录 */
export interface BrowseHistory {
/** 记录编号 */
id?: number;
/** 用户编号 */
userId?: number;
/** 商品 SPU 编号 */
spuId?: number;
/** 浏览时间 */
createTime?: Date;
}
}
/**
* 获得商品浏览记录分页
*
* @param params 请求参数
*/
export function getBrowseHistoryPage(params: PageParam) {
return requestClient.get<PageResult<MallHistoryApi.BrowseHistory>>(
'/product/browse-history/page',
{ params },
);
}

View File

@@ -1,111 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallPropertyApi {
/** 商品属性 */
export interface Property {
/** 属性编号 */
id?: number;
/** 名称 */
name: string;
/** 备注 */
remark?: string;
}
/** 属性值 */
export interface PropertyValue {
/** 属性值编号 */
id?: number;
/** 属性项的编号 */
propertyId?: number;
/** 名称 */
name: string;
/** 备注 */
remark?: string;
}
/** 属性值查询参数 */
export interface PropertyValueQuery extends PageParam {
propertyId?: number;
}
}
/** 创建属性项 */
export function createProperty(data: MallPropertyApi.Property) {
return requestClient.post('/product/property/create', data);
}
/** 更新属性项 */
export function updateProperty(data: MallPropertyApi.Property) {
return requestClient.put('/product/property/update', data);
}
/** 删除属性项 */
export function deleteProperty(id: number) {
return requestClient.delete(`/product/property/delete?id=${id}`);
}
/** 获得属性项 */
export function getProperty(id: number) {
return requestClient.get<MallPropertyApi.Property>(
`/product/property/get?id=${id}`,
);
}
/** 获得属性项分页 */
export function getPropertyPage(params: PageParam) {
return requestClient.get<PageResult<MallPropertyApi.Property>>(
'/product/property/page',
{ params },
);
}
/** 获得属性项精简列表 */
export function getPropertySimpleList() {
return requestClient.get<MallPropertyApi.Property[]>(
'/product/property/simple-list',
);
}
/** 获得属性值分页 */
export function getPropertyValuePage(
params: MallPropertyApi.PropertyValueQuery,
) {
return requestClient.get<PageResult<MallPropertyApi.PropertyValue>>(
'/product/property/value/page',
{ params },
);
}
/** 获得属性值 */
export function getPropertyValue(id: number) {
return requestClient.get<MallPropertyApi.PropertyValue>(
`/product/property/value/get?id=${id}`,
);
}
/** 创建属性值 */
export function createPropertyValue(data: MallPropertyApi.PropertyValue) {
return requestClient.post('/product/property/value/create', data);
}
/** 更新属性值 */
export function updatePropertyValue(data: MallPropertyApi.PropertyValue) {
return requestClient.put('/product/property/value/update', data);
}
/** 删除属性值 */
export function deletePropertyValue(id: number) {
return requestClient.delete(`/product/property/value/delete?id=${id}`);
}
/** 获得属性值精简列表 */
export function getPropertyValueSimpleList(propertyId: number) {
return requestClient.get<MallPropertyApi.PropertyValue[]>(
'/product/property/value/simple-list',
{
params: { propertyId },
},
);
}

View File

@@ -1,177 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallSpuApi {
/** 商品属性 */
export interface Property {
/** 属性编号 */
propertyId?: number;
/** 属性名称 */
propertyName?: string;
/** 属性值编号 */
valueId?: number;
/** 属性值名称 */
valueName?: string;
}
/** 商品 SKU */
export interface Sku {
/** 商品 SKU 编号 */
id?: number;
/** 商品 SKU 名称 */
name?: string;
/** SPU 编号 */
spuId?: number;
/** 属性数组 */
properties?: Property[];
/** 商品价格 */
price?: number | string;
/** 市场价 */
marketPrice?: number | string;
/** 成本价 */
costPrice?: number | string;
/** 商品条码 */
barCode?: string;
/** 图片地址 */
picUrl?: string;
/** 库存 */
stock?: number;
/** 商品重量单位kg 千克 */
weight?: number;
/** 商品体积单位m^3 平米 */
volume?: number;
/** 一级分销的佣金 */
firstBrokeragePrice?: number | string;
/** 二级分销的佣金 */
secondBrokeragePrice?: number | string;
/** 商品销量 */
salesCount?: number;
}
/** 优惠券模板 */
export interface GiveCouponTemplate {
/** 优惠券编号 */
id?: number;
/** 优惠券名称 */
name?: string;
}
/** 商品 SPU */
export interface Spu {
/** 商品编号 */
id?: number;
/** 商品名称 */
name?: string;
/** 商品分类 */
categoryId?: number;
/** 关键字 */
keyword?: string;
/** 单位 */
unit?: number | undefined;
/** 商品封面图 */
picUrl?: string;
/** 商品轮播图 */
sliderPicUrls?: string[];
/** 商品简介 */
introduction?: string;
/** 配送方式 */
deliveryTypes?: number[];
/** 运费模版 */
deliveryTemplateId?: number | undefined;
/** 商品品牌编号 */
brandId?: number;
/** 商品规格 */
specType?: boolean;
/** 分销类型 */
subCommissionType?: boolean;
/** sku数组 */
skus?: Sku[];
/** 商品详情 */
description?: string;
/** 商品排序 */
sort?: number;
/** 赠送积分 */
giveIntegral?: number;
/** 虚拟销量 */
virtualSalesCount?: number;
/** 商品价格 */
price?: number;
/** 商品拼团价格 */
combinationPrice?: number;
/** 商品秒杀价格 */
seckillPrice?: number;
/** 商品销量 */
salesCount?: number;
/** 市场价 */
marketPrice?: number;
/** 成本价 */
costPrice?: number;
/** 商品库存 */
stock?: number;
/** 商品创建时间 */
createTime?: Date;
/** 商品状态 */
status?: number;
}
/** 商品状态更新 */
export interface StatusUpdate {
/** 商品编号 */
id: number;
/** 商品状态 */
status: number;
}
}
/** 获得商品 SPU 列表 */
export function getSpuPage(params: PageParam) {
return requestClient.get<PageResult<MallSpuApi.Spu>>('/product/spu/page', {
params,
});
}
/** 获得商品 SPU 列表 tabsCount */
export function getTabsCount() {
return requestClient.get<Record<string, number>>('/product/spu/get-count');
}
/** 创建商品 SPU */
export function createSpu(data: MallSpuApi.Spu) {
return requestClient.post('/product/spu/create', data);
}
/** 更新商品 SPU */
export function updateSpu(data: MallSpuApi.Spu) {
return requestClient.put('/product/spu/update', data);
}
/** 更新商品 SPU 状态 */
export function updateStatus(data: MallSpuApi.StatusUpdate) {
return requestClient.put('/product/spu/update-status', data);
}
/** 获得商品 SPU */
export function getSpu(id: number) {
return requestClient.get<MallSpuApi.Spu>(`/product/spu/get-detail?id=${id}`);
}
/** 获得商品 SPU 详情列表 */
export function getSpuDetailList(ids: number[]) {
return requestClient.get<MallSpuApi.Spu[]>(`/product/spu/list?spuIds=${ids}`);
}
/** 删除商品 SPU */
export function deleteSpu(id: number) {
return requestClient.delete(`/product/spu/delete?id=${id}`);
}
/** 导出商品 SPU Excel */
export function exportSpu(params: PageParam) {
return requestClient.download('/product/spu/export-excel', { params });
}
/** 获得商品 SPU 精简列表 */
export function getSpuSimpleList() {
return requestClient.get<MallSpuApi.Spu[]>('/product/spu/list-all-simple');
}

View File

@@ -1,65 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallArticleApi {
/** 文章管理 */
export interface Article {
/** 文章编号 */
id: number;
/** 分类编号 */
categoryId: number;
/** 文章标题 */
title: string;
/** 作者 */
author: string;
/** 封面图 */
picUrl: string;
/** 文章简介 */
introduction: string;
/** 浏览数量 */
browseCount: string;
/** 排序 */
sort: number;
/** 状态 */
status: number;
/** 商品编号 */
spuId: number;
/** 是否热门 */
recommendHot: boolean;
/** 是否轮播图 */
recommendBanner: boolean;
/** 文章内容 */
content: string;
}
}
/** 查询文章管理列表 */
export function getArticlePage(params: PageParam) {
return requestClient.get<PageResult<MallArticleApi.Article>>(
'/promotion/article/page',
{ params },
);
}
/** 查询文章管理详情 */
export function getArticle(id: number) {
return requestClient.get<MallArticleApi.Article>(
`/promotion/article/get?id=${id}`,
);
}
/** 新增文章管理 */
export function createArticle(data: MallArticleApi.Article) {
return requestClient.post('/promotion/article/create', data);
}
/** 修改文章管理 */
export function updateArticle(data: MallArticleApi.Article) {
return requestClient.put('/promotion/article/update', data);
}
/** 删除文章管理 */
export function deleteArticle(id: number) {
return requestClient.delete(`/promotion/article/delete?id=${id}`);
}

View File

@@ -1,60 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallArticleCategoryApi {
/** 文章分类 */
export interface ArticleCategory {
/** 分类编号 */
id: number;
/** 分类名称 */
name: string;
/** 分类图片 */
picUrl: string;
/** 状态 */
status: number;
/** 排序 */
sort: number;
}
}
/** 查询文章分类列表 */
export function getArticleCategoryPage(params: PageParam) {
return requestClient.get<PageResult<MallArticleCategoryApi.ArticleCategory>>(
'/promotion/article-category/page',
{ params },
);
}
/** 查询文章分类精简信息列表 */
export function getSimpleArticleCategoryList() {
return requestClient.get<MallArticleCategoryApi.ArticleCategory[]>(
'/promotion/article-category/list-all-simple',
);
}
/** 查询文章分类详情 */
export function getArticleCategory(id: number) {
return requestClient.get<MallArticleCategoryApi.ArticleCategory>(
`/promotion/article-category/get?id=${id}`,
);
}
/** 新增文章分类 */
export function createArticleCategory(
data: MallArticleCategoryApi.ArticleCategory,
) {
return requestClient.post('/promotion/article-category/create', data);
}
/** 修改文章分类 */
export function updateArticleCategory(
data: MallArticleCategoryApi.ArticleCategory,
) {
return requestClient.put('/promotion/article-category/update', data);
}
/** 删除文章分类 */
export function deleteArticleCategory(id: number) {
return requestClient.delete(`/promotion/article-category/delete?id=${id}`);
}

View File

@@ -1,106 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import type { MallSpuApi } from '#/api/mall/product/spu';
import { requestClient } from '#/api/request';
export namespace MallBargainActivityApi {
/** 砍价活动 */
export interface BargainActivity {
/** 活动编号 */
id?: number;
/** 活动名称 */
name?: string;
/** 开始时间 */
startTime?: Date;
/** 结束时间 */
endTime?: Date;
/** 状态 */
status?: number;
/** 达到该人数,才能砍到低价 */
helpMaxCount?: number;
/** 最大帮砍次数 */
bargainCount?: number;
/** 最大购买次数 */
totalLimitCount?: number;
/** 商品 SPU 编号 */
spuId: number;
/** 商品 SKU 编号 */
skuId: number;
/** 砍价起始价格,单位分 */
bargainFirstPrice: number;
/** 砍价底价 */
bargainMinPrice: number;
/** 活动库存 */
stock: number;
/** 用户每次砍价的最小金额,单位:分 */
randomMinPrice?: number;
/** 用户每次砍价的最大金额,单位:分 */
randomMaxPrice?: number;
}
/** 砍价活动所需属性。选择的商品和属性的时候使用方便使用活动的通用封装 */
export interface BargainProduct {
/** 商品 SPU 编号 */
spuId: number;
/** 商品 SKU 编号 */
skuId: number;
/** 砍价起始价格,单位分 */
bargainFirstPrice: number;
/** 砍价底价 */
bargainMinPrice: number;
/** 活动库存 */
stock: number;
}
/** 扩展 SKU 配置 */
export type SkuExtension = {
/** 砍价活动配置 */
productConfig: BargainProduct;
} & MallSpuApi.Sku;
/** 扩展 SPU 配置 */
export interface SpuExtension extends MallSpuApi.Spu {
/** SKU 列表 */
skus: SkuExtension[];
}
}
/** 查询砍价活动列表 */
export function getBargainActivityPage(params: PageParam) {
return requestClient.get<PageResult<MallBargainActivityApi.BargainActivity>>(
'/promotion/bargain-activity/page',
{ params },
);
}
/** 查询砍价活动详情 */
export function getBargainActivity(id: number) {
return requestClient.get<MallBargainActivityApi.BargainActivity>(
`/promotion/bargain-activity/get?id=${id}`,
);
}
/** 新增砍价活动 */
export function createBargainActivity(
data: MallBargainActivityApi.BargainActivity,
) {
return requestClient.post('/promotion/bargain-activity/create', data);
}
/** 修改砍价活动 */
export function updateBargainActivity(
data: MallBargainActivityApi.BargainActivity,
) {
return requestClient.put('/promotion/bargain-activity/update', data);
}
/** 关闭砍价活动 */
export function closeBargainActivity(id: number) {
return requestClient.put(`/promotion/bargain-activity/close?id=${id}`);
}
/** 删除砍价活动 */
export function deleteBargainActivity(id: number) {
return requestClient.delete(`/promotion/bargain-activity/delete?id=${id}`);
}

View File

@@ -1,27 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallBargainHelpApi {
/** 砍价记录 */
export interface BargainHelp {
/** 记录编号 */
id: number;
/** 砍价记录编号 */
record: number;
/** 用户编号 */
userId: number;
/** 砍掉金额 */
reducePrice: number;
/** 结束时间 */
endTime: Date;
}
}
/** 查询砍价记录列表 */
export function getBargainHelpPage(params: PageParam) {
return requestClient.get<PageResult<MallBargainHelpApi.BargainHelp>>(
'/promotion/bargain-help/page',
{ params },
);
}

View File

@@ -1,37 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallBargainRecordApi {
/** 砍价记录 */
export interface BargainRecord {
/** 记录编号 */
id: number;
/** 活动编号 */
activityId: number;
/** 用户编号 */
userId: number;
/** 商品 SPU 编号 */
spuId: number;
/** 商品 SKU 编号 */
skuId: number;
/** 砍价起始价格 */
bargainFirstPrice: number;
/** 砍价价格 */
bargainPrice: number;
/** 状态 */
status: number;
/** 订单编号 */
orderId: number;
/** 结束时间 */
endTime: Date;
}
}
/** 查询砍价记录列表 */
export function getBargainRecordPage(params: PageParam) {
return requestClient.get<PageResult<MallBargainRecordApi.BargainRecord>>(
'/promotion/bargain-record/page',
{ params },
);
}

View File

@@ -1,111 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import type { MallSpuApi } from '#/api/mall/product/spu';
import { requestClient } from '#/api/request';
export namespace MallCombinationActivityApi {
/** 拼团活动所需属性 */
export interface CombinationProduct {
/** 商品 SPU 编号 */
spuId: number;
/** 商品 SKU 编号 */
skuId: number;
/** 拼团价格 */
combinationPrice: number;
}
/** 拼团活动 */
export interface CombinationActivity {
/** 活动编号 */
id?: number;
/** 活动名称 */
name?: string;
/** 商品 SPU 编号 */
spuId?: number;
/** 总限购数量 */
totalLimitCount?: number;
/** 单次限购数量 */
singleLimitCount?: number;
/** 开始时间 */
startTime?: Date;
/** 结束时间 */
endTime?: Date;
/** 用户数量 */
userSize?: number;
/** 总数量 */
totalCount?: number;
/** 成功数量 */
successCount?: number;
/** 订单用户数量 */
orderUserCount?: number;
/** 虚拟成团 */
virtualGroup?: number;
/** 状态 */
status?: number;
/** 限制时长 */
limitDuration?: number;
/** 拼团价格 */
combinationPrice?: number;
/** 商品列表 */
products: CombinationProduct[];
}
/** 扩展 SKU 配置 */
export type SkuExtension = {
/** 拼团活动配置 */
productConfig: CombinationProduct;
} & MallSpuApi.Sku;
/** 扩展 SPU 配置 */
export interface SpuExtension extends MallSpuApi.Spu {
/** SKU 列表 */
skus: SkuExtension[];
}
}
/** 查询拼团活动列表 */
export function getCombinationActivityPage(params: PageParam) {
return requestClient.get<
PageResult<MallCombinationActivityApi.CombinationActivity>
>('/promotion/combination-activity/page', { params });
}
/** 查询拼团活动详情 */
export function getCombinationActivity(id: number) {
return requestClient.get<MallCombinationActivityApi.CombinationActivity>(
`/promotion/combination-activity/get?id=${id}`,
);
}
/** 获得拼团活动列表,基于活动编号数组 */
export function getCombinationActivityListByIds(ids: number[]) {
return requestClient.get<MallCombinationActivityApi.CombinationActivity[]>(
`/promotion/combination-activity/list-by-ids?ids=${ids}`,
);
}
/** 新增拼团活动 */
export function createCombinationActivity(
data: MallCombinationActivityApi.CombinationActivity,
) {
return requestClient.post('/promotion/combination-activity/create', data);
}
/** 修改拼团活动 */
export function updateCombinationActivity(
data: MallCombinationActivityApi.CombinationActivity,
) {
return requestClient.put('/promotion/combination-activity/update', data);
}
/** 关闭拼团活动 */
export function closeCombinationActivity(id: number) {
return requestClient.put(`/promotion/combination-activity/close?id=${id}`);
}
/** 删除拼团活动 */
export function deleteCombinationActivity(id: number) {
return requestClient.delete(
`/promotion/combination-activity/delete?id=${id}`,
);
}

View File

@@ -1,61 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallCombinationRecordApi {
/** 拼团记录 */
export interface CombinationRecord {
/** 拼团记录编号 */
id: number;
/** 拼团活动编号 */
activityId: number;
/** 用户昵称 */
nickname: string;
/** 用户头像 */
avatar: string;
/** 团长编号 */
headId: number;
/** 过期时间 */
expireTime: string;
/** 可参团人数 */
userSize: number;
/** 已参团人数 */
userCount: number;
/** 拼团状态 */
status: number;
/** 商品名字 */
spuName: string;
/** 商品图片 */
picUrl: string;
/** 是否虚拟成团 */
virtualGroup: boolean;
/** 开始时间 (订单付款后开始的时间) */
startTime: string;
/** 结束时间(成团时间/失败时间) */
endTime: string;
}
/** 拼团记录概要信息 */
export interface RecordSummary {
/** 待成团数量 */
pendingCount: number;
/** 已成团数量 */
successCount: number;
/** 已失败数量 */
failCount: number;
}
}
/** 查询拼团记录列表 */
export function getCombinationRecordPage(params: PageParam) {
return requestClient.get<
PageResult<MallCombinationRecordApi.CombinationRecord>
>('/promotion/combination-record/page', { params });
}
/** 获得拼团记录的概要信息 */
export function getCombinationRecordSummary() {
return requestClient.get<MallCombinationRecordApi.RecordSummary>(
'/promotion/combination-record/get-summary',
);
}

View File

@@ -1,67 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallCouponApi {
/** 优惠券 */
export interface Coupon {
/** 优惠券编号 */
id: number;
/** 优惠券名称 */
name: string;
/** 优惠券状态 */
status: number;
/** 优惠券类型 */
type: number;
/** 优惠券金额 */
price: number;
/** 使用门槛 */
usePrice: number;
/** 商品范围 */
productScope: number;
/** 商品编号数组 */
productSpuIds: number[];
/** 有效期类型 */
validityType: number;
/** 固定日期-生效开始时间 */
validStartTime: Date;
/** 固定日期-生效结束时间 */
validEndTime: Date;
/** 领取日期-开始天数 */
fixedStartTerm: number;
/** 领取日期-结束天数 */
fixedEndTerm: number;
/** 每人限领个数 */
takeLimitCount: number;
/** 是否设置满多少金额可用 */
usePriceEnabled: boolean;
/** 商品分类编号数组 */
productCategoryIds: number[];
}
/** 发送优惠券 */
export interface SendCoupon {
/** 优惠券编号 */
couponId: number;
/** 用户编号数组 */
userIds: number[];
}
}
/** 删除优惠劵 */
export function deleteCoupon(id: number) {
return requestClient.delete(`/promotion/coupon/delete?id=${id}`);
}
/** 获得优惠劵分页 */
export function getCouponPage(params: PageParam) {
return requestClient.get<PageResult<MallCouponApi.Coupon>>(
'/promotion/coupon/page',
{ params },
);
}
/** 发送优惠券 */
export function sendCoupon(data: MallCouponApi.SendCoupon) {
return requestClient.post('/promotion/coupon/send', data);
}

View File

@@ -1,112 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallCouponTemplateApi {
/** 优惠券模板 */
export interface CouponTemplate {
/** 模板编号 */
id: number;
/** 模板名称 */
name: string;
/** 状态 */
status: number;
/** 发放数量 */
totalCount: number;
/** 每人限领个数 */
takeLimitCount: number;
/** 领取方式 */
takeType: number;
/** 使用门槛 */
usePrice: number;
/** 商品范围 */
productScope: number;
/** 商品范围值 */
productScopeValues: number[];
/** 有效期类型 */
validityType: number;
/** 固定日期-生效开始时间 */
validStartTime: Date;
/** 固定日期-生效结束时间 */
validEndTime: Date;
/** 领取日期-开始天数 */
fixedStartTerm: number;
/** 领取日期-结束天数 */
fixedEndTerm: number;
/** 优惠类型 */
discountType: number;
/** 折扣百分比 */
discountPercent: number;
/** 优惠金额 */
discountPrice: number;
/** 折扣上限 */
discountLimitPrice: number;
/** 已领取数量 */
takeCount: number;
/** 已使用数量 */
useCount: number;
}
/** 优惠券模板状态更新 */
export interface StatusUpdate {
/** 模板编号 */
id: number;
/** 状态 */
status: 0 | 1;
}
}
/** 创建优惠劵模板 */
export function createCouponTemplate(
data: MallCouponTemplateApi.CouponTemplate,
) {
return requestClient.post('/promotion/coupon-template/create', data);
}
/** 更新优惠劵模板 */
export function updateCouponTemplate(
data: MallCouponTemplateApi.CouponTemplate,
) {
return requestClient.put('/promotion/coupon-template/update', data);
}
/** 更新优惠劵模板的状态 */
export function updateCouponTemplateStatus(id: number, status: 0 | 1) {
const data: MallCouponTemplateApi.StatusUpdate = { id, status };
return requestClient.put('/promotion/coupon-template/update-status', data);
}
/** 删除优惠劵模板 */
export function deleteCouponTemplate(id: number) {
return requestClient.delete(`/promotion/coupon-template/delete?id=${id}`);
}
/** 获得优惠劵模板 */
export function getCouponTemplate(id: number) {
return requestClient.get<MallCouponTemplateApi.CouponTemplate>(
`/promotion/coupon-template/get?id=${id}`,
);
}
/** 获得优惠劵模板分页 */
export function getCouponTemplatePage(params: PageParam) {
return requestClient.get<PageResult<MallCouponTemplateApi.CouponTemplate>>(
'/promotion/coupon-template/page',
{ params },
);
}
/** 获得优惠劵模板列表 */
export function getCouponTemplateList(ids: number[]) {
return requestClient.get<MallCouponTemplateApi.CouponTemplate[]>(
`/promotion/coupon-template/list?ids=${ids}`,
);
}
/** 导出优惠劵模板 Excel */
export function exportCouponTemplateExcel(params: PageParam) {
return requestClient.get('/promotion/coupon-template/export-excel', {
params,
responseType: 'blob',
});
}

View File

@@ -1,91 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import type { MallSpuApi } from '#/api/mall/product/spu';
import { requestClient } from '#/api/request';
export namespace MallDiscountActivityApi {
/** 限时折扣相关属性 */
export interface DiscountProduct {
/** 商品 SPU 编号 */
spuId: number;
/** 商品 SKU 编号 */
skuId: number;
/** 折扣类型 */
discountType: number;
/** 折扣百分比 */
discountPercent: number;
/** 折扣价格 */
discountPrice: number;
}
/** 限时折扣活动 */
export interface DiscountActivity {
/** 活动编号 */
id?: number;
/** 商品 SPU 编号 */
spuId?: number;
/** 活动名称 */
name?: string;
/** 状态 */
status?: number;
/** 备注 */
remark?: string;
/** 开始时间 */
startTime?: Date;
/** 结束时间 */
endTime?: Date;
/** 商品列表 */
products?: DiscountProduct[];
}
/** 扩展 SKU 配置 */
export type SkuExtension = {
/** 限时折扣配置 */
productConfig: DiscountProduct;
} & MallSpuApi.Sku;
/** 扩展 SPU 配置 */
export interface SpuExtension extends MallSpuApi.Spu {
/** SKU 列表 */
skus: SkuExtension[];
}
}
/** 查询限时折扣活动列表 */
export function getDiscountActivityPage(params: PageParam) {
return requestClient.get<
PageResult<MallDiscountActivityApi.DiscountActivity>
>('/promotion/discount-activity/page', { params });
}
/** 查询限时折扣活动详情 */
export function getDiscountActivity(id: number) {
return requestClient.get<MallDiscountActivityApi.DiscountActivity>(
`/promotion/discount-activity/get?id=${id}`,
);
}
/** 新增限时折扣活动 */
export function createDiscountActivity(
data: MallDiscountActivityApi.DiscountActivity,
) {
return requestClient.post('/promotion/discount-activity/create', data);
}
/** 修改限时折扣活动 */
export function updateDiscountActivity(
data: MallDiscountActivityApi.DiscountActivity,
) {
return requestClient.put('/promotion/discount-activity/update', data);
}
/** 关闭限时折扣活动 */
export function closeDiscountActivity(id: number) {
return requestClient.put(`/promotion/discount-activity/close?id=${id}`);
}
/** 删除限时折扣活动 */
export function deleteDiscountActivity(id: number) {
return requestClient.delete(`/promotion/discount-activity/delete?id=${id}`);
}

View File

@@ -1,61 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallDiyPageApi {
/** 装修页面 */
export interface DiyPage {
/** 页面编号 */
id?: number;
/** 模板编号 */
templateId?: number;
/** 页面名称 */
name: string;
/** 备注 */
remark: string;
/** 预览图片地址数组 */
previewPicUrls: string[];
/** 页面属性 */
property: string;
}
}
/** 查询装修页面列表 */
export function getDiyPagePage(params: PageParam) {
return requestClient.get<PageResult<MallDiyPageApi.DiyPage>>(
'/promotion/diy-page/page',
{ params },
);
}
/** 查询装修页面详情 */
export function getDiyPage(id: number) {
return requestClient.get<MallDiyPageApi.DiyPage>(
`/promotion/diy-page/get?id=${id}`,
);
}
/** 新增装修页面 */
export function createDiyPage(data: MallDiyPageApi.DiyPage) {
return requestClient.post('/promotion/diy-page/create', data);
}
/** 修改装修页面 */
export function updateDiyPage(data: MallDiyPageApi.DiyPage) {
return requestClient.put('/promotion/diy-page/update', data);
}
/** 删除装修页面 */
export function deleteDiyPage(id: number) {
return requestClient.delete(`/promotion/diy-page/delete?id=${id}`);
}
/** 获得装修页面属性 */
export function getDiyPageProperty(id: number) {
return requestClient.get<string>(`/promotion/diy-page/get-property?id=${id}`);
}
/** 更新装修页面属性 */
export function updateDiyPageProperty(data: MallDiyPageApi.DiyPage) {
return requestClient.put('/promotion/diy-page/update-property', data);
}

View File

@@ -1,80 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import type { MallDiyPageApi } from './page';
import { requestClient } from '#/api/request';
export namespace MallDiyTemplateApi {
/** 装修模板 */
export interface DiyTemplate {
/** 模板编号 */
id?: number;
/** 模板名称 */
name: string;
/** 是否使用 */
used: boolean;
/** 使用时间 */
usedTime?: Date;
/** 备注 */
remark: string;
/** 预览图片地址数组 */
previewPicUrls: string[];
/** 模板属性 */
property: string;
}
/** 装修模板属性(包含页面列表) */
export interface DiyTemplateProperty extends DiyTemplate {
/** 页面列表 */
pages: MallDiyPageApi.DiyPage[];
}
}
/** 查询装修模板列表 */
export function getDiyTemplatePage(params: PageParam) {
return requestClient.get<PageResult<MallDiyTemplateApi.DiyTemplate>>(
'/promotion/diy-template/page',
{ params },
);
}
/** 查询装修模板详情 */
export function getDiyTemplate(id: number) {
return requestClient.get<MallDiyTemplateApi.DiyTemplate>(
`/promotion/diy-template/get?id=${id}`,
);
}
/** 新增装修模板 */
export function createDiyTemplate(data: MallDiyTemplateApi.DiyTemplate) {
return requestClient.post('/promotion/diy-template/create', data);
}
/** 修改装修模板 */
export function updateDiyTemplate(data: MallDiyTemplateApi.DiyTemplate) {
return requestClient.put('/promotion/diy-template/update', data);
}
/** 删除装修模板 */
export function deleteDiyTemplate(id: number) {
return requestClient.delete(`/promotion/diy-template/delete?id=${id}`);
}
/** 使用装修模板 */
export function useDiyTemplate(id: number) {
return requestClient.put(`/promotion/diy-template/use?id=${id}`);
}
/** 获得装修模板属性 */
export function getDiyTemplateProperty(id: number) {
return requestClient.get<MallDiyTemplateApi.DiyTemplateProperty>(
`/promotion/diy-template/get-property?id=${id}`,
);
}
/** 更新装修模板属性 */
export function updateDiyTemplateProperty(
data: MallDiyTemplateApi.DiyTemplate,
) {
return requestClient.put('/promotion/diy-template/update-property', data);
}

View File

@@ -1,70 +0,0 @@
import type { PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallKefuConversationApi {
/** 客服会话 */
export interface Conversation {
/** 编号 */
id: number;
/** 会话所属用户 */
userId: number;
/** 会话所属用户头像 */
userAvatar: string;
/** 会话所属用户昵称 */
userNickname: string;
/** 最后聊天时间 */
lastMessageTime: Date;
/** 最后聊天内容 */
lastMessageContent: string;
/** 最后发送的消息类型 */
lastMessageContentType: number;
/** 管理端置顶 */
adminPinned: boolean;
/** 用户是否可见 */
userDeleted: boolean;
/** 管理员是否可见 */
adminDeleted: boolean;
/** 管理员未读消息数 */
adminUnreadMessageCount: number;
/** 创建时间 */
createTime?: string;
}
/** 会话置顶请求 */
export interface ConversationPinnedUpdate {
/** 会话编号 */
id: number;
/** 是否置顶 */
pinned: boolean;
}
}
/** 获得客服会话列表 */
export function getConversationList() {
return requestClient.get<PageResult<MallKefuConversationApi.Conversation>>(
'/promotion/kefu-conversation/list',
);
}
/** 获得客服会话 */
export function getConversation(id: number) {
return requestClient.get<MallKefuConversationApi.Conversation>(
`/promotion/kefu-conversation/get?id=${id}`,
);
}
/** 客服会话置顶 */
export function updateConversationPinned(
data: MallKefuConversationApi.ConversationPinnedUpdate,
) {
return requestClient.put(
'/promotion/kefu-conversation/update-conversation-pinned',
data,
);
}
/** 删除客服会话 */
export function deleteConversation(id: number) {
return requestClient.delete(`/promotion/kefu-conversation/delete?id=${id}`);
}

View File

@@ -1,67 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallKefuMessageApi {
/** 客服消息 */
export interface Message {
/** 编号 */
id: number;
/** 会话编号 */
conversationId: number;
/** 发送人编号 */
senderId: number;
/** 发送人头像 */
senderAvatar: string;
/** 发送人类型 */
senderType: number;
/** 接收人编号 */
receiverId: number;
/** 接收人类型 */
receiverType: number;
/** 消息类型 */
contentType: number;
/** 消息内容 */
content: string;
/** 是否已读 */
readStatus: boolean;
/** 创建时间 */
createTime: Date;
}
/** 发送消息请求 */
export interface MessageSend {
/** 会话编号 */
conversationId: number;
/** 消息类型 */
contentType: number;
/** 消息内容 */
content: string;
}
/** 消息列表查询参数 */
export interface MessageQuery extends PageParam {
/** 会话编号 */
conversationId: number;
}
}
/** 发送客服消息 */
export function sendKeFuMessage(data: MallKefuMessageApi.MessageSend) {
return requestClient.post('/promotion/kefu-message/send', data);
}
/** 更新客服消息已读状态 */
export function updateKeFuMessageReadStatus(conversationId: number) {
return requestClient.put(
`/promotion/kefu-message/update-read-status?conversationId=${conversationId}`,
);
}
/** 获得消息列表(流式加载) */
export function getKeFuMessageList(params: MallKefuMessageApi.MessageQuery) {
return requestClient.get<PageResult<MallKefuMessageApi.Message>>(
'/promotion/kefu-message/list',
{ params },
);
}

View File

@@ -1,127 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import type { MallSpuApi } from '#/api/mall/product/spu';
import { requestClient } from '#/api/request';
export namespace MallPointActivityApi {
/** 积分商城商品 */
export interface PointProduct {
/** 积分商城商品编号 */
id?: number;
/** 积分商城活动 id */
activityId?: number;
/** 商品 SPU 编号 */
spuId?: number;
/** 商品 SKU 编号 */
skuId: number;
/** 可兑换数量 */
count: number;
/** 兑换积分 */
point: number;
/** 兑换金额,单位:分 */
price: number;
/** 积分商城商品库存 */
stock: number;
/** 积分商城商品状态 */
activityStatus?: number;
}
/** 积分商城活动 */
export interface PointActivity {
/** 积分商城活动编号 */
id: number;
/** 积分商城活动商品 */
spuId: number;
/** 活动状态 */
status: number;
/** 积分商城活动库存 */
stock: number;
/** 积分商城活动总库存 */
totalStock: number;
/** 备注 */
remark?: string;
/** 排序 */
sort: number;
/** 创建时间 */
createTime: string;
/** 积分商城商品 */
products: PointProduct[];
/** 商品名称 */
spuName: string;
/** 商品主图 */
picUrl: string;
/** 商品市场价,单位:分 */
marketPrice: number;
/** 兑换积分 */
point: number;
/** 兑换金额,单位:分 */
price: number;
}
/** 扩展 SKU 配置 */
export type SkuExtension = {
/** 积分商城商品配置 */
productConfig: PointProduct;
} & MallSpuApi.Sku;
/** 扩展 SPU 配置 */
export interface SpuExtension extends MallSpuApi.Spu {
/** SKU 列表 */
skus: SkuExtension[];
}
/** 扩展 SPU 配置(带积分信息) */
export interface SpuExtensionWithPoint extends MallSpuApi.Spu {
/** 积分商城活动库存 */
pointStock: number;
/** 积分商城活动总库存 */
pointTotalStock: number;
/** 兑换积分 */
point: number;
/** 兑换金额,单位:分 */
pointPrice: number;
}
}
/** 查询积分商城活动分页 */
export function getPointActivityPage(params: PageParam) {
return requestClient.get<PageResult<MallPointActivityApi.PointActivity>>(
'/promotion/point-activity/page',
{ params },
);
}
/** 查询积分商城活动详情 */
export function getPointActivity(id: number) {
return requestClient.get<MallPointActivityApi.PointActivity>(
`/promotion/point-activity/get?id=${id}`,
);
}
/** 查询积分商城活动列表,基于活动编号数组 */
export function getPointActivityListByIds(ids: number[]) {
return requestClient.get<MallPointActivityApi.PointActivity[]>(
`/promotion/point-activity/list-by-ids?ids=${ids}`,
);
}
/** 新增积分商城活动 */
export function createPointActivity(data: MallPointActivityApi.PointActivity) {
return requestClient.post('/promotion/point-activity/create', data);
}
/** 修改积分商城活动 */
export function updatePointActivity(data: MallPointActivityApi.PointActivity) {
return requestClient.put('/promotion/point-activity/update', data);
}
/** 删除积分商城活动 */
export function deletePointActivity(id: number) {
return requestClient.delete(`/promotion/point-activity/delete?id=${id}`);
}
/** 关闭积分商城活动 */
export function closePointActivity(id: number) {
return requestClient.put(`/promotion/point-activity/close?id=${id}`);
}

View File

@@ -1,88 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallRewardActivityApi {
/** 优惠规则 */
export interface RewardRule {
/** 满足金额 */
limit?: number;
/** 优惠金额 */
discountPrice?: number;
/** 是否包邮 */
freeDelivery?: boolean;
/** 赠送积分 */
point: number;
/** 赠送优惠券数量 */
giveCouponTemplateCounts?: {
[key: number]: number;
};
}
/** 满减送活动 */
export interface RewardActivity {
/** 活动编号 */
id?: number;
/** 活动名称 */
name?: string;
/** 开始时间 */
startTime?: Date;
/** 结束时间 */
endTime?: Date;
/** 开始和结束时间(仅前端使用) */
startAndEndTime?: Date[];
/** 备注 */
remark?: string;
/** 条件类型 */
conditionType?: number;
/** 商品范围 */
productScope?: number;
/** 优惠规则列表 */
rules: RewardRule[];
/** 商品范围值(仅表单使用):值为品类编号列表、商品编号列表 */
productScopeValues?: number[];
/** 商品分类编号列表(仅表单使用) */
productCategoryIds?: number[];
/** 商品 SPU 编号列表(仅表单使用) */
productSpuIds?: number[];
}
}
/** 新增满减送活动 */
export function createRewardActivity(
data: MallRewardActivityApi.RewardActivity,
) {
return requestClient.post('/promotion/reward-activity/create', data);
}
/** 更新满减送活动 */
export function updateRewardActivity(
data: MallRewardActivityApi.RewardActivity,
) {
return requestClient.put('/promotion/reward-activity/update', data);
}
/** 查询满减送活动列表 */
export function getRewardActivityPage(params: PageParam) {
return requestClient.get<PageResult<MallRewardActivityApi.RewardActivity>>(
'/promotion/reward-activity/page',
{ params },
);
}
/** 查询满减送活动详情 */
export function getReward(id: number) {
return requestClient.get<MallRewardActivityApi.RewardActivity>(
`/promotion/reward-activity/get?id=${id}`,
);
}
/** 删除满减送活动 */
export function deleteRewardActivity(id: number) {
return requestClient.delete(`/promotion/reward-activity/delete?id=${id}`);
}
/** 关闭满减送活动 */
export function closeRewardActivity(id: number) {
return requestClient.put(`/promotion/reward-activity/close?id=${id}`);
}

View File

@@ -1,117 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import type { MallSpuApi } from '#/api/mall/product/spu';
import { requestClient } from '#/api/request';
export namespace MallSeckillActivityApi {
/** 秒杀商品 */
export interface SeckillProduct {
/** 商品 SKU 编号 */
skuId: number;
/** 商品 SPU 编号 */
spuId: number;
/** 秒杀价格 */
seckillPrice: number;
/** 秒杀库存 */
stock: number;
}
/** 秒杀活动 */
export interface SeckillActivity {
/** 活动编号 */
id?: number;
/** 商品 SPU 编号 */
spuId?: number;
/** 活动名称 */
name?: string;
/** 活动状态 */
status?: number;
/** 备注 */
remark?: string;
/** 开始时间 */
startTime?: Date;
/** 结束时间 */
endTime?: Date;
/** 排序 */
sort?: number;
/** 配置编号 */
configIds?: string;
/** 订单数量 */
orderCount?: number;
/** 用户数量 */
userCount?: number;
/** 总金额 */
totalPrice?: number;
/** 总限购数量 */
totalLimitCount?: number;
/** 单次限购数量 */
singleLimitCount?: number;
/** 秒杀库存 */
stock?: number;
/** 秒杀总库存 */
totalStock?: number;
/** 秒杀价格 */
seckillPrice?: number;
/** 秒杀商品列表 */
products?: SeckillProduct[];
}
/** 扩展 SKU 配置 */
export type SkuExtension = {
/** 秒杀商品配置 */
productConfig: SeckillProduct;
} & MallSpuApi.Sku;
/** 扩展 SPU 配置 */
export interface SpuExtension extends MallSpuApi.Spu {
/** SKU 列表 */
skus: SkuExtension[];
}
}
/** 查询秒杀活动列表 */
export function getSeckillActivityPage(params: PageParam) {
return requestClient.get<PageResult<MallSeckillActivityApi.SeckillActivity>>(
'/promotion/seckill-activity/page',
{ params },
);
}
/** 查询秒杀活动列表,基于活动编号数组 */
export function getSeckillActivityListByIds(ids: number[]) {
return requestClient.get<MallSeckillActivityApi.SeckillActivity[]>(
`/promotion/seckill-activity/list-by-ids?ids=${ids}`,
);
}
/** 查询秒杀活动详情 */
export function getSeckillActivity(id: number) {
return requestClient.get<MallSeckillActivityApi.SeckillActivity>(
`/promotion/seckill-activity/get?id=${id}`,
);
}
/** 新增秒杀活动 */
export function createSeckillActivity(
data: MallSeckillActivityApi.SeckillActivity,
) {
return requestClient.post('/promotion/seckill-activity/create', data);
}
/** 修改秒杀活动 */
export function updateSeckillActivity(
data: MallSeckillActivityApi.SeckillActivity,
) {
return requestClient.put('/promotion/seckill-activity/update', data);
}
/** 关闭秒杀活动 */
export function closeSeckillActivity(id: number) {
return requestClient.put(`/promotion/seckill-activity/close?id=${id}`);
}
/** 删除秒杀活动 */
export function deleteSeckillActivity(id: number) {
return requestClient.delete(`/promotion/seckill-activity/delete?id=${id}`);
}

View File

@@ -1,74 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MallSeckillConfigApi {
/** 秒杀时段 */
export interface SeckillConfig {
/** 编号 */
id: number;
/** 秒杀时段名称 */
name: string;
/** 开始时间点 */
startTime: string;
/** 结束时间点 */
endTime: string;
/** 秒杀轮播图 */
sliderPicUrls: string[];
/** 活动状态 */
status: number;
}
/** 时段配置状态更新 */
export interface StatusUpdate {
/** 编号 */
id: number;
/** 状态 */
status: number;
}
}
/** 查询秒杀时段分页 */
export function getSeckillConfigPage(params: PageParam) {
return requestClient.get<PageResult<MallSeckillConfigApi.SeckillConfig>>(
'/promotion/seckill-config/page',
{ params },
);
}
/** 查询秒杀时段列表 */
export function getSimpleSeckillConfigList() {
return requestClient.get<MallSeckillConfigApi.SeckillConfig[]>(
'/promotion/seckill-config/list',
);
}
/** 查询秒杀时段详情 */
export function getSeckillConfig(id: number) {
return requestClient.get<MallSeckillConfigApi.SeckillConfig>(
`/promotion/seckill-config/get?id=${id}`,
);
}
/** 新增秒杀时段 */
export function createSeckillConfig(data: MallSeckillConfigApi.SeckillConfig) {
return requestClient.post('/promotion/seckill-config/create', data);
}
/** 修改秒杀时段 */
export function updateSeckillConfig(data: MallSeckillConfigApi.SeckillConfig) {
return requestClient.put('/promotion/seckill-config/update', data);
}
/** 删除秒杀时段 */
export function deleteSeckillConfig(id: number) {
return requestClient.delete(`/promotion/seckill-config/delete?id=${id}`);
}
/** 修改时段配置状态 */
export function updateSeckillConfigStatus(id: number, status: number) {
return requestClient.put('/promotion/seckill-config/update-status', {
id,
status,
});
}

View File

@@ -1,5 +0,0 @@
/** 数据对照 Response */
export interface MallDataComparisonResp<T> {
value: T;
reference: T;
}

View File

@@ -1,131 +0,0 @@
import type { MallDataComparisonResp } from './common';
import { formatDate } from '@vben/utils';
import { requestClient } from '#/api/request';
export namespace MallMemberStatisticsApi {
/** 会员分析 Request */
export interface AnalyseReq {
times: Date[];
}
/** 会员分析对照数据 Response */
export interface AnalyseComparison {
registerUserCount: number;
visitUserCount: number;
rechargeUserCount: number;
}
/** 会员分析 Response */
export interface Analyse {
visitUserCount: number;
orderUserCount: number;
payUserCount: number;
atv: number;
comparison: MallDataComparisonResp<AnalyseComparison>;
}
/** 会员地区统计 Response */
export interface AreaStatistics {
areaId: number;
areaName: string;
userCount: number;
orderCreateUserCount: number;
orderPayUserCount: number;
orderPayPrice: number;
}
/** 会员性别统计 Response */
export interface SexStatistics {
sex: number;
userCount: number;
}
/** 会员统计 Response */
export interface Summary {
userCount: number;
rechargeUserCount: number;
rechargePrice: number;
expensePrice: number;
}
/** 会员终端统计 Response */
export interface TerminalStatistics {
terminal: number;
userCount: number;
}
/** 会员数量统计 Response */
export interface Count {
/** 用户访问量 */
visitUserCount: string;
/** 注册用户数量 */
registerUserCount: number;
}
/** 会员注册数量 Response */
export interface RegisterCount {
date: string;
count: number;
}
}
/** 查询会员统计 */
export function getMemberSummary() {
return requestClient.get<MallMemberStatisticsApi.Summary>(
'/statistics/member/summary',
);
}
/** 查询会员分析数据 */
export function getMemberAnalyse(params: MallMemberStatisticsApi.AnalyseReq) {
return requestClient.get<MallMemberStatisticsApi.Analyse>(
'/statistics/member/analyse',
{
params: {
times: [formatDate(params.times[0]), formatDate(params.times[1])],
},
},
);
}
/** 按照省份,查询会员统计列表 */
export function getMemberAreaStatisticsList() {
return requestClient.get<MallMemberStatisticsApi.AreaStatistics[]>(
'/statistics/member/area-statistics-list',
);
}
/** 按照性别,查询会员统计列表 */
export function getMemberSexStatisticsList() {
return requestClient.get<MallMemberStatisticsApi.SexStatistics[]>(
'/statistics/member/sex-statistics-list',
);
}
/** 按照终端,查询会员统计列表 */
export function getMemberTerminalStatisticsList() {
return requestClient.get<MallMemberStatisticsApi.TerminalStatistics[]>(
'/statistics/member/terminal-statistics-list',
);
}
/** 获得用户数量量对照 */
export function getUserCountComparison() {
return requestClient.get<
MallDataComparisonResp<MallMemberStatisticsApi.Count>
>('/statistics/member/user-count-comparison');
}
/** 获得会员注册数量列表 */
export function getMemberRegisterCountList(beginTime: Date, endTime: Date) {
return requestClient.get<MallMemberStatisticsApi.RegisterCount[]>(
'/statistics/member/register-count-list',
{
params: {
times: [formatDate(beginTime), formatDate(endTime)],
},
},
);
}

View File

@@ -1,16 +0,0 @@
import { requestClient } from '#/api/request';
export namespace MallPayStatisticsApi {
/** 支付统计 */
export interface PaySummaryResp {
/** 充值金额,单位分 */
rechargePrice: number;
}
}
/** 获取钱包充值金额 */
export function getWalletRechargePrice() {
return requestClient.get<MallPayStatisticsApi.PaySummaryResp>(
'/statistics/pay/summary',
);
}

View File

@@ -1,68 +0,0 @@
import type { PageParam, PageResult } from '@vben/request';
import type { MallDataComparisonResp } from './common';
import { requestClient } from '#/api/request';
export namespace MallProductStatisticsApi {
/** 商品统计数据 */
export interface ProductStatistics {
/** 编号 */
id: number;
/** 统计日期 */
day: string;
/** 商品 SPU 编号 */
spuId: number;
/** 商品 SPU 名称 */
spuName: string;
/** 商品 SPU 图片 */
spuPicUrl: string;
/** 浏览次数 */
browseCount: number;
/** 浏览人数 */
browseUserCount: number;
/** 收藏次数 */
favoriteCount: number;
/** 加购次数 */
cartCount: number;
/** 下单次数 */
orderCount: number;
/** 支付次数 */
orderPayCount: number;
/** 支付金额 */
orderPayPrice: number;
/** 售后次数 */
afterSaleCount: number;
/** 退款金额 */
afterSaleRefundPrice: number;
/** 浏览转化率 */
browseConvertPercent: number;
}
}
/** 获得商品统计分析 */
export function getProductStatisticsAnalyse(params: PageParam) {
return requestClient.get<
MallDataComparisonResp<MallProductStatisticsApi.ProductStatistics>
>('/statistics/product/analyse', { params });
}
/** 获得商品状况明细 */
export function getProductStatisticsList(params: PageParam) {
return requestClient.get<MallProductStatisticsApi.ProductStatistics[]>(
'/statistics/product/list',
{ params },
);
}
/** 导出获得商品状况明细 Excel */
export function exportProductStatisticsExcel(params: PageParam) {
return requestClient.download('/statistics/product/export-excel', { params });
}
/** 获得商品排行榜分页 */
export function getProductStatisticsRankPage(params: PageParam) {
return requestClient.get<
PageResult<MallProductStatisticsApi.ProductStatistics>
>('/statistics/product/rank-page', { params });
}

View File

@@ -1,135 +0,0 @@
import type { MallDataComparisonResp } from './common';
import { formatDate } from '@vben/utils';
import { requestClient } from '#/api/request';
export namespace MallTradeStatisticsApi {
/** 交易统计 Response */
export interface TradeSummary {
yesterdayOrderCount: number;
monthOrderCount: number;
yesterdayPayPrice: number;
monthPayPrice: number;
}
/** 交易状况 Request */
export interface TradeTrendReq {
times: [Date, Date];
}
/** 交易状况统计 Response */
export interface TradeTrendSummary {
time: string;
turnoverPrice: number;
orderPayPrice: number;
rechargePrice: number;
expensePrice: number;
walletPayPrice: number;
brokerageSettlementPrice: number;
afterSaleRefundPrice: number;
}
/** 交易订单数量 Response */
export interface TradeOrderCount {
/** 待发货 */
undelivered?: number;
/** 待核销 */
pickUp?: number;
/** 退款中 */
afterSaleApply?: number;
/** 提现待审核 */
auditingWithdraw?: number;
}
/** 交易订单统计 Response */
export interface TradeOrderSummary {
/** 支付订单商品数 */
orderPayCount?: number;
/** 总支付金额,单位:分 */
orderPayPrice?: number;
}
/** 订单量趋势统计 Response */
export interface TradeOrderTrend {
/** 日期 */
date: string;
/** 订单数量 */
orderPayCount: number;
/** 订单支付金额 */
orderPayPrice: number;
}
}
/** 时间参数需要格式化, 确保接口能识别 */
const formatDateParam = (params: MallTradeStatisticsApi.TradeTrendReq) => {
return {
times: [formatDate(params.times[0]), formatDate(params.times[1])],
} as MallTradeStatisticsApi.TradeTrendReq;
};
/** 查询交易统计 */
export function getTradeStatisticsSummary() {
return requestClient.get<
MallDataComparisonResp<MallTradeStatisticsApi.TradeSummary>
>('/statistics/trade/summary');
}
/** 获得交易状况统计 */
export function getTradeStatisticsAnalyse(
params: MallTradeStatisticsApi.TradeTrendReq,
) {
return requestClient.get<
MallDataComparisonResp<MallTradeStatisticsApi.TradeTrendSummary>
>('/statistics/trade/analyse', { params: formatDateParam(params) });
}
/** 获得交易状况明细 */
export function getTradeStatisticsList(
params: MallTradeStatisticsApi.TradeTrendReq,
) {
return requestClient.get<MallTradeStatisticsApi.TradeTrendSummary[]>(
'/statistics/trade/list',
{ params: formatDateParam(params) },
);
}
/** 导出交易状况明细 */
export function exportTradeStatisticsExcel(
params: MallTradeStatisticsApi.TradeTrendReq,
) {
return requestClient.download('/statistics/trade/export-excel', {
params: formatDateParam(params),
});
}
/** 获得交易订单数量 */
export function getOrderCount() {
return requestClient.get<MallTradeStatisticsApi.TradeOrderCount>(
'/statistics/trade/order-count',
);
}
/** 获得交易订单数量对照 */
export function getOrderComparison() {
return requestClient.get<
MallDataComparisonResp<MallTradeStatisticsApi.TradeOrderSummary>
>('/statistics/trade/order-comparison');
}
/** 获得订单量趋势统计 */
export function getOrderCountTrendComparison(
type: number,
beginTime: Date,
endTime: Date,
) {
return requestClient.get<
MallDataComparisonResp<MallTradeStatisticsApi.TradeOrderTrend>[]
>('/statistics/trade/order-count-trend', {
params: {
type,
beginTime: formatDate(beginTime),
endTime: formatDate(endTime),
},
});
}

Some files were not shown because too many files have changed in this diff Show More