= ({ id }) => {
+ const [data, setData] = useState(null);
+ const [loading, setLoading] = useState(true);
+ const [error, setError] = useState(null);
+
+ useEffect(() => {
+ const fetchData = async () => {
+ try {
+ const response = await axios.get(`/api/tools/logistics/detail/${id}`);
+ if (response.data && response.data.length > 0) {
+ setData(response.data[0]);
+ } else {
+ setError('No data found');
+ }
+ } catch (err) {
+ setError('Error fetching data');
+ } finally {
+ setLoading(false);
+ }
+ };
+
+ fetchData();
+ }, [id]);
+
+ if (loading) {
+ return (
+
+
+ );
+ }
+
+ if (error) {
+ return = {};
+const detailsCache: Record = {};
+
+// 缓存过期时间（毫秒）
+const CACHE_EXPIRY = 5 * 60 * 1000; // 5分钟
+
+const statusColorMapping: { [key: string]: string } = {
+ '已退回': 'red',
+ '退回中': 'orange',
+ '已拒收': 'volcano',
+ '已签收': 'green',
+ '派送中': 'blue',
+ '已发出': 'geekblue',
+ '已揽收': 'cyan',
+ '处理中': 'grey',
+ '待发货': 'magenta'
+};
+
+// 生成缓存键
+const getCacheKey = (recordId: string, productId: string) => `${recordId}_${productId}`;
+
+const LogisticsStatus: React.FC = React.memo(({ recordId, productId }) => {
+ const [logisticsStatus, setLogisticsStatus] = useState(null);
+ const [logisticsDetails, setLogisticsDetails] = useState(null);
+ const [loading, setLoading] = useState(true);
+ const [detailsLoading, setDetailsLoading] = useState(false);
+ const [logisticsNumber, setLogisticsNumber] = useState(null);
+
+ // 使用 ref 来跟踪当前组件是否已挂载，避免在组件卸载后设置状态
+ const isMountedRef = useRef(true);
+
+ // 使用 ref 来存储当前进行中的请求，用于取消
+ const currentRequestRef = useRef(null);
+
+ // 检查缓存是否有效
+ const isCacheValid = (timestamp: number) => {
+ return Date.now() - timestamp < CACHE_EXPIRY;
+ };
+
+ useEffect(() => {
+ isMountedRef.current = true;
+ const cacheKey = getCacheKey(recordId, productId);
+ const cachedStatus = statusCache[cacheKey];
+
+ // 如果缓存存在且未过期，使用缓存
+ if (cachedStatus && isCacheValid(cachedStatus.timestamp)) {
+ if (isMountedRef.current) {
+ setLogisticsStatus(cachedStatus.status);
+ setLoading(false);
+ }
+ return;
+ }
+
+ const fetchLogisticsStatus = async () => {
+ if (!isMountedRef.current) return;
+
+ setLoading(true);
+
+ // 取消之前的请求
+ if (currentRequestRef.current) {
+ currentRequestRef.current.abort();
+ }
+
+ // 创建新的 AbortController
+ const abortController = new AbortController();
+ currentRequestRef.current = abortController;
+
+ try {
+ const response = await fetch(`/api/logistics/status?recordId=${recordId}&productId=${productId}`, {
+ signal: abortController.signal
+ });
+
+ if (!response.ok) {
+ console.error('获取物流状态失败:', `HTTP ${response.status}`);
+ if (isMountedRef.current) {
+ setLogisticsStatus(null);
+ }
+ return;
+ }
+
+ const responseData = await response.json();
+ const status = responseData.data.物流状态;
+
+ // 更新缓存
+ statusCache[cacheKey] = {
+ status,
+ timestamp: Date.now()
+ };
+
+ if (isMountedRef.current) {
+ setLogisticsStatus(status);
+ }
+ } catch (error: any) {
+ // 忽略取消的请求错误
+ if (error.name !== 'AbortError') {
+ console.error('获取物流状态失败:', error);
+ if (isMountedRef.current) {
+ setLogisticsStatus(null);
+ }
+ }
+ } finally {
+ if (isMountedRef.current) {
+ setLoading(false);
+ }
+ currentRequestRef.current = null;
+ }
+ };
+
+ fetchLogisticsStatus();
+
+ // 当依赖项变化时，重置物流详情和物流单号
+ if (isMountedRef.current) {
+ setLogisticsDetails(null);
+ setLogisticsNumber(null);
+ }
+
+ // 清理函数
+ return () => {
+ if (currentRequestRef.current) {
+ currentRequestRef.current.abort();
+ currentRequestRef.current = null;
+ }
+ };
+ }, [recordId, productId]);
+
+ // 组件卸载时的清理
+ useEffect(() => {
+ return () => {
+ isMountedRef.current = false;
+ if (currentRequestRef.current) {
+ currentRequestRef.current.abort();
+ }
+ };
+ }, []);
+
+ // 使用debounce防止频繁请求，并添加请求取消机制
+ const fetchLogisticsDetails = useCallback(
+ debounce(async () => {
+ if (!isMountedRef.current) return;
+
+ const cacheKey = getCacheKey(recordId, productId);
+ const cachedDetails = detailsCache[cacheKey];
+
+ // 如果缓存存在且未过期，使用缓存
+ if (cachedDetails && isCacheValid(cachedDetails.timestamp)) {
+ if (isMountedRef.current) {
+ setLogisticsDetails(cachedDetails.details);
+ setLogisticsNumber(cachedDetails.number);
+ }
+ return;
+ }
+
+ if (isMountedRef.current) {
+ setDetailsLoading(true);
+ }
+
+ try {
+ const response = await fetch(`/api/logistics/details?recordId=${recordId}&productId=${productId}`);
+
+ if (!response.ok) {
+ console.error('获取物流详情失败:', `HTTP ${response.status}`);
+ if (isMountedRef.current) {
+ setLogisticsDetails('暂无物流详情');
+ setLogisticsNumber('');
+ }
+ return;
+ }
+
+ const responseData = await response.json();
+ const details = responseData[0]?.物流详情 || '暂无物流详情';
+ const number = responseData[0]?.物流单号 || '';
+
+ // 更新缓存
+ detailsCache[cacheKey] = {
+ details,
+ number,
+ timestamp: Date.now()
+ };
+
+ if (isMountedRef.current) {
+ setLogisticsDetails(details);
+ setLogisticsNumber(number);
+ }
+ } catch (error) {
+ console.error('获取物流详情失败:', error);
+ if (isMountedRef.current) {
+ setLogisticsDetails('暂无物流详情');
+ setLogisticsNumber('');
+ }
+ } finally {
+ if (isMountedRef.current) {
+ setDetailsLoading(false);
+ }
+ }
+ }, 300), // 300ms的防抖时间
+ [recordId, productId]
+ );
+
+ if (loading) {
+ return
+ {logisticsStatus}
+
+
+ );
+});
+
+// 设置组件显示名称，便于调试
+LogisticsStatus.displayName = 'LogisticsStatus';
+
+// 使用React.memo避免不必要的重新渲染
+export default LogisticsStatus;
diff --git a/src/components/product/ProductCardList.tsx b/src/components/product/ProductCardList.tsx
new file mode 100644
index 0000000..a586089
--- /dev/null
+++ b/src/components/product/ProductCardList.tsx
@@ -0,0 +1,299 @@
+//src\pages\team\SaleRecord\ProductCardList.tsx
+//import React from 'react';
+import React, { useState, useMemo, useCallback } from 'react';
+import { message, Tag } from 'antd';
+import ProductImage from '@/components/product/ProductImage';
+import { IconButton, Iconify } from '@/components/icon';
+import MyTooltip from '@/components/tooltip/MyTooltip';
+import LogisticsStatus from '@/components/logistics/status';
+import { IAfterSalesRecord, IProduct, ISalesRecord } from '@/models/types';
+import { useUserInfo } from '@/store/userStore'; // 使用 Zustand 获取用户信息
+//src\pages\management\product\product-modal.tsx
+//src\pages\backstage\product\product-modal.tsx
+import ProductModal from '@/pages/backstage/product/product-modal';
+
+interface ProductCardListProps {
+ products: IProduct[];
+ //record: ISalesRecord;
+ //record可以是ISalesRecord类型，也可以是IAfterSalesRecord
+ record: ISalesRecord | IAfterSalesRecord;
+ //record: any;
+}
+
+// 将布局封装为可复用的组件
+const ProductCardList: React.FC = ({ products, record }) => {
+ // 新增状态管理
+ const [productModalVisible, setProductModalVisible] = useState(false);
+ const [editingProduct, setEditingProduct] = useState(null);
+
+ // 获取用户角色
+ const userInfo = useUserInfo(); // 获取当前用户信息
+ const userRole = userInfo?.角色?.名称; // 用户角色名称
+ const isAdmin = userRole === '系统管理员' || userRole === '团队管理员'; // 是否为管理员角色
+
+ // 使用useMemo缓存售后产品ID集合
+ const afterSalesProductIds = useMemo(() => {
+ return new Set(
+ '售后记录' in record && record.售后记录?.flatMap(afterSales =>
+ afterSales.原产品.map(productId => String(productId))
+ ) || []
+ );
+ }, [record]);
+
+ // 优化base64转Blob的函数，避免内存消耗
+ const fetchBase64ImageAsBlob = useCallback(async (productId: string): Promise => {
+ try {
+ const response = await fetch(`/api/products/images/${productId}`);
+ if (!response.ok) {
+ throw new Error(`API请求失败: ${response.status}`);
+ }
+
+ const data = await response.json();
+ if (!data || !data.image) {
+ throw new Error(`未找到有效的image数据`);
+ }
+
+ const base64Data = data.image;
+ // 优化: 检查base64格式并对大型图片进行处理
+ if (!base64Data.includes(',')) {
+ throw new Error(`无效的Base64数据`);
+ }
+
+ // 使用更高效的blob处理方式
+ const response2 = await fetch(base64Data);
+ return await response2.blob();
+ } catch (error) {
+ console.error(`获取产品${productId}图片失败:`, error);
+ throw error;
+ }
+ }, []);
+
+ // 使用useCallback优化点击处理函数
+ const handleCopy = useCallback(async (productId: string) => {
+ try {
+ const blob = await fetchBase64ImageAsBlob(productId);
+ const clipboardItem = new ClipboardItem({ [blob.type]: blob });
+ await navigator.clipboard.write([clipboardItem]);
+ message.success(`产品图片已复制`);
+ } catch (err) {
+ console.error('复制失败:', err);
+ message.error('复制失败');
+ }
+ }, [fetchBase64ImageAsBlob]);
+
+ // 点击编辑按钮的处理函数
+ const handleEdit = useCallback((product: IProduct) => {
+ setEditingProduct(product);
+ setProductModalVisible(true);
+ }, []);
+
+ const handleProductModalOk = useCallback(() => {
+ setProductModalVisible(false);
+ setEditingProduct(null);
+ }, []);
+
+ const handleProductModalCancel = useCallback(() => {
+ setProductModalVisible(false);
+ setEditingProduct(null);
+ }, []);
+
+ // 使用条件渲染避免不必要的渲染
+ if (!products || products.length === 0) {
+ return = {};
+
+// 批量获取产品图片的函数
+export const batchFetchProductImages = async (productIds: string[]): Promise> => {
+ try {
+ const uniqueIds = [...new Set(productIds)]; // 确保ID不重复
+ const cachedIds = uniqueIds.filter(id => !imageCache[id]); // 只获取未缓存的ID
+
+ if (cachedIds.length === 0) {
+ return imageCache; // 如果所有图片已缓存，直接返回缓存
+ }
+
+ // 实际API调用可能需要根据后端实现调整
+ const response = await fetch(`/api/products/batchImages`, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ },
+ body: JSON.stringify({ productIds: cachedIds })
+ });
+
+ if (!response.ok) {
+ throw new Error(`HTTP error! status: ${response.status}`);
+ }
+
+ const data = await response.json();
+ const images = data.images || {};
+
+ // 更新缓存
+ Object.entries(images).forEach(([id, image]) => {
+ if (id && image) {
+ imageCache[id] = image as string;
+ }
+ });
+
+ return { ...imageCache };
+ } catch (error: unknown) {
+ console.error('批量获取产品图片失败:', error);
+ return imageCache;
+ }
+};
+
+const fetchProductImage = async (productId: string): Promise => {
+ // 检查缓存
+ if (imageCache[productId]) {
+ return imageCache[productId];
+ }
+
+ try {
+ const response = await fetch(`/api/products/images/${productId}`);
+
+ if (!response.ok) {
+ throw new Error(`HTTP error! status: ${response.status}`);
+ }
+
+ const data = await response.json();
+ const image = data.image;
+
+ // 更新缓存
+ if (image) {
+ imageCache[productId] = image;
+ }
+
+ return image;
+ } catch (error: unknown) {
+ console.error(`获取产品图片失败 ID:${productId}`, error);
+ throw error;
+ }
+};
+
+const ProductImage: React.FC = React.memo(({
+ productId,
+ alt = 'Product Image',
+ width = '100%',
+ height = 'auto',
+ style = {} // 默认空对象
+}) => {
+ const [imageSrc, setImageSrc] = useState(null); // 用于存储图片地址
+ const [isLoading, setIsLoading] = useState(false); // 用于管理加载状态
+ const [isError, setIsError] = useState(false); // 用于管理错误状态
+
+ const containerStyle = useMemo(() => ({
+ width,
+ height,
+ display: 'flex',
+ flexDirection: 'column' as const, // 确保 flexDirection 为合法类型
+ alignItems: 'center',
+ justifyContent: 'center',
+ padding: '40px 0',
+ textAlign: 'center' as const, // 确保 textAlign 为合法类型
+ //border: '1px solid #f0f0f0', // 给容器增加轻微边框
+ borderRadius: '8px',
+ ...style // 合并传入的外部样式
+ }), [width, height, style]);
+
+ const imageStyle = useMemo(() => ({
+ maxWidth: '100%',
+ maxHeight: '100%',
+ borderRadius: '8px',
+ width,
+ height,
+ ...style // 合并传入的外部样式
+ }), [width, height, style]);
+
+ // 当 productId 存在时，执行图片加载
+ useEffect(() => {
+ if (!productId) return;
+
+ // 如果已缓存，直接使用缓存
+ if (imageCache[productId]) {
+ setImageSrc(imageCache[productId]);
+ return;
+ }
+
+ const loadImage = async () => {
+ setIsLoading(true);
+ setIsError(false);
+ try {
+ const image = await fetchProductImage(productId);
+ setImageSrc(image);
+ } catch (error) {
+ setIsError(true);
+ } finally {
+ setIsLoading(false);
+ }
+ };
+
+ loadImage();
+ }, [productId]);
+
+ // 当 productId 不存在时显示 "暂无图片"
+ if (!productId || productId === "default") {
+ return (
+ = ({
+ title,
+ children,
+ placement = 'topRight',
+ shouldWrapChildren = false,
+ ...props
+}) => {
+ // 使用 App.useApp() 获取消息实例
+ const { message } = App.useApp();
+
+ // 提取 title 中的文本内容，并保留格式（例如换行符）的函数
+ const extractTextFromTitle = (node: React.ReactNode): string => {
+ if (typeof node === 'string') {
+ return node;
+ }
+
+ if (Array.isArray(node)) {
+ return node.map(child => extractTextFromTitle(child)).join('');
+ }
+
+ if (React.isValidElement(node)) {
+ if (node.type === 'br') {
+ return '\n'; // 保留
标签为换行符 + } + // 安全地访问 props.children + if (node.props && typeof node.props === 'object' && 'children' in node.props) { + return extractTextFromTitle(node.props.children as React.ReactNode); + } + } + + return ''; + }; + + // 获取要复制的文本内容 + const getCopyText = () => { + return typeof title === 'string' ? title : extractTextFromTitle(title); + }; + + return ( + message.success('内容已复制到剪贴板'),
+ tooltips: ['点击复制', '复制成功']
+ }}
+ style={{
+ margin: 0,
+ color: '#1A202C',
+ fontSize: '12px',
+ whiteSpace: 'pre-wrap'
+ }}
+ >
+ {title}
+
+ }
+ placement={placement}
+ classNames={{ root: "customTooltip" }}
+ styles={{
+ root: {
+ maxWidth: '960px',
+ width: 'auto',
+ },
+ body: {
+ padding: '12px 24px',// 设置内边距
+ borderRadius: '8px',// 设置圆角
+ whiteSpace: 'pre-wrap',// 设置自动换行
+ //color: '#1A202C', // 文本颜色
+ fontSize: '12px' // 设置字体大小
+ }
+ }}
+ getPopupContainer={() => document.body}
+ {...props}
+ >
+ {shouldWrapChildren ? {children} : children}
+
+ );
+};
+
+export default MyTooltip;
diff --git a/src/pages/api/backstage/sales/Records/[id].ts b/src/pages/api/backstage/sales/Records/[id].ts
new file mode 100644
index 0000000..9a60565
--- /dev/null
+++ b/src/pages/api/backstage/sales/Records/[id].ts
@@ -0,0 +1,99 @@
+// src/pages/api/backstage/sales/Records/[id].ts
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { SalesRecord } from '@/models';
+import connectDB from '@/utils/connectDB';
+
+const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+ const { id } = req.query; // 从请求中获取销售记录的 ID
+
+ if (req.method === 'GET') {
+ try {
+ const salesRecord = await SalesRecord.findById(id)
+ .populate({
+ path: '导购',
+ select: '姓名',
+ })
+ .populate({
+ path: '客户',
+ select: '姓名 电话 地址 加粉日期',
+ })
+ .populate({
+ path: '产品',
+ select: '名称 售价 品类 品牌 供应商',
+ populate: [
+ { path: '品类', select: 'name' },
+ { path: '品牌', select: 'name' },
+ { path: '供应商', select: '供应商名称 联系方式' },
+ ],
+ })
+ .populate({
+ path: '订单来源',
+ select: '账号负责人 前端引流人员 账号编号 微信号',
+ populate: {
+ path: '账号负责人 前端引流人员',
+ select: '姓名',
+ },
+ })
+ .populate({
+ path: '收款平台',
+ select: '名称',
+ })
+ .populate('团队');
+
+ if (!salesRecord) {
+ return res.status(404).json({ message: '未找到销售记录' });
+ }
+
+ res.status(200).json({ salesRecord });
+ } catch (error) {
+ res.status(500).json({ message: '服务器错误' });
+ }
+ } else if (req.method === 'PUT') {
+ try {
+ const { 客户, 产品, 成交日期, 应收金额, 收款金额, 待收款, 收款平台, 待收已收, 收款状态, 备注, 导购 } = req.body;
+
+ const updatedSalesRecord = await SalesRecord.findByIdAndUpdate(
+ id,
+ {
+ 客户,
+ 产品,
+ 成交日期,
+ 应收金额,
+ 收款金额,
+ 待收款,
+ 收款平台,
+ 收款状态,
+ 待收已收,
+ 备注,
+ 导购,
+ },
+ { new: true } // 返回更新后的文档
+ );
+
+ if (!updatedSalesRecord) {
+ return res.status(404).json({ message: '未找到销售记录' });
+ }
+
+ res.status(200).json({ message: '销售记录更新成功', salesRecord: updatedSalesRecord });
+ } catch (error: any) {
+ res.status(400).json({ message: '更新销售记录失败', error: error.message });
+ }
+ } else if (req.method === 'DELETE') {
+ try {
+ const deletedSalesRecord = await SalesRecord.findByIdAndDelete(id);
+
+ if (!deletedSalesRecord) {
+ return res.status(404).json({ message: '未找到销售记录' });
+ }
+
+ res.status(200).json({ message: '销售记录删除成功' });
+ } catch (error: any) {
+ res.status(500).json({ message: '删除销售记录失败', error: error.message });
+ }
+ } else {
+ res.setHeader('Allow', ['GET', 'PUT', 'DELETE']);
+ res.status(405).end(`不允许 ${req.method} 方法`);
+ }
+};
+
+export default connectDB(handler);
diff --git a/src/pages/api/backstage/sales/Records/index.ts b/src/pages/api/backstage/sales/Records/index.ts
new file mode 100644
index 0000000..21615cb
--- /dev/null
+++ b/src/pages/api/backstage/sales/Records/index.ts
@@ -0,0 +1,76 @@
+//src\pages\api\backstage\sales\Records\index.ts
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { SalesRecord } from '@/models';
+import connectDB from '@/utils/connectDB';
+
+const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+ if (req.method === 'GET') {
+ try {
+ const { teamId } = req.query; // 获取团队ID
+ const salesRecords = await SalesRecord.find({ 团队: teamId })
+ .populate({
+ path: '导购',
+ select: '姓名'
+ })
+ .populate({
+ path: '客户',
+ select: '姓名 电话 地址 加粉日期'
+ })
+ .populate({
+ path: '产品',
+ //select: '-图片', // 排除产品的图片字段
+ select: '名称 售价 成本 品类 品牌 供应商', // 选择需要的产品字段并排除图片
+ populate: [
+ { path: '品类', select: 'name' }, // 填充品类，选择名称字段
+ { path: '品牌', select: 'name' }, // 填充品牌，选择名称字段
+ { path: '供应商', select: '供应商名称 联系方式' }, // 填充供应商，选择名称和联系方式字段
+ ]
+ })
+ .populate({
+ path: '订单来源',
+ select: '账号负责人 账号编号 微信号', // 选择订单来源中的账号负责人
+ populate: {
+ path: '账号负责人', // 填充账号负责人信息
+ select: '姓名' // 仅选择姓名字段
+ }
+ })
+ .populate({
+ path: '收款平台',
+ select: '名称', // 选择订单来源中的账号负责人
+ })
+ .populate({
+ path: '优惠券._id', // 使用优惠券子文档中的ID字段进行关联
+ select: '优惠券类型 券码 金额 折扣 已使用 使用日期', // 选择优惠券的券码、是否已使用和使用日期字段
+ model: 'Coupon' // 关联的模型名称
+ })
+ .populate({
+ path: '余额抵用', // 使用余额抵用子文档中的ID字段进行关联
+ select: '类型 金额', // 选择余额抵用的类型和金额字段
+ model: 'Transaction' // 关联的模型名称
+ })
+ .populate({
+ path: '售后记录', // 使用余额抵用子文档中的ID字段进行关联
+ select: '原产品 售后进度', // 选择余额抵用的类型和金额字段
+ })
+
+ .sort({ createdAt: -1 }); // 按成交日期倒序排列
+ res.status(200).json({ salesRecords });
+ } catch (error) {
+ res.status(500).json({ message: '服务器错误' });
+ }
+ } else if (req.method === 'POST') {
+ try {
+ const { 客户, 产品, 成交日期, 产品售价, 收款状态, 团队 } = req.body;
+ const newSalesRecord = new SalesRecord({ 客户, 产品, 成交日期, 产品售价, 收款状态, 团队 });
+ await newSalesRecord.save();
+ res.status(201).json({ message: '销售记录创建成功', salesRecord: newSalesRecord });
+ } catch (error) {
+ res.status(400).json({ message: '创建销售记录失败' });
+ }
+ } else {
+ res.setHeader('Allow', ['GET', 'POST']);
+ res.status(405).end(`不允许 ${req.method} 方法`);
+ }
+};
+
+export default connectDB(handler);
diff --git a/src/pages/api/login.ts b/src/pages/api/login.ts
index b51abb6..c7021f1 100644
--- a/src/pages/api/login.ts
+++ b/src/pages/api/login.ts
@@ -3,7 +3,7 @@ import jwt from 'jsonwebtoken';
import type { NextApiRequest, NextApiResponse } from 'next';
import { User } from '@/models';
import bcrypt from 'bcryptjs';
-import connectDB from '@/utils/ConnectDB';
+import connectDB from '@/utils/connectDB';
import { buildPermissionTree } from './buildPermissionTree';
import type { IPermission } from '@/models/types';
diff --git a/src/pages/api/logistics/batchStatus.ts b/src/pages/api/logistics/batchStatus.ts
new file mode 100644
index 0000000..df6f6b7
--- /dev/null
+++ b/src/pages/api/logistics/batchStatus.ts
@@ -0,0 +1,61 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import connectDB from '@/utils/connectDB';
+import { LogisticsRecord } from '@/models';
+
+const handler = connectDB(async (req: NextApiRequest, res: NextApiResponse) => {
+ if (req.method !== 'POST') {
+ return res.status(405).json({ message: '只允许POST请求' });
+ }
+
+ try {
+ const { recordIds } = req.body;
+
+ if (!recordIds || !Array.isArray(recordIds) || recordIds.length === 0) {
+ return res.status(400).json({ message: '必须提供记录ID数组' });
+ }
+
+ // 限制一次请求的最大记录数量
+ const maxBatchSize = 50;
+ const limitedIds = recordIds.slice(0, maxBatchSize);
+
+ // 批量查询物流状态
+ const logisticsRecords = await LogisticsRecord.find(
+ { 关联记录: { $in: limitedIds } },
+ '关联记录 物流单号 物流状态'
+ ).lean();
+
+ // 构建id->状态的映射对象
+ const statusMap: Record = {};
+
+ logisticsRecords.forEach(record => {
+ if (record.关联记录) {
+ const recordId = record.关联记录.toString();
+ statusMap[recordId] = {
+ 物流状态: record.物流状态 || '处理中',
+ 物流单号: record.物流单号
+ };
+ }
+ });
+
+ // 为未找到记录的ID设置默认状态
+ limitedIds.forEach(id => {
+ if (!statusMap[id]) {
+ statusMap[id] = { 物流状态: '待填单' };
+ }
+ });
+
+ return res.status(200).json({
+ success: true,
+ count: Object.keys(statusMap).length,
+ statuses: statusMap
+ });
+ } catch (error) {
+ console.error('批量获取物流状态失败:', error);
+ return res.status(500).json({
+ message: '服务器错误',
+ error: (error as Error).message
+ });
+ }
+});
+
+export default handler;
\ No newline at end of file
diff --git a/src/pages/api/logistics/details.ts b/src/pages/api/logistics/details.ts
new file mode 100644
index 0000000..a6a0375
--- /dev/null
+++ b/src/pages/api/logistics/details.ts
@@ -0,0 +1,60 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import connectDB from '@/utils/connectDB';
+import { LogisticsRecord } from '@/models';
+import mongoose from 'mongoose';
+
+// 定义物流记录类型
+interface ILogisticsRecord {
+ 物流单号?: string;
+ 物流公司?: string;
+ 物流详情?: string;
+ 物流状态?: string;
+ 更新时间?: Date;
+ 产品?: mongoose.Types.ObjectId[];
+ _id?: mongoose.Types.ObjectId;
+}
+
+const handler = connectDB(async (req: NextApiRequest, res: NextApiResponse) => {
+ if (req.method !== 'GET') {
+ return res.status(405).json({ message: '只允许GET请求' });
+ }
+
+ try {
+ const { recordId, productId } = req.query;
+
+ if (!recordId) {
+ return res.status(400).json({ message: '缺少必要参数recordId' });
+ }
+
+ // 验证recordId格式
+ if (!mongoose.Types.ObjectId.isValid(recordId as string)) {
+ return res.status(400).json({ message: '无效的recordId格式' });
+ }
+
+ // 构建查询条件
+ const query: any = { 关联记录: recordId };
+
+ // 如果提供了productId，添加产品筛选条件
+ if (productId && typeof productId === 'string' && mongoose.Types.ObjectId.isValid(productId)) {
+ query.产品 = productId;
+ }
+
+ const logisticsRecords = await LogisticsRecord.find(query)
+ .select('物流单号 物流公司 物流详情 物流状态 更新时间 产品')
+ .lean() as ILogisticsRecord[];
+
+ // 设置缓存控制头，允许客户端缓存5分钟
+ res.setHeader('Cache-Control', 'public, max-age=300');
+ res.setHeader('Expires', new Date(Date.now() + 300000).toUTCString());
+
+ return res.status(200).json(logisticsRecords);
+ } catch (error) {
+ console.error('获取物流详情失败:', error);
+ return res.status(500).json({
+ message: '服务器错误',
+ error: (error as Error).message
+ });
+ }
+});
+
+export default handler;
\ No newline at end of file
diff --git a/src/pages/api/logistics/status.ts b/src/pages/api/logistics/status.ts
new file mode 100644
index 0000000..edabf8a
--- /dev/null
+++ b/src/pages/api/logistics/status.ts
@@ -0,0 +1,88 @@
+/**
+ * 物流状态查询API
+ * 作者: 阿瑞
+ * 功能: 根据记录ID和产品ID获取物流状态
+ * 版本: v2.0
+ */
+import type { NextApiRequest, NextApiResponse } from 'next';
+import connectDB from '@/utils/connectDB';
+import { LogisticsRecord } from '@/models';
+import mongoose from 'mongoose';
+
+// 定义物流记录类型
+interface ILogisticsRecord {
+ 物流单号?: string;
+ 物流状态?: string;
+ _id?: mongoose.Types.ObjectId;
+}
+
+const handler = connectDB(async (req: NextApiRequest, res: NextApiResponse) => {
+ if (req.method !== 'GET') {
+ return res.status(405).json({ message: '只允许GET请求' });
+ }
+
+ try {
+ const { recordId, productId } = req.query;
+
+ // 参数验证
+ if (!recordId || typeof recordId !== 'string') {
+ return res.status(400).json({ message: '缺少必要参数recordId' });
+ }
+
+ // 验证recordId格式
+ if (!mongoose.Types.ObjectId.isValid(recordId)) {
+ return res.status(400).json({ message: '无效的recordId格式' });
+ }
+
+ // 构建查询条件
+ const query: any = { 关联记录: recordId };
+ if (productId && typeof productId === 'string' && mongoose.Types.ObjectId.isValid(productId)) {
+ // 如果提供了有效的productId，可以在查询中添加额外条件
+ query.产品 = productId;
+ }
+
+ // 查询物流记录，使用lean()提高性能
+ const logisticsRecord = await LogisticsRecord.findOne(query)
+ .select('物流单号 物流状态')
+ .lean()
+ .exec() as ILogisticsRecord | null;
+
+ // 设置缓存控制头，允许客户端缓存5分钟
+ res.setHeader('Cache-Control', 'public, max-age=300, stale-while-revalidate=150');
+ res.setHeader('Expires', new Date(Date.now() + 300000).toUTCString());
+
+ // 如果没有找到物流记录，返回"待填单"
+ if (!logisticsRecord) {
+ return res.status(200).json({
+ data: {
+ 物流单号: null,
+ 物流状态: '待填单'
+ }
+ });
+ }
+
+ // 如果有物流单号但没有物流状态，返回"待发货"
+ const logisticsStatus = logisticsRecord.物流状态 || (logisticsRecord.物流单号 ? '待发货' : '待填单');
+
+ return res.status(200).json({
+ data: {
+ 物流单号: logisticsRecord.物流单号,
+ 物流状态: logisticsStatus
+ }
+ });
+ } catch (error) {
+ console.error('获取物流状态失败:', error);
+
+ // 根据错误类型返回不同的状态码
+ if ((error as any).name === 'CastError') {
+ return res.status(400).json({ message: '无效的ID格式' });
+ }
+
+ return res.status(500).json({
+ message: '获取物流状态失败',
+ error: process.env.NODE_ENV === 'development' ? (error as Error).message : '服务器内部错误'
+ });
+ }
+});
+
+export default handler;
\ No newline at end of file
diff --git a/src/pages/api/products/batchImages.ts b/src/pages/api/products/batchImages.ts
new file mode 100644
index 0000000..3366b4b
--- /dev/null
+++ b/src/pages/api/products/batchImages.ts
@@ -0,0 +1,49 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import connectDB from '@/utils/connectDB';
+import { Product } from '@/models';
+
+const handler = connectDB(async (req: NextApiRequest, res: NextApiResponse) => {
+ if (req.method !== 'POST') {
+ return res.status(405).json({ message: '只允许POST请求' });
+ }
+
+ try {
+ const { productIds } = req.body;
+
+ if (!productIds || !Array.isArray(productIds) || productIds.length === 0) {
+ return res.status(400).json({ message: '必须提供产品ID数组' });
+ }
+
+ // 限制一次请求的最大产品数量，防止请求过大
+ const maxBatchSize = 50;
+ const limitedIds = productIds.slice(0, maxBatchSize);
+
+ // 使用MongoDB的$in操作符批量查询
+ const products = await Product.find(
+ { _id: { $in: limitedIds } },
+ '图片 _id'
+ ).lean();
+
+ // 构建id->图片的映射对象
+ const images: Record = {};
+ products.forEach(product => {
+ if (product._id && product.图片) {
+ images[product._id.toString()] = product.图片;
+ }
+ });
+
+ return res.status(200).json({
+ success: true,
+ count: Object.keys(images).length,
+ images
+ });
+ } catch (error) {
+ console.error('批量获取产品图片失败:', error);
+ return res.status(500).json({
+ message: '服务器错误',
+ error: (error as Error).message
+ });
+ }
+});
+
+export default handler;
\ No newline at end of file
diff --git a/src/pages/api/products/images/[id].ts b/src/pages/api/products/images/[id].ts
new file mode 100644
index 0000000..e1cf559
--- /dev/null
+++ b/src/pages/api/products/images/[id].ts
@@ -0,0 +1,57 @@
+/**
+ * 产品图片获取API
+ * 作者: 阿瑞
+ * 功能: 根据产品ID获取产品图片
+ * 版本: v2.0
+ */
+import type { NextApiRequest, NextApiResponse } from 'next';
+import connectDB from '@/utils/connectDB';
+import { Product } from '@/models';
+
+const handler = connectDB(async (req: NextApiRequest, res: NextApiResponse) => {
+ // 只允许GET请求
+ if (req.method !== 'GET') {
+ return res.status(405).json({ message: '只允许GET请求' });
+ }
+
+ const { id } = req.query;
+
+ // 参数验证
+ if (!id || typeof id !== 'string') {
+ return res.status(400).json({ message: '无效的产品ID' });
+ }
+
+ try {
+ // 设置缓存控制头，允许客户端缓存10分钟
+ res.setHeader('Cache-Control', 'public, max-age=600, stale-while-revalidate=300');
+ res.setHeader('Expires', new Date(Date.now() + 600000).toUTCString());
+
+ // 查询产品图片，使用lean()提高性能
+ const product = await Product.findById(id, '图片').lean().exec() as { 图片?: string } | null;
+
+ if (!product) {
+ return res.status(404).json({ message: '产品不存在' });
+ }
+
+ // 返回图片数据
+ return res.status(200).json({
+ image: product.图片 || null,
+ productId: id
+ });
+
+ } catch (error) {
+ console.error(`获取产品图片失败 ID:${id}`, error);
+
+ // 根据错误类型返回不同的状态码
+ if ((error as any).name === 'CastError') {
+ return res.status(400).json({ message: '无效的产品ID格式' });
+ }
+
+ return res.status(500).json({
+ message: '获取产品图片失败',
+ error: process.env.NODE_ENV === 'development' ? (error as Error).message : '服务器内部错误'
+ });
+ }
+});
+
+export default handler;
diff --git a/src/pages/api/roles/[id].ts b/src/pages/api/roles/[id].ts
index ff4544c..32f9a04 100644
--- a/src/pages/api/roles/[id].ts
+++ b/src/pages/api/roles/[id].ts
@@ -1,7 +1,7 @@
//src\pages\api\roles\[id].ts
import type { NextApiRequest, NextApiResponse } from 'next';
import { Role } from '@/models';
-import connectDB from '@/utils/ConnectDB';
+import connectDB from '@/utils/connectDB';
const handler = async (req: NextApiRequest, res: NextApiResponse) => {
const { query: { id }, method } = req;
diff --git a/src/pages/api/roles/index.ts b/src/pages/api/roles/index.ts
index 8ea8da0..6f6d3cf 100644
--- a/src/pages/api/roles/index.ts
+++ b/src/pages/api/roles/index.ts
@@ -1,7 +1,7 @@
//src\pages\api\roles\index.ts
import type { NextApiRequest, NextApiResponse } from 'next';
import { Role } from '@/models';
-import connectDB from '@/utils/ConnectDB';
+import connectDB from '@/utils/connectDB';
import { buildPermissionTree } from '@/pages/api/buildPermissionTree';
import { IPermission } from '@/models/types';
diff --git a/src/pages/api/team/create.ts b/src/pages/api/team/create.ts
index 6b966aa..b56b1ba 100644
--- a/src/pages/api/team/create.ts
+++ b/src/pages/api/team/create.ts
@@ -1,6 +1,6 @@
//src\pages\api\team\create.ts
import { NextApiRequest, NextApiResponse } from 'next';
-import connectDB from '@/utils/ConnectDB'; // 确保数据库连接
+import connectDB from '@/utils/connectDB'; // 确保数据库连接
import { Team, User } from '@/models'; // 引入 Team 和 User 模型
import { ITeam } from '@/models/types'; // 引入类型定义
diff --git a/src/pages/api/team/index.ts b/src/pages/api/team/index.ts
index 5ef69ea..154c20f 100644
--- a/src/pages/api/team/index.ts
+++ b/src/pages/api/team/index.ts
@@ -1,6 +1,6 @@
import type { NextApiRequest, NextApiResponse } from 'next';
import { Team } from '@/models';
-import connectDB from '@/utils/ConnectDB';
+import connectDB from '@/utils/connectDB';
const handler = async (req: NextApiRequest, res: NextApiResponse) => {
if (req.method === 'GET') {
diff --git a/src/pages/api/tools/SFExpress/updateLogisticsDetails.ts b/src/pages/api/tools/SFExpress/updateLogisticsDetails.ts
new file mode 100644
index 0000000..07c451a
--- /dev/null
+++ b/src/pages/api/tools/SFExpress/updateLogisticsDetails.ts
@@ -0,0 +1,92 @@
+//src\pages/api/tools/SFExpress/updateLogisticsDetails.ts
+import type { NextApiRequest, NextApiResponse } from 'next';
+import connectDB from '@/utils/connectDB';
+import { LogisticsRecord } from '@/models';
+import { querySFExpress } from '@/utils/querySFExpress';
+
+const handler = async (_req: NextApiRequest, res: NextApiResponse) => {
+ try {
+ // 查询所有需要更新的物流记录，这些记录有有效的物流单号且标记为需要查询
+ const logisticsRecords = await LogisticsRecord.find({ 是否查询: true, 物流单号: { $ne: null } });
+
+ const updateResults = []; // 用于存储每个物流单号和对应的查询结果
+
+ // 遍历每个物流记录，查询最新的物流信息，并决定是否需要继续查询
+ for (const record of logisticsRecords) {
+ const logisticsDetail = await querySFExpress(record.物流单号, record.客户尾号 || '');
+ const details = JSON.parse(logisticsDetail.apiResultData).msgData.routeResps[0].routes;
+
+ const formattedDetails = details.map((detail: { acceptTime: any; acceptAddress: any; remark: any; }) =>
+ `时间: ${detail.acceptTime}, 地点: ${detail.acceptAddress}, 描述: ${detail.remark}`
+ );
+
+ // 判断是否需要继续查询物流信息
+ const continueQuery = shouldContinueQuery(formattedDetails);
+
+ // 根据物流详情和是否有物流单号来确定物流状态
+ const logisticsStatus = determineLogisticsStatus(formattedDetails, !!record.物流单号);
+
+ // 更新物流记录的详细信息、状态及是否继续查询的标志
+ await LogisticsRecord.findByIdAndUpdate(record._id, {
+ 物流详情: formattedDetails.join('\n'),
+ 物流状态: logisticsStatus, // 新增物流状态字段的更新
+ 是否查询: continueQuery,
+ 更新时间: new Date(),
+ });
+
+ updateResults.push({ 物流单号: record.物流单号, 是否继续查询: continueQuery ? '是' : '否', 物流状态: logisticsStatus });
+ }
+
+ // 构建响应消息，显示本次查询的结果
+ const responseMessage = `本次查询共计${updateResults.length}个：\n`
+ + updateResults.map((result) =>
+ `物流单号：${result.物流单号}，物流状态：${result.物流状态}：继续查询（${result.是否继续查询}）`).join('\n')
+
+ res.status(200).json({ message: responseMessage });
+ } catch (error: any) {
+ console.error('Failed to update logistics details:', error);
+ res.status(500).json({ error: error.message || 'Unknown error' });
+ }
+};
+
+// 连接数据库并导出处理函数
+export default connectDB(handler);
+
+// 根据物流详情决定是否继续查询的函数
+function shouldContinueQuery(details: string[]): boolean {
+ const joinedDetails = details.join(" ");
+ // 使用正则表达式判断物流状态，根据状态确定是否继续查询
+ return !(/已收取快件.*发往.*分拣.*派送途中.*拒收.*退回.*签收/.test(joinedDetails) ||
+ /已收取快件.*发往.*分拣.*派送途中.*拒收.*签收/.test(joinedDetails) ||
+ /已收取快件.*发往.*分拣.*派送途中.*签收/.test(joinedDetails));
+}
+
+// 根据物流详情和是否有物流单号来确定物流状态
+function determineLogisticsStatus(details: string[], hasLogisticsNumber: boolean): string {
+ if (details.length === 0) {
+ return hasLogisticsNumber ? '待发货' : '待填单'; // 如果有物流单号但没有详情，则返回“待发货”
+ }
+ const joinedDetails = details.join(" "); // 将所有物流详情连成一个长字符串，以便进行模式匹配
+
+ if (/已收取快件.*发往.*分拣.*派送途中.*拒收.*退回.*签收/.test(joinedDetails)) {
+ return '已退回';
+ } else if (/已收取快件.*发往.*分拣.*派送途中.*拒收.*退回/.test(joinedDetails)) {
+ return '退回中';
+ } else if (/已收取快件.*发往.*分拣.*派送途中.*拒收.*签收/.test(joinedDetails)) {
+ return '已签收';
+ } else if (/已收取快件.*发往.*分拣.*派送途中.*拒收/.test(joinedDetails)) {
+ return '已拒收';
+ } else if (/已收取快件.*发往.*分拣.*派送途中.*签收/.test(joinedDetails)) {
+ return '已签收';
+ } else if (/已收取快件.*发往.*分拣.*派送途中/.test(joinedDetails)) {
+ return '派送中';
+ //} else if (/已收取快件.*发往.*分拣/.test(joinedDetails)) {
+ // return '分拣中';
+ } else if (/已收取快件.*发往/.test(joinedDetails)) {
+ return '已发出';
+ } else if (/已收取快件/.test(joinedDetails)) {
+ return '已揽收';
+ } else {
+ return '处理中'; // 默认状态
+ }
+}
diff --git a/src/pages/api/tools/logistics/detail/[id].ts b/src/pages/api/tools/logistics/detail/[id].ts
new file mode 100644
index 0000000..1a1ec11
--- /dev/null
+++ b/src/pages/api/tools/logistics/detail/[id].ts
@@ -0,0 +1,27 @@
+// src/pages/api/logistics/detail/[id].ts
+import type { NextApiRequest, NextApiResponse } from 'next';
+import connectDB from '@/utils/connectDB';
+import { LogisticsRecord } from '@/models';
+const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+ const { id } = req.query; // 从 URL 中获取订单 ID
+ if (!id) {
+ return res.status(400).json({ message: 'Missing logistics record ID.' });
+ }
+ try {
+ // 根据订单 ID 查找相关的物流记录
+ const logisticsRecords = await LogisticsRecord.find({
+ 关联记录: id,
+ });
+ // 如果没有找到记录，返回空数组而不是404
+ if (!logisticsRecords || logisticsRecords.length === 0) {
+ return res.status(200).json([]); // 返回空数组表示没有找到记录
+ }
+ // 返回查询到的物流记录
+ res.status(200).json(logisticsRecords);
+ } catch (error: any) {
+ console.error('Error fetching logistics records:', error);
+ res.status(500).json({ message: 'Server error', error: error.message });
+ }
+};
+
+export default connectDB(handler);
diff --git a/src/pages/api/tools/logistics/index.ts b/src/pages/api/tools/logistics/index.ts
new file mode 100644
index 0000000..c7c50b9
--- /dev/null
+++ b/src/pages/api/tools/logistics/index.ts
@@ -0,0 +1,84 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import connectDB from '@/utils/connectDB';
+import { LogisticsRecord } from '@/models';
+
+const handler = connectDB(async (req: NextApiRequest, res: NextApiResponse) => {
+ if (req.method === 'GET') {
+ const { 关联记录 } = req.query; // 使用req.query获取URL参数
+ if (!关联记录) {
+ return res.status(400).json({ message: '缺少关联记录ID' });
+ }
+
+ try {
+ // 查询所有相关的物流记录
+ const logisticsRecords = await LogisticsRecord.find({ 关联记录 });
+
+ if (logisticsRecords.length > 0) {
+ return res.status(200).json(logisticsRecords); // 返回多个记录
+ } else {
+ return res.status(404).json({ message: '未找到对应的物流记录' });
+ }
+ } catch (error: any) {
+ console.error('查询物流记录失败:', error);
+ return res.status(500).json({ message: '查询物流记录失败，请检查服务器状态', error: error.message });
+ }
+ }
+
+ // 处理 POST 请求的逻辑保持不变
+ if (req.method === 'POST') {
+ const { 关联记录, 类型, 客户尾号, 产品 } = req.body;
+
+ // 确保所有必要的字段都被提供
+ if (!关联记录 || !类型 || !客户尾号 || !产品 || !Array.isArray(产品)) {
+ return res.status(400).json({ message: '缺少必要的字段' });
+ }
+
+ try {
+ // 逐个处理每个产品和物流单号
+ const logisticsRecords = await Promise.all(产品.map(async ({ productId, logisticsNumber }) => {
+ if (!logisticsNumber) {
+ return null; // 忽略未填写物流单号的产品
+ }
+
+ // 查找是否有现有的物流记录（使用$in操作符查询数组字段）
+ let existingRecord = await LogisticsRecord.findOne({
+ 关联记录,
+ 类型,
+ 产品: { $in: [productId] }
+ });
+
+ if (existingRecord) {
+ // 更新现有记录
+ existingRecord.物流单号 = logisticsNumber;
+ existingRecord.客户尾号 = 客户尾号;
+ existingRecord.更新时间 = new Date();
+ existingRecord.是否查询 = true; // 修正为boolean类型
+ return existingRecord.save();
+ } else {
+ // 创建新记录 - 产品字段应该是数组
+ const newLogisticsRecord = await LogisticsRecord.create({
+ 物流单号: logisticsNumber,
+ 客户尾号,
+ 更新时间: new Date(),
+ 关联记录,
+ 类型,
+ 产品: [productId], // 修正：设置为数组格式
+ 是否查询: true // 修正为boolean类型
+ });
+ return newLogisticsRecord;
+ }
+ }));
+
+ return res.status(201).json(logisticsRecords.filter(record => record !== null)); // 返回成功创建或更新的记录
+ } catch (error: any) {
+ console.error('处理物流记录失败:', error);
+ return res.status(500).json({ message: '处理物流记录失败，请检查提供的数据格式及服务器状态', error: error.message });
+ }
+ } else {
+ // 如果不是 POST 请求，返回 405 Method Not Allowed
+ res.setHeader('Allow', ['GET', 'POST']); // 修正：添加GET方法
+ res.status(405).end(`Method ${req.method} Not Allowed`);
+ }
+});
+
+export default handler;
diff --git a/src/pages/api/tools/parseAddress.ts b/src/pages/api/tools/parseAddress.ts
new file mode 100644
index 0000000..07e7332
--- /dev/null
+++ b/src/pages/api/tools/parseAddress.ts
@@ -0,0 +1,133 @@
+/**
+ * @file: parseAddress.ts
+ * @author: 阿瑞
+ * @description: 地址解析服务API路由
+ * @version: 1.0.1
+ */
+
+// src/pages/api/tools/parseAddress.ts
+import type { NextApiRequest, NextApiResponse } from 'next';
+import axios from 'axios';
+
+interface ExtractedInfoItem {
+ text: string;
+ start: number;
+ end: number;
+ probability: number;
+}
+
+interface ExtractedInfo {
+ 姓名?: ExtractedInfoItem[];
+ 电话?: ExtractedInfoItem[];
+}
+
+interface ExtractInfoResponse {
+ extracted_info: ExtractedInfo[];
+}
+
+interface ParseLocationResponse {
+ province: string | null;
+ city: string | null;
+ county: string | null;
+ detail: string | null;
+ full_location: string | null;
+ orig_location: string | null;
+ town: string | null;
+ village: string | null;
+}
+
+interface CombinedResponse {
+ name: string | null;
+ phone: string | null;
+ address: ParseLocationResponse | null;
+}
+
+export default async function handler(
+ req: NextApiRequest,
+ res: NextApiResponse
+) {
+ if (req.method !== 'POST') {
+ res.status(405).json({ error: '方法不被允许' });
+ return;
+ }
+
+ const { text } = req.body;
+
+ if (!text || typeof text !== 'string') {
+ res.status(400).json({ error: '请求参数错误，缺少文本内容' });
+ return;
+ }
+
+ try {
+ // 从环境变量获取 API 的 URL
+ const extractInfoUrl = process.env.EXTRACT_INFO_API_URL;
+ const parseLocationUrl = process.env.PARSE_LOCATION_API_URL;
+
+ // 检查环境变量是否配置
+ if (!extractInfoUrl || !parseLocationUrl) {
+ console.error('环境变量未配置:', {
+ EXTRACT_INFO_API_URL: extractInfoUrl,
+ PARSE_LOCATION_API_URL: parseLocationUrl
+ });
+ throw new Error('服务配置错误：API地址未设置');
+ }
+
+ // 第一步：提取姓名和电话
+ const extractInfoResponse = await axios.post(
+ extractInfoUrl,
+ { text },
+ { headers: { 'Content-Type': 'application/json' } }
+ );
+
+ const extractedInfo = extractInfoResponse.data.extracted_info[0];
+
+ let name: string | null = null;
+ let phone: string | null = null;
+
+ if (extractedInfo['姓名'] && extractedInfo['姓名'].length > 0) {
+ name = extractedInfo['姓名'][0].text;
+ }
+
+ if (extractedInfo['电话'] && extractedInfo['电话'].length > 0) {
+ phone = extractedInfo['电话'][0].text;
+ }
+
+ // 从原始文本中移除姓名和电话，得到地址部分
+ let addressText = text;
+
+ if (name) {
+ addressText = addressText.replace(name, '').trim();
+ }
+
+ if (phone) {
+ addressText = addressText.replace(phone, '').trim();
+ }
+
+ // 第二步：解析地址
+ const parseLocationResponse = await axios.post(
+ parseLocationUrl,
+ { text: addressText },
+ { headers: { 'Content-Type': 'application/json' } }
+ );
+
+ const combinedResponse: CombinedResponse = {
+ name,
+ phone,
+ address: parseLocationResponse.data,
+ };
+
+ res.status(200).json(combinedResponse);
+ } catch (error: any) {
+ console.error('解析出错：', error.message || error);
+ // 根据错误类型返回不同的错误信息
+ if (error.message === '服务配置错误：API地址未设置') {
+ res.status(500).json({ error: '服务配置错误，请联系管理员' });
+ } else if (axios.isAxiosError(error)) {
+ res.status(500).json({
+ error: `外部服务请求失败: ${error.response?.status || '未知错误'}`
+ });
+ } else {
+ res.status(500).json({ error: '服务器内部错误' });
+ }
+ }
+}
diff --git a/src/pages/api/tools/parseAddressKuaidi100.ts b/src/pages/api/tools/parseAddressKuaidi100.ts
new file mode 100644
index 0000000..6a790ac
--- /dev/null
+++ b/src/pages/api/tools/parseAddressKuaidi100.ts
@@ -0,0 +1,239 @@
+/**
+ * 快递100智能地址解析API
+ * 作者: 阿瑞
+ * 功能: 使用快递100 API进行智能地址解析，识别姓名、电话、地址信息
+ * 版本: v1.0
+ */
+import type { NextApiRequest, NextApiResponse } from 'next';
+import crypto from 'crypto';
+
+// 快递100 API响应接口定义
+interface Kuaidi100Response {
+ success: boolean;
+ code: number;
+ message: string;
+ time: number;
+ data?: {
+ taskId: string;
+ result: Array<{
+ content: string;
+ mobile: string[];
+ name: string;
+ address: string;
+ xzq: {
+ fullName: string;
+ province: string;
+ city: string;
+ district: string;
+ fourth?: string;
+ subArea: string;
+ parentCode: string;
+ code: string;
+ level: number;
+ };
+ }>;
+ };
+}
+
+// 统一响应格式
+interface ParsedAddress {
+ name: string | null;
+ phone: string | null;
+ address: {
+ province: string | null;
+ city: string | null;
+ county: string | null;
+ detail: string | null;
+ full_location: string | null;
+ orig_location: string | null;
+ town: string | null;
+ village: string | null;
+ } | null;
+}
+
+/**
+ * 生成MD5签名
+ * @param param - 参数字符串
+ * @param t - 时间戳
+ * @param key - API密钥
+ * @param secret - API密钥
+ * @returns MD5签名（32位大写）
+ */
+function generateSign(param: string, t: string, key: string, secret: string): string {
+ const signString = param + t + key + secret;
+ return crypto.createHash('md5').update(signString).digest('hex').toUpperCase();
+}
+
+/**
+ * 调用快递100地址解析API
+ * @param content - 需要解析的地址内容
+ * @returns 解析结果
+ */
+async function callKuaidi100API(content: string): Promise {
+ const key = process.env.KUAIDI100_KEY;
+ const secret = process.env.KUAIDI100_SECRET;
+
+ if (!key || !secret) {
+ throw new Error('快递100 API配置缺失，请检查环境变量 KUAIDI100_KEY 和 KUAIDI100_SECRET');
+ }
+
+ // 构建请求参数
+ const t = Date.now().toString();
+ const param = JSON.stringify({
+ addressLevel: 4, // 解析到四级地址（街道/乡镇）
+ content: content.trim()
+ });
+
+ // 生成签名
+ const sign = generateSign(param, t, key, secret);
+
+ // 构建请求体
+ const requestBody = new URLSearchParams({
+ key,
+ sign,
+ t,
+ param
+ });
+
+ console.log('快递100 API请求参数:', { key, t, param: JSON.parse(param) });
+
+ try {
+ // 使用AbortController实现超时控制
+ const controller = new AbortController();
+ const timeoutId = setTimeout(() => controller.abort(), 8000); // 8秒超时
+
+ const response = await fetch('https://api.kuaidi100.com/address/resolution', {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/x-www-form-urlencoded',
+ },
+ body: requestBody.toString(),
+ signal: controller.signal,
+ });
+
+ clearTimeout(timeoutId);
+
+ if (!response.ok) {
+ throw new Error(`HTTP错误: ${response.status} ${response.statusText}`);
+ }
+
+ const data: Kuaidi100Response = await response.json();
+ console.log('快递100 API响应:', data);
+
+ return data;
+ } catch (error) {
+ console.error('快递100 API调用失败:', error);
+ throw error;
+ }
+}
+
+/**
+ * 转换快递100响应为统一格式
+ * @param kuaidi100Data - 快递100 API响应数据
+ * @returns 统一格式的解析结果
+ */
+function convertToUnifiedFormat(kuaidi100Data: Kuaidi100Response): ParsedAddress {
+ if (!kuaidi100Data.success || !kuaidi100Data.data?.result?.length) {
+ return {
+ name: null,
+ phone: null,
+ address: null
+ };
+ }
+
+ const result = kuaidi100Data.data.result[0];
+ const xzq = result.xzq;
+
+ return {
+ name: result.name || null,
+ phone: result.mobile?.length > 0 ? result.mobile[0] : null,
+ address: {
+ province: xzq.province || null,
+ city: xzq.city || null,
+ county: xzq.district || null,
+ detail: result.address || xzq.subArea || null,
+ full_location: xzq.fullName || null,
+ orig_location: result.content || null,
+ town: xzq.fourth || null,
+ village: null // 快递100暂不提供村级信息
+ }
+ };
+}
+
+export default async function handler(
+ req: NextApiRequest,
+ res: NextApiResponse
+) {
+ // 只允许POST请求
+ if (req.method !== 'POST') {
+ return res.status(405).json({ error: '只支持POST请求' });
+ }
+
+ try {
+ const { text } = req.body;
+
+ // 验证输入参数
+ if (!text || typeof text !== 'string' || text.trim().length === 0) {
+ return res.status(400).json({ error: '请提供有效的地址文本' });
+ }
+
+ // 检查文本长度（快递100限制）
+ if (text.length > 1000) {
+ return res.status(400).json({ error: '地址文本过长，请控制在1000字符以内' });
+ }
+
+ console.log('开始解析地址:', text);
+
+ // 调用快递100 API
+ const kuaidi100Response = await callKuaidi100API(text);
+
+ // 检查API响应
+ if (!kuaidi100Response.success) {
+ const errorMessage = getErrorMessage(kuaidi100Response.code);
+ console.error('快递100 API返回错误:', kuaidi100Response);
+ return res.status(400).json({
+ error: `地址解析失败: ${errorMessage} (错误码: ${kuaidi100Response.code})`
+ });
+ }
+
+ // 转换为统一格式
+ const parsedResult = convertToUnifiedFormat(kuaidi100Response);
+
+ console.log('地址解析成功:', parsedResult);
+ return res.status(200).json(parsedResult);
+
+ } catch (error) {
+ console.error('地址解析API错误:', error);
+
+ if (error instanceof Error) {
+ if (error.message.includes('配置缺失')) {
+ return res.status(500).json({ error: error.message });
+ }
+ if (error.message.includes('timeout') || error.message.includes('超时')) {
+ return res.status(408).json({ error: '请求超时，请稍后重试' });
+ }
+ }
+
+ return res.status(500).json({ error: '地址解析服务暂时不可用，请稍后重试' });
+ }
+}
+
+/**
+ * 根据错误码获取错误信息
+ * @param code - 快递100错误码
+ * @returns 错误描述
+ */
+function getErrorMessage(code: number): string {
+ const errorMessages: Record = {
+ [-1]: '解析失败/异常，请稍后重试',
+ [200]: '提交成功',
+ [10000]: '解析失败，请检查输入内容',
+ [10002]: '请求参数错误',
+ [10007]: '系统内部调用异常',
+ [10025]: '非法请求，异常文件',
+ [30002]: '验证签名失败，请检查API配置',
+ [30004]: '账号单量不足，需要充值'
+ };
+
+ return errorMessages[code] || `未知错误 (${code})`;
+}
\ No newline at end of file
diff --git a/src/pages/api/tools/test4.ts b/src/pages/api/tools/test4.ts
new file mode 100644
index 0000000..f057ab4
--- /dev/null
+++ b/src/pages/api/tools/test4.ts
@@ -0,0 +1,51 @@
+import { NextApiRequest, NextApiResponse } from 'next';
+import axios from 'axios';
+import connectDB from '@/utils/connectDB';
+
+//const extractInfoAPI = 'http://192.168.1.8:8006/extract_info/';
+//const parseLocationAPI = 'http://192.168.1.8:8000/parse_location/';
+// 从环境变量获取 API 的 URL
+const extractInfoAPI = process.env.EXTRACT_INFO_API_URL || '';
+const parseLocationAPI = process.env.PARSE_LOCATION_API_URL || '';
+
+const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+ if (req.method !== 'POST') {
+ return res.status(405).json({ error: 'Method not allowed' });
+ }
+
+ try {
+ const { text } = req.body;
+
+ // 1. 使用 extract_info API 提取信息
+ const extractResponse = await axios.post(extractInfoAPI, { text });
+ const extractedInfo = extractResponse.data.extracted_info[0];
+
+ // 提取信息失败时抛出异常
+ if (!extractedInfo) {
+ throw new Error('Failed to extract information');
+ }
+
+ // 2. 将城市、县区、详细地址拼接为完整地址
+ const city = extractedInfo['城市'][0]?.text || '';
+ const county = extractedInfo['县区'][0]?.text || '';
+ const detailAddress = extractedInfo['详细地址'][0]?.text || '';
+ const fullAddress = `${city}${county}${detailAddress}`;
+
+ // 3. 使用 parse_location API 解析完整地址
+ const parseResponse = await axios.post(parseLocationAPI, { text: fullAddress });
+ const parsedLocation = parseResponse.data;
+
+ // 4. 返回组合后的结果
+ const result = {
+ ...extractedInfo,
+ 解析地址: parsedLocation,
+ };
+
+ res.status(200).json(result);
+ } catch (error) {
+ console.error('Error in processing request:', error);
+ res.status(500).json({ error: 'Internal Server Error' });
+ }
+};
+
+export default connectDB(handler);
diff --git a/src/pages/api/user.ts b/src/pages/api/user.ts
index 4d28580..a7c3d8f 100644
--- a/src/pages/api/user.ts
+++ b/src/pages/api/user.ts
@@ -1,6 +1,6 @@
import { NextApiRequest, NextApiResponse } from 'next';
import { User } from '@/models'; // 用户模型存储在 models 目录中
-import connectDB from '@/utils/ConnectDB'; // 数据库连接工具
+import connectDB from '@/utils/connectDB'; // 数据库连接工具
import { buildPermissionTree } from './buildPermissionTree'; // 存在的权限树构建工具
export default connectDB(async (req: NextApiRequest, res: NextApiResponse) => {
diff --git a/src/pages/api/users/[id].ts b/src/pages/api/users/[id].ts
index d92f78b..bbd6aeb 100644
--- a/src/pages/api/users/[id].ts
+++ b/src/pages/api/users/[id].ts
@@ -1,7 +1,7 @@
//src\pages\api\users\[id].ts
import type { NextApiRequest, NextApiResponse } from 'next';
import { User } from '@/models';
-import connectDB from '@/utils/ConnectDB';
+import connectDB from '@/utils/connectDB';
import { IUser } from '@/models/types'; // 导入 IUser 接口类型
import bcrypt from 'bcryptjs';
diff --git a/src/pages/api/users/index.ts b/src/pages/api/users/index.ts
index d629b21..410a38a 100644
--- a/src/pages/api/users/index.ts
+++ b/src/pages/api/users/index.ts
@@ -1,7 +1,7 @@
//src\pages\api\users\index.ts
import type { NextApiRequest, NextApiResponse } from 'next';
import { User } from '@/models';
-import connectDB from '@/utils/ConnectDB';
+import connectDB from '@/utils/connectDB';
import bcrypt from 'bcryptjs';
const handler = async (req: NextApiRequest, res: NextApiResponse) => {
diff --git a/src/pages/backstage/product/index.tsx b/src/pages/backstage/product/index.tsx
new file mode 100644
index 0000000..d1a5fa8
--- /dev/null
+++ b/src/pages/backstage/product/index.tsx
@@ -0,0 +1,284 @@
+// src/pages/test/test8.tsx
+
+import React, { useCallback, useEffect, useState, useMemo } from 'react';
+import { Card, Row, Col, Button, Tooltip, message, Popconfirm, Select, Space } from 'antd';
+import type { NextPage } from 'next';
+import { useUserInfo } from '@/store/userStore'; // 使用 Zustand 获取用户信息
+import { EditOutlined, DeleteOutlined } from '@ant-design/icons';
+import ProductImage from '@/components/product/ProductImage';
+import { IProduct } from '@/models/types';
+import ProductModal from './product-modal';
+
+const { Option } = Select;
+
+interface ProductsResponse {
+ products: IProduct[];
+}
+
+const Test8Page: NextPage = () => {
+ const [products, setProducts] = useState([]);
+ const userInfo = useUserInfo(); // 获取当前用户信息
+ const [isModalVisible, setIsModalVisible] = useState(false);
+ const [currentProduct, setCurrentProduct] = useState(null);
+
+ // 新增筛选状态
+ const [selectedBrand, setSelectedBrand] = useState(undefined);
+ const [selectedCategory, setSelectedCategory] = useState(undefined);
+ const [selectedSupplier, setSelectedSupplier] = useState(undefined);
+
+ useEffect(() => {
+ const teamId = userInfo.团队?._id;
+
+ if (teamId) {
+ // 使用 teamId 获取产品数据
+ fetch(`/api/backstage/products?teamId=${teamId}`)
+ .then((res) => {
+ if (!res.ok) {
+ throw new Error('网络响应不正常');
+ }
+ return res.json();
+ })
+ .then((data: ProductsResponse) => {
+ setProducts(data.products);
+ })
+ .catch((error) => {
+ console.error('获取产品数据出错:', error);
+ });
+ }
+ }, [userInfo]);
+
+ const handleModalOk = () => {
+ setIsModalVisible(false);
+ if (userInfo.团队?._id) {
+ // 重新获取产品列表
+ // fetchProducts(userInfo.团队._id);
+ }
+ };
+
+ const handleEdit = useCallback((product: IProduct) => {
+ setCurrentProduct(product);
+ setIsModalVisible(true);
+ }, []);
+
+ const handleDelete = useCallback(
+ async (id: string) => {
+ try {
+ const response = await fetch(`/api/backstage/products/${id}`, {
+ method: 'DELETE',
+ });
+
+ if (!response.ok) {
+ throw new Error('删除请求失败');
+ }
+
+ message.success('产品删除成功');
+ // 从列表中移除已删除的产品
+ setProducts((prevProducts) => prevProducts.filter((product) => product._id !== id));
+ } catch (error) {
+ message.error('删除产品失败');
+ }
+ },
+ []
+ );
+
+ // 从产品数据中提取品牌、品类和供应商列表
+ const brands = useMemo(() => {
+ const brandSet = new Set();
+ products.forEach((product) => {
+ if (product.品牌?.name) {
+ brandSet.add(product.品牌.name);
+ }
+ });
+ return Array.from(brandSet);
+ }, [products]);
+
+ const categories = useMemo(() => {
+ const categorySet = new Set();
+ products.forEach((product) => {
+ if (product.品类?.name) {
+ categorySet.add(product.品类.name);
+ }
+ });
+ return Array.from(categorySet);
+ }, [products]);
+
+ const suppliers = useMemo(() => {
+ const supplierSet = new Set();
+ products.forEach((product) => {
+ if (product.供应商?.联系方式?.联系人) {
+ supplierSet.add(product.供应商.联系方式.联系人);
+ }
+ });
+ return Array.from(supplierSet);
+ }, [products]);
+
+ // 实现筛选逻辑
+ const filteredProducts = useMemo(() => {
+ return products.filter((product) => {
+ const matchesBrand = selectedBrand ? product.品牌?.name === selectedBrand : true;
+ const matchesCategory = selectedCategory ? product.品类?.name === selectedCategory : true;
+ const matchesSupplier = selectedSupplier
+ ? product.供应商?.联系方式?.联系人 === selectedSupplier
+ : true;
+ return matchesBrand && matchesCategory && matchesSupplier;
+ });
+ }, [products, selectedBrand, selectedCategory, selectedSupplier]);
+
+ return (
+ setIsModalVisible(false)}
+ product={currentProduct}
+ />
+ )}
+
+ );
+};
+
+export default Test8Page;
\ No newline at end of file
diff --git a/src/pages/backstage/product/product-modal.tsx b/src/pages/backstage/product/product-modal.tsx
new file mode 100644
index 0000000..c463e6a
--- /dev/null
+++ b/src/pages/backstage/product/product-modal.tsx
@@ -0,0 +1,344 @@
+//src\pages\backstage\product\product-modal.tsx
+import React, { useEffect, useState, ClipboardEvent, useCallback } from 'react';
+import {
+ Modal, Form, Input, message, Select, InputNumber,
+ Row, Col
+} from 'antd';
+import { IProduct, IBrand, ICategory, ISupplier } from '@/models/types';
+import { useUserInfo } from '@/store/userStore'; // 使用 Zustand 获取用户信息
+import { CloseOutlined } from '@ant-design/icons';
+
+interface ProductModalProps {
+ visible: boolean;
+ onCancel: () => void;
+ onOk: () => void;
+ product: IProduct | null;
+}
+
+const ProductModal: React.FCLoading...
+
+
+ );
+};
+
+export default LogisticsQuery;
diff --git a/src/components/logistics/status.tsx b/src/components/logistics/status.tsx
new file mode 100644
index 0000000..9df3d4e
--- /dev/null
+++ b/src/components/logistics/status.tsx
@@ -0,0 +1,251 @@
+//src\components\logistics\status.tsx
+import React, { useEffect, useState, useCallback, useRef } from 'react';
+import { Tag, Spin } from 'antd';
+import MyTooltip from '@/components/tooltip/MyTooltip';
+import { debounce } from 'lodash'; // 导入lodash的debounce函数
+
+interface LogisticsStatusProps {
+ recordId: string; // 关联记录的id
+ productId: string; // 产品的id
+}
+
+// 添加状态缓存
+const statusCache: Record物流单号: {data.物流单号}
+更新时间: {new Date(data.更新时间).toLocaleString()}
+物流详情:
+{data.物流详情}
+
+ 物流单号：{logisticsNumber}
+
+ )
+ }
+ onMouseEnter={fetchLogisticsDetails}
+ >
+ {logisticsDetails || '暂无物流详情'}
+无产品信息
;
+ }
+
+ return (
+
+ {products.map(product => {
+ const isAfterSales = afterSalesProductIds.has(String(product._id));
+ const supplierInfo = product.供应商?.联系方式
+ ? <>
+ 联系人: {product.供应商.联系方式.联系人}
+ 电话: {product.供应商.联系方式.电话}
+ 地址: {product.供应商.联系方式.地址} + + : '无供应商信息'; + + return ( +
+ );
+};
+
+// 移除React.memo，避免过度优化导致的刷新问题
+export default ProductCardList;
diff --git a/src/components/product/ProductImage.tsx b/src/components/product/ProductImage.tsx
new file mode 100644
index 0000000..8c53d1a
--- /dev/null
+++ b/src/components/product/ProductImage.tsx
@@ -0,0 +1,203 @@
+//src\components\product\ProductImage.tsx
+import React, { useState, useEffect, useMemo, CSSProperties } from 'react';
+import { Typography, Image } from 'antd';
+import { LoadingOutlined, PictureOutlined } from '@ant-design/icons';
+
+const { Text } = Typography;
+
+interface ProductImageProps {
+ productId?: string; // productId 变为可选
+ alt?: string; // 添加 alt 属性
+ width?: number | string;
+ height?: number | string;
+ style?: CSSProperties; // 添加 style 属性
+}
+
+// 添加图片缓存机制
+const imageCache: Record+ 电话: {product.供应商.联系方式.电话}
+ 地址: {product.供应商.联系方式.地址} + + : '无供应商信息'; + + return ( +
+ {/* 产品图片 */}
+
+
+ {/* 成本价，显示在价格上方 */}
+
+ );
+ })}
+ {/* 编辑产品弹窗 */}
+ {productModalVisible && (
+
+
+ {/* 编辑和复制按钮 */}
+ {isAdmin && (
+
+ handleEdit(product)}
+ >
+
+ handleCopy(product._id)}
+ >
+
+
+ )}
+ {/* 供应商名称 */}
+
+
+
+
+ {/* 产品名称 */}
+ {product.供应商?.供应商名称}
+
+ {product.名称}
+
+
+ {(() => {
+ // 计算总成本 = 成本价 + 包装费 + 运费
+ const costPrice = product.成本?.成本价 || 0;
+ const packagingFee = product.成本?.包装费 || 0;
+ const shippingFee = product.成本?.运费 || 0;
+ const totalCost = costPrice + packagingFee + shippingFee;
+
+ // 创建成本明细信息
+ const costDetails = (
+ <>
+ 成本价: ￥{costPrice}
+ 包装费: ￥{packagingFee}
+ 运费: ￥{shippingFee}
+ 总成本: ￥{totalCost} + + ); + + return totalCost === 0 ? ( + '￥无成本' + ) : ( +
+ ￥{totalCost.toFixed(2)}
+
+ );
+ })()}
+
+ {/* 价格 */}
+ + 包装费: ￥{packagingFee}
+ 运费: ￥{shippingFee}
+ 总成本: ￥{totalCost} + + ); + + return totalCost === 0 ? ( + '￥无成本' + ) : ( +
+ ￥{product.售价}
+
+ {/* 物流状态 */}
+
+ {isAfterSales && (
+
+
+
+ 已售后
+
+
+ )}
+
+ 暂无图片
+
+ );
+ }
+
+ // 加载中状态
+ if (isLoading) {
+ return (
+
+ 加载中...
+
+ );
+ }
+
+ // 加载错误状态，展示 productId
+ if (isError) {
+ return (
+
+ 加载失败
+ ID: {productId}
+
+ );
+ }
+
+ //如果没有imageSrc。则显示请稍后...
+ if (!imageSrc) {
+ return (
+
+ 请稍后...
+
+ );
+ }
+
+ // 成功加载图片
+ return (
+ 标签为换行符 + } + // 安全地访问 props.children + if (node.props && typeof node.props === 'object' && 'children' in node.props) { + return extractTextFromTitle(node.props.children as React.ReactNode); + } + } + + return ''; + }; + + // 获取要复制的文本内容 + const getCopyText = () => { + return typeof title === 'string' ? title : extractTextFromTitle(title); + }; + + return ( +
+ {/* 筛选器 */}
+
+
+
+
+
+
+
+
+
+ {filteredProducts.map((product) => {
+ const fullInfo = `${product.品牌?.name || '无'} ${product.名称}\n售价: ¥${
+ product.售价
+ }\n供应商: ${product.供应商?.联系方式?.联系人 || '无'}`;
+
+ return (
+ handleDelete(product._id)}
+ okText="是"
+ cancelText="否"
+ placement="left"
+ >
+ }
+ danger
+ size="small"
+ >
+ 删除
+
+ ,
+ ]}
+ >
+ {fullInfo}}
+ placement="top"
+ >
+
+ {product.品牌?.name || '无'} {product.名称}
+
+ }
+ description={
+
+
+
+
+ }
+ />
+
+
+
+ );
+ })}
+
+ {isModalVisible && (
+ + 售价: ¥{product.售价} +
+ ++ 供应商: {product.供应商?.联系方式?.联系人 || '无'} +
+ +
+
+ {type === '换货' ? {product.名称}}
+ description={
+
+ ¥{(product as any).价格?.售价 || '未知'}
+
+ }
+ style={{ textAlign: 'center' }}
+ />
+
+ ))}
+
+ ) : (
+
+ {selectedProducts.map(product => (
+
+
+ }
+ actions={[
+ }
+ key="remove"
+ onClick={() => {
+ setSelectedProducts(prev => prev.filter(p => p._id !== product._id));
+ }}
+ size="small"
+ />
+ ]}
+ >
+
+ {/* 第一行：导购 */}
+
+ );
+ },
+ },
+ {
+ title: "客户信息",
+ width: 60,
+ align: "center",
+ key: "客户信息",
+ render: (record: any) => {
+ const address = buildCustomerAddress(record.客户?.地址);
+ const customerName = record.客户?.姓名 ?? "未知";
+ const transactionDate = record.成交日期 ? new Date(record.成交日期) : new Date();
+ const addFansDate = record.客户?.加粉日期 ? new Date(record.客户.加粉日期) : null;
+ const diffDays = calculateDaysDiff(transactionDate, addFansDate);
+ const unreceivedAmount = parseFloat((record.待收款 || 0).toFixed(2));
+ const customerTagColor = getCustomerTagColor(unreceivedAmount);
+
+ // 准备复制文本
+ const customerCopyText = `姓名：${record.客户?.姓名 ?? "未知"}\n电话：${record.客户?.电话 ?? "未知"}\n地址：${address}`;
+
+ return (
+
+
+
+ {/* 第三行：成交日期 */}
+
+ {/* 左侧复制按钮 */}
+
+
+
+ );
+ },
+ },
+ //备注
+ {
+ title: "备注",
+ key: "备注",
+ dataIndex: "备注",
+ width: 260,
+ render: (text: string, record: any) => {
+ // 获取产品列表
+ const products = record.产品 || [];
+ const fetchBase64ImageAsBlob = async (
+ productId: string
+ ): Promise
+ {isAdmin && (
+ message.success(`客户 ${customerName} 信息复制成功！`),
+ tooltips: ['复制客户信息', '复制成功'],
+ icon:
+ )}
+
+
+ {/* 右侧标签信息，每行一个标签 */}
+
+
+ 成交周期：{diffDays}天
+
+
+
+
+
+
+ );
+ },
+ },
+ //使用
+
+ {
+ try {
+ if (products.length > 0) {
+ try {
+ // 尝试复制第一款产品的图片
+ const productId = products[0]._id;
+ const blob = await fetchBase64ImageAsBlob(productId);
+
+ const clipboardItems: Record = {
+ "text/plain": new Blob([combinedText], { type: "text/plain" }),
+ };
+ clipboardItems[blob.type] = blob;
+
+ const clipboardItem = new ClipboardItem(clipboardItems);
+ await navigator.clipboard.write([clipboardItem]);
+ message.success("客户信息、所有产品名称、备注和图片已复制");
+ } catch (imageError) {
+ // 图片复制失败，降级到文本复制
+ console.error("图片复制失败，仅复制文本信息:", imageError);
+ await navigator.clipboard.writeText(combinedText);
+ message.success("客户信息、所有产品名称和备注已复制");
+ }
+ } else {
+ // 没有产品时只复制文本
+ await navigator.clipboard.writeText(combinedText);
+ message.success("客户信息、备注已复制");
+ }
+ } catch (err) {
+ console.error("复制失败:", err);
+ message.error("复制信息失败");
+ }
+ }}
+ >
+
+
+
+
+ {/* 备注内容 */}
+
+ {text || "无备注"}
+
+
+
+ ),
+ },
+ {
+ title: "财务信息",
+ key: "financialInfo",
+ width: 180, // 适当调整宽度
+ render: (record: any) => {
+ const paymentPlatform = record.收款平台?.名称 ?? "未知";
+ const receivedAmount = record.收款金额
+ ? record.收款金额.toFixed(2)
+ : "0.00";
+ const paymentStatus = record.收款状态 ?? "未知";
+ const receivableAmount = record.应收金额
+ ? record.应收金额.toFixed(2)
+ : "0.00";
+ const unreceivedAmount = record.待收款
+ ? record.待收款.toFixed(2)
+ : "0.00";
+ const receivedPendingAmount = record.待收已收
+ ? record.待收已收.toFixed(2)
+ : "0.00"; // 待收已收字段
+
+ return (
+
+
+ );
+ },
+ },
+ ];
+
+ // 如果用户不是财务角色，添加操作列
+ if (isNotFinanceRole) {
+ baseColumns.push({
+ title: "操作",
+ key: "action",
+ align: "center",
+ fixed: "right",
+ width: 160,
+ render: (_: any, record: ISalesRecord) => (
+
+ {paymentPlatform}
+
+ 应收: ¥{receivableAmount}
+
+
+
+ {paymentStatus}
+
+ 收款: ¥{receivedAmount}
+
+
+
+ 余额抵用:
+
+ ¥{record.余额抵用?.金额 ?? 0}
+
+
+
+ 优惠券:
+
+
+
+ {record.优惠券?.map((coupon: ICoupon) => (
+
+ 类型：{coupon._id.优惠券类型}
+
+ 金额：{coupon._id.金额} +
+ 折扣：{coupon._id.折扣} + + } + > +
+ {coupon._id.优惠券类型}
+
+
+ ))}
+
+ + 金额：{coupon._id.金额} +
+ 折扣：{coupon._id.折扣} + + } + > +
+
+ 0
+ ? "#ff4d4f"
+ : "inherit", // 只有大于0时才显示红色
+ }}
+ >
+ 待收：¥{unreceivedAmount}
+
+
+
+
+ 已收:
+
+ ¥{receivedPendingAmount}
+
+
+
+
+ ),
+ });
+ }
+
+ return baseColumns;
+ }, [isNotFinanceRole, isAdmin, userInfo]);
+
+ return (
+ // 外层容器 - 占据全部可用空间
+
+ {AFTER_SALES_TYPES.map((type) => (
+
+
+
+ ))}
+
+
+
+
+
+
+ `共 ${total} 条记录`,
+ size: 'small'
+ }}
+ size="small"
+ loading={loading}
+ columns={columns}
+ dataSource={salesRecords}
+ rowKey="_id"
+ // 添加行渲染优化
+ rowClassName={(_, index) => (index % 2 === 0 ? 'even-row' : 'odd-row')}
+ // 表格样式 - 确保占满容器
+ style={{
+ height: '100%',
+ width: '100%'
+ }}
+ />
+