Compare commits

..

No commits in common. 'main' and 'test' have entirely different histories.
main ... test

@ -1,37 +0,0 @@
# 生产环境: 只在打包时使用
NODE_ENV=production
VITE_DEV=false
# 请求路径
# 【修改点】这里指向内部环境的网关,比如 /admin-api-inner 或者直接留空走相对路径
VITE_BASE_URL=' '
# 文件上传类型: server - 后端上传, client - 前端直连,仅支持S3服务
VITE_UPLOAD_TYPE=server
# 上传路径
VITE_UPLOAD_URL=/admin-api/infra/file/upload
# 接口地址
# 【修改点】这里改成一个内部域名或IP例如 http://192.168.1.100:8080
# 如果前端和后端在同一个 Docker 网络,也可以用内部服务名,比如 http://besure-server-inner:48081
VITE_API_URL=/admin-api
# 是否删除debugger
VITE_DROP_DEBUGGER=true
# 是否删除console.log
VITE_DROP_CONSOLE=true
# 是否sourcemap (内网环境建议开启方便排查线上问题如果想极致压缩也可以false)
VITE_SOURCEMAP=false
# 打包路径
VITE_BASE_PATH=/
# 输出路径
VITE_OUT_DIR=dist
# 商城H5会员端域名
# 【修改点】内网测试时这里可能不需要或者指向一个内部H5地址
VITE_MALL_H5_DOMAIN='http://mall.yudao.test.cn'

@ -8,9 +8,8 @@ VITE_DEV=true
# 线上环境 # 线上环境
# VITE_BASE_URL='https://besure.ngsk.tech:7001' # VITE_BASE_URL='https://besure.ngsk.tech:7001'
# 本地联调 # 本地联调
VITE_BASE_URL='http://192.168.5.37:48081' VITE_BASE_URL='http://192.168.5.106:48081'
# VITE_BASE_URL='http://47.106.185.127:8089' # VITE_BASE_URL='http://192.168.5.164:48081'
# VITE_BASE_URL='http://192.168.43.233:48081'
# VITE_BASE_URL='http://192.168.5.5:48081' # VITE_BASE_URL='http://192.168.5.5:48081'

@ -1,4 +1,4 @@
# 使用轻量级的 Nginx 镜像 # 使用轻量级的 Nginx 镜像
FROM nginx:alpine FROM nginx:alpine
ARG NGINX_CONF=nginx.conf ARG NGINX_CONF=nginx.conf
@ -10,8 +10,7 @@ COPY dist /usr/share/nginx/html
EXPOSE 8088 EXPOSE 8088
# 安装 getent 依赖Alpine 自带)
# 创建启动脚本:轮询等待后端 DNS 解析成功后再启动 nginx
# 创建启动脚本 # 创建启动脚本
RUN echo -e '#!/bin/sh\n\ RUN echo -e '#!/bin/sh\n\
echo "Waiting for MySQL/Redis/MinIO to start..."\n\ echo "Waiting for MySQL/Redis/MinIO to start..."\n\
@ -19,4 +18,4 @@ sleep 15\n\
nginx -g "daemon off;"' > /start.sh && \ nginx -g "daemon off;"' > /start.sh && \
chmod +x /start.sh chmod +x /start.sh
CMD ["/start.sh"] CMD ["/start.sh"]

@ -1,121 +0,0 @@
style产品物料信息-新增/编辑-编码输入框大小调整
feat仓库信息-添加详情弹框
feat库区信息/库位信息-新增页面
style任务单排产-排产甘特图样式优化
style甘特图菜单样式调整
style甘特图适配中英文
Merge branch 'main' of https://git.ngsk.tech/linweidong/besure_web
style生产报表页面适配中英文
style出库单据-默认展示tabs修改
style生产报表-质检信息字段调整
style任务单排产-create-batch接口添加领料人/是否计算损耗入参
style生产计划/任务单排产生产报表-进度条样式修改
style生产计划-检验明细添加分页
feat生产报表-质检信息对接
feat甘特图菜单页添加刷新按钮
style任务单排产-进度条样式修改
feat甘特图菜单页-添加排产看板
style生产计划-检验按钮保存后刷新列表
style检验记录-新增/编辑-生产计划选项框调整
style检验记录-编辑添加显示判断
style检验模板-新增/编辑-检验方案添加productId传参
style任务单排产-任务单明细-是否计算损耗字段
style检验模板-编辑回显
style任务单排产-任务单明细-新增计划添加领料人、是否完成质检字段
style生产报表-报工信息-添加日期筛选条件
style生产报表-列表添加刷新按钮
style生产报表-基础信息-查看产品信息字段修改
feat生产计划-已开工-检验按钮逻辑修改
style修复甘特图保存后弹框报错
style生产投料-数量不填的默认为0
style产品物料信息-设备-所属车间字段更改
feat检验模板-添加关联产品
style产品物料信息-关联设备选项接口添加deviceStatus=0入参
style产品物料信息-状态字段位置更改
style任务制单-技术要求、备注样式修改
style任务制单-明细-编辑-打包数量字段自动填充
style产品物料信息-去掉字段:采购价格、最低价格、销售价格
style产品BOM-产品BOM明细-单位自动带入
style生产计划-添加“所有”tabs
style甘特图菜单添加设备筛选框
style排产甘特图日期调整
feat菜单甘特图页面/一键排查-甘特图拆开两个组件
style排产弹框-任务单汇总明细-未计划数为0的不能勾选
style排产弹框适配中英文
style检验记录-新增添加单号自动生成
style产品BOM-产品筛选框接口更改
style任务单排产-排产弹框样式调整
style任务制单-父列表项的status值为2,7,8,9,10时子列表不展示编辑和删除按钮
Merge branch 'main' of https://git.ngsk.tech/linweidong/besure_web
style任务单排产-生产进度条样式修改
feat添加生产报表页面
style生产计划-暂停状态操作栏添加开工按钮
Merge branch 'main' of https://git.ngsk.tech/linweidong/besure_web
style厂区结构-关联采集设备字段回显
feat待入库-入库按钮添加仓库选择
style厂区结构-新增/编辑-关联采集设备选项接口更换
feat甘特图添加颜色区分
feat添加报工记录页面
style甘特图菜单页添加每日报工平均值、数据采集产能字段
style甘特图显示样式优化
style任务单排产-新增-计划开始、计划结束、最晚开工时间添加时分秒
style任务制单-新增-交货日期不能选往日
style任务单排产-添加生产进度条
style任务制单-tabs项更换
style任务单排产-新增计划-数量值添加校验(不能大于未计划数量)
style甘特图tooltip隐藏逻辑优化
Merge branch 'main' of https://git.ngsk.tech/linweidong/besure_web
style修改任务单排产-新增计划及生产计划详情字段
style任务制单-任务单明细-新增按钮显示逻辑修改
style任务单排产-tabs更换
style任务单排产-未计划为0的不显示新增计划按钮
style任务制单-任务单明细-新增按钮显示逻辑修改
style生产计划-报工后刷新报工记录列表
style生产计划-详情弹框字段与排产的新增计划弹框字段同步
style生产投料-新增-生产计划status值修改
style删除甘特图菜单无用代码
feat甘特图组件封装
style生产计划列表添加任务编码
style产品BOM-编辑-bomDetails集合里不传createTime字段
Merge branch 'main' of https://git.ngsk.tech/linweidong/besure_web
style排产甘特图样式优化
style排产弹框-添加是否跳过节假日switch
style排产甘特图样式调整
style检验记录-编辑-ticketType回显
style检验记录-生产计划传参修改
style任务单排产-关联设备保存后刷新列表
feat排产弹框-新增设备名称列/关联设备按钮
feat生产计划-添加已开工tabs
style任务单排产-新增计划-计划开始时间不能晚于结束时间
style设备台账-是否排产勾选后展示额定产能、每日报工平均值、数据采集产能
Merge branch 'main' of https://git.ngsk.tech/linweidong/besure_web
style处理设备台账代码合并问题
Merge branch 'main' of https://git.ngsk.tech/linweidong/besure_web
style甘特图查询时间默认本月
feat新增甘特图页面
style任务单排产-排产弹框-复选框逻辑优化
style任务单排产-甘特图样式修改
style任务单排产-一键排查接口字段调整
style任务单排产字段调整
style甘特图样式修改
style任务单排产-新增计划-taskDetailId传参调整
style产品物料信息-新增/编辑-设备列表添加已排产过滤
style排产接口入参添加产品编码
feat甘特图弹框抽离组件
style任务单排产-甘特图保存字段调整
style生产计划-甘特图样式修改
feat添加甘特图预览
style设备台账-新增/编辑-是否排产字段修改
style产品物料信息-阻止表单原生事件
style设备台账-是否排产字段修改
feat任务单排产-列表表头调整、排产弹框对接
style表管理-计算规则添加文案提示
feat采集设备-点位规则添加四则运算规则
style采集设备-添加新增产量按钮
style任务单排产-新增计划刷新列表
Merge branch 'main' of https://git.ngsk.tech/linweidong/besure_web
style任务单排产-列表添加“是否完成排产”列
style产品BOM-新增-清除单位默认值
feat任务制单-添加是否急单字段
feat产品管理-产品物料信息-产品分类时添加关联设备、关联模具字段
feat设备台账-添加是否排产、额定产能字段状态改成switch切换

@ -1,9 +1,8 @@
<!DOCTYPE html> <!DOCTYPE html>
<html lang="en"> <html lang="en">
<head> <head>
<meta charset="UTF-8" /> <meta charset="UTF-8" />
<link rel="icon" href="/favicon.ico" /> <link rel="icon" href="/favicon.ico" />
<link rel="stylesheet" type="text/css" media="print" href="/print-lock.css" />
<meta http-equiv="X-UA-Compatible" content="IE=edge" /> <meta http-equiv="X-UA-Compatible" content="IE=edge" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" />
<meta <meta
@ -147,34 +146,6 @@
</div> </div>
</div> </div>
</div> </div>
<!-- Edge 兼容hiprint socket.io 连接添加 polling 降级策略,防止 WebSocket-only 连接在 Edge 下失败 -->
<script>
(function() {
try {
if (window.__hiprintEdgeFixApplied) return;
var _io = window.io;
Object.defineProperty(window, 'io', {
configurable: true,
enumerable: true,
get: function() { return _io; },
set: function(fn) {
if (typeof fn === 'function' && fn !== _io && !fn.__hiprintPatched) {
var _orig = fn;
_io = function(url, opts) {
opts = Object.assign({}, opts || {});
opts.transports = ['websocket', 'polling'];
return _orig(url, opts);
};
_io.__hiprintPatched = true;
} else {
_io = fn;
}
}
});
window.__hiprintEdgeFixApplied = true;
} catch(e) { console.warn('[hiprint-fix]', e); }
})();
</script>
<script type="module" src="/src/main.ts"></script> <script type="module" src="/src/main.ts"></script>
</body> </body>
</html> </html>

@ -1,112 +0,0 @@
server {
listen 8088;
server_name localhost;
# 关键允许上传最大100MB
client_max_body_size 100m;
# 超时时间
proxy_connect_timeout 300s;
proxy_send_timeout 300s;
proxy_read_timeout 300s;
client_body_timeout 300s;
send_timeout 300s;
# 防止大文件上传被缓冲卡死
proxy_request_buffering off;
proxy_buffering off;
# Docker DNS resolver to enable runtime upstream resolution, preventing host not found at startup
resolver 127.0.0.11 valid=10s;
# ========== 内网环境特有配置 ==========
# 如果 inner 环境的后端服务名不同,比如叫 besure-server-inner
# 就把下面的 proxy_pass 改成对应的服务名或IP
location /admin-api/ {
proxy_pass http://besure_server_inner:48081; # 👈 这里改!
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
# 其他路径保持不变
location /api/ {
proxy_pass http://besure_server_inner:48081; # 👈 原生产后端
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
location /jmreport/ {
proxy_pass http://besure_server_inner:48081; # 👈 原生产后端
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
location /v3/api-docs/ {
proxy_pass http://besure_server_inner:48081; # 👈 原生产后端
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
location /doc.html {
proxy_pass http://besure_server_inner:48081; # 👈 原生产后端
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
location /swagger-ui/ {
proxy_pass http://besure_server_inner:48081; # 👈 原生产后端
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
}
# 处理Swagger静态资源
location /webjars/ {
proxy_pass http://besure_server_inner:48081; # 👈 原生产后端
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
}
# 处理API文档JSON文件
location ~ /v3/api-docs/.*\.json$ {
proxy_pass http://besure_server_inner:48081; # 👈 原生产后端
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
}
# 前端静态资源
location / {
root /usr/share/nginx/html;
index index.html index.htm;
try_files $uri $uri/ /index.html;
}
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root /usr/share/nginx/html;
}
}

@ -7,16 +7,14 @@
"scripts": { "scripts": {
"i": "pnpm install", "i": "pnpm install",
"dev": "vite --mode env.local", "dev": "vite --mode env.local",
"dev:local": "cross-env VITE_BASE_URL=http://localhost:48081 vite --mode env.local",
"pro": "vite --mode env.prod", "pro": "vite --mode env.prod",
"dev-server": "vite --mode dev", "dev-server": "vite --mode dev",
"ts:check": "vue-tsc --noEmit", "ts:check": "vue-tsc --noEmit",
"build:local": "node --max_old_space_size=8192 ./node_modules/vite/bin/vite.js build", "build:local": "node --max_old_space_size=6144 ./node_modules/vite/bin/vite.js build",
"build:dev": "node --max_old_space_size=8192 ./node_modules/vite/bin/vite.js build --mode dev", "build:dev": "node --max_old_space_size=6144 ./node_modules/vite/bin/vite.js build --mode dev",
"build:test": "node --max_old_space_size=8192 ./node_modules/vite/bin/vite.js build --mode test", "build:test": "node --max_old_space_size=6144 ./node_modules/vite/bin/vite.js build --mode test",
"build:stage": "node --max_old_space_size=8192 ./node_modules/vite/bin/vite.js build --mode stage", "build:stage": "node --max_old_space_size=6144 ./node_modules/vite/bin/vite.js build --mode stage",
"build:prod": "node --max_old_space_size=8192 ./node_modules/vite/bin/vite.js build --mode prod", "build:prod": "node --max_old_space_size=6144 ./node_modules/vite/bin/vite.js build --mode prod",
"build:inner": "node --max_old_space_size=8192 ./node_modules/vite/bin/vite.js build --mode inner",
"serve:dev": "vite preview --mode dev", "serve:dev": "vite preview --mode dev",
"serve:prod": "vite preview --mode prod", "serve:prod": "vite preview --mode prod",
"preview": "pnpm build:local && vite preview", "preview": "pnpm build:local && vite preview",
@ -63,13 +61,11 @@
"markmap-view": "^0.16.0", "markmap-view": "^0.16.0",
"min-dash": "^4.1.1", "min-dash": "^4.1.1",
"mitt": "^3.0.1", "mitt": "^3.0.1",
"node-machine-id": "^1.1.12",
"nprogress": "^0.2.0", "nprogress": "^0.2.0",
"pinia": "^2.1.7", "pinia": "^2.1.7",
"pinia-plugin-persistedstate": "^3.2.1", "pinia-plugin-persistedstate": "^3.2.1",
"qrcode": "^1.5.3", "qrcode": "^1.5.3",
"qs": "^6.12.0", "qs": "^6.12.0",
"socket.io-client": "^4.8.3",
"sortablejs": "^1.15.3", "sortablejs": "^1.15.3",
"steady-xml": "^0.1.0", "steady-xml": "^0.1.0",
"url": "^0.11.3", "url": "^0.11.3",
@ -106,7 +102,6 @@
"bpmn-js": "^17.9.2", "bpmn-js": "^17.9.2",
"bpmn-js-properties-panel": "5.23.0", "bpmn-js-properties-panel": "5.23.0",
"consola": "^3.2.3", "consola": "^3.2.3",
"cross-env": "^10.1.0",
"eslint": "^8.57.0", "eslint": "^8.57.0",
"eslint-config-prettier": "^9.1.0", "eslint-config-prettier": "^9.1.0",
"eslint-define-config": "^2.1.0", "eslint-define-config": "^2.1.0",

@ -0,0 +1,53 @@
import request from '@/config/axios'
// BPM 流程分类 VO
export interface CategoryVO {
id: number // 分类编号
name: string // 分类名
code: string // 分类标志
status: number // 分类状态
sort: number // 分类排序
}
// BPM 流程分类 API
export const CategoryApi = {
// 查询流程分类分页
getCategoryPage: async (params: any) => {
return await request.get({ url: `/bpm/category/page`, params })
},
// 查询流程分类列表
getCategorySimpleList: async () => {
return await request.get({ url: `/bpm/category/simple-list` })
},
// 查询流程分类详情
getCategory: async (id: number) => {
return await request.get({ url: `/bpm/category/get?id=` + id })
},
// 新增流程分类
createCategory: async (data: CategoryVO) => {
return await request.post({ url: `/bpm/category/create`, data })
},
// 修改流程分类
updateCategory: async (data: CategoryVO) => {
return await request.put({ url: `/bpm/category/update`, data })
},
// 批量修改流程分类的排序
updateCategorySortBatch: async (ids: number[]) => {
return await request.put({
url: `/bpm/category/update-sort-batch`,
params: {
ids: ids.join(',')
}
})
},
// 删除流程分类
deleteCategory: async (id: number) => {
return await request.delete({ url: `/bpm/category/delete?id=` + id })
}
}

@ -0,0 +1,22 @@
import request from '@/config/axios'
export const getProcessDefinition = async (id?: string, key?: string) => {
return await request.get({
url: '/bpm/process-definition/get',
params: { id, key }
})
}
export const getProcessDefinitionPage = async (params) => {
return await request.get({
url: '/bpm/process-definition/page',
params
})
}
export const getProcessDefinitionList = async (params) => {
return await request.get({
url: '/bpm/process-definition/list',
params
})
}

@ -0,0 +1,56 @@
import request from '@/config/axios'
export type FormVO = {
id: number
name: string
conf: string
fields: string[]
status: number
remark: string
createTime: string
}
// 创建工作流的表单定义
export const createForm = async (data: FormVO) => {
return await request.post({
url: '/bpm/form/create',
data: data
})
}
// 更新工作流的表单定义
export const updateForm = async (data: FormVO) => {
return await request.put({
url: '/bpm/form/update',
data: data
})
}
// 删除工作流的表单定义
export const deleteForm = async (id: number) => {
return await request.delete({
url: '/bpm/form/delete?id=' + id
})
}
// 获得工作流的表单定义
export const getForm = async (id: number) => {
return await request.get({
url: '/bpm/form/get?id=' + id
})
}
// 获得工作流的表单定义分页
export const getFormPage = async (params) => {
return await request.get({
url: '/bpm/form/page',
params
})
}
// 获得动态表单的精简列表
export const getFormSimpleList = async () => {
return await request.get({
url: '/bpm/form/simple-list'
})
}

@ -0,0 +1,27 @@
import request from '@/config/axios'
export type LeaveVO = {
id: number
status: number
type: number
reason: string
processInstanceId: string
startTime: string
endTime: string
createTime: string
}
// 创建请假申请
export const createLeave = async (data: LeaveVO) => {
return await request.post({ url: '/bpm/oa/leave/create', data: data })
}
// 获得请假申请
export const getLeave = async (id: number) => {
return await request.get({ url: '/bpm/oa/leave/get?id=' + id })
}
// 获得请假申请分页
export const getLeavePage = async (params: PageParam) => {
return await request.get({ url: '/bpm/oa/leave/page', params })
}

@ -0,0 +1,74 @@
import request from '@/config/axios'
export type ProcessDefinitionVO = {
id: string
version: number
deploymentTIme: string
suspensionState: number
formType?: number
}
export type ModelVO = {
id: number
formName: string
key: string
name: string
description: string
category: string
formType: number
formId: number
formCustomCreatePath: string
formCustomViewPath: string
processDefinition: ProcessDefinitionVO
status: number
remark: string
createTime: string
bpmnXml: string
}
export const getModelList = async (name: string | undefined) => {
return await request.get({ url: '/bpm/model/list', params: { name } })
}
export const getModel = async (id: string) => {
return await request.get({ url: '/bpm/model/get?id=' + id })
}
export const updateModel = async (data: ModelVO) => {
return await request.put({ url: '/bpm/model/update', data: data })
}
// 批量修改流程分类的排序
export const updateModelSortBatch = async (ids: number[]) => {
return await request.put({
url: `/bpm/model/update-sort-batch`,
params: {
ids: ids.join(',')
}
})
}
export const updateModelBpmn = async (data: ModelVO) => {
return await request.put({ url: '/bpm/model/update-bpmn', data: data })
}
// 任务状态修改
export const updateModelState = async (id: number, state: number) => {
const data = {
id: id,
state: state
}
return await request.put({ url: '/bpm/model/update-state', data: data })
}
export const createModel = async (data: ModelVO) => {
return await request.post({ url: '/bpm/model/create', data: data })
}
export const deleteModel = async (id: number) => {
return await request.delete({ url: '/bpm/model/delete?id=' + id })
}
export const deployModel = async (id: number) => {
return await request.post({ url: '/bpm/model/deploy?id=' + id })
}

@ -0,0 +1,42 @@
import request from '@/config/axios'
// BPM 流程表达式 VO
export interface ProcessExpressionVO {
id: number // 编号
name: string // 表达式名字
status: number // 表达式状态
expression: string // 表达式
}
// BPM 流程表达式 API
export const ProcessExpressionApi = {
// 查询BPM 流程表达式分页
getProcessExpressionPage: async (params: any) => {
return await request.get({ url: `/bpm/process-expression/page`, params })
},
// 查询BPM 流程表达式详情
getProcessExpression: async (id: number) => {
return await request.get({ url: `/bpm/process-expression/get?id=` + id })
},
// 新增BPM 流程表达式
createProcessExpression: async (data: ProcessExpressionVO) => {
return await request.post({ url: `/bpm/process-expression/create`, data })
},
// 修改BPM 流程表达式
updateProcessExpression: async (data: ProcessExpressionVO) => {
return await request.put({ url: `/bpm/process-expression/update`, data })
},
// 删除BPM 流程表达式
deleteProcessExpression: async (id: number) => {
return await request.delete({ url: `/bpm/process-expression/delete?id=` + id })
},
// 导出BPM 流程表达式 Excel
exportProcessExpression: async (params) => {
return await request.download({ url: `/bpm/process-expression/export-excel`, params })
}
}

@ -0,0 +1,103 @@
import request from '@/config/axios'
import { ProcessDefinitionVO } from '@/api/bpm/model'
import { NodeType, CandidateStrategy } from '@/components/SimpleProcessDesignerV2/src/consts'
export type Task = {
id: string
name: string
}
export type ProcessInstanceVO = {
id: number
name: string
processDefinitionId: string
category: string
result: number
tasks: Task[]
fields: string[]
status: number
remark: string
businessKey: string
createTime: string
endTime: string
processDefinition?: ProcessDefinitionVO
}
// 用户信息
export type User = {
id: number
nickname: string
avatar: string
}
// 审批任务信息
export type ApprovalTaskInfo = {
id: number
ownerUser: User
assigneeUser: User
status: number
reason: string
}
// 审批节点信息
export type ApprovalNodeInfo = {
id: number
name: string
nodeType: NodeType
candidateStrategy?: CandidateStrategy
status: number
startTime?: Date
endTime?: Date
candidateUsers?: User[]
tasks: ApprovalTaskInfo[]
}
export const getProcessInstanceMyPage = async (params: any) => {
return await request.get({ url: '/bpm/process-instance/my-page', params })
}
export const getProcessInstanceManagerPage = async (params: any) => {
return await request.get({ url: '/bpm/process-instance/manager-page', params })
}
export const createProcessInstance = async (data) => {
return await request.post({ url: '/bpm/process-instance/create', data: data })
}
export const cancelProcessInstanceByStartUser = async (id: number, reason: string) => {
const data = {
id: id,
reason: reason
}
return await request.delete({ url: '/bpm/process-instance/cancel-by-start-user', data: data })
}
export const cancelProcessInstanceByAdmin = async (id: number, reason: string) => {
const data = {
id: id,
reason: reason
}
return await request.delete({ url: '/bpm/process-instance/cancel-by-admin', data: data })
}
export const getProcessInstance = async (id: string) => {
return await request.get({ url: '/bpm/process-instance/get?id=' + id })
}
export const getProcessInstanceCopyPage = async (params: any) => {
return await request.get({ url: '/bpm/process-instance/copy/page', params })
}
// 获取审批详情
export const getApprovalDetail = async (params: any) => {
return await request.get({ url: 'bpm/process-instance/get-approval-detail' , params })
}
// 获取表单字段权限
export const getFormFieldsPermission = async (params: any) => {
return await request.get({ url: '/bpm/process-instance/get-form-fields-permission', params })
}
// 获取流程实例的 BPMN 模型视图
export const getProcessInstanceBpmnModelView = async (id: string) => {
return await request.get({ url: '/bpm/process-instance/get-bpmn-model-view?id=' + id })
}

@ -0,0 +1,40 @@
import request from '@/config/axios'
// BPM 流程监听器 VO
export interface ProcessListenerVO {
id: number // 编号
name: string // 监听器名字
type: string // 监听器类型
status: number // 监听器状态
event: string // 监听事件
valueType: string // 监听器值类型
value: string // 监听器值
}
// BPM 流程监听器 API
export const ProcessListenerApi = {
// 查询流程监听器分页
getProcessListenerPage: async (params: any) => {
return await request.get({ url: `/bpm/process-listener/page`, params })
},
// 查询流程监听器详情
getProcessListener: async (id: number) => {
return await request.get({ url: `/bpm/process-listener/get?id=` + id })
},
// 新增流程监听器
createProcessListener: async (data: ProcessListenerVO) => {
return await request.post({ url: `/bpm/process-listener/create`, data })
},
// 修改流程监听器
updateProcessListener: async (data: ProcessListenerVO) => {
return await request.put({ url: `/bpm/process-listener/update`, data })
},
// 删除流程监听器
deleteProcessListener: async (id: number) => {
return await request.delete({ url: `/bpm/process-listener/delete?id=` + id })
}
}

@ -0,0 +1,15 @@
import request from '@/config/axios'
export const updateBpmSimpleModel = async (data) => {
return await request.post({
url: '/bpm/model/simple/update',
data: data
})
}
export const getBpmSimpleModel = async (id) => {
return await request.get({
url: '/bpm/model/simple/get?id=' + id
})
}

@ -0,0 +1,113 @@
import request from '@/config/axios'
/**
*
*/
export enum TaskStatusEnum {
/**
*
*/
NOT_START = -1,
/**
*
*/
WAIT = 0,
/**
*
*/
RUNNING = 1,
/**
*
*/
APPROVE = 2,
/**
*
*/
REJECT = 3,
/**
*
*/
CANCEL = 4,
/**
* 退
*/
RETURN = 5,
/**
*
*/
APPROVING = 7
}
export const getTaskTodoPage = async (params: any) => {
return await request.get({ url: '/bpm/task/todo-page', params })
}
export const getTaskDonePage = async (params: any) => {
return await request.get({ url: '/bpm/task/done-page', params })
}
export const getTaskManagerPage = async (params: any) => {
return await request.get({ url: '/bpm/task/manager-page', params })
}
export const approveTask = async (data: any) => {
return await request.put({ url: '/bpm/task/approve', data })
}
export const rejectTask = async (data: any) => {
return await request.put({ url: '/bpm/task/reject', data })
}
export const getTaskListByProcessInstanceId = async (processInstanceId: string) => {
return await request.get({
url: '/bpm/task/list-by-process-instance-id?processInstanceId=' + processInstanceId
})
}
// 获取所有可退回的节点
export const getTaskListByReturn = async (id: string) => {
return await request.get({ url: '/bpm/task/list-by-return', params: { id } })
}
// 退回
export const returnTask = async (data: any) => {
return await request.put({ url: '/bpm/task/return', data })
}
// 委派
export const delegateTask = async (data: any) => {
return await request.put({ url: '/bpm/task/delegate', data })
}
// 转派
export const transferTask = async (data: any) => {
return await request.put({ url: '/bpm/task/transfer', data })
}
// 加签
export const signCreateTask = async (data: any) => {
return await request.put({ url: '/bpm/task/create-sign', data })
}
// 减签
export const signDeleteTask = async (data: any) => {
return await request.delete({ url: '/bpm/task/delete-sign', data })
}
// 抄送
export const copyTask = async (data: any) => {
return await request.put({ url: '/bpm/task/copy', data })
}
// 获取我的待办任务
export const myTodoTask = async (processInstanceId: string) => {
return await request.get({ url: '/bpm/task/my-todo?processInstanceId=' + processInstanceId })
}
// 获取减签任务列表
export const getChildrenTaskList = async (id: string) => {
return await request.get({ url: '/bpm/task/list-by-parent-task-id?parentTaskId=' + id })
}

@ -0,0 +1,47 @@
import request from '@/config/axios'
export type UserGroupVO = {
id: number
name: string
description: string
userIds: number[]
status: number
remark: string
createTime: string
}
// 创建用户组
export const createUserGroup = async (data: UserGroupVO) => {
return await request.post({
url: '/bpm/user-group/create',
data: data
})
}
// 更新用户组
export const updateUserGroup = async (data: UserGroupVO) => {
return await request.put({
url: '/bpm/user-group/update',
data: data
})
}
// 删除用户组
export const deleteUserGroup = async (id: number) => {
return await request.delete({ url: '/bpm/user-group/delete?id=' + id })
}
// 获得用户组
export const getUserGroup = async (id: number) => {
return await request.get({ url: '/bpm/user-group/get?id=' + id })
}
// 获得用户组分页
export const getUserGroupPage = async (params) => {
return await request.get({ url: '/bpm/user-group/page', params })
}
// 获取用户组精简信息列表
export const getUserGroupSimpleList = async (): Promise<UserGroupVO[]> => {
return await request.get({ url: '/bpm/user-group/simple-list' })
}

@ -0,0 +1,98 @@
import request from '@/config/axios'
import { TransferReqVO } from '@/api/crm/permission'
export interface BusinessVO {
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
remark: string
creator: string // 创建人
creatorName?: string // 创建人名称
createTime: Date // 创建时间
updateTime: Date // 更新时间
products?: [
{
id: number
productId: number
productName: string
productNo: string
productUnit: number
productPrice: number
businessPrice: number
count: number
totalPrice: number
}
]
}
// 查询 CRM 商机列表
export const getBusinessPage = async (params) => {
return await request.get({ url: `/crm/business/page`, params })
}
// 查询 CRM 商机列表,基于指定客户
export const getBusinessPageByCustomer = async (params) => {
return await request.get({ url: `/crm/business/page-by-customer`, params })
}
// 查询 CRM 商机详情
export const getBusiness = async (id: number) => {
return await request.get({ url: `/crm/business/get?id=` + id })
}
// 获得 CRM 商机列表(精简)
export const getSimpleBusinessList = async () => {
return await request.get({ url: `/crm/business/simple-all-list` })
}
// 新增 CRM 商机
export const createBusiness = async (data: BusinessVO) => {
return await request.post({ url: `/crm/business/create`, data })
}
// 修改 CRM 商机
export const updateBusiness = async (data: BusinessVO) => {
return await request.put({ url: `/crm/business/update`, data })
}
// 修改 CRM 商机状态
export const updateBusinessStatus = async (data: BusinessVO) => {
return await request.put({ url: `/crm/business/update-status`, data })
}
// 删除 CRM 商机
export const deleteBusiness = async (id: number) => {
return await request.delete({ url: `/crm/business/delete?id=` + id })
}
// 导出 CRM 商机 Excel
export const exportBusiness = async (params) => {
return await request.download({ url: `/crm/business/export-excel`, params })
}
// 联系人关联商机列表
export const getBusinessPageByContact = async (params) => {
return await request.get({ url: `/crm/business/page-by-contact`, params })
}
// 商机转移
export const transferBusiness = async (data: TransferReqVO) => {
return await request.put({ url: '/crm/business/transfer', data })
}

@ -0,0 +1,68 @@
import request from '@/config/axios'
export interface BusinessStatusTypeVO {
id: number
name: string
deptIds: number[]
statuses?: {
id: number
name: string
percent: number
}
}
export const DEFAULT_STATUSES = [
{
endStatus: 1,
key: '结束',
name: '赢单',
percent: 100
},
{
endStatus: 2,
key: '结束',
name: '输单',
percent: 0
},
{
endStatus: 3,
key: '结束',
name: '无效',
percent: 0
}
]
// 查询商机状态组列表
export const getBusinessStatusPage = async (params: any) => {
return await request.get({ url: `/crm/business-status/page`, params })
}
// 新增商机状态组
export const createBusinessStatus = async (data: BusinessStatusTypeVO) => {
return await request.post({ url: `/crm/business-status/create`, data })
}
// 修改商机状态组
export const updateBusinessStatus = async (data: BusinessStatusTypeVO) => {
return await request.put({ url: `/crm/business-status/update`, data })
}
// 查询商机状态类型详情
export const getBusinessStatus = async (id: number) => {
return await request.get({ url: `/crm/business-status/get?id=` + id })
}
// 删除商机状态
export const deleteBusinessStatus = async (id: number) => {
return await request.delete({ url: `/crm/business-status/delete?id=` + id })
}
// 获得商机状态组列表
export const getBusinessStatusTypeSimpleList = async () => {
return await request.get({ url: `/crm/business-status/type-simple-list` })
}
// 获得商机阶段列表
export const getBusinessStatusSimpleList = async (typeId: number) => {
return await request.get({ url: `/crm/business-status/status-simple-list`, params: { typeId } })
}

@ -0,0 +1,78 @@
import request from '@/config/axios'
import { TransferReqVO } from '@/api/crm/permission'
export interface ClueVO {
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 const getCluePage = async (params: any) => {
return await request.get({ url: `/crm/clue/page`, params })
}
// 查询线索详情
export const getClue = async (id: number) => {
return await request.get({ url: `/crm/clue/get?id=` + id })
}
// 新增线索
export const createClue = async (data: ClueVO) => {
return await request.post({ url: `/crm/clue/create`, data })
}
// 修改线索
export const updateClue = async (data: ClueVO) => {
return await request.put({ url: `/crm/clue/update`, data })
}
// 删除线索
export const deleteClue = async (id: number) => {
return await request.delete({ url: `/crm/clue/delete?id=` + id })
}
// 导出线索 Excel
export const exportClue = async (params) => {
return await request.download({ url: `/crm/clue/export-excel`, params })
}
// 线索转移
export const transferClue = async (data: TransferReqVO) => {
return await request.put({ url: '/crm/clue/transfer', data })
}
// 线索转化为客户
export const transformClue = async (id: number) => {
return await request.put({ url: '/crm/clue/transform', params: { id } })
}
// 获得分配给我的、待跟进的线索数量
export const getFollowClueCount = async () => {
return await request.get({ url: '/crm/clue/follow-count' })
}

@ -0,0 +1,113 @@
import request from '@/config/axios'
import { TransferReqVO } from '@/api/crm/permission'
export interface ContactVO {
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 ContactBusinessReqVO {
contactId: number
businessIds: number[]
}
export interface ContactBusiness2ReqVO {
businessId: number
contactIds: number[]
}
// 查询 CRM 联系人列表
export const getContactPage = async (params) => {
return await request.get({ url: `/crm/contact/page`, params })
}
// 查询 CRM 联系人列表,基于指定客户
export const getContactPageByCustomer = async (params: any) => {
return await request.get({ url: `/crm/contact/page-by-customer`, params })
}
// 查询 CRM 联系人列表,基于指定商机
export const getContactPageByBusiness = async (params: any) => {
return await request.get({ url: `/crm/contact/page-by-business`, params })
}
// 查询 CRM 联系人详情
export const getContact = async (id: number) => {
return await request.get({ url: `/crm/contact/get?id=` + id })
}
// 新增 CRM 联系人
export const createContact = async (data: ContactVO) => {
return await request.post({ url: `/crm/contact/create`, data })
}
// 修改 CRM 联系人
export const updateContact = async (data: ContactVO) => {
return await request.put({ url: `/crm/contact/update`, data })
}
// 删除 CRM 联系人
export const deleteContact = async (id: number) => {
return await request.delete({ url: `/crm/contact/delete?id=` + id })
}
// 导出 CRM 联系人 Excel
export const exportContact = async (params) => {
return await request.download({ url: `/crm/contact/export-excel`, params })
}
// 获得 CRM 联系人列表(精简)
export const getSimpleContactList = async () => {
return await request.get({ url: `/crm/contact/simple-all-list` })
}
// 批量新增联系人商机关联
export const createContactBusinessList = async (data: ContactBusinessReqVO) => {
return await request.post({ url: `/crm/contact/create-business-list`, data })
}
// 批量新增联系人商机关联
export const createContactBusinessList2 = async (data: ContactBusiness2ReqVO) => {
return await request.post({ url: `/crm/contact/create-business-list2`, data })
}
// 解除联系人商机关联
export const deleteContactBusinessList = async (data: ContactBusinessReqVO) => {
return await request.delete({ url: `/crm/contact/delete-business-list`, data })
}
// 解除联系人商机关联
export const deleteContactBusinessList2 = async (data: ContactBusiness2ReqVO) => {
return await request.delete({ url: `/crm/contact/delete-business-list2`, data })
}
// 联系人转移
export const transferContact = async (data: TransferReqVO) => {
return await request.put({ url: '/crm/contact/transfer', data })
}

@ -0,0 +1,16 @@
import request from '@/config/axios'
export interface ContractConfigVO {
notifyEnabled?: boolean
notifyDays?: number
}
// 获取合同配置
export const getContractConfig = async () => {
return await request.get({ url: `/crm/contract-config/get` })
}
// 更新合同配置
export const saveContractConfig = async (data: ContractConfigVO) => {
return await request.put({ url: `/crm/contract-config/save`, data })
}

@ -0,0 +1,114 @@
import request from '@/config/axios'
import { TransferReqVO } from '@/api/crm/permission'
export interface ContractVO {
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?: [
{
id: number
productId: number
productName: string
productNo: string
productUnit: number
productPrice: number
contractPrice: number
count: number
totalPrice: number
}
]
}
// 查询 CRM 合同列表
export const getContractPage = async (params) => {
return await request.get({ url: `/crm/contract/page`, params })
}
// 查询 CRM 联系人列表,基于指定客户
export const getContractPageByCustomer = async (params: any) => {
return await request.get({ url: `/crm/contract/page-by-customer`, params })
}
// 查询 CRM 联系人列表,基于指定商机
export const getContractPageByBusiness = async (params: any) => {
return await request.get({ url: `/crm/contract/page-by-business`, params })
}
// 查询 CRM 合同详情
export const getContract = async (id: number) => {
return await request.get({ url: `/crm/contract/get?id=` + id })
}
// 查询 CRM 合同下拉列表
export const getContractSimpleList = async (customerId: number) => {
return await request.get({
url: `/crm/contract/simple-list?customerId=${customerId}`
})
}
// 新增 CRM 合同
export const createContract = async (data: ContractVO) => {
return await request.post({ url: `/crm/contract/create`, data })
}
// 修改 CRM 合同
export const updateContract = async (data: ContractVO) => {
return await request.put({ url: `/crm/contract/update`, data })
}
// 删除 CRM 合同
export const deleteContract = async (id: number) => {
return await request.delete({ url: `/crm/contract/delete?id=` + id })
}
// 导出 CRM 合同 Excel
export const exportContract = async (params) => {
return await request.download({ url: `/crm/contract/export-excel`, params })
}
// 提交审核
export const submitContract = async (id: number) => {
return await request.put({ url: `/crm/contract/submit?id=${id}` })
}
// 合同转移
export const transferContract = async (data: TransferReqVO) => {
return await request.put({ url: '/crm/contract/transfer', data })
}
// 获得待审核合同数量
export const getAuditContractCount = async () => {
return await request.get({ url: '/crm/contract/audit-count' })
}
// 获得即将到期(提醒)的合同数量
export const getRemindContractCount = async () => {
return await request.get({ url: '/crm/contract/remind-count' })
}

@ -1,11 +1,9 @@
import request from '@/config/axios' import request from '@/config/axios'
import { TransferReqVO } from '@/api/crm/permission'
export interface CustomerVO { export interface CustomerVO {
id: number // 编号 id: number // 编号
name: string // 客户名称 name: string // 客户名称
customerCode?: string // 客户编码
isCode?: boolean // 是否自动生成客户编码
contactName?: string // 联系人
followUpStatus: boolean // 跟进状态 followUpStatus: boolean // 跟进状态
contactLastTime: Date // 最后跟进时间 contactLastTime: Date // 最后跟进时间
contactLastContent: string // 最后跟进内容 contactLastContent: string // 最后跟进内容
@ -33,109 +31,102 @@ export interface CustomerVO {
updateTime: Date // 更新时间 updateTime: Date // 更新时间
} }
export interface TransferReqVO {
id: number
newOwnerUserId: number
oldOwnerPermissionLevel?: number
toBizTypes?: number[]
}
// 查询客户列表 // 查询客户列表
export const getCustomerPage = async (params) => { export const getCustomerPage = async (params) => {
return await request.get({ url: `/mes/customer/page`, params }) return await request.get({ url: `/crm/customer/page`, params })
} }
// 进入公海客户提醒的客户列表 // 进入公海客户提醒的客户列表
export const getPutPoolRemindCustomerPage = async (params) => { export const getPutPoolRemindCustomerPage = async (params) => {
return await request.get({ url: `/mes/customer/put-pool-remind-page`, params }) return await request.get({ url: `/crm/customer/put-pool-remind-page`, params })
} }
// 获得待进入公海客户数量 // 获得待进入公海客户数量
export const getPutPoolRemindCustomerCount = async () => { export const getPutPoolRemindCustomerCount = async () => {
return await request.get({ url: `/mes/customer/put-pool-remind-count` }) return await request.get({ url: `/crm/customer/put-pool-remind-count` })
} }
// 获得今日需联系客户数量 // 获得今日需联系客户数量
export const getTodayContactCustomerCount = async () => { export const getTodayContactCustomerCount = async () => {
return await request.get({ url: `/mes/customer/today-contact-count` }) return await request.get({ url: `/crm/customer/today-contact-count` })
} }
// 获得分配给我、待跟进的线索数量的客户数量 // 获得分配给我、待跟进的线索数量的客户数量
export const getFollowCustomerCount = async () => { export const getFollowCustomerCount = async () => {
return await request.get({ url: `/mes/customer/follow-count` }) return await request.get({ url: `/crm/customer/follow-count` })
} }
// 查询客户详情 // 查询客户详情
export const getCustomer = async (id: number) => { export const getCustomer = async (id: number) => {
return await request.get({ url: `/mes/customer/get?id=` + id }) return await request.get({ url: `/crm/customer/get?id=` + id })
} }
// 新增客户 // 新增客户
export const createCustomer = async (data: CustomerVO) => { export const createCustomer = async (data: CustomerVO) => {
return await request.post({ url: `/mes/customer/create`, data }) return await request.post({ url: `/crm/customer/create`, data })
} }
// 修改客户 // 修改客户
export const updateCustomer = async (data: CustomerVO) => { export const updateCustomer = async (data: CustomerVO) => {
return await request.put({ url: `/mes/customer/update`, data }) return await request.put({ url: `/crm/customer/update`, data })
} }
// 更新客户的成交状态 // 更新客户的成交状态
export const updateCustomerDealStatus = async (id: number, dealStatus: boolean) => { export const updateCustomerDealStatus = async (id: number, dealStatus: boolean) => {
return await request.put({ url: `/mes/customer/update-deal-status`, params: { id, dealStatus } }) return await request.put({ url: `/crm/customer/update-deal-status`, params: { id, dealStatus } })
} }
// 删除客户 // 删除客户
export const deleteCustomer = async (id: number) => { export const deleteCustomer = async (id: number) => {
return await request.delete({ url: `/mes/customer/delete?id=` + id }) return await request.delete({ url: `/crm/customer/delete?id=` + id })
} }
// 导出客户 Excel // 导出客户 Excel
export const exportCustomer = async (params: any) => { export const exportCustomer = async (params: any) => {
return await request.download({ url: `/mes/customer/export-excel`, params }) return await request.download({ url: `/crm/customer/export-excel`, params })
} }
// 下载客户导入模板 // 下载客户导入模板
export const importCustomerTemplate = () => { export const importCustomerTemplate = () => {
return request.download({ url: '/mes/customer/get-import-template' }) return request.download({ url: '/crm/customer/get-import-template' })
} }
// 导入客户 // 导入客户
export const handleImport = async (formData) => { export const handleImport = async (formData) => {
return await request.upload({ url: `/mes/customer/import`, data: formData }) return await request.upload({ url: `/crm/customer/import`, data: formData })
} }
// 客户列表 // 客户列表
export const getCustomerSimpleList = async () => { export const getCustomerSimpleList = async () => {
return await request.get({ url: `/mes/customer/simple-list` }) return await request.get({ url: `/crm/customer/simple-list` })
} }
// ======================= 业务操作 ======================= // ======================= 业务操作 =======================
// 客户转移 // 客户转移
export const transferCustomer = async (data: TransferReqVO) => { export const transferCustomer = async (data: TransferReqVO) => {
return await request.put({ url: '/mes/customer/transfer', data }) return await request.put({ url: '/crm/customer/transfer', data })
} }
// 锁定/解锁客户 // 锁定/解锁客户
export const lockCustomer = async (id: number, lockStatus: boolean) => { export const lockCustomer = async (id: number, lockStatus: boolean) => {
return await request.put({ url: `/mes/customer/lock`, data: { id, lockStatus } }) return await request.put({ url: `/crm/customer/lock`, data: { id, lockStatus } })
} }
// 领取公海客户 // 领取公海客户
export const receiveCustomer = async (ids: any[]) => { export const receiveCustomer = async (ids: any[]) => {
return await request.put({ url: '/mes/customer/receive', params: { ids: ids.join(',') } }) return await request.put({ url: '/crm/customer/receive', params: { ids: ids.join(',') } })
} }
// 分配公海给对应负责人 // 分配公海给对应负责人
export const distributeCustomer = async (ids: any[], ownerUserId: number) => { export const distributeCustomer = async (ids: any[], ownerUserId: number) => {
return await request.put({ return await request.put({
url: '/mes/customer/distribute', url: '/crm/customer/distribute',
data: { ids: ids, ownerUserId } data: { ids: ids, ownerUserId }
}) })
} }
// 客户放入公海 // 客户放入公海
export const putCustomerPool = async (id: number) => { export const putCustomerPool = async (id: number) => {
return await request.put({ url: `/mes/customer/put-pool?id=${id}` }) return await request.put({ url: `/crm/customer/put-pool?id=${id}` })
} }

@ -25,25 +25,25 @@ export enum LimitConfType {
// 查询客户限制配置列表 // 查询客户限制配置列表
export const getCustomerLimitConfigPage = async (params) => { export const getCustomerLimitConfigPage = async (params) => {
return await request.get({ url: `/mes/customer-limit-config/page`, params }) return await request.get({ url: `/crm/customer-limit-config/page`, params })
} }
// 查询客户限制配置详情 // 查询客户限制配置详情
export const getCustomerLimitConfig = async (id: number) => { export const getCustomerLimitConfig = async (id: number) => {
return await request.get({ url: `/mes/customer-limit-config/get?id=` + id }) return await request.get({ url: `/crm/customer-limit-config/get?id=` + id })
} }
// 新增客户限制配置 // 新增客户限制配置
export const createCustomerLimitConfig = async (data: CustomerLimitConfigVO) => { export const createCustomerLimitConfig = async (data: CustomerLimitConfigVO) => {
return await request.post({ url: `/mes/customer-limit-config/create`, data }) return await request.post({ url: `/crm/customer-limit-config/create`, data })
} }
// 修改客户限制配置 // 修改客户限制配置
export const updateCustomerLimitConfig = async (data: CustomerLimitConfigVO) => { export const updateCustomerLimitConfig = async (data: CustomerLimitConfigVO) => {
return await request.put({ url: `/mes/customer-limit-config/update`, data }) return await request.put({ url: `/crm/customer-limit-config/update`, data })
} }
// 删除客户限制配置 // 删除客户限制配置
export const deleteCustomerLimitConfig = async (id: number) => { export const deleteCustomerLimitConfig = async (id: number) => {
return await request.delete({ url: `/mes/customer-limit-config/delete?id=` + id }) return await request.delete({ url: `/crm/customer-limit-config/delete?id=` + id })
} }

@ -10,10 +10,10 @@ export interface CustomerPoolConfigVO {
// 获取客户公海规则设置 // 获取客户公海规则设置
export const getCustomerPoolConfig = async () => { export const getCustomerPoolConfig = async () => {
return await request.get({ url: `/mes/customer-pool-config/get` }) return await request.get({ url: `/crm/customer-pool-config/get` })
} }
// 更新客户公海规则设置 // 更新客户公海规则设置
export const saveCustomerPoolConfig = async (data: CustomerPoolConfigVO) => { export const saveCustomerPoolConfig = async (data: CustomerPoolConfigVO) => {
return await request.put({ url: `/mes/customer-pool-config/save`, data }) return await request.put({ url: `/crm/customer-pool-config/save`, data })
} }

@ -0,0 +1,43 @@
import request from '@/config/axios'
// 跟进记录 VO
export interface FollowUpRecordVO {
id: number // 编号
bizType: number // 数据类型
bizId: number // 数据编号
type: number // 跟进类型
content: string // 跟进内容
picUrls: string[] // 图片
fileUrls: string[] // 附件
nextTime: Date // 下次联系时间
businessIds: number[] // 关联的商机编号数组
businesses: {
id: number
name: string
}[] // 关联的商机数组
contactIds: number[] // 关联的联系人编号数组
contacts: {
id: number
name: string
}[] // 关联的联系人数组
creator: string
creatorName?: string
}
// 跟进记录 API
export const FollowUpRecordApi = {
// 查询跟进记录分页
getFollowUpRecordPage: async (params: any) => {
return await request.get({ url: `/crm/follow-up-record/page`, params })
},
// 新增跟进记录
createFollowUpRecord: async (data: FollowUpRecordVO) => {
return await request.post({ url: `/crm/follow-up-record/create`, data })
},
// 删除跟进记录
deleteFollowUpRecord: async (id: number) => {
return await request.delete({ url: `/crm/follow-up-record/delete?id=` + id })
}
}

@ -0,0 +1,11 @@
import request from '@/config/axios'
export interface OperateLogVO extends PageParam {
bizType: number
bizId: number
}
// 获得操作日志
export const getOperateLogPage = async (params: OperateLogVO) => {
return await request.get({ url: `/crm/operate-log/page`, params })
}

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

@ -0,0 +1,33 @@
import request from '@/config/axios'
// TODO @zange挪到 product 下,建个 category 包,挪进去哈;
export interface ProductCategoryVO {
id: number
name: string
parentId: number
}
// 查询产品分类详情
export const getProductCategory = async (id: number) => {
return await request.get({ url: `/crm/product-category/get?id=` + id })
}
// 新增产品分类
export const createProductCategory = async (data: ProductCategoryVO) => {
return await request.post({ url: `/crm/product-category/create`, data })
}
// 修改产品分类
export const updateProductCategory = async (data: ProductCategoryVO) => {
return await request.put({ url: `/crm/product-category/update`, data })
}
// 删除产品分类
export const deleteProductCategory = async (id: number) => {
return await request.delete({ url: `/crm/product-category/delete?id=` + id })
}
// 产品分类列表
export const getProductCategoryList = async (params) => {
return await request.get({ url: `/crm/product-category/list`, params })
}

@ -0,0 +1,49 @@
import request from '@/config/axios'
export interface ProductVO {
id: number
name: string
no: string
unit: number
price: number
status: number
categoryId: number
categoryName?: string
description: string
ownerUserId: number
}
// 查询产品列表
export const getProductPage = async (params) => {
return await request.get({ url: `/crm/product/page`, params })
}
// 获得产品精简列表
export const getProductSimpleList = async () => {
return await request.get({ url: `/crm/product/simple-list` })
}
// 查询产品详情
export const getProduct = async (id: number) => {
return await request.get({ url: `/crm/product/get?id=` + id })
}
// 新增产品
export const createProduct = async (data: ProductVO) => {
return await request.post({ url: `/crm/product/create`, data })
}
// 修改产品
export const updateProduct = async (data: ProductVO) => {
return await request.put({ url: `/crm/product/update`, data })
}
// 删除产品
export const deleteProduct = async (id: number) => {
return await request.delete({ url: `/crm/product/delete?id=` + id })
}
// 导出产品 Excel
export const exportProduct = async (params) => {
return await request.download({ url: `/crm/product/export-excel`, params })
}

@ -0,0 +1,73 @@
import request from '@/config/axios'
export interface ReceivableVO {
id: number
no: string
planId?: number
customerId?: number
customerName?: string
contractId?: number
contract?: {
id?: number
name?: string
no: string
totalPrice: number
}
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 const getReceivablePage = async (params) => {
return await request.get({ url: `/crm/receivable/page`, params })
}
// 查询回款列表
export const getReceivablePageByCustomer = async (params) => {
return await request.get({ url: `/crm/receivable/page-by-customer`, params })
}
// 查询回款详情
export const getReceivable = async (id: number) => {
return await request.get({ url: `/crm/receivable/get?id=` + id })
}
// 新增回款
export const createReceivable = async (data: ReceivableVO) => {
return await request.post({ url: `/crm/receivable/create`, data })
}
// 修改回款
export const updateReceivable = async (data: ReceivableVO) => {
return await request.put({ url: `/crm/receivable/update`, data })
}
// 删除回款
export const deleteReceivable = async (id: number) => {
return await request.delete({ url: `/crm/receivable/delete?id=` + id })
}
// 导出回款 Excel
export const exportReceivable = async (params) => {
return await request.download({ url: `/crm/receivable/export-excel`, params })
}
// 提交审核
export const submitReceivable = async (id: number) => {
return await request.put({ url: `/crm/receivable/submit?id=${id}` })
}
// 获得待审核回款数量
export const getAuditReceivableCount = async () => {
return await request.get({ url: '/crm/receivable/audit-count' })
}

@ -0,0 +1,74 @@
import request from '@/config/axios'
export interface ReceivablePlanVO {
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 const getReceivablePlanPage = async (params) => {
return await request.get({ url: `/crm/receivable-plan/page`, params })
}
// 查询回款计划列表
export const getReceivablePlanPageByCustomer = async (params) => {
return await request.get({ url: `/crm/receivable-plan/page-by-customer`, params })
}
// 查询回款计划详情
export const getReceivablePlan = async (id: number) => {
return await request.get({ url: `/crm/receivable-plan/get?id=` + id })
}
// 查询回款计划下拉数据
export const getReceivablePlanSimpleList = async (customerId: number, contractId: number) => {
return await request.get({
url: `/crm/receivable-plan/simple-list?customerId=${customerId}&contractId=${contractId}`
})
}
// 新增回款计划
export const createReceivablePlan = async (data: ReceivablePlanVO) => {
return await request.post({ url: `/crm/receivable-plan/create`, data })
}
// 修改回款计划
export const updateReceivablePlan = async (data: ReceivablePlanVO) => {
return await request.put({ url: `/crm/receivable-plan/update`, data })
}
// 删除回款计划
export const deleteReceivablePlan = async (id: number) => {
return await request.delete({ url: `/crm/receivable-plan/delete?id=` + id })
}
// 导出回款计划 Excel
export const exportReceivablePlan = async (params) => {
return await request.download({ url: `/crm/receivable-plan/export-excel`, params })
}
// 获得待回款提醒数量
export const getReceivablePlanRemindCount = async () => {
return await request.get({ url: '/crm/receivable-plan/remind-count' })
}

@ -0,0 +1,168 @@
import request from '@/config/axios'
export interface CrmStatisticsCustomerSummaryByDateRespVO {
time: string
customerCreateCount: number
customerDealCount: number
}
export interface CrmStatisticsCustomerSummaryByUserRespVO {
ownerUserName: string
customerCreateCount: number
customerDealCount: number
contractPrice: number
receivablePrice: number
}
export interface CrmStatisticsFollowUpSummaryByDateRespVO {
time: string
followUpRecordCount: number
followUpCustomerCount: number
}
export interface CrmStatisticsFollowUpSummaryByUserRespVO {
ownerUserName: string
followupRecordCount: number
followupCustomerCount: number
}
export interface CrmStatisticsFollowUpSummaryByTypeRespVO {
followUpType: string
followUpRecordCount: number
}
export interface CrmStatisticsCustomerContractSummaryRespVO {
customerName: string
contractName: string
totalPrice: number
receivablePrice: number
customerType: string
customerSource: string
ownerUserName: string
creatorUserName: string
createTime: Date
orderDate: Date
}
export interface CrmStatisticsPoolSummaryByDateRespVO {
time: string
customerPutCount: number
customerTakeCount: number
}
export interface CrmStatisticsPoolSummaryByUserRespVO {
ownerUserName: string
customerPutCount: number
customerTakeCount: number
}
export interface CrmStatisticsCustomerDealCycleByDateRespVO {
time: string
customerDealCycle: number
}
export interface CrmStatisticsCustomerDealCycleByUserRespVO {
ownerUserName: string
customerDealCycle: number
customerDealCount: number
}
export interface CrmStatisticsCustomerDealCycleByAreaRespVO {
areaName: string
customerDealCycle: number
customerDealCount: number
}
export interface CrmStatisticsCustomerDealCycleByProductRespVO {
productName: string
customerDealCycle: number
customerDealCount: number
}
// 客户分析 API
export const StatisticsCustomerApi = {
// 1.1 客户总量分析(按日期)
getCustomerSummaryByDate: (params: any) => {
return request.get({
url: '/crm/statistics-customer/get-customer-summary-by-date',
params
})
},
// 1.2 客户总量分析(按用户)
getCustomerSummaryByUser: (params: any) => {
return request.get({
url: '/crm/statistics-customer/get-customer-summary-by-user',
params
})
},
// 2.1 客户跟进次数分析(按日期)
getFollowUpSummaryByDate: (params: any) => {
return request.get({
url: '/crm/statistics-customer/get-follow-up-summary-by-date',
params
})
},
// 2.2 客户跟进次数分析(按用户)
getFollowUpSummaryByUser: (params: any) => {
return request.get({
url: '/crm/statistics-customer/get-follow-up-summary-by-user',
params
})
},
// 3.1 获取客户跟进方式统计数
getFollowUpSummaryByType: (params: any) => {
return request.get({
url: '/crm/statistics-customer/get-follow-up-summary-by-type',
params
})
},
// 4.1 合同摘要信息(客户转化率页面)
getContractSummary: (params: any) => {
return request.get({
url: '/crm/statistics-customer/get-contract-summary',
params
})
},
// 5.1 获取客户公海分析(按日期)
getPoolSummaryByDate: (param: any) => {
return request.get({
url: '/crm/statistics-customer/get-pool-summary-by-date',
params: param
})
},
// 5.2 获取客户公海分析(按用户)
getPoolSummaryByUser: (param: any) => {
return request.get({
url: '/crm/statistics-customer/get-pool-summary-by-user',
params: param
})
},
// 6.1 获取客户成交周期(按日期)
getCustomerDealCycleByDate: (params: any) => {
return request.get({
url: '/crm/statistics-customer/get-customer-deal-cycle-by-date',
params
})
},
// 6.2 获取客户成交周期(按用户)
getCustomerDealCycleByUser: (params: any) => {
return request.get({
url: '/crm/statistics-customer/get-customer-deal-cycle-by-user',
params
})
},
// 6.2 获取客户成交周期(按用户)
getCustomerDealCycleByArea: (params: any) => {
return request.get({
url: '/crm/statistics-customer/get-customer-deal-cycle-by-area',
params
})
},
// 6.2 获取客户成交周期(按用户)
getCustomerDealCycleByProduct: (params: any) => {
return request.get({
url: '/crm/statistics-customer/get-customer-deal-cycle-by-product',
params
})
}
}

@ -0,0 +1,58 @@
import request from '@/config/axios'
export interface CrmStatisticFunnelRespVO {
customerCount: number // 客户数
businessCount: number // 商机数
businessWinCount: number // 赢单数
}
export interface CrmStatisticsBusinessSummaryByDateRespVO {
time: string // 时间
businessCreateCount: number // 商机数
totalPrice: number | string // 商机金额
}
export interface CrmStatisticsBusinessInversionRateSummaryByDateRespVO {
time: string // 时间
businessCount: number // 商机数量
businessWinCount: number // 赢单商机数
}
// 客户分析 API
export const StatisticFunnelApi = {
// 1. 获取销售漏斗统计数据
getFunnelSummary: (params: any) => {
return request.get({
url: '/crm/statistics-funnel/get-funnel-summary',
params
})
},
// 2. 获取商机结束状态统计
getBusinessSummaryByEndStatus: (params: any) => {
return request.get({
url: '/crm/statistics-funnel/get-business-summary-by-end-status',
params
})
},
// 3. 获取新增商机分析(按日期)
getBusinessSummaryByDate: (params: any) => {
return request.get({
url: '/crm/statistics-funnel/get-business-summary-by-date',
params
})
},
// 4. 获取商机转化率分析(按日期)
getBusinessInversionRateSummaryByDate: (params: any) => {
return request.get({
url: '/crm/statistics-funnel/get-business-inversion-rate-summary-by-date',
params
})
},
// 5. 获取商机列表(按日期)
getBusinessPageByDate: (params: any) => {
return request.get({
url: '/crm/statistics-funnel/get-business-page-by-date',
params
})
}
}

@ -0,0 +1,33 @@
import request from '@/config/axios'
export interface StatisticsPerformanceRespVO {
time: string
currentMonthCount: number
lastMonthCount: number
lastYearCount: number
}
// 排行 API
export const StatisticsPerformanceApi = {
// 员工获得合同金额统计
getContractPricePerformance: (params: any) => {
return request.get({
url: '/crm/statistics-performance/get-contract-price-performance',
params
})
},
// 员工获得回款统计
getReceivablePricePerformance: (params: any) => {
return request.get({
url: '/crm/statistics-performance/get-receivable-price-performance',
params
})
},
//员工获得签约合同数量统计
getContractCountPerformance: (params: any) => {
return request.get({
url: '/crm/statistics-performance/get-contract-count-performance',
params
})
}
}

@ -0,0 +1,60 @@
import request from '@/config/axios'
export interface CrmStatisticCustomerBaseRespVO {
customerCount: number
dealCount: number
dealPortion: string | number
}
export interface CrmStatisticCustomerIndustryRespVO extends CrmStatisticCustomerBaseRespVO {
industryId: number
industryPortion: string | number
}
export interface CrmStatisticCustomerSourceRespVO extends CrmStatisticCustomerBaseRespVO {
source: number
sourcePortion: string | number
}
export interface CrmStatisticCustomerLevelRespVO extends CrmStatisticCustomerBaseRespVO {
level: number
levelPortion: string | number
}
export interface CrmStatisticCustomerAreaRespVO extends CrmStatisticCustomerBaseRespVO {
areaId: number
areaName: string
areaPortion: string | number
}
// 客户分析 API
export const StatisticsPortraitApi = {
// 1. 获取客户行业统计数据
getCustomerIndustry: (params: any) => {
return request.get({
url: '/crm/statistics-portrait/get-customer-industry-summary',
params
})
},
// 2. 获取客户来源统计数据
getCustomerSource: (params: any) => {
return request.get({
url: '/crm/statistics-portrait/get-customer-source-summary',
params
})
},
// 3. 获取客户级别统计数据
getCustomerLevel: (params: any) => {
return request.get({
url: '/crm/statistics-portrait/get-customer-level-summary',
params
})
},
// 4. 获取客户地区统计数据
getCustomerArea: (params: any) => {
return request.get({
url: '/crm/statistics-portrait/get-customer-area-summary',
params
})
}
}

@ -0,0 +1,67 @@
import request from '@/config/axios'
export interface StatisticsRankRespVO {
count: number
nickname: string
deptName: string
}
// 排行 API
export const StatisticsRankApi = {
// 获得合同排行榜
getContractPriceRank: (params: any) => {
return request.get({
url: '/crm/statistics-rank/get-contract-price-rank',
params
})
},
// 获得回款排行榜
getReceivablePriceRank: (params: any) => {
return request.get({
url: '/crm/statistics-rank/get-receivable-price-rank',
params
})
},
// 签约合同排行
getContractCountRank: (params: any) => {
return request.get({
url: '/crm/statistics-rank/get-contract-count-rank',
params
})
},
// 产品销量排行
getProductSalesRank: (params: any) => {
return request.get({
url: '/crm/statistics-rank/get-product-sales-rank',
params
})
},
// 新增客户数排行
getCustomerCountRank: (params: any) => {
return request.get({
url: '/crm/statistics-rank/get-customer-count-rank',
params
})
},
// 新增联系人数排行
getContactsCountRank: (params: any) => {
return request.get({
url: '/crm/statistics-rank/get-contacts-count-rank',
params
})
},
// 跟进次数排行
getFollowCountRank: (params: any) => {
return request.get({
url: '/crm/statistics-rank/get-follow-count-rank',
params
})
},
// 跟进客户数排行
getFollowCustomerCountRank: (params: any) => {
return request.get({
url: '/crm/statistics-rank/get-follow-customer-count-rank',
params
})
}
}

@ -6,31 +6,13 @@ export interface MoldBrandVO {
code: string // 型号编码 code: string // 型号编码
name: string // 型号名称 name: string // 型号名称
moldType: string // 规格 moldType: string // 规格
productId?: number // 产品ID productId: number // 产品ID
productName?: string // 产品名称 useTime: number // 预期寿命(小时)
productIds?: Array<number> | string // 产品ID列表 maintainType: number // 维保模式
products?: any[] maintainTime: number // 维保周期
images?: string // 图片
drawings?: string // 图纸
operationManual?: string // 操作手册
operationVideo?: string // 操作视频
version?: string // 版本
status?: number // 状态
currentPosition?: string // 当前位置
currentDevice?: string // 当前设备
deviceId?: number // 当前设备ID
deviceName?: string // 当前设备
machineName?: string // 当前设备
useTime?: number // 预期寿命(小时)
maintainType?: number // 维保模式
maintainTime?: number // 维保周期
moldSize: number // 模具系数 moldSize: number // 模具系数
remark?: string // 备注 remark: string // 备注
isEnable: boolean // 是否启用 isEnable: boolean // 是否启用
isCode?: boolean // 是否自动生成编码
orgType?: string
createTime?: string
qrCodeUrl?: string
} }
export interface MoldBrandTreeVO extends MoldBrandVO { export interface MoldBrandTreeVO extends MoldBrandVO {
@ -178,22 +160,6 @@ export const MoldBrandApi = {
// 获得模具产品 // 获得模具产品
getMoldBrandProduct: async (id: number) => { getMoldBrandProduct: async (id: number) => {
return await request.get({ url: `/erp/mold-brand/mold-brand-product/get?id=` + id }) return await request.get({ url: `/erp/mold-brand/mold-brand-product/get?id=` + id })
},
// ==================== 压网记录 ====================
// 新增压网记录
createPressureNetRecord: async (data: any) => {
return await request.post({ url: `/erp/mold-pressure-net-record/create`, data })
},
// 批量增压网记录
batchCreatePressureNetRecord: async (data: any) => {
return await request.post({ url: `/erp/mold-pressure-net-record/batch-create`, data })
},
// 查询压网记录分页
getPressureNetRecordPage: async (params: any) => {
return await request.get({ url: `/erp/mold-pressure-net-record/page`, params })
} }
} }

@ -8,29 +8,18 @@ export interface ProductCategoryVO {
code: string // 分类编码 code: string // 分类编码
sort: number // 分类排序 sort: number // 分类排序
status: number // 开启状态 status: number // 开启状态
type: number // 类型
processRouteId?: string | number // 工艺路线 ID
processRouteName?: string // 工艺路线名称
} }
const getProductCategoryRequestParams = (data: ProductCategoryVO) => ({
processRouteId: data.processRouteId || undefined
})
// ERP 产品分类 API // ERP 产品分类 API
export const ProductCategoryApi = { export const ProductCategoryApi = {
// 查询产品分类分组树
getProductCategoryGroupTree: async () => {
return await request.get({ url: `/erp/product-category/group-tree` })
},
// 查询产品分类列表 // 查询产品分类列表
getProductCategoryList: async (type?: number) => { getProductCategoryList: async () => {
return await request.get({ url: `/erp/product-category/list`, params: { type } }) return await request.get({ url: `/erp/product-category/list` })
}, },
// 查询产品分类精简列表 // 查询产品分类精简列表
getProductCategorySimpleList: async (type?: number) => { getProductCategorySimpleList: async () => {
return await request.get({ url: `/erp/product-category/simple-list`, params: { type } }) return await request.get({ url: `/erp/product-category/simple-list` })
}, },
// 查询产品分类详情 // 查询产品分类详情
@ -40,12 +29,12 @@ export const ProductCategoryApi = {
// 新增产品分类 // 新增产品分类
createProductCategory: async (data: ProductCategoryVO) => { createProductCategory: async (data: ProductCategoryVO) => {
return await request.post({ url: `/erp/product-category/create`, data, params: getProductCategoryRequestParams(data) }) return await request.post({ url: `/erp/product-category/create`, data })
}, },
// 修改产品分类 // 修改产品分类
updateProductCategory: async (data: ProductCategoryVO) => { updateProductCategory: async (data: ProductCategoryVO) => {
return await request.put({ url: `/erp/product-category/update`, data, params: getProductCategoryRequestParams(data) }) return await request.put({ url: `/erp/product-category/update`, data })
}, },
// 删除产品分类 // 删除产品分类

@ -29,26 +29,6 @@ export interface ProductVO {
moldList?: any[] moldList?: any[]
} }
export interface ErpProductCategoryProcessRouteItemRespVO {
id?: number
categoryId?: number
processRouteId?: number
processRouteItemId?: number
sort?: number
processParameterId?: number
processParameterCode?: string
processParameterName?: string
remark?: string
deviceId?: number | string
deviceName?: string
}
export interface ErpProductProcessRouteRespVO {
productId?: number
processRouteId?: number
processRouteName?: string
processRouteItems?: ErpProductCategoryProcessRouteItemRespVO[]
}
// ERP 产品 API // ERP 产品 API
export const ProductApi = { export const ProductApi = {
// 查询产品分页 // 查询产品分页
@ -57,7 +37,7 @@ export const ProductApi = {
}, },
// 查询产品精简列表 // 查询产品精简列表
getProductSimpleList: async (params?: { categoryId?: string | number; categoryType?: number }) => { getProductSimpleList: async (params?: { categoryId?: string | number }) => {
return await request.get({ url: `/erp/product/simple-list-all`, params }) return await request.get({ url: `/erp/product/simple-list-all`, params })
}, },
// 查询原料精简列表 // 查询原料精简列表
@ -69,19 +49,14 @@ export const ProductApi = {
return await request.get({ url: `/erp/product/simple-list-order` }) return await request.get({ url: `/erp/product/simple-list-order` })
}, },
// 查询所有商品精简列表 // 查询所有商品精简列表
getMesProductSimpleList: async (params?: { categoryType?: number }) => { getMesProductSimpleList: async () => {
return await request.get({ url: `/erp/product/simple-list-product`, params }) return await request.get({ url: `/erp/product/simple-list-product` })
}, },
// 查询备件精简列表 // 查询备件精简列表
getComponentSimpleList: async () => { getComponentSimpleList: async () => {
return await request.get({ url: `/erp/product/simple-list-component` }) return await request.get({ url: `/erp/product/simple-list-component` })
}, },
// 查询产品工艺路线快照
getProductProcessRoute: async (productId: number | string) => {
return await request.get<ErpProductProcessRouteRespVO>({ url: '/erp/product/get-process-route', params: { productId } })
},
// 查询产品详情 // 查询产品详情
getProduct: async (id: number) => { getProduct: async (id: number) => {
return await request.get({ url: `/erp/product/get?id=` + id }) return await request.get({ url: `/erp/product/get?id=` + id })

@ -57,8 +57,8 @@ export const ProductUnitApi = {
return await request.get({ url: `/erp/product-unit/flag-list`}) return await request.get({ url: `/erp/product-unit/flag-list`})
}, },
// 下载产品主单位导入模板 // 下载用户导入模板
importProductUnitTemplate: async () => { importUserTemplate: async () => {
return await request.download({ url: '/erp/product-unit/get-import-template' }) return await request.download({ url: '/erp/product-unit/get-import-template' })
} }
} }

@ -2,89 +2,13 @@ import request from '@/config/axios'
// ERP 库存盘点单 VO // ERP 库存盘点单 VO
export interface StockCheckVO { export interface StockCheckVO {
id: number // 盘点编号 id: number // 出库编号
no: string // 盘点单号 no: string // 出库单号
checkTime: Date | string // 盘点时间 outTime: Date // 出库时间
sourceType?: number | string // 生成来源类型1-按库存2-按产品
categoryType?: number | string // 分类
totalCount: number // 合计数量 totalCount: number // 合计数量
totalPrice: number // 合计金额,单位:元 totalPrice: number // 合计金额,单位:元
status: number // 状态 status: number // 状态
checkStatus?: number | string // 盘点状态0-未盘点1-已盘点 remark: string // 备注
auditUserId?: number // 审核人编号
auditUserName?: string // 审核人名称
remark?: string // 备注
fileUrl?: string // 附件 URL
creator?: string // 创建人
creatorName?: string // 创建人名称
createTime?: Date | string // 创建时间
productNames?: string // 产品信息
items?: StockCheckItemVO[] // 盘点项列表
approveRecords?: StockCheckApproveRecordVO[] // 审核记录
}
export interface StockCheckItemVO {
id?: number // 盘点项编号
warehouseId: number // 仓库编号
warehouseName?: string // 仓库名称
areaId?: number // 库区编号
areaName?: string // 库区名称
productId: number // 产品编号
productPrice: number // 产品单价
stockCount: number // 账面数量
actualCount: number // 实际数量
count: number // 盈亏数量
remark?: string // 备注
productName: string // 产品名称
productBarCode: string // 产品条码
productUnitName: string // 产品单位名称
purchaseUnitName?: string // 采购单位名称
}
export interface StockCheckRecordVO {
id: number
stockCheckId?: number
stockCheckItemId?: number
no?: string
checkTime?: Date | string
sourceType?: number | string
categoryType?: number | string
status?: number | string
checkStatus?: number | string
productId?: number
productName?: string
productBarCode?: string
barCode?: string
standard?: string
productUnitName?: string
purchaseUnitName?: string
unitName?: string
warehouseId?: number
warehouseName?: string
areaId?: number
areaName?: string
stockCount?: number | string
actualCount?: number | string
count?: number | string
remark?: string
creator?: string
creatorName?: string
createTime?: Date | string
[key: string]: any
}
export interface StockCheckApproveRecordVO {
id?: number // 编号
stockCheckId?: number // 盘点单编号
actionType?: string // 操作类型
fromStatus?: number // 变更前状态
toStatus?: number // 变更后状态
targetUserId?: number // 目标审核人编号
targetUserName?: string // 目标审核人名称
remark?: string // 备注
creator?: string // 操作人
creatorName?: string // 操作人名称
createTime?: Date | string // 创建时间
} }
// ERP 库存盘点单 API // ERP 库存盘点单 API
@ -94,31 +18,11 @@ export const StockCheckApi = {
return await request.get({ url: `/erp/stock-check/page`, params }) return await request.get({ url: `/erp/stock-check/page`, params })
}, },
// 查询库存盘点记录分页
getStockCheckRecordPage: async (params: any) => {
return await request.get({ url: `/erp/stock-check/record-page`, params })
},
// 导出库存盘点记录 Excel
exportStockCheckRecord: async (params) => {
return await request.download({ url: `/erp/stock-check/record-export-excel`, params })
},
// 查询库存盘点单详情 // 查询库存盘点单详情
getStockCheck: async (id: number) => { getStockCheck: async (id: number) => {
return await request.get({ url: `/erp/stock-check/get?id=` + id }) return await request.get({ url: `/erp/stock-check/get?id=` + id })
}, },
// 按仓库/库区生成盘点项
generateItemsByLocation: async (data: any) => {
return await request.post({ url: `/erp/stock-check/generate-items/by-location`, data })
},
// 按产品生成盘点项
generateItemsByProduct: async (data: any) => {
return await request.post({ url: `/erp/stock-check/generate-items/by-product`, data })
},
// 新增库存盘点单 // 新增库存盘点单
createStockCheck: async (data: StockCheckVO) => { createStockCheck: async (data: StockCheckVO) => {
return await request.post({ url: `/erp/stock-check/create`, data }) return await request.post({ url: `/erp/stock-check/create`, data })
@ -140,16 +44,6 @@ export const StockCheckApi = {
}) })
}, },
// 提交库存盘点单
submitStockCheck: async (data: { id: number; auditUserId?: number; remark?: string }) => {
return await request.put({ url: `/erp/stock-check/submit`, data })
},
// 审核库存盘点单
auditStockCheck: async (data: { id: number; status: number; remark?: string }) => {
return await request.put({ url: `/erp/stock-check/audit`, data })
},
// 删除库存盘点单 // 删除库存盘点单
deleteStockCheck: async (ids: number[]) => { deleteStockCheck: async (ids: number[]) => {
return await request.delete({ return await request.delete({

@ -1,21 +1,4 @@
import request from '@/config/axios' import request from '@/config/axios'
import qs from 'qs'
const normalizeStockQueryParams = (params: any) => {
if (!params) return params
const nextParams = { ...params }
if (Array.isArray(nextParams.statusList)) {
if (nextParams.statusList.length) {
nextParams.statusList = nextParams.statusList.join(',')
} else {
delete nextParams.statusList
}
}
return nextParams
}
const stockQueryParamsSerializer = (params: any) =>
qs.stringify(params, { allowDots: true, arrayFormat: 'repeat' })
// ERP 其它入库单 VO // ERP 其它入库单 VO
export interface StockInVO { export interface StockInVO {
@ -24,37 +7,17 @@ export interface StockInVO {
supplierId: number // 供应商编号 supplierId: number // 供应商编号
inTime: Date // 入库时间 inTime: Date // 入库时间
inType: string //入库类型 inType: string //入库类型
stockUserId?: string // 经办人编号
totalCount: number // 合计数量 totalCount: number // 合计数量
totalPrice: number // 合计金额,单位:元 totalPrice: number // 合计金额,单位:元
status: number // 状态 status: number // 状态
remark: string // 备注 remark: string // 备注
} }
export interface StockInApproveRecordVO {
id: number
stockInId: number
actionType: string
fromStatus: number
toStatus: number
targetUserId: number
targetUserName: string
remark: string
creator: string
creatorName: string
createTime: string
}
// ERP 其它入库单 API // ERP 其它入库单 API
export const StockInApi = { export const StockInApi = {
// 查询其它入库单分页 // 查询其它入库单分页
getStockInPage: async (params: any) => { getStockInPage: async (params: any) => {
const finalParams = normalizeStockQueryParams(params) return await request.get({ url: `/erp/stock-in/page`, params })
return await request.get({
url: `/erp/stock-in/page`,
params: finalParams,
paramsSerializer: stockQueryParamsSerializer
})
}, },
// 查询其它入库单详情 // 查询其它入库单详情
@ -75,7 +38,7 @@ export const StockInApi = {
// 更新其它入库单的状态 // 更新其它入库单的状态
updateStockInStatus: async (id: number, status: number) => { updateStockInStatus: async (id: number, status: number) => {
return await request.put({ return await request.put({
url: `/erp/stock-in/update-mold-status`, url: `/erp/stock-in/update-status`,
params: { params: {
id, id,
status status
@ -83,21 +46,6 @@ export const StockInApi = {
}) })
}, },
// 提交入库单审核
submitStockIn: async (data: { id: string; auditUserId?: string; remark?: string }) => {
return await request.put({ url: `/erp/stock-in/submit`, data })
},
// 审核入库单
auditStockIn: async (data: { id: string; status: string; remark?: string }) => {
return await request.put({ url: `/erp/stock-in/audit`, data })
},
// 查询入库单审核记录
getApproveRecordList: async (id: number) => {
return await request.get({ url: `/erp/stock-in/approve-record-list`, params: { id } })
},
// 删除其它入库单 // 删除其它入库单
deleteStockIn: async (ids: number[]) => { deleteStockIn: async (ids: number[]) => {
return await request.delete({ return await request.delete({
@ -110,12 +58,7 @@ export const StockInApi = {
// 导出其它入库单 Excel // 导出其它入库单 Excel
exportStockIn: async (params) => { exportStockIn: async (params) => {
const finalParams = normalizeStockQueryParams(params) return await request.download({ url: `/erp/stock-in/export-excel`, params })
return await request.download({
url: `/erp/stock-in/export-excel`,
params: finalParams,
paramsSerializer: stockQueryParamsSerializer
})
}, },
// 查询生产入库单分页 // 查询生产入库单分页

@ -1,53 +1,39 @@
import request from '@/config/axios' import request from '@/config/axios'
// ERP 库存调度单 VO
export interface StockMoveVO { export interface StockMoveVO {
id: number id: number // 出库编号
no: string no: string // 出库单号
categoryType?: number outTime: Date // 出库时间
outTime: Date totalCount: number // 合计数量
totalCount: number totalPrice: number // 合计金额,单位:元
totalPrice: number status: number // 状态
status: number remark: string // 备注
auditUserId?: number
auditUserName?: string
approveRecords?: StockMoveApproveRecordVO[]
remark: string
} }
export interface StockMoveApproveRecordVO { // ERP 库存调度单 API
id?: number
stockMoveId?: number
actionType?: string
fromStatus?: number
toStatus?: number
targetUserId?: number
targetUserName?: string
remark?: string
creator?: string
creatorName?: string
createTime?: Date | string
}
export const StockMoveApi = { export const StockMoveApi = {
// 查询库存调度单分页
getStockMovePage: async (params: any) => { getStockMovePage: async (params: any) => {
return await request.get({ url: `/erp/stock-move/page`, params }) return await request.get({ url: `/erp/stock-move/page`, params })
}, },
// 查询库存调度单详情
getStockMove: async (id: number) => { getStockMove: async (id: number) => {
return await request.get({ url: `/erp/stock-move/get?id=` + id }) return await request.get({ url: `/erp/stock-move/get?id=` + id })
}, },
getProductStockList: async (productId: number) => { // 新增库存调度单
return await request.get({ url: `/erp/stock-move/product-stock-list`, params: { productId } })
},
createStockMove: async (data: StockMoveVO) => { createStockMove: async (data: StockMoveVO) => {
return await request.post({ url: `/erp/stock-move/create`, data }) return await request.post({ url: `/erp/stock-move/create`, data })
}, },
// 修改库存调度单
updateStockMove: async (data: StockMoveVO) => { updateStockMove: async (data: StockMoveVO) => {
return await request.put({ url: `/erp/stock-move/update`, data }) return await request.put({ url: `/erp/stock-move/update`, data })
}, },
// 更新库存调度单的状态
updateStockMoveStatus: async (id: number, status: number) => { updateStockMoveStatus: async (id: number, status: number) => {
return await request.put({ return await request.put({
url: `/erp/stock-move/update-status`, url: `/erp/stock-move/update-status`,
@ -58,14 +44,7 @@ export const StockMoveApi = {
}) })
}, },
submitStockMove: async (data: { id: number; auditUserId?: number; remark?: string }) => { // 删除库存调度单
return await request.put({ url: `/erp/stock-move/submit`, data })
},
auditStockMove: async (data: { id: number; status: number; remark?: string }) => {
return await request.put({ url: `/erp/stock-move/audit`, data })
},
deleteStockMove: async (ids: number[]) => { deleteStockMove: async (ids: number[]) => {
return await request.delete({ return await request.delete({
url: `/erp/stock-move/delete`, url: `/erp/stock-move/delete`,
@ -75,7 +54,8 @@ export const StockMoveApi = {
}) })
}, },
// 导出库存调度单 Excel
exportStockMove: async (params) => { exportStockMove: async (params) => {
return await request.download({ url: `/erp/stock-move/export-excel`, params }) return await request.download({ url: `/erp/stock-move/export-excel`, params })
} }
} }

@ -1,21 +1,4 @@
import request from '@/config/axios' import request from '@/config/axios'
import qs from 'qs'
const normalizeStockQueryParams = (params: any) => {
if (!params) return params
const nextParams = { ...params }
if (Array.isArray(nextParams.statusList)) {
if (nextParams.statusList.length) {
nextParams.statusList = nextParams.statusList.join(',')
} else {
delete nextParams.statusList
}
}
return nextParams
}
const stockQueryParamsSerializer = (params: any) =>
qs.stringify(params, { allowDots: true, arrayFormat: 'repeat' })
// ERP 其它出库单 VO // ERP 其它出库单 VO
export interface StockOutVO { export interface StockOutVO {
@ -24,37 +7,17 @@ export interface StockOutVO {
customerId: number // 客户编号 customerId: number // 客户编号
outTime: Date // 出库时间 outTime: Date // 出库时间
outType: string //出库类型 outType: string //出库类型
stockUserId?: string
totalCount: number // 合计数量 totalCount: number // 合计数量
totalPrice: number // 合计金额,单位:元 totalPrice: number // 合计金额,单位:元
status: number // 状态 status: number // 状态
remark: string // 备注 remark: string // 备注
} }
export interface StockOutApproveRecordVO {
id: number
stockOutId: number
actionType: string
fromStatus: number
toStatus: number
targetUserId: number
targetUserName: string
remark: string
creator: string
creatorName: string
createTime: string
}
// ERP 其它出库单 API // ERP 其它出库单 API
export const StockOutApi = { export const StockOutApi = {
// 查询其它出库单分页 // 查询其它出库单分页
getStockOutPage: async (params: any) => { getStockOutPage: async (params: any) => {
const finalParams = normalizeStockQueryParams(params) return await request.get({ url: `/erp/stock-out/page`, params })
return await request.get({
url: `/erp/stock-out/page`,
params: finalParams,
paramsSerializer: stockQueryParamsSerializer
})
}, },
// 查询其它出库单详情 // 查询其它出库单详情
@ -75,7 +38,7 @@ export const StockOutApi = {
// 更新其它出库单的状态 // 更新其它出库单的状态
updateStockOutStatus: async (id: number, status: number) => { updateStockOutStatus: async (id: number, status: number) => {
return await request.put({ return await request.put({
url: `/erp/stock-out/update-mold-status`, url: `/erp/stock-out/update-status`,
params: { params: {
id, id,
status status
@ -83,18 +46,6 @@ export const StockOutApi = {
}) })
}, },
submitStockOut: async (data: { id: string; auditUserId?: string; remark?: string }) => {
return await request.put({ url: `/erp/stock-out/submit`, data })
},
auditStockOut: async (data: { id: string; status: string; remark?: string }) => {
return await request.put({ url: `/erp/stock-out/audit`, data })
},
getApproveRecordList: async (id: number) => {
return await request.get({ url: `/erp/stock-out/approve-record-list`, params: { id } })
},
// 删除其它出库单 // 删除其它出库单
deleteStockOut: async (ids: number[]) => { deleteStockOut: async (ids: number[]) => {
return await request.delete({ return await request.delete({
@ -107,12 +58,7 @@ export const StockOutApi = {
// 导出其它出库单 Excel // 导出其它出库单 Excel
exportStockOut: async (params) => { exportStockOut: async (params) => {
const finalParams = normalizeStockQueryParams(params) return await request.download({ url: `/erp/stock-out/export-excel`, params })
return await request.download({
url: `/erp/stock-out/export-excel`,
params: finalParams,
paramsSerializer: stockQueryParamsSerializer
})
}, },
// 查询其它出库单分页 // 查询其它出库单分页
getMesStockOutPage: async (params: any) => { getMesStockOutPage: async (params: any) => {

@ -1,42 +0,0 @@
import request from '@/config/axios'
// ERP 包装方案 VO
export interface PackagingSchemeVO {
id: number // 包装方案编号
code: string // 方案编码
name: string // 方案名称
packageQuantity: number // 每包数量(件)
palletPackageQuantity: number // 每托包数(包)
palletTotalQuantity: number // 每托总数量(件)
remark: string // 备注
status: number // 状态
createTime: string // 创建时间
}
// ERP 包装方案 API
export const PackagingSchemeApi = {
// 查询包装方案分页
getPackagingSchemePage: async (params: any) => {
return await request.get({ url: `/erp/packaging-scheme/page`, params })
},
// 查询包装方案详情
getPackagingScheme: async (id: number) => {
return await request.get({ url: `/erp/packaging-scheme/get?id=` + id })
},
// 新增包装方案
createPackagingScheme: async (data: PackagingSchemeVO) => {
return await request.post({ url: `/erp/packaging-scheme/create`, data })
},
// 修改包装方案
updatePackagingScheme: async (data: PackagingSchemeVO) => {
return await request.put({ url: `/erp/packaging-scheme/update`, data })
},
// 删除包装方案
deletePackagingScheme: async (id: number) => {
return await request.delete({ url: `/erp/packaging-scheme/delete?id=` + id })
}
}

@ -1,46 +0,0 @@
import request from '@/config/axios'
export interface PalletVO {
id?: number
code?: string
isCode?: boolean
palletType?: number | string
specification?: string
ratedLoadWeight?: number | string
unit?: string
status?: number | string
warehouseId?: number | string
areaId?: number | string
planCode?: string
productId?: number | string
productCount?: number | string
lockedPackageCount?: number | string
qrcode?: string
templateJson?: string | any
purchaseDate?: string
useDate?: string
remark?: string
createTime?: string
}
export const PalletApi = {
getPalletPage: async (params: any) => {
return await request.get({ url: `/erp/pallet/page`, params })
},
getPallet: async (id: number) => {
return await request.get({ url: `/erp/pallet/get?id=` + id })
},
createPallet: async (data: PalletVO) => {
return await request.post({ url: `/erp/pallet/create`, data })
},
updatePallet: async (data: PalletVO) => {
return await request.put({ url: `/erp/pallet/update`, data })
},
deletePallet: async (id: number) => {
return await request.delete({ url: `/erp/pallet/delete?id=` + id })
}
}

@ -2,29 +2,15 @@ import request from '@/config/axios'
// ERP 产品库存明细 VO // ERP 产品库存明细 VO
export interface StockRecordVO { export interface StockRecordVO {
id: number id: number // 编号
productId: number productId: number // 产品编号
bizDirection?: string warehouseId: number // 仓库编号
bizDocType?: number count: number // 出入库数量
categoryType?: number totalCount: number // 总库存量
warehouseId: number bizType: number // 业务类型
areaId?: number bizId: number // 业务编号
areaName?: string bizItemId: number // 业务项编号
count: number bizNo: string // 业务单号
totalCount: number
bizType: number
bizId: number
bizItemId: number
bizNo: string
createTime?: string
creator?: string
productName: string
categoryName: string
unitName: string
purchaseUnitName?: string
warehouseName: string
creatorName: string
recordTime?: string
} }
// ERP 产品库存明细 API // ERP 产品库存明细 API

@ -1,126 +1,19 @@
import request from '@/config/axios' import request from '@/config/axios'
// ERP 产品库存 VO // ERP 产品库存 VO
export interface StockUnitStockVO {
unitId?: number
unitName?: string
count?: number
stockDisplay?: string
}
export interface ProductPackagingStockVO {
productId?: number
productName?: string
packagingSchemeId?: number
packagingSchemeName?: string
totalCount?: number
unitName?: string
stockDisplay?: string
packagingDisplay?: string
packageQuantity?: number
palletPackageQuantity?: number
palletTotalQuantity?: number
}
export interface ProductStockCardVO {
skuCount?: number
stockDisplay?: string
totalCount?: number
unitName?: string
packagingStocks?: ProductPackagingStockVO[]
todayFinishedInDisplay?: string
}
export interface UnitGroupedStockCardVO {
skuCount?: number
stockDisplay?: string
unitStocks?: StockUnitStockVO[]
}
export interface TodayInCardVO {
orderCount?: number
itemCount?: number
productStock?: ProductStockCardVO
materialStock?: UnitGroupedStockCardVO
sparePartStock?: UnitGroupedStockCardVO
productDisplay?: string
materialDisplay?: string
sparePartDisplay?: string
}
export interface TodayOutCardVO {
orderCount?: number
itemCount?: number
materialStock?: UnitGroupedStockCardVO
sparePartStock?: UnitGroupedStockCardVO
productStock?: ProductStockCardVO
materialDisplay?: string
sparePartDisplay?: string
productDisplay?: string
}
export interface StockStatisticsCardsRespVO {
productStock?: ProductStockCardVO
materialStock?: UnitGroupedStockCardVO
sparePartStock?: UnitGroupedStockCardVO
todayIn?: TodayInCardVO
todayOut?: TodayOutCardVO
}
export interface StockVO { export interface StockVO {
// 编号 // 编号
id: number id: number
// 产品编号 // 产品编号
productId: number productId: number
name?: string
productName?: string
barCode?: string
categoryName?: string
unitName?: string
purchaseUnitName?: string
// 产品分类类型
categoryType?: number
// 仓库编号 // 仓库编号
warehouseId: number warehouseId: number
warehouseName?: string
areaId?: number
areaName?: string
// 包装/换算规则
packagingRule?: string
// 库存展示
stockDisplay?: string
areaStocks?: Array<{
areaId?: number
areaName?: string
count?: number
packageCount?: number
baseCount?: number
stockDisplay?: string
}>
totalPackageCount?: number
totalBaseCount?: number
// 库存数量 // 库存数量
count: number count: number
lockedStockCount?: number
latestInTime?: number | string
lastInTime?: number | string
recentInTime?: number | string
latestStockInTime?: number | string
lastStockInTime?: number | string
latestOutTime?: number | string
lastOutTime?: number | string
recentOutTime?: number | string
latestStockOutTime?: number | string
lastStockOutTime?: number | string
} }
// ERP 产品库存 API // ERP 产品库存 API
export const StockApi = { export const StockApi = {
// 查询库存统计卡片
getStockStatisticsCards: async () => {
return await request.get<StockStatisticsCardsRespVO>({ url: `/erp/stock/statistics-cards` })
},
// 查询产品库存分页 // 查询产品库存分页
getStockPage: async (params: any) => { getStockPage: async (params: any) => {
return await request.get({ url: `/erp/stock/page`, params }) return await request.get({ url: `/erp/stock/page`, params })
@ -132,8 +25,8 @@ export const StockApi = {
}, },
// 查询产品库存详情 // 查询产品库存详情
getStock2: async (productId: number, warehouseId: number, areaId?: number) => { getStock2: async (productId: number, warehouseId: number) => {
return await request.get({ url: `/erp/stock/get`, params: { productId, warehouseId, areaId } }) return await request.get({ url: `/erp/stock/get`, params: { productId, warehouseId } })
}, },
// 获得产品库存数量 // 获得产品库存数量

@ -4,7 +4,6 @@ import request from '@/config/axios'
export interface WarehouseVO { export interface WarehouseVO {
id: number // 仓库编号 id: number // 仓库编号
name: string // 仓库名称 name: string // 仓库名称
categoryType?: number // 仓库分类
address: string // 仓库地址 address: string // 仓库地址
sort: number // 排序 sort: number // 排序
remark: string // 备注 remark: string // 备注
@ -50,8 +49,8 @@ export const WarehouseApi = {
}, },
// 查询仓库精简列表 // 查询仓库精简列表
getWarehouseSimpleList: async (params?: any) => { getWarehouseSimpleList: async () => {
return await request.get({ url: `/erp/warehouse/simple-list`, params }) return await request.get({ url: `/erp/warehouse/simple-list` })
}, },
// 查询仓库详情 // 查询仓库详情

@ -4,10 +4,6 @@ export interface WarehouseAreaVO {
id: number id: number
warehouseId: number warehouseId: number
areaCode: string areaCode: string
isCode?: boolean
qrcode?: string
qrcodeUrl?: string
templateJson?: string | any
areaName: string areaName: string
areaSize: number areaSize: number
description: string description: string

@ -26,11 +26,6 @@ export interface WeatherVO {
// 生产计划 API // 生产计划 API
export const HomeApi = { export const HomeApi = {
// 是否允许免登录访问首页
isPublicAccessEnabled: async () => {
return await request.get<boolean>({ url: `/home/info/public-access-enabled` })
},
// 查询天气 // 查询天气
getWeatherInfo: async () => { getWeatherInfo: async () => {

@ -6,7 +6,6 @@ export interface DeviceVO {
id: number // ID id: number // ID
deviceCode: string // 设备编号 deviceCode: string // 设备编号
deviceName: string // 设备名称 deviceName: string // 设备名称
boundLedgerName?: string // 已绑定的设备台账名称
deviceType: string // 设备类型 deviceType: string // 设备类型
status: string // 状态 status: string // 状态
isConnect?: string | number isConnect?: string | number
@ -20,15 +19,15 @@ export interface DeviceVO {
remark: string // 备注 remark: string // 备注
isEnable: boolean // 是否启用 isEnable: boolean // 是否启用
deviceModelId: number // 关联设备模型 deviceModelId: number // 关联设备模型
protocol: string // 通讯协议 protocol: string // 通讯协议
sampleCycle: number // 采集周期 sampleCycle: number // 采集周期
url: string // 端点url url: string // 端点url
username: string // 用户名 username: string // 用户名
password: string // 密码 password: string // 密码
certificate?: string // 证书 certificate?: string // 证书
secretKey?: string // 秘钥 secretKey?: string // 秘钥
collectionTime?: string | number collectionTime?: string | number
images: string //图片 images: string,//图片
} }
export interface DeviceConnectParams { export interface DeviceConnectParams {
@ -80,13 +79,14 @@ export interface DeviceContactModelVO {
dataUnit?: string dataUnit?: string
} }
// 物联设备 API // 物联设备 API
export const DeviceApi = { export const DeviceApi = {
// 查询物联设备分页 // 查询物联设备分页
getDevicePage: async (params: any) => { getDevicePage: async (params: any) => {
return await request.get({ url: `/iot/device/page`, params }) return await request.get({ url: `/iot/device/page`, params })
}, },
// 查询物联设备 // 查询物联设备
getDeviceList: async (params?: any) => { getDeviceList: async (params?: any) => {
return await request.get({ url: `/iot/device/deviceList`, params }) return await request.get({ url: `/iot/device/deviceList`, params })
}, },
@ -104,7 +104,7 @@ export const DeviceApi = {
return await request.get({ url: `/iot/device/available-list` }) return await request.get({ url: `/iot/device/available-list` })
}, },
getAvailableListPage: async (params: any) => { getAvailableListPage: async (params: any) => {
return await request.get({ url: `/iot/device/available-page`, params }) return await request.get({ url: `/iot/device/available-page` , params})
}, },
// 新增物联设备 // 新增物联设备
createDevice: async (data: DeviceVO) => { createDevice: async (data: DeviceVO) => {
@ -112,10 +112,7 @@ export const DeviceApi = {
}, },
// 批量获取设备属性列表 // 批量获取设备属性列表
getDeviceAttributeBatchList: async (params: { getDeviceAttributeBatchList: async (params: { goviewId: number | string; orgId?: number | string }) => {
goviewId: number | string
orgId?: number | string
}) => {
return await request.get({ url: `/iot/device/device-attribute/batchList`, params }) return await request.get({ url: `/iot/device/device-attribute/batchList`, params })
}, },
// 修改物联设备 // 修改物联设备
@ -166,6 +163,7 @@ export const DeviceApi = {
}) })
}, },
getHistoryAnalyse: async (params: HistoryRecordParams) => { getHistoryAnalyse: async (params: HistoryRecordParams) => {
return await request.get({ return await request.get({
url: `/iot/device/historyAnalyse`, url: `/iot/device/historyAnalyse`,
@ -183,7 +181,7 @@ export const DeviceApi = {
return await request.put({ url: `/iot/device/update-enabled`, data }) return await request.put({ url: `/iot/device/update-enabled`, data })
}, },
// ==================== 子表(设备属性) ==================== // ==================== 子表(设备属性) ====================
// 获得设备属性分页 // 获得设备属性分页
getDeviceAttributePage: async (params) => { getDeviceAttributePage: async (params) => {
@ -197,10 +195,6 @@ export const DeviceApi = {
getDeviceAttributeList: async (deviceId: number | string) => { getDeviceAttributeList: async (deviceId: number | string) => {
return await request.get({ url: `/iot/device/device-attribute/list?deviceId=` + deviceId }) return await request.get({ url: `/iot/device/device-attribute/list?deviceId=` + deviceId })
}, },
// 下载设备属性导入模板
importDeviceAttributeTemplate: async () => {
return await request.download({ url: '/iot/device/device-attribute/get-import-template' })
},
getDeviceContactModelPage: async () => { getDeviceContactModelPage: async () => {
return await request.get({ url: `/iot/device-contact-model/page` }) return await request.get({ url: `/iot/device-contact-model/page` })
@ -225,7 +219,7 @@ export const DeviceApi = {
return await request.download({ url: `/iot/device-contact-model/export-excel`, params }) return await request.download({ url: `/iot/device-contact-model/export-excel`, params })
}, },
// 获得设备点位 // 获得设备属性
getDeviceAttribute: async (id: number) => { getDeviceAttribute: async (id: number) => {
return await request.get({ url: `/iot/device-contact-model/get?id=` + id }) return await request.get({ url: `/iot/device-contact-model/get?id=` + id })
} }

@ -0,0 +1,37 @@
import request from '@/config/axios'
export interface BannerVO {
id: number
title: string
picUrl: string
status: number
url: string
position: number
sort: number
memo: string
}
// 查询Banner管理列表
export const getBannerPage = async (params) => {
return await request.get({ url: `/promotion/banner/page`, params })
}
// 查询Banner管理详情
export const getBanner = async (id: number) => {
return await request.get({ url: `/promotion/banner/get?id=` + id })
}
// 新增Banner管理
export const createBanner = async (data: BannerVO) => {
return await request.post({ url: `/promotion/banner/create`, data })
}
// 修改Banner管理
export const updateBanner = async (data: BannerVO) => {
return await request.put({ url: `/promotion/banner/update`, data })
}
// 删除Banner管理
export const deleteBanner = async (id: number) => {
return await request.delete({ url: `/promotion/banner/delete?id=` + id })
}

@ -0,0 +1,61 @@
import request from '@/config/axios'
/**
*
*/
export interface BrandVO {
/**
*
*/
id?: number
/**
*
*/
name: string
/**
*
*/
picUrl: string
/**
*
*/
sort?: number
/**
*
*/
description?: string
/**
*
*/
status: number
}
// 创建商品品牌
export const createBrand = (data: BrandVO) => {
return request.post({ url: '/product/brand/create', data })
}
// 更新商品品牌
export const updateBrand = (data: BrandVO) => {
return request.put({ url: '/product/brand/update', data })
}
// 删除商品品牌
export const deleteBrand = (id: number) => {
return request.delete({ url: `/product/brand/delete?id=${id}` })
}
// 获得商品品牌
export const getBrand = (id: number) => {
return request.get({ url: `/product/brand/get?id=${id}` })
}
// 获得商品品牌列表
export const getBrandParam = (params: PageParam) => {
return request.get({ url: '/product/brand/page', params })
}
// 获得商品品牌精简信息列表
export const getSimpleBrandList = () => {
return request.get({ url: '/product/brand/list-all-simple' })
}

@ -0,0 +1,56 @@
import request from '@/config/axios'
/**
*
*/
export interface CategoryVO {
/**
*
*/
id?: number
/**
*
*/
parentId?: number
/**
*
*/
name: string
/**
*
*/
picUrl: string
/**
*
*/
sort: number
/**
*
*/
status: number
}
// 创建商品分类
export const createCategory = (data: CategoryVO) => {
return request.post({ url: '/product/category/create', data })
}
// 更新商品分类
export const updateCategory = (data: CategoryVO) => {
return request.put({ url: '/product/category/update', data })
}
// 删除商品分类
export const deleteCategory = (id: number) => {
return request.delete({ url: `/product/category/delete?id=${id}` })
}
// 获得商品分类
export const getCategory = (id: number) => {
return request.get({ url: `/product/category/get?id=${id}` })
}
// 获得商品分类列表
export const getCategoryList = (params: any) => {
return request.get({ url: '/product/category/list', params })
}

@ -0,0 +1,49 @@
import request from '@/config/axios'
export interface CommentVO {
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
}
// 查询商品评论列表
export const getCommentPage = async (params) => {
return await request.get({ url: `/product/comment/page`, params })
}
// 查询商品评论详情
export const getComment = async (id: number) => {
return await request.get({ url: `/product/comment/get?id=` + id })
}
// 添加自评
export const createComment = async (data: CommentVO) => {
return await request.post({ url: `/product/comment/create`, data })
}
// 显示 / 隐藏评论
export const updateCommentVisible = async (data: any) => {
return await request.put({ url: `/product/comment/update-visible`, data })
}
// 商家回复
export const replyComment = async (data: any) => {
return await request.put({ url: `/product/comment/reply`, data })
}

@ -0,0 +1,12 @@
import request from '@/config/axios'
export interface Favorite {
id?: number
userId?: string // 用户编号
spuId?: number | null // 商品 SPU 编号
}
// 获得 ProductFavorite 列表
export const getFavoritePage = (params: PageParam) => {
return request.get({ url: '/product/favorite/page', params })
}

@ -0,0 +1,10 @@
import request from '@/config/axios'
/**
*
*
* @param params
*/
export const getBrowseHistoryPage = (params: any) => {
return request.get({ url: '/product/browse-history/page', params })
}

@ -0,0 +1,89 @@
import request from '@/config/axios'
/**
*
*/
export interface PropertyVO {
id?: number
/** 名称 */
name: string
/** 备注 */
remark?: string
}
/**
*
*/
export interface PropertyValueVO {
id?: number
/** 属性项的编号 */
propertyId?: number
/** 名称 */
name: string
/** 备注 */
remark?: string
}
// ------------------------ 属性项 -------------------
// 创建属性项
export const createProperty = (data: PropertyVO) => {
return request.post({ url: '/product/property/create', data })
}
// 更新属性项
export const updateProperty = (data: PropertyVO) => {
return request.put({ url: '/product/property/update', data })
}
// 删除属性项
export const deleteProperty = (id: number) => {
return request.delete({ url: `/product/property/delete?id=${id}` })
}
// 获得属性项
export const getProperty = (id: number): Promise<PropertyVO> => {
return request.get({ url: `/product/property/get?id=${id}` })
}
// 获得属性项分页
export const getPropertyPage = (params: PageParam) => {
return request.get({ url: '/product/property/page', params })
}
// 获得属性项精简列表
export const getPropertySimpleList = (): Promise<PropertyVO[]> => {
return request.get({ url: '/product/property/simple-list' })
}
// ------------------------ 属性值 -------------------
// 获得属性值分页
export const getPropertyValuePage = (params: PageParam & any) => {
return request.get({ url: '/product/property/value/page', params })
}
// 获得属性值
export const getPropertyValue = (id: number): Promise<PropertyValueVO> => {
return request.get({ url: `/product/property/value/get?id=${id}` })
}
// 创建属性值
export const createPropertyValue = (data: PropertyValueVO) => {
return request.post({ url: '/product/property/value/create', data })
}
// 更新属性值
export const updatePropertyValue = (data: PropertyValueVO) => {
return request.put({ url: '/product/property/value/update', data })
}
// 删除属性值
export const deletePropertyValue = (id: number) => {
return request.delete({ url: `/product/property/value/delete?id=${id}` })
}
// 获得属性值精简列表
export const getPropertyValueSimpleList = (propertyId: number): Promise<PropertyValueVO[]> => {
return request.get({ url: '/product/property/value/simple-list', params: { propertyId } })
}

@ -0,0 +1,111 @@
import request from '@/config/axios'
export interface Property {
propertyId?: number // 属性编号
propertyName?: string // 属性名称
valueId?: number // 属性值编号
valueName?: string // 属性值名称
}
export interface Sku {
id?: number // 商品 SKU 编号
name?: string // 商品 SKU 名称
spuId?: number // SPU 编号
properties?: Property[] // 属性数组
price?: number | string // 商品价格
marketPrice?: number | string // 市场价
costPrice?: number | string // 成本价
barCode?: string // 商品条码
picUrl?: string // 图片地址
stock?: number // 库存
weight?: number // 商品重量单位kg 千克
volume?: number // 商品体积单位m^3 平米
firstBrokeragePrice?: number | string // 一级分销的佣金
secondBrokeragePrice?: number | string // 二级分销的佣金
salesCount?: number // 商品销量
}
export interface GiveCouponTemplate {
id?: number
name?: string // 优惠券名称
}
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 // 分销类型
skus?: Sku[] // 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 // 商品状态
}
// 获得 Spu 列表
export const getSpuPage = (params: PageParam) => {
return request.get({ url: '/product/spu/page', params })
}
// 获得 Spu 列表 tabsCount
export const getTabsCount = () => {
return request.get({ url: '/product/spu/get-count' })
}
// 创建商品 Spu
export const createSpu = (data: Spu) => {
return request.post({ url: '/product/spu/create', data })
}
// 更新商品 Spu
export const updateSpu = (data: Spu) => {
return request.put({ url: '/product/spu/update', data })
}
// 更新商品 Spu status
export const updateStatus = (data: { id: number; status: number }) => {
return request.put({ url: '/product/spu/update-status', data })
}
// 获得商品 Spu
export const getSpu = (id: number) => {
return request.get({ url: `/product/spu/get-detail?id=${id}` })
}
// 获得商品 Spu 详情列表
export const getSpuDetailList = (ids: number[]) => {
return request.get({ url: `/product/spu/list?spuIds=${ids}` })
}
// 删除商品 Spu
export const deleteSpu = (id: number) => {
return request.delete({ url: `/product/spu/delete?id=${id}` })
}
// 导出商品 Spu Excel
export const exportSpu = async (params) => {
return await request.download({ url: '/product/spu/export', params })
}
// 获得商品 SPU 精简列表
export const getSpuSimpleList = async () => {
return request.get({ url: '/product/spu/list-all-simple' })
}

@ -0,0 +1,42 @@
import request from '@/config/axios'
export interface ArticleVO {
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 const getArticlePage = async (params: any) => {
return await request.get({ url: `/promotion/article/page`, params })
}
// 查询文章管理详情
export const getArticle = async (id: number) => {
return await request.get({ url: `/promotion/article/get?id=` + id })
}
// 新增文章管理
export const createArticle = async (data: ArticleVO) => {
return await request.post({ url: `/promotion/article/create`, data })
}
// 修改文章管理
export const updateArticle = async (data: ArticleVO) => {
return await request.put({ url: `/promotion/article/update`, data })
}
// 删除文章管理
export const deleteArticle = async (id: number) => {
return await request.delete({ url: `/promotion/article/delete?id=` + id })
}

@ -0,0 +1,39 @@
import request from '@/config/axios'
export interface ArticleCategoryVO {
id: number
name: string
picUrl: string
status: number
sort: number
}
// 查询文章分类列表
export const getArticleCategoryPage = async (params) => {
return await request.get({ url: `/promotion/article-category/page`, params })
}
// 查询文章分类精简信息列表
export const getSimpleArticleCategoryList = async () => {
return await request.get({ url: `/promotion/article-category/list-all-simple` })
}
// 查询文章分类详情
export const getArticleCategory = async (id: number) => {
return await request.get({ url: `/promotion/article-category/get?id=` + id })
}
// 新增文章分类
export const createArticleCategory = async (data: ArticleCategoryVO) => {
return await request.post({ url: `/promotion/article-category/create`, data })
}
// 修改文章分类
export const updateArticleCategory = async (data: ArticleCategoryVO) => {
return await request.put({ url: `/promotion/article-category/update`, data })
}
// 删除文章分类
export const deleteArticleCategory = async (id: number) => {
return await request.delete({ url: `/promotion/article-category/delete?id=` + id })
}

@ -0,0 +1,68 @@
import request from '@/config/axios'
import { Sku, Spu } from '@/api/mall/product/spu'
export interface BargainActivityVO {
id?: number
name?: string
startTime?: Date
endTime?: Date
status?: number
helpMaxCount?: number // 达到该人数,才能砍到低价
bargainCount?: number // 最大帮砍次数
totalLimitCount?: number // 最大购买次数
spuId: number
skuId: number
bargainFirstPrice: number // 砍价起始价格,单位分
bargainMinPrice: number // 砍价底价
stock: number // 活动库存
randomMinPrice?: number // 用户每次砍价的最小金额,单位:分
randomMaxPrice?: number // 用户每次砍价的最大金额,单位:分
}
// 砍价活动所需属性。选择的商品和属性的时候使用方便使用活动的通用封装
export interface BargainProductVO {
spuId: number
skuId: number
bargainFirstPrice: number // 砍价起始价格,单位分
bargainMinPrice: number // 砍价底价
stock: number // 活动库存
}
// 扩展 Sku 配置
export type SkuExtension = Sku & {
productConfig: BargainProductVO
}
export interface SpuExtension extends Spu {
skus: SkuExtension[] // 重写类型
}
// 查询砍价活动列表
export const getBargainActivityPage = async (params: any) => {
return await request.get({ url: '/promotion/bargain-activity/page', params })
}
// 查询砍价活动详情
export const getBargainActivity = async (id: number) => {
return await request.get({ url: '/promotion/bargain-activity/get?id=' + id })
}
// 新增砍价活动
export const createBargainActivity = async (data: BargainActivityVO) => {
return await request.post({ url: '/promotion/bargain-activity/create', data })
}
// 修改砍价活动
export const updateBargainActivity = async (data: BargainActivityVO) => {
return await request.put({ url: '/promotion/bargain-activity/update', data })
}
// 关闭砍价活动
export const closeBargainActivity = async (id: number) => {
return await request.put({ url: '/promotion/bargain-activity/close?id=' + id })
}
// 删除砍价活动
export const deleteBargainActivity = async (id: number) => {
return await request.delete({ url: '/promotion/bargain-activity/delete?id=' + id })
}

@ -0,0 +1,14 @@
import request from '@/config/axios'
export interface BargainHelpVO {
id: number
record: number
userId: number
reducePrice: number
endTime: Date
}
// 查询砍价记录列表
export const getBargainHelpPage = async (params) => {
return await request.get({ url: `/promotion/bargain-help/page`, params })
}

@ -0,0 +1,19 @@
import request from '@/config/axios'
export interface BargainRecordVO {
id: number
activityId: number
userId: number
spuId: number
skuId: number
bargainFirstPrice: number
bargainPrice: number
status: number
orderId: number
endTime: Date
}
// 查询砍价记录列表
export const getBargainRecordPage = async (params) => {
return await request.get({ url: `/promotion/bargain-record/page`, params })
}

@ -0,0 +1,72 @@
import request from '@/config/axios'
import { Sku, Spu } from '@/api/mall/product/spu'
export interface CombinationActivityVO {
id?: number
name?: string
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: CombinationProductVO[]
}
// 拼团活动所需属性
export interface CombinationProductVO {
spuId: number
skuId: number
combinationPrice: number // 拼团价格
}
// 扩展 Sku 配置
export type SkuExtension = Sku & {
productConfig: CombinationProductVO
}
export interface SpuExtension extends Spu {
skus: SkuExtension[] // 重写类型
}
// 查询拼团活动列表
export const getCombinationActivityPage = async (params: any) => {
return await request.get({ url: '/promotion/combination-activity/page', params })
}
// 查询拼团活动详情
export const getCombinationActivity = async (id: number) => {
return await request.get({ url: '/promotion/combination-activity/get?id=' + id })
}
// 获得拼团活动列表,基于活动编号数组
export const getCombinationActivityListByIds = (ids: number[]) => {
return request.get({ url: `/promotion/combination-activity/list-by-ids?ids=${ids}` })
}
// 新增拼团活动
export const createCombinationActivity = async (data: CombinationActivityVO) => {
return await request.post({ url: '/promotion/combination-activity/create', data })
}
// 修改拼团活动
export const updateCombinationActivity = async (data: CombinationActivityVO) => {
return await request.put({ url: '/promotion/combination-activity/update', data })
}
// 关闭拼团活动
export const closeCombinationActivity = async (id: number) => {
return await request.put({ url: '/promotion/combination-activity/close?id=' + id })
}
// 删除拼团活动
export const deleteCombinationActivity = async (id: number) => {
return await request.delete({ url: '/promotion/combination-activity/delete?id=' + id })
}

@ -0,0 +1,28 @@
import request from '@/config/axios'
export interface CombinationRecordVO {
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 const getCombinationRecordPage = async (params: any) => {
return await request.get({ url: '/promotion/combination-record/page', params })
}
// 获得拼团记录的概要信息
export const getCombinationRecordSummary = async () => {
return await request.get({ url: '/promotion/combination-record/get-summary' })
}

@ -0,0 +1,26 @@
import request from '@/config/axios'
// TODO @dhb52vo 缺少
// 删除优惠劵
export const deleteCoupon = async (id: number) => {
return request.delete({
url: `/promotion/coupon/delete?id=${id}`
})
}
// 获得优惠劵分页
export const getCouponPage = async (params: PageParam) => {
return request.get({
url: '/promotion/coupon/page',
params: params
})
}
// 发送优惠券
export const sendCoupon = async (data: any) => {
return request.post({
url: '/promotion/coupon/send',
data: data
})
}

@ -0,0 +1,90 @@
import request from '@/config/axios'
export interface CouponTemplateVO {
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 function createCouponTemplate(data: CouponTemplateVO) {
return request.post({
url: '/promotion/coupon-template/create',
data: data
})
}
// 更新优惠劵模板
export function updateCouponTemplate(data: CouponTemplateVO) {
return request.put({
url: '/promotion/coupon-template/update',
data: data
})
}
// 更新优惠劵模板的状态
export function updateCouponTemplateStatus(id: number, status: [0, 1]) {
const data = {
id,
status
}
return request.put({
url: '/promotion/coupon-template/update-status',
data: data
})
}
// 删除优惠劵模板
export function deleteCouponTemplate(id: number) {
return request.delete({
url: '/promotion/coupon-template/delete?id=' + id
})
}
// 获得优惠劵模板
export function getCouponTemplate(id: number) {
return request.get({
url: '/promotion/coupon-template/get?id=' + id
})
}
// 获得优惠劵模板分页
export function getCouponTemplatePage(params: PageParam) {
return request.get({
url: '/promotion/coupon-template/page',
params: params
})
}
// 获得优惠劵模板分页
export function getCouponTemplateList(ids: number[]): Promise<CouponTemplateVO[]> {
return request.get({
url: `/promotion/coupon-template/list?ids=${ids}`
})
}
// 导出优惠劵模板 Excel
export function exportCouponTemplateExcel(params: PageParam) {
return request.get({
url: '/promotion/coupon-template/export-excel',
params: params,
responseType: 'blob'
})
}

@ -0,0 +1,60 @@
import request from '@/config/axios'
import { Sku, Spu } from '@/api/mall/product/spu'
export interface DiscountActivityVO {
id?: number
spuId?: number
name?: string
status?: number
remark?: string
startTime?: Date
endTime?: Date
products?: DiscountProductVO[]
}
// 限时折扣相关 属性
export interface DiscountProductVO {
spuId: number
skuId: number
discountType: number
discountPercent: number
discountPrice: number
}
// 扩展 Sku 配置
export type SkuExtension = Sku & {
productConfig: DiscountProductVO
}
export interface SpuExtension extends Spu {
skus: SkuExtension[] // 重写类型
}
// 查询限时折扣活动列表
export const getDiscountActivityPage = async (params) => {
return await request.get({ url: '/promotion/discount-activity/page', params })
}
// 查询限时折扣活动详情
export const getDiscountActivity = async (id: number) => {
return await request.get({ url: '/promotion/discount-activity/get?id=' + id })
}
// 新增限时折扣活动
export const createDiscountActivity = async (data: DiscountActivityVO) => {
return await request.post({ url: '/promotion/discount-activity/create', data })
}
// 修改限时折扣活动
export const updateDiscountActivity = async (data: DiscountActivityVO) => {
return await request.put({ url: '/promotion/discount-activity/update', data })
}
// 关闭限时折扣活动
export const closeDiscountActivity = async (id: number) => {
return await request.put({ url: '/promotion/discount-activity/close?id=' + id })
}
// 删除限时折扣活动
export const deleteDiscountActivity = async (id: number) => {
return await request.delete({ url: '/promotion/discount-activity/delete?id=' + id })
}

@ -0,0 +1,45 @@
import request from '@/config/axios'
export interface DiyPageVO {
id?: number
templateId?: number
name: string
remark: string
previewPicUrls: string[]
property: string
}
// 查询装修页面列表
export const getDiyPagePage = async (params: any) => {
return await request.get({ url: `/promotion/diy-page/page`, params })
}
// 查询装修页面详情
export const getDiyPage = async (id: number) => {
return await request.get({ url: `/promotion/diy-page/get?id=` + id })
}
// 新增装修页面
export const createDiyPage = async (data: DiyPageVO) => {
return await request.post({ url: `/promotion/diy-page/create`, data })
}
// 修改装修页面
export const updateDiyPage = async (data: DiyPageVO) => {
return await request.put({ url: `/promotion/diy-page/update`, data })
}
// 删除装修页面
export const deleteDiyPage = async (id: number) => {
return await request.delete({ url: `/promotion/diy-page/delete?id=` + id })
}
// 获得装修页面属性
export const getDiyPageProperty = async (id: number) => {
return await request.get({ url: `/promotion/diy-page/get-property?id=` + id })
}
// 更新装修页面属性
export const updateDiyPageProperty = async (data: DiyPageVO) => {
return await request.put({ url: `/promotion/diy-page/update-property`, data })
}

@ -0,0 +1,58 @@
import request from '@/config/axios'
import { DiyPageVO } from '@/api/mall/promotion/diy/page'
export interface DiyTemplateVO {
id?: number
name: string
used: boolean
usedTime?: Date
remark: string
previewPicUrls: string[]
property: string
}
export interface DiyTemplatePropertyVO extends DiyTemplateVO {
pages: DiyPageVO[]
}
// 查询装修模板列表
export const getDiyTemplatePage = async (params: any) => {
return await request.get({ url: `/promotion/diy-template/page`, params })
}
// 查询装修模板详情
export const getDiyTemplate = async (id: number) => {
return await request.get({ url: `/promotion/diy-template/get?id=` + id })
}
// 新增装修模板
export const createDiyTemplate = async (data: DiyTemplateVO) => {
return await request.post({ url: `/promotion/diy-template/create`, data })
}
// 修改装修模板
export const updateDiyTemplate = async (data: DiyTemplateVO) => {
return await request.put({ url: `/promotion/diy-template/update`, data })
}
// 删除装修模板
export const deleteDiyTemplate = async (id: number) => {
return await request.delete({ url: `/promotion/diy-template/delete?id=` + id })
}
// 使用装修模板
export const useDiyTemplate = async (id: number) => {
return await request.put({ url: `/promotion/diy-template/use?id=` + id })
}
// 获得装修模板属性
export const getDiyTemplateProperty = async (id: number) => {
return await request.get<DiyTemplatePropertyVO>({
url: `/promotion/diy-template/get-property?id=` + id
})
}
// 更新装修模板属性
export const updateDiyTemplateProperty = async (data: DiyTemplateVO) => {
return await request.put({ url: `/promotion/diy-template/update-property`, data })
}

@ -0,0 +1,39 @@
import request from '@/config/axios'
export interface KeFuConversationRespVO {
id: number // 编号
userId: number // 会话所属用户
userAvatar: string // 会话所属用户头像
userNickname: string // 会话所属用户昵称
lastMessageTime: Date // 最后聊天时间
lastMessageContent: string // 最后聊天内容
lastMessageContentType: number // 最后发送的消息类型
adminPinned: boolean // 管理端置顶
userDeleted: boolean // 用户是否可见
adminDeleted: boolean // 管理员是否可见
adminUnreadMessageCount: number // 管理员未读消息数
createTime?: string // 创建时间
}
// 客服会话 API
export const KeFuConversationApi = {
// 获得客服会话列表
getConversationList: async () => {
return await request.get({ url: '/promotion/kefu-conversation/list' })
},
// 获得客服会话
getConversation: async (id: number) => {
return await request.get({ url: `/promotion/kefu-conversation/get?id=` + id })
},
// 客服会话置顶
updateConversationPinned: async (data: any) => {
return await request.put({
url: '/promotion/kefu-conversation/update-conversation-pinned',
data
})
},
// 删除客服会话
deleteConversation: async (id: number) => {
return await request.delete({ url: `/promotion/kefu-conversation/delete?id=${id}` })
}
}

@ -0,0 +1,36 @@
import request from '@/config/axios'
export interface KeFuMessageRespVO {
id: number // 编号
conversationId: number // 会话编号
senderId: number // 发送人编号
senderAvatar: string // 发送人头像
senderType: number // 发送人类型
receiverId: number // 接收人编号
receiverType: number // 接收人类型
contentType: number // 消息类型
content: string // 消息
readStatus: boolean // 是否已读
createTime: Date // 创建时间
}
// 客服会话 API
export const KeFuMessageApi = {
// 发送客服消息
sendKeFuMessage: async (data: any) => {
return await request.post({
url: '/promotion/kefu-message/send',
data
})
},
// 更新客服消息已读状态
updateKeFuMessageReadStatus: async (conversationId: number) => {
return await request.put({
url: '/promotion/kefu-message/update-read-status?conversationId=' + conversationId
})
},
// 获得消息列表(流式加载)
getKeFuMessageList: async (params: any) => {
return await request.get({ url: '/promotion/kefu-message/list', params })
}
}

@ -0,0 +1,91 @@
import request from '@/config/axios'
import { Sku, Spu } from '@/api/mall/product/spu' // 积分商城活动 VO
// 积分商城活动 VO
export interface PointActivityVO {
id: number // 积分商城活动编号
spuId: number // 积分商城活动商品
status: number // 活动状态
stock: number // 积分商城活动库存
totalStock: number // 积分商城活动总库存
remark?: string // 备注
sort: number // 排序
createTime: string // 创建时间
products: PointProductVO[] // 积分商城商品
// ========== 商品字段 ==========
spuName: string // 商品名称
picUrl: string // 商品主图
marketPrice: number // 商品市场价,单位:分
//======================= 显示所需兑换积分最少的 sku 信息 =======================
point: number // 兑换积分
price: number // 兑换金额,单位:分
}
// 秒杀活动所需属性
export interface PointProductVO {
id?: number // 积分商城商品编号
activityId?: number // 积分商城活动 id
spuId?: number // 商品 SPU 编号
skuId: number // 商品 SKU 编号
count: number // 可兑换数量
point: number // 兑换积分
price: number // 兑换金额,单位:分
stock: number // 积分商城商品库存
activityStatus?: number // 积分商城商品状态
}
// 扩展 Sku 配置
export type SkuExtension = Sku & {
productConfig: PointProductVO
}
export interface SpuExtension extends Spu {
skus: SkuExtension[] // 重写类型
}
export interface SpuExtension0 extends Spu {
pointStock: number // 积分商城活动库存
pointTotalStock: number // 积分商城活动总库存
point: number // 兑换积分
pointPrice: number // 兑换金额,单位:分
}
// 积分商城活动 API
export const PointActivityApi = {
// 查询积分商城活动分页
getPointActivityPage: async (params: any) => {
return await request.get({ url: `/promotion/point-activity/page`, params })
},
// 查询积分商城活动详情
getPointActivity: async (id: number) => {
return await request.get({ url: `/promotion/point-activity/get?id=` + id })
},
// 查询积分商城活动列表,基于活动编号数组
getPointActivityListByIds: async (ids: number[]) => {
return request.get({ url: `/promotion/point-activity/list-by-ids?ids=${ids}` })
},
// 新增积分商城活动
createPointActivity: async (data: PointActivityVO) => {
return await request.post({ url: `/promotion/point-activity/create`, data })
},
// 修改积分商城活动
updatePointActivity: async (data: PointActivityVO) => {
return await request.put({ url: `/promotion/point-activity/update`, data })
},
// 删除积分商城活动
deletePointActivity: async (id: number) => {
return await request.delete({ url: `/promotion/point-activity/delete?id=` + id })
},
// 关闭秒杀活动
closePointActivity: async (id: number) => {
return await request.put({ url: '/promotion/point-activity/close?id=' + id })
}
}

@ -0,0 +1,58 @@
import request from '@/config/axios'
export interface RewardActivityVO {
id?: number
name?: string
startTime?: Date
endTime?: Date
startAndEndTime?: Date[] // 只前端使用
remark?: string
conditionType?: number
productScope?: number
rules: RewardRule[]
// 如下仅用于表单,不提交
productScopeValues?: number[] // 商品范围:值为品类编号列表、商品编号列表
productCategoryIds?: number[]
productSpuIds?: number[]
}
// 优惠规则
export interface RewardRule {
limit?: number
discountPrice?: number
freeDelivery?: boolean
point: number
giveCouponTemplateCounts?: {
[key: number]: number
}
}
// 新增满减送活动
export const createRewardActivity = async (data: RewardActivityVO) => {
return await request.post({ url: '/promotion/reward-activity/create', data })
}
// 更新满减送活动
export const updateRewardActivity = async (data: RewardActivityVO) => {
return await request.put({ url: '/promotion/reward-activity/update', data })
}
// 查询满减送活动列表
export const getRewardActivityPage = async (params) => {
return await request.get({ url: '/promotion/reward-activity/page', params })
}
// 查询满减送活动详情
export const getReward = async (id: number) => {
return await request.get({ url: '/promotion/reward-activity/get?id=' + id })
}
// 删除满减送活动
export const deleteRewardActivity = async (id: number) => {
return await request.delete({ url: '/promotion/reward-activity/delete?id=' + id })
}
// 关闭满减送活动
export const closeRewardActivity = async (id: number) => {
return await request.put({ url: '/promotion/reward-activity/close?id=' + id })
}

@ -0,0 +1,75 @@
import request from '@/config/axios'
import { Sku, Spu } from '@/api/mall/product/spu'
export interface SeckillActivityVO {
id?: number
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?: SeckillProductVO[]
}
// 秒杀活动所需属性
export interface SeckillProductVO {
skuId: number
spuId: number
seckillPrice: number
stock: number
}
// 扩展 Sku 配置
export type SkuExtension = Sku & {
productConfig: SeckillProductVO
}
export interface SpuExtension extends Spu {
skus: SkuExtension[] // 重写类型
}
// 查询秒杀活动列表
export const getSeckillActivityPage = async (params) => {
return await request.get({ url: '/promotion/seckill-activity/page', params })
}
// 查询秒杀活动列表,基于活动编号数组
export const getSeckillActivityListByIds = (ids: number[]) => {
return request.get({ url: `/promotion/seckill-activity/list-by-ids?ids=${ids}` })
}
// 查询秒杀活动详情
export const getSeckillActivity = async (id: number) => {
return await request.get({ url: '/promotion/seckill-activity/get?id=' + id })
}
// 新增秒杀活动
export const createSeckillActivity = async (data: SeckillActivityVO) => {
return await request.post({ url: '/promotion/seckill-activity/create', data })
}
// 修改秒杀活动
export const updateSeckillActivity = async (data: SeckillActivityVO) => {
return await request.put({ url: '/promotion/seckill-activity/update', data })
}
// 关闭秒杀活动
export const closeSeckillActivity = async (id: number) => {
return await request.put({ url: '/promotion/seckill-activity/close?id=' + id })
}
// 删除秒杀活动
export const deleteSeckillActivity = async (id: number) => {
return await request.delete({ url: '/promotion/seckill-activity/delete?id=' + id })
}

@ -0,0 +1,53 @@
import request from '@/config/axios'
// 秒杀时段 VO
export interface SeckillConfigVO {
id: number // 编号
name: string // 秒杀时段名称
startTime: string // 开始时间点
endTime: string // 结束时间点
sliderPicUrls: string[] // 秒杀轮播图
status: number // 活动状态
}
// 秒杀时段 API
export const SeckillConfigApi = {
// 查询秒杀时段分页
getSeckillConfigPage: async (params: any) => {
return await request.get({ url: `/promotion/seckill-config/page`, params })
},
// 查询秒杀时段列表
getSimpleSeckillConfigList: async () => {
return await request.get({ url: `/promotion/seckill-config/list` })
},
// 查询秒杀时段详情
getSeckillConfig: async (id: number) => {
return await request.get({ url: `/promotion/seckill-config/get?id=` + id })
},
// 新增秒杀时段
createSeckillConfig: async (data: SeckillConfigVO) => {
return await request.post({ url: `/promotion/seckill-config/create`, data })
},
// 修改秒杀时段
updateSeckillConfig: async (data: SeckillConfigVO) => {
return await request.put({ url: `/promotion/seckill-config/update`, data })
},
// 删除秒杀时段
deleteSeckillConfig: async (id: number) => {
return await request.delete({ url: `/promotion/seckill-config/delete?id=` + id })
},
// 修改时段配置状态
updateSeckillConfigStatus: async (id: number, status: number) => {
const data = {
id,
status
}
return request.put({ url: '/promotion/seckill-config/update-status', data: data })
}
}

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

@ -0,0 +1,123 @@
import request from '@/config/axios'
import dayjs from 'dayjs'
import { DataComparisonRespVO } from '@/api/mall/statistics/common'
import { formatDate } from '@/utils/formatTime'
/** 会员分析 Request VO */
export interface MemberAnalyseReqVO {
times: dayjs.ConfigType[]
}
/** 会员分析 Response VO */
export interface MemberAnalyseRespVO {
visitUserCount: number
orderUserCount: number
payUserCount: number
atv: number
comparison: DataComparisonRespVO<MemberAnalyseComparisonRespVO>
}
/** 会员分析对照数据 Response VO */
export interface MemberAnalyseComparisonRespVO {
registerUserCount: number
visitUserCount: number
rechargeUserCount: number
}
/** 会员地区统计 Response VO */
export interface MemberAreaStatisticsRespVO {
areaId: number
areaName: string
userCount: number
orderCreateUserCount: number
orderPayUserCount: number
orderPayPrice: number
}
/** 会员性别统计 Response VO */
export interface MemberSexStatisticsRespVO {
sex: number
userCount: number
}
/** 会员统计 Response VO */
export interface MemberSummaryRespVO {
userCount: number
rechargeUserCount: number
rechargePrice: number
expensePrice: number
}
/** 会员终端统计 Response VO */
export interface MemberTerminalStatisticsRespVO {
terminal: number
userCount: number
}
/** 会员数量统计 Response VO */
export interface MemberCountRespVO {
/** 用户访问量 */
visitUserCount: string
/** 注册用户数量 */
registerUserCount: number
}
/** 会员注册数量 Response VO */
export interface MemberRegisterCountRespVO {
date: string
count: number
}
// 查询会员统计
export const getMemberSummary = () => {
return request.get<MemberSummaryRespVO>({
url: '/statistics/member/summary'
})
}
// 查询会员分析数据
export const getMemberAnalyse = (params: MemberAnalyseReqVO) => {
return request.get<MemberAnalyseRespVO>({
url: '/statistics/member/analyse',
params: { times: [formatDate(params.times[0]), formatDate(params.times[1])] }
})
}
// 按照省份,查询会员统计列表
export const getMemberAreaStatisticsList = () => {
return request.get<MemberAreaStatisticsRespVO[]>({
url: '/statistics/member/area-statistics-list'
})
}
// 按照性别,查询会员统计列表
export const getMemberSexStatisticsList = () => {
return request.get<MemberSexStatisticsRespVO[]>({
url: '/statistics/member/sex-statistics-list'
})
}
// 按照终端,查询会员统计列表
export const getMemberTerminalStatisticsList = () => {
return request.get<MemberTerminalStatisticsRespVO[]>({
url: '/statistics/member/terminal-statistics-list'
})
}
// 获得用户数量量对照
export const getUserCountComparison = () => {
return request.get<DataComparisonRespVO<MemberCountRespVO>>({
url: '/statistics/member/user-count-comparison'
})
}
// 获得会员注册数量列表
export const getMemberRegisterCountList = (
beginTime: dayjs.ConfigType,
endTime: dayjs.ConfigType
) => {
return request.get<MemberRegisterCountRespVO[]>({
url: '/statistics/member/register-count-list',
params: { times: [formatDate(beginTime), formatDate(endTime)] }
})
}

@ -0,0 +1,12 @@
import request from '@/config/axios'
/** 支付统计 */
export interface PaySummaryRespVO {
/** 充值金额,单位分 */
rechargePrice: number
}
/** 获取钱包充值金额 */
export const getWalletRechargePrice = async () => {
return await request.get<PaySummaryRespVO>({ url: `/statistics/pay/summary` })
}

@ -0,0 +1,52 @@
import request from '@/config/axios'
import { DataComparisonRespVO } from '@/api/mall/statistics/common'
export interface ProductStatisticsVO {
id: number
day: string
spuId: number
spuName: string
spuPicUrl: string
browseCount: number
browseUserCount: number
favoriteCount: number
cartCount: number
orderCount: number
orderPayCount: number
orderPayPrice: number
afterSaleCount: number
afterSaleRefundPrice: number
browseConvertPercent: number
}
// 商品统计 API
export const ProductStatisticsApi = {
// 获得商品统计分析
getProductStatisticsAnalyse: (params: any) => {
return request.get<DataComparisonRespVO<ProductStatisticsVO>>({
url: '/statistics/product/analyse',
params
})
},
// 获得商品状况明细
getProductStatisticsList: (params: any) => {
return request.get<ProductStatisticsVO[]>({
url: '/statistics/product/list',
params
})
},
// 导出获得商品状况明细 Excel
exportProductStatisticsExcel: (params: any) => {
return request.download({
url: '/statistics/product/export-excel',
params
})
},
// 获得商品排行榜分页
getProductStatisticsRankPage: async (params: any) => {
return await request.get({
url: `/statistics/product/rank-page`,
params
})
}
}

@ -0,0 +1,119 @@
import request from '@/config/axios'
import dayjs from 'dayjs'
import { formatDate } from '@/utils/formatTime'
import { DataComparisonRespVO } from '@/api/mall/statistics/common'
/** 交易统计 Response VO */
export interface TradeSummaryRespVO {
yesterdayOrderCount: number
monthOrderCount: number
yesterdayPayPrice: number
monthPayPrice: number
}
/** 交易状况 Request VO */
export interface TradeTrendReqVO {
times: [dayjs.ConfigType, dayjs.ConfigType]
}
/** 交易状况统计 Response VO */
export interface TradeTrendSummaryRespVO {
time: string
turnoverPrice: number
orderPayPrice: number
rechargePrice: number
expensePrice: number
walletPayPrice: number
brokerageSettlementPrice: number
afterSaleRefundPrice: number
}
/** 交易订单数量 Response VO */
export interface TradeOrderCountRespVO {
/** 待发货 */
undelivered?: number
/** 待核销 */
pickUp?: number
/** 退款中 */
afterSaleApply?: number
/** 提现待审核 */
auditingWithdraw?: number
}
/** 交易订单统计 Response VO */
export interface TradeOrderSummaryRespVO {
/** 支付订单商品数 */
orderPayCount?: number
/** 总支付金额,单位:分 */
orderPayPrice?: number
}
/** 订单量趋势统计 Response VO */
export interface TradeOrderTrendRespVO {
/** 日期 */
date: string
/** 订单数量 */
orderPayCount: number
/** 订单支付金额 */
orderPayPrice: number
}
// 查询交易统计
export const getTradeStatisticsSummary = () => {
return request.get<DataComparisonRespVO<TradeSummaryRespVO>>({
url: '/statistics/trade/summary'
})
}
// 获得交易状况统计
export const getTradeStatisticsAnalyse = (params: TradeTrendReqVO) => {
return request.get<DataComparisonRespVO<TradeTrendSummaryRespVO>>({
url: '/statistics/trade/analyse',
params: formatDateParam(params)
})
}
// 获得交易状况明细
export const getTradeStatisticsList = (params: TradeTrendReqVO) => {
return request.get<TradeTrendSummaryRespVO[]>({
url: '/statistics/trade/list',
params: formatDateParam(params)
})
}
// 导出交易状况明细
export const exportTradeStatisticsExcel = (params: TradeTrendReqVO) => {
return request.download({
url: '/statistics/trade/export-excel',
params: formatDateParam(params)
})
}
// 获得交易订单数量
export const getOrderCount = async () => {
return await request.get<TradeOrderCountRespVO>({ url: `/statistics/trade/order-count` })
}
// 获得交易订单数量对照
export const getOrderComparison = async () => {
return await request.get<DataComparisonRespVO<TradeOrderSummaryRespVO>>({
url: `/statistics/trade/order-comparison`
})
}
// 获得订单量趋势统计
export const getOrderCountTrendComparison = (
type: number,
beginTime: dayjs.ConfigType,
endTime: dayjs.ConfigType
) => {
return request.get<DataComparisonRespVO<TradeOrderTrendRespVO>[]>({
url: '/statistics/trade/order-count-trend',
params: { type, beginTime: formatDate(beginTime), endTime: formatDate(endTime) }
})
}
/** 时间参数需要格式化, 确保接口能识别 */
const formatDateParam = (params: TradeTrendReqVO) => {
return { times: [formatDate(params.times[0]), formatDate(params.times[1])] } as TradeTrendReqVO
}

@ -0,0 +1,75 @@
import request from '@/config/axios'
export interface TradeAfterSaleVO {
id?: number | null // 售后编号,主键自增
no?: string // 售后单号
status?: number | null // 退款状态
way?: number | null // 售后方式
type?: number | null // 售后类型
userId?: number | null // 用户编号
applyReason?: string // 申请原因
applyDescription?: string // 补充描述
applyPicUrls?: string[] // 补充凭证图片
orderId?: number | null // 交易订单编号
orderNo?: string // 订单流水号
orderItemId?: number | null // 交易订单项编号
spuId?: number | null // 商品 SPU 编号
spuName?: string // 商品 SPU 名称
skuId?: number | null // 商品 SKU 编号
properties?: ProductPropertiesVO[] // 属性数组
picUrl?: string // 商品图片
count?: number | null // 退货商品数量
auditTime?: Date // 审批时间
auditUserId?: number | null // 审批人
auditReason?: string // 审批备注
refundPrice?: number | null // 退款金额,单位:分。
payRefundId?: number | null // 支付退款编号
refundTime?: Date // 退款时间
logisticsId?: number | null // 退货物流公司编号
logisticsNo?: string // 退货物流单号
deliveryTime?: Date // 退货时间
receiveTime?: Date // 收货时间
receiveReason?: string // 收货备注
}
export interface ProductPropertiesVO {
propertyId?: number | null // 属性的编号
propertyName?: string // 属性的名称
valueId?: number | null //属性值的编号
valueName?: string // 属性值的名称
}
// 获得交易售后分页
export const getAfterSalePage = async (params) => {
return await request.get({ url: `/trade/after-sale/page`, params })
}
// 获得交易售后详情
export const getAfterSale = async (id: any) => {
return await request.get({ url: `/trade/after-sale/get-detail?id=${id}` })
}
// 同意售后
export const agree = async (id: any) => {
return await request.put({ url: `/trade/after-sale/agree?id=${id}` })
}
// 拒绝售后
export const disagree = async (data: any) => {
return await request.put({ url: `/trade/after-sale/disagree`, data })
}
// 确认收货
export const receive = async (id: any) => {
return await request.put({ url: `/trade/after-sale/receive?id=${id}` })
}
// 拒绝收货
export const refuse = async (id: any) => {
return await request.put({ url: `/trade/after-sale/refuse?id=${id}` })
}
// 确认退款
export const refund = async (id: any) => {
return await request.put({ url: `/trade/after-sale/refund?id=${id}` })
}

@ -0,0 +1,11 @@
import request from '@/config/axios'
// 查询佣金记录列表
export const getBrokerageRecordPage = async (params: any) => {
return await request.get({ url: `/trade/brokerage-record/page`, params })
}
// 查询佣金记录详情
export const getBrokerageRecord = async (id: number) => {
return await request.get({ url: `/trade/brokerage-record/get?id=` + id })
}

@ -0,0 +1,39 @@
import request from '@/config/axios'
export interface BrokerageUserVO {
id: number
bindUserId: number
bindUserTime: Date
brokerageEnabled: boolean
brokerageTime: Date
price: number
frozenPrice: number
nickname: string
avatar: string
}
// 查询分销用户列表
export const getBrokerageUserPage = async (params: any) => {
return await request.get({ url: `/trade/brokerage-user/page`, params })
}
// 查询分销用户详情
export const getBrokerageUser = async (id: number) => {
return await request.get({ url: `/trade/brokerage-user/get?id=` + id })
}
// 修改推广员
export const updateBindUser = async (data: any) => {
return await request.put({ url: `/trade/brokerage-user/update-bind-user`, data })
}
// 清除推广员
export const clearBindUser = async (data: any) => {
return await request.put({ url: `/trade/brokerage-user/clear-bind-user`, data })
}
// 修改推广资格
export const updateBrokerageEnabled = async (data: any) => {
return await request.put({ url: `/trade/brokerage-user/update-brokerage-enable`, data })
}

@ -0,0 +1,39 @@
import request from '@/config/axios'
export interface BrokerageWithdrawVO {
id: number
userId: number
price: number
feePrice: number
totalPrice: number
type: number
name: string
accountNo: string
bankName: string
bankAddress: string
accountQrCodeUrl: string
status: number
auditReason: string
auditTime: Date
remark: string
}
// 查询佣金提现列表
export const getBrokerageWithdrawPage = async (params: any) => {
return await request.get({ url: `/trade/brokerage-withdraw/page`, params })
}
// 查询佣金提现详情
export const getBrokerageWithdraw = async (id: number) => {
return await request.get({ url: `/trade/brokerage-withdraw/get?id=` + id })
}
// 佣金提现 - 通过申请
export const approveBrokerageWithdraw = async (id: number) => {
return await request.put({ url: `/trade/brokerage-withdraw/approve?id=` + id })
}
// 审核佣金提现 - 驳回申请
export const rejectBrokerageWithdraw = async (data: BrokerageWithdrawVO) => {
return await request.put({ url: `/trade/brokerage-withdraw/reject`, data })
}

@ -0,0 +1,23 @@
import request from '@/config/axios'
export interface ConfigVO {
brokerageEnabled: boolean
brokerageEnabledCondition: number
brokerageBindMode: number
brokeragePosterUrls: string
brokerageFirstPercent: number
brokerageSecondPercent: number
brokerageWithdrawMinPrice: number
brokerageFrozenDays: number
brokerageWithdrawTypes: string
}
// 查询交易中心配置详情
export const getTradeConfig = async () => {
return await request.get({ url: `/trade/config/get` })
}
// 保存交易中心配置
export const saveTradeConfig = async (data: ConfigVO) => {
return await request.put({ url: `/trade/config/save`, data })
}

@ -0,0 +1,45 @@
import request from '@/config/axios'
export interface DeliveryExpressVO {
id: number
code: string
name: string
logo: string
sort: number
status: number
}
// 查询快递公司列表
export const getDeliveryExpressPage = async (params: PageParam) => {
return await request.get({ url: '/trade/delivery/express/page', params })
}
// 查询快递公司详情
export const getDeliveryExpress = async (id: number) => {
return await request.get({ url: '/trade/delivery/express/get?id=' + id })
}
// 获得快递公司精简信息列表
export const getSimpleDeliveryExpressList = () => {
return request.get({ url: '/trade/delivery/express/list-all-simple' })
}
// 新增快递公司
export const createDeliveryExpress = async (data: DeliveryExpressVO) => {
return await request.post({ url: '/trade/delivery/express/create', data })
}
// 修改快递公司
export const updateDeliveryExpress = async (data: DeliveryExpressVO) => {
return await request.put({ url: '/trade/delivery/express/update', data })
}
// 删除快递公司
export const deleteDeliveryExpress = async (id: number) => {
return await request.delete({ url: '/trade/delivery/express/delete?id=' + id })
}
// 导出快递公司 Excel
export const exportDeliveryExpressApi = async (params) => {
return await request.download({ url: '/trade/delivery/express/export-excel', params })
}

@ -0,0 +1,54 @@
import request from '@/config/axios'
export interface DeliveryExpressTemplateVO {
id: number
name: string
chargeMode: number
sort: number
templateCharge: ExpressTemplateChargeVO[]
templateFree: ExpressTemplateFreeVO[]
}
export declare type ExpressTemplateChargeVO = {
areaIds: number[]
startCount: number
startPrice: number
extraCount: number
extraPrice: number
}
export declare type ExpressTemplateFreeVO = {
areaIds: number[]
freeCount: number
freePrice: number
}
// 查询快递运费模板列表
export const getDeliveryExpressTemplatePage = async (params: PageParam) => {
return await request.get({ url: '/trade/delivery/express-template/page', params })
}
// 查询快递运费模板详情
export const getDeliveryExpressTemplate = async (id: number) => {
return await request.get({ url: '/trade/delivery/express-template/get?id=' + id })
}
// 查询快递运费模板详情
export const getSimpleTemplateList = async () => {
return await request.get({ url: '/trade/delivery/express-template/list-all-simple' })
}
// 新增快递运费模板
export const createDeliveryExpressTemplate = async (data: DeliveryExpressTemplateVO) => {
return await request.post({ url: '/trade/delivery/express-template/create', data })
}
// 修改快递运费模板
export const updateDeliveryExpressTemplate = async (data: DeliveryExpressTemplateVO) => {
return await request.put({ url: '/trade/delivery/express-template/update', data })
}
// 删除快递运费模板
export const deleteDeliveryExpressTemplate = async (id: number) => {
return await request.delete({ url: '/trade/delivery/express-template/delete?id=' + id })
}

@ -0,0 +1,52 @@
import request from '@/config/axios'
export interface DeliveryPickUpStoreVO {
id: number
name: string
introduction: string
phone: string
areaId: number
detailAddress: string
logo: string
openingTime: string
closingTime: string
latitude: number
longitude: number
status: number
verifyUserIds: number[] // 绑定用户编号组数
}
// 查询自提门店列表
export const getDeliveryPickUpStorePage = async (params: any) => {
return await request.get({ url: '/trade/delivery/pick-up-store/page', params })
}
// 查询自提门店详情
export const getDeliveryPickUpStore = async (id: number) => {
return await request.get({ url: '/trade/delivery/pick-up-store/get?id=' + id })
}
// 查询自提门店精简列表
export const getSimpleDeliveryPickUpStoreList = async (): Promise<DeliveryPickUpStoreVO[]> => {
return await request.get({ url: '/trade/delivery/pick-up-store/simple-list' })
}
// 新增自提门店
export const createDeliveryPickUpStore = async (data: DeliveryPickUpStoreVO) => {
return await request.post({ url: '/trade/delivery/pick-up-store/create', data })
}
// 修改自提门店
export const updateDeliveryPickUpStore = async (data: DeliveryPickUpStoreVO) => {
return await request.put({ url: '/trade/delivery/pick-up-store/update', data })
}
// 删除自提门店
export const deleteDeliveryPickUpStore = async (id: number) => {
return await request.delete({ url: '/trade/delivery/pick-up-store/delete?id=' + id })
}
// 绑定自提店员
export const bindStoreStaffId = async (data: any) => {
return await request.post({ url: '/trade/delivery/pick-up-store/bind', data })
}

@ -0,0 +1,188 @@
import request from '@/config/axios'
export interface OrderVO {
// ========== 订单基本信息 ==========
id?: number | null // 订单编号
no?: string // 订单流水号
createTime?: Date | null // 下单时间
type?: number | null // 订单类型
terminal?: number | null // 订单来源
userId?: number | null // 用户编号
userIp?: string // 用户 IP
userRemark?: string // 用户备注
status?: number | null // 订单状态
productCount?: number | null // 购买的商品数量
finishTime?: Date | null // 订单完成时间
cancelTime?: Date | null // 订单取消时间
cancelType?: number | null // 取消类型
remark?: string // 商家备注
// ========== 价格 + 支付基本信息 ==========
payOrderId?: number | null // 支付订单编号
payStatus?: boolean // 是否已支付
payTime?: Date | null // 付款时间
payChannelCode?: string // 支付渠道
totalPrice?: number | null // 商品原价(总)
discountPrice?: number | null // 订单优惠(总)
deliveryPrice?: number | null // 运费金额
adjustPrice?: number | null // 订单调价(总)
payPrice?: number | null // 应付金额(总)
// ========== 收件 + 物流基本信息 ==========
deliveryType?: number | null // 发货方式
pickUpStoreId?: number // 自提门店编号
pickUpVerifyCode?: string // 自提核销码
deliveryTemplateId?: number | null // 配送模板编号
logisticsId?: number | null // 发货物流公司编号
logisticsNo?: string // 发货物流单号
deliveryTime?: Date | null // 发货时间
receiveTime?: Date | null // 收货时间
receiverName?: string // 收件人名称
receiverMobile?: string // 收件人手机
receiverPostCode?: number | null // 收件人邮编
receiverAreaId?: number | null // 收件人地区编号
receiverAreaName?: string //收件人地区名字
receiverDetailAddress?: string // 收件人详细地址
// ========== 售后基本信息 ==========
afterSaleStatus?: number | null // 售后状态
refundPrice?: number | null // 退款金额
// ========== 营销基本信息 ==========
couponId?: number | null // 优惠劵编号
couponPrice?: number | null // 优惠劵减免金额
pointPrice?: number | null // 积分抵扣的金额
vipPrice?: number | null // VIP 减免金额
items?: OrderItemRespVO[] // 订单项列表
// 下单用户信息
user?: {
id?: number | null
nickname?: string
avatar?: string
}
// 推广用户信息
brokerageUser?: {
id?: number | null
nickname?: string
avatar?: string
}
// 订单操作日志
logs?: OrderLogRespVO[]
}
export interface OrderLogRespVO {
content?: string
createTime?: Date
userType?: number
}
export interface OrderItemRespVO {
// ========== 订单项基本信息 ==========
id?: number | null // 编号
userId?: number | null // 用户编号
orderId?: number | null // 订单编号
// ========== 商品基本信息 ==========
spuId?: number | null // 商品 SPU 编号
spuName?: string //商品 SPU 名称
skuId?: number | null // 商品 SKU 编号
picUrl?: string //商品图片
count?: number | null //购买数量
// ========== 价格 + 支付基本信息 ==========
originalPrice?: number | null //商品原价(总)
originalUnitPrice?: number | null //商品原价(单)
discountPrice?: number | null //商品优惠(总)
payPrice?: number | null //商品实付金额(总)
orderPartPrice?: number | null //子订单分摊金额(总)
orderDividePrice?: number | null //分摊后子订单实付金额(总)
// ========== 营销基本信息 ==========
// TODO 芋艿:在捉摸一下
// ========== 售后基本信息 ==========
afterSaleStatus?: number | null // 售后状态
properties?: ProductPropertiesVO[] //属性数组
}
export interface ProductPropertiesVO {
propertyId?: number | null // 属性的编号
propertyName?: string // 属性的名称
valueId?: number | null //属性值的编号
valueName?: string // 属性值的名称
}
/** 交易订单统计 */
export interface TradeOrderSummaryRespVO {
/** 订单数量 */
orderCount?: number
/** 订单金额 */
orderPayPrice?: string
/** 退款单数 */
afterSaleCount?: number
/** 退款金额 */
afterSalePrice?: string
}
// 查询交易订单列表
export const getOrderPage = async (params: any) => {
return await request.get({ url: `/trade/order/page`, params })
}
// 查询交易订单统计
export const getOrderSummary = async (params: any) => {
return await request.get<TradeOrderSummaryRespVO>({ url: `/trade/order/summary`, params })
}
// 查询交易订单详情
export const getOrder = async (id: number | null) => {
return await request.get({ url: `/trade/order/get-detail?id=` + id })
}
// 查询交易订单物流详情
export const getExpressTrackList = async (id: number | null) => {
return await request.get({ url: `/trade/order/get-express-track-list?id=` + id })
}
export interface DeliveryVO {
id?: number // 订单编号
logisticsId: number | null // 物流公司编号
logisticsNo: string // 物流编号
}
// 订单发货
export const deliveryOrder = async (data: DeliveryVO) => {
return await request.put({ url: `/trade/order/delivery`, data })
}
// 订单备注
export const updateOrderRemark = async (data: any) => {
return await request.put({ url: `/trade/order/update-remark`, data })
}
// 订单调价
export const updateOrderPrice = async (data: any) => {
return await request.put({ url: `/trade/order/update-price`, data })
}
// 修改订单地址
export const updateOrderAddress = async (data: any) => {
return await request.put({ url: `/trade/order/update-address`, data })
}
// 订单核销
export const pickUpOrder = async (id: number) => {
return await request.put({ url: `/trade/order/pick-up-by-id?id=${id}` })
}
// 订单核销
export const pickUpOrderByVerifyCode = async (pickUpVerifyCode: string) => {
return await request.put({
url: `/trade/order/pick-up-by-verify-code`,
params: { pickUpVerifyCode }
})
}
// 查询核销码对应的订单
export const getOrderByPickUpVerifyCode = async (pickUpVerifyCode: string) => {
return await request.get<OrderVO>({
url: `/trade/order/get-by-pick-up-verify-code`,
params: { pickUpVerifyCode }
})
}

@ -0,0 +1,15 @@
import request from '@/config/axios'
export interface AddressVO {
id: number
name: string
mobile: string
areaId: number
detailAddress: string
defaultStatus: boolean
}
// 查询用户收件地址列表
export const getAddressList = async (params) => {
return await request.get({ url: `/member/address/list`, params })
}

@ -0,0 +1,19 @@
import request from '@/config/axios'
export interface ConfigVO {
id: number
pointTradeDeductEnable: number
pointTradeDeductUnitPrice: number
pointTradeDeductMaxPrice: number
pointTradeGivePoint: number
}
// 查询积分设置详情
export const getConfig = async () => {
return await request.get({ url: `/member/config/get` })
}
// 新增修改积分设置
export const saveConfig = async (data: ConfigVO) => {
return await request.put({ url: `/member/config/save`, data })
}

@ -0,0 +1,22 @@
import request from '@/config/axios'
export interface ExperienceRecordVO {
id: number
userId: number
bizId: string
bizType: number
title: string
description: string
experience: number
totalExperience: number
}
// 查询会员经验记录列表
export const getExperienceRecordPage = async (params) => {
return await request.get({ url: `/member/experience-record/page`, params })
}
// 查询会员经验记录详情
export const getExperienceRecord = async (id: number) => {
return await request.get({ url: `/member/experience-record/get?id=` + id })
}

@ -0,0 +1,38 @@
import request from '@/config/axios'
export interface GroupVO {
id: number
name: string
remark: string
status: number
}
// 查询用户分组列表
export const getGroupPage = async (params: any) => {
return await request.get({ url: `/member/group/page`, params })
}
// 查询用户分组详情
export const getGroup = async (id: number) => {
return await request.get({ url: `/member/group/get?id=` + id })
}
// 新增用户分组
export const createGroup = async (data: GroupVO) => {
return await request.post({ url: `/member/group/create`, data })
}
// 查询用户分组 - 精简信息列表
export const getSimpleGroupList = async () => {
return await request.get({ url: `/member/group/list-all-simple` })
}
// 修改用户分组
export const updateGroup = async (data: GroupVO) => {
return await request.put({ url: `/member/group/update`, data })
}
// 删除用户分组
export const deleteGroup = async (id: number) => {
return await request.delete({ url: `/member/group/delete?id=` + id })
}

@ -0,0 +1,42 @@
import request from '@/config/axios'
export interface LevelVO {
id: number
name: string
experience: number
value: number
discountPercent: number
icon: string
bgUrl: string
status: number
}
// 查询会员等级列表
export const getLevelList = async (params) => {
return await request.get({ url: `/member/level/list`, params })
}
// 查询会员等级详情
export const getLevel = async (id: number) => {
return await request.get({ url: `/member/level/get?id=` + id })
}
// 查询会员等级 - 精简信息列表
export const getSimpleLevelList = async () => {
return await request.get({ url: `/member/level/list-all-simple` })
}
// 新增会员等级
export const createLevel = async (data: LevelVO) => {
return await request.post({ url: `/member/level/create`, data })
}
// 修改会员等级
export const updateLevel = async (data: LevelVO) => {
return await request.put({ url: `/member/level/update`, data })
}
// 删除会员等级
export const deleteLevel = async (id: number) => {
return await request.delete({ url: `/member/level/delete?id=` + id })
}

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

Loading…
Cancel
Save