From 2e09f12ad84dc3c0533c8e4578df64ac939bab37 Mon Sep 17 00:00:00 2001
From: zlwu <704541015@qq.com>
Date: Sun, 17 Aug 2025 20:25:21 +0800
Subject: [PATCH] =?UTF-8?q?=E6=8F=90=E4=BA=A4=E4=BB=A3=E7=A0=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../impl/XgDormHygieneCheckServiceImpl.java   |   66 +-
 mobile/src/pages/xgss/wsjc/wsjcAdd.vue        | 1675 +++++++++++++++--
 2 files changed, 1571 insertions(+), 170 deletions(-)

diff --git a/backend/ruoyi-modules/ruoyi-xg/src/main/java/org/dromara/xg/service/impl/XgDormHygieneCheckServiceImpl.java b/backend/ruoyi-modules/ruoyi-xg/src/main/java/org/dromara/xg/service/impl/XgDormHygieneCheckServiceImpl.java
index 15c252c6..53d890c2 100644
--- a/backend/ruoyi-modules/ruoyi-xg/src/main/java/org/dromara/xg/service/impl/XgDormHygieneCheckServiceImpl.java
+++ b/backend/ruoyi-modules/ruoyi-xg/src/main/java/org/dromara/xg/service/impl/XgDormHygieneCheckServiceImpl.java
@@ -22,6 +22,7 @@ import org.dromara.xg.mapper.XgDormHygieneCheckMapper;
 import org.dromara.xg.mapper.XgDormHygieneStudentScoreMapper;
 import org.dromara.xg.service.IXgDormHygieneCheckService;
 import org.dromara.xg.service.IXgStudentMsgService;
+import org.dromara.system.service.ISysDictDataService;
 
 import java.util.List;
 import java.util.Map;
@@ -41,6 +42,7 @@ public class XgDormHygieneCheckServiceImpl implements IXgDormHygieneCheckService
     private final XgDormHygieneCheckMapper baseMapper;
     private final XgDormHygieneStudentScoreMapper studentScoreMapper;
     private final IXgStudentMsgService xgStudentMsgService;
+    private final ISysDictDataService sysDictDataService;
 
     /**
      * 查询宿舍卫生检查
@@ -82,7 +84,8 @@ public class XgDormHygieneCheckServiceImpl implements IXgDormHygieneCheckService
     private LambdaQueryWrapper<XgDormHygieneCheck> buildQueryWrapper(XgDormHygieneCheckBo bo) {
         Map<String, Object> params = bo.getParams();
         LambdaQueryWrapper<XgDormHygieneCheck> lqw = Wrappers.lambdaQuery();
-        lqw.orderByAsc(XgDormHygieneCheck::getId);
+        // lqw.orderByAsc(XgDormHygieneCheck::getId);
+        lqw.orderByDesc(XgDormHygieneCheck::getCreateTime);
         lqw.eq(bo.getDeleted() != null, XgDormHygieneCheck::getDeleted, bo.getDeleted());
         lqw.like(StringUtils.isNotBlank(bo.getCheckTitle()), XgDormHygieneCheck::getCheckTitle, bo.getCheckTitle());
         lqw.eq(bo.getCheckDate() != null, XgDormHygieneCheck::getCheckDate, bo.getCheckDate());
@@ -372,7 +375,7 @@ public class XgDormHygieneCheckServiceImpl implements IXgDormHygieneCheckService
             exportVo.setStudentGradeText(convertStudentGradeToText(exportVo.getStudentGradeText()));
 
             // 转换是否寝室长
-            exportVo.setIsResponsiblePersonText(convertResponsiblePersonToText(exportVo.getIsResponsiblePersonText()));
+            // exportVo.setIsResponsiblePersonText(convertResponsiblePersonToText(exportVo.getIsResponsiblePersonText()));
         }
 
         return exportList;
@@ -385,12 +388,12 @@ public class XgDormHygieneCheckServiceImpl implements IXgDormHygieneCheckService
         if (StringUtils.isEmpty(checkType)) {
             return "";
         }
-        Map<String, String> typeMap = Map.of(
-                "1", "日常检查",
-                "2", "专项检查",
-                "3", "突击检查",
-                "4", "复查");
-        return typeMap.getOrDefault(checkType, checkType);
+        try {
+            return sysDictDataService.selectDictLabel("xg_dorm_hygiene_check_type", checkType);
+        } catch (Exception e) {
+            log.warn("获取字典标签失败，字典类型: xg_dorm_hygiene_check_type, 字典值: {}, 错误: {}", checkType, e.getMessage());
+            return checkType;
+        }
     }
 
     /**
@@ -400,11 +403,12 @@ public class XgDormHygieneCheckServiceImpl implements IXgDormHygieneCheckService
         if (StringUtils.isEmpty(checkLevel)) {
             return "";
         }
-        Map<String, String> levelMap = Map.of(
-                "1", "宿管员",
-                "2", "学院",
-                "3", "学校");
-        return levelMap.getOrDefault(checkLevel, checkLevel);
+        try {
+            return sysDictDataService.selectDictLabel("xg_dorm_hygiene_check_level", checkLevel);
+        } catch (Exception e) {
+            log.warn("获取字典标签失败，字典类型: xg_dorm_hygiene_check_level, 字典值: {}, 错误: {}", checkLevel, e.getMessage());
+            return checkLevel;
+        }
     }
 
     /**
@@ -414,12 +418,12 @@ public class XgDormHygieneCheckServiceImpl implements IXgDormHygieneCheckService
         if (StringUtils.isEmpty(hygieneGrade)) {
             return "";
         }
-        Map<String, String> gradeMap = Map.of(
-                "A", "优秀",
-                "B", "良好",
-                "C", "合格",
-                "D", "不合格");
-        return gradeMap.getOrDefault(hygieneGrade, hygieneGrade);
+        try {
+            return sysDictDataService.selectDictLabel("xg_dorm_hygiene_grade", hygieneGrade);
+        } catch (Exception e) {
+            log.warn("获取字典标签失败，字典类型: xg_dorm_hygiene_grade, 字典值: {}, 错误: {}", hygieneGrade, e.getMessage());
+            return hygieneGrade;
+        }
     }
 
     /**
@@ -429,12 +433,12 @@ public class XgDormHygieneCheckServiceImpl implements IXgDormHygieneCheckService
         if (StringUtils.isEmpty(attendanceStatus)) {
             return "";
         }
-        Map<String, String> statusMap = Map.of(
-                "1", "在寝",
-                "2", "外出",
-                "3", "请假",
-                "4", "其他");
-        return statusMap.getOrDefault(attendanceStatus, attendanceStatus);
+        try {
+            return sysDictDataService.selectDictLabel("xg_student_attendance_status", attendanceStatus);
+        } catch (Exception e) {
+            log.warn("获取字典标签失败，字典类型: xg_student_attendance_status, 字典值: {}, 错误: {}", attendanceStatus, e.getMessage());
+            return attendanceStatus;
+        }
     }
 
     /**
@@ -444,12 +448,12 @@ public class XgDormHygieneCheckServiceImpl implements IXgDormHygieneCheckService
         if (StringUtils.isEmpty(studentGrade)) {
             return "";
         }
-        Map<String, String> gradeMap = Map.of(
-                "A", "优秀",
-                "B", "良好",
-                "C", "合格",
-                "D", "不合格");
-        return gradeMap.getOrDefault(studentGrade, studentGrade);
+        try {
+            return sysDictDataService.selectDictLabel("xg_dorm_hygiene_grade", studentGrade);
+        } catch (Exception e) {
+            log.warn("获取字典标签失败，字典类型: xg_dorm_hygiene_grade, 字典值: {}, 错误: {}", studentGrade, e.getMessage());
+            return studentGrade;
+        }
     }
 
     /**
diff --git a/mobile/src/pages/xgss/wsjc/wsjcAdd.vue b/mobile/src/pages/xgss/wsjc/wsjcAdd.vue
index 7f99d2a8..7741dcfa 100644
--- a/mobile/src/pages/xgss/wsjc/wsjcAdd.vue
+++ b/mobile/src/pages/xgss/wsjc/wsjcAdd.vue
@@ -416,6 +416,25 @@
                             </view>
                         </view>
 
+                        <!-- 微信图片上传进度条 -->
+                        <view
+                            v-if="uploadProgress > 0 && uploadProgress < 100"
+                            class="upload-progress"
+                        >
+                            <u-line-progress
+                                :percent="uploadProgress"
+                                :show-percent="true"
+                                active-color="#2979ff"
+                                inactive-color="#f0f0f0"
+                                height="8"
+                                :striped="true"
+                                :striped-active="true"
+                            ></u-line-progress>
+                            <text class="progress-text">
+                                微信图片上传进度: {{ uploadProgress }}%
+                            </text>
+                        </view>
+
                         <!-- 自定义文件列表（用于显示非图片文件和上传状态） -->
                         <view class="custom-file-list" v-if="nonImageFiles.length > 0">
                             <view class="file-title">文档附件</view>
@@ -547,6 +566,9 @@
                                 • 支持格式：JPG、PNG等 • 单个文件不超过10MB • 最多上传15个文件
                             </text>
                             <text class="tip-item">• 图片文件将以图片形式展示，支持预览和下载</text>
+                            <text v-if="isWechatBrowser" class="tip-item wechat-tip">
+                                • 在微信中使用可获得更好的图片选择体验
+                            </text>
                         </view>
                     </view>
                 </view>
@@ -601,8 +623,10 @@
 </template>
 
 <script>
-import { request, smartUploadFile } from '@/common/request.js';
+import { request, smartUploadFile, isWeChat } from '@/common/request.js';
 import { getDict, getDictLabel } from '@/common/dict.js';
+import weChatSDK from '@/utils/wechat.js';
+import { downloadFile } from '@/common/request.js';
 
 export default {
     name: 'DormHygieneCheckAdd',
@@ -696,6 +720,16 @@ export default {
 
             // 附件数据
             attachmentList: [], // 用于存储所有附件的原始数据
+
+            // 微信SDK相关
+            wechatSDK: weChatSDK,
+            isWechatBrowser: false,
+            wechatInitializing: false,
+            wechatImageLoading: false,
+
+            // 微信图片相关
+            selectedWechatImages: [],
+            uploadProgress: 0, // 上传进度
         };
     },
 
@@ -829,10 +863,141 @@ export default {
         this.pageType = options.type || 'add';
         this.checkId = options.id;
 
+        // 初始化微信环境检查并自动初始化SDK
+        await this.checkWechatEnvironment();
+
         await this.initPage();
     },
+    onUnload() {
+        // 清理blob URL，防止内存泄漏
+        this.cleanupBlobUrls();
+    },
 
     methods: {
+        // === 微信SDK相关方法 ===
+
+        // 检查微信环境并自动初始化SDK
+        async checkWechatEnvironment() {
+            try {
+                // 检查是否在微信浏览器中
+                this.isWechatBrowser = this.wechatSDK.isWeChatBrowser();
+
+                if (this.isWechatBrowser) {
+                    // 在微信环境中，自动初始化SDK
+                    await this.initWechatSDK();
+                }
+            } catch (error) {
+                console.error('微信环境检查失败:', error);
+            }
+        },
+
+        // 初始化微信SDK
+        async initWechatSDK() {
+            if (this.wechatInitializing) {
+                return;
+            }
+
+            this.wechatInitializing = true;
+
+            try {
+                // 使用微信SDK工具类进行初始化
+                await this.wechatSDK.init({
+                    debug: process.env.NODE_ENV === 'development',
+                    jsApiList: ['chooseImage', 'previewImage', 'getLocation', 'openLocation'],
+                });
+
+                // 检查关键API支持情况
+                try {
+                    const apiCheckResult = await this.wechatSDK.checkJsApi([
+                        'chooseImage',
+                        'getLocation',
+                    ]);
+                } catch (apiError) {
+                    console.warn('API支持检查失败:', apiError.message);
+                }
+            } catch (error) {
+                console.error('微信SDK初始化失败:', error);
+            } finally {
+                this.wechatInitializing = false;
+            }
+        },
+
+        // 重新初始化微信SDK
+        async reinitWechatSDK() {
+            this.wechatSDK.isInitialized = false;
+            await this.initWechatSDK();
+        },
+
+        // 上传微信图片到OSS（参考stuMsgDialog.vue的实现）
+        async uploadWechatImageToOSS(localId) {
+            try {
+                this.uploadProgress = 10;
+
+                // 步骤1：上传到微信服务器（20%进度）
+                const wxUploadRes = await this.wechatSDK.uploadImage(localId);
+
+                if (!wxUploadRes.serverId) {
+                    throw new Error('微信服务器上传失败，未获取到serverId');
+                }
+
+                const mediaId = wxUploadRes.serverId;
+                this.uploadProgress = 30;
+
+                // 步骤2：保存到OSS（80%进度）
+                this.uploadProgress = 50;
+
+                const ossResponse = await request({
+                    url: '/system/wechat/downloadToOss',
+                    method: 'GET',
+                    params: {
+                        mediaId: mediaId,
+                    },
+                    timeout: 30000, // 30秒超时
+                });
+
+                if (ossResponse.code === 200) {
+                    const ossResult = ossResponse.data;
+                    this.uploadProgress = 90;
+
+                    this.uploadProgress = 100;
+                    return {
+                        ossId: ossResult.ossId,
+                        url: ossResult.url,
+                        fileName: ossResult.fileName,
+                        fileSize: ossResult.fileSize || 0,
+                    };
+                } else {
+                    throw new Error(ossResponse.msg || '保存图片到云端存储失败');
+                }
+            } catch (error) {
+                console.error('上传微信图片失败:', error);
+
+                // 上传失败时重置进度
+                this.uploadProgress = 0;
+
+                // 显示详细错误信息
+                let errorMsg = '图片上传失败，请重试';
+                if (error.message.includes('timeout')) {
+                    errorMsg = '上传超时，请检查网络连接后重试';
+                } else if (
+                    error.message.includes('mediaId') ||
+                    error.message.includes('serverId')
+                ) {
+                    errorMsg = '微信服务器上传失败，请重试';
+                } else if (error.message.includes('OSS')) {
+                    errorMsg = '保存到云端存储失败，请重试';
+                }
+
+                uni.showToast({
+                    title: errorMsg,
+                    icon: 'none',
+                    duration: 2000,
+                });
+
+                throw error;
+            }
+        },
+
         // 初始化页面
         async initPage() {
             this.pageLoading = true;
@@ -940,6 +1105,14 @@ export default {
                     await this.loadRoomStudents();
                     // 加载附件数据
                     await this.loadAttachmentData();
+                    // 为图片文件获取blob数据以确保正确显示
+                    await this.processImageFiles();
+
+                    // 强制刷新组件显示
+                    this.$nextTick(() => {
+                        // 预加载图片以确保能正确显示
+                        this.preloadImages();
+                    });
                 }
             } catch (error) {
                 console.error('加载检查数据失败:', error);
@@ -1097,20 +1270,93 @@ export default {
                 });
 
                 if (res.code === 200 && res.data) {
-                    this.attachmentList = res.data.map((item, index) => ({
-                        uid: `existing_${index}_${Date.now()}`,
-                        name: item.originalName || `附件${index + 1}`,
-                        url: item.url,
-                        ossId: item.ossId,
-                        status: 'success',
-                        size: item.fileSize || 0,
-                    }));
+                    const attachmentFiles = res.data.map((item, index) => {
+                        // 使用fileSuffix字段判断文件类型
+                        const fileType = this.getFileTypeBySuffix(item.fileSuffix);
+                        const isImage = this.isImageFile({
+                            name: item.originalName,
+                            type: fileType,
+                        });
+
+                        // 处理图片URL - 确保有正确的API前缀
+                        let processedUrl = item.url;
+                        if (isImage && item.url && item.url.startsWith('/resource/')) {
+                            // 图片文件需要添加/api前缀
+                            processedUrl = `/api${item.url}`;
+                        }
+
+                        // 构造完整的文件名（包含扩展名）
+                        let fullFileName = item.originalName || `附件${index + 1}`;
+                        if (
+                            item.fileSuffix &&
+                            !fullFileName
+                                .toLowerCase()
+                                .endsWith(`.${item.fileSuffix.toLowerCase()}`)
+                        ) {
+                            fullFileName = `${fullFileName}.${item.fileSuffix}`;
+                        }
+
+                        const fileObj = {
+                            uid: `existing_${index}_${Date.now()}`,
+                            name: fullFileName,
+                            url: processedUrl,
+                            ossId: item.ossId,
+                            status: 'success',
+                            type: fileType,
+                            // 确保图片文件有正确的显示属性
+                            size: item.fileSize || 0,
+                            // 为uview2 upload组件添加必要的属性
+                            file: {
+                                name: fullFileName,
+                                type: fileType,
+                                size: item.fileSize || 0,
+                                path: processedUrl,
+                                url: processedUrl,
+                            },
+                        };
+
+                        return fileObj;
+                    });
+
+                    this.attachmentList = attachmentFiles;
                 }
             } catch (error) {
                 console.error('加载附件数据失败:', error);
             }
         },
 
+        // 根据文件后缀获取文件类型（新增方法）
+        getFileTypeBySuffix(fileSuffix) {
+            if (!fileSuffix) return '';
+
+            // 移除点号，转换为小写
+            const ext = fileSuffix.replace('.', '').toLowerCase();
+
+            // 图片类型判断
+            const imageTypes = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp'];
+            if (imageTypes.includes(ext)) {
+                // 修正MIME类型映射
+                const mimeTypeMap = {
+                    jpg: 'image/jpeg',
+                    jpeg: 'image/jpeg',
+                    png: 'image/png',
+                    gif: 'image/gif',
+                    bmp: 'image/bmp',
+                    webp: 'image/webp',
+                };
+                return mimeTypeMap[ext] || `image/${ext}`;
+            }
+
+            // 文档类型判断
+            const documentTypes = ['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'txt'];
+            if (documentTypes.includes(ext)) {
+                return `file/${ext}`;
+            }
+
+            // 其他类型
+            return `file/${ext}`;
+        },
+
         // 时间选择确认
         handleDateConfirm(e) {
             this.checkDateValue = e.value;
@@ -1323,170 +1569,861 @@ export default {
 
         // 选择图片
         handleImageClick(image, index, event) {
-            // 阻止 u-picker 的点击事件冒泡
-            event.stopPropagation();
-            if (image.status === 'success') {
-                uni.previewImage({
-                    current: index,
-                    urls: this.imageFiles.map((item) => item.url),
+            // 检查点击目标是否是操作按钮区域
+            const target = event.target;
+            const isActionButton =
+                target.closest('.image-actions') ||
+                target.closest('u-button') ||
+                target.tagName === 'BUTTON';
+        },
+
+        // 统一附件上传方法（支持图片和文档）
+        handleDocUpload() {
+            console.log('=== 统一附件上传方法 ===');
+
+            // 检查文件数量限制
+            if (this.attachmentList.length >= 15) {
+                uni.showToast({
+                    title: '最多只能上传15个文件',
+                    icon: 'none',
                 });
+                return;
+            }
+
+            // 显示选择文件类型的操作菜单
+            uni.showActionSheet({
+                itemList: ['选择图片'],
+                success: (res) => {
+                    switch (res.tapIndex) {
+                        case 0:
+                            this.chooseDocuments();
+                            break;
+                    }
+                },
+                fail: () => {
+                    console.log('用户取消选择');
+                },
+            });
+        },
+
+        // 选择文档文件
+        chooseDocuments() {
+            // 使用uni.chooseFile选择文档
+            if (typeof uni.chooseFile === 'function') {
+                uni.chooseFile({
+                    count: Math.min(5, 15 - this.attachmentList.length),
+                    success: (res) => {
+                        console.log('选择文档成功:', res);
+                        if (res.tempFiles && res.tempFiles.length > 0) {
+                            this.handleFileUpload({
+                                tempFiles: res.tempFiles,
+                            });
+                        }
+                    },
+                    fail: (err) => {
+                        console.error('选择文档失败:', err);
+                        uni.showToast({
+                            title: '选择文档失败',
+                            icon: 'none',
+                        });
+                    },
+                });
+            } else {
+                // 降级方案：跳转到备用上传方式
+                this.handleBackupUpload();
             }
         },
 
-        // 选择文档
-        handleDocUpload() {
-            uni.chooseImage({
-                count: 9,
-                sizeType: ['compressed'],
-                sourceType: ['album', 'camera'],
+        // 备用上传方法（用户可见）
+        handleBackupUpload() {
+            console.log('=== 备用上传方法 ===');
+
+            // 先检查平台支持情况
+            uni.showActionSheet({
+                itemList: ['选择图片', '选择视频', '选择文档'],
                 success: (res) => {
-                    res.tempFilePaths.forEach((path) => {
-                        this.uploadFile(path, true);
-                    });
+                    if (res.tapIndex === 0) {
+                        // 选择图片
+                        uni.chooseImage({
+                            count: 5,
+                            sizeType: ['original', 'compressed'],
+                            sourceType: ['album', 'camera'],
+                            success: (imageRes) => {
+                                console.log('选择图片成功 - 完整响应:', imageRes);
+                                console.log('tempFilePaths:', imageRes.tempFilePaths);
+                                console.log('tempFiles:', imageRes.tempFiles);
+
+                                const files = imageRes.tempFilePaths.map((path, index) => {
+                                    const fileName =
+                                        path.split('/').pop() || `image_${Date.now()}_${index}.jpg`;
+                                    const tempFile = imageRes.tempFiles?.[index];
+                                    const fileObj = {
+                                        name: fileName,
+                                        path: path,
+                                        url: path,
+                                        tempFilePath: path,
+                                        size: tempFile?.size || 0,
+                                        type: tempFile?.type || 'image/jpeg',
+                                    };
+                                    console.log(`创建图片文件对象 ${index}:`, fileObj);
+                                    console.log(`对应的tempFile:`, tempFile);
+                                    return fileObj;
+                                });
+
+                                // 检查文件大小
+                                const validFiles = files.filter((file) => {
+                                    if (!this.checkFileSize(file)) {
+                                        return false;
+                                    }
+                                    return true;
+                                });
+
+                                if (validFiles.length > 0) {
+                                    this.handleFileUpload({ tempFiles: validFiles });
+                                } else {
+                                    console.log('所有文件都超过大小限制，取消上传');
+                                }
+                            },
+                            fail: (err) => {
+                                console.error('选择图片失败:', err);
+                                uni.showToast({
+                                    title: '选择图片失败',
+                                    icon: 'none',
+                                });
+                            },
+                        });
+                    } else if (res.tapIndex === 1) {
+                        // 选择视频
+                        uni.chooseVideo({
+                            sourceType: ['album', 'camera'],
+                            maxDuration: 60,
+                            success: (videoRes) => {
+                                console.log('选择视频成功:', videoRes);
+                                const file = {
+                                    name: `video_${Date.now()}.mp4`,
+                                    path: videoRes.tempFilePath,
+                                    url: videoRes.tempFilePath,
+                                    tempFilePath: videoRes.tempFilePath,
+                                    size: videoRes.size || 0,
+                                    type: 'video/mp4',
+                                };
+
+                                // 检查文件大小
+                                if (this.checkFileSize(file)) {
+                                    this.handleFileUpload({ tempFiles: [file] });
+                                }
+                            },
+                            fail: (err) => {
+                                console.error('选择视频失败:', err);
+                                uni.showToast({
+                                    title: '选择视频失败',
+                                    icon: 'none',
+                                });
+                            },
+                        });
+                    } else if (res.tapIndex === 2) {
+                        // 选择文档
+                        this.handleDocUpload();
+                    }
                 },
             });
         },
 
         // 文件上传
-        async uploadFile(fileOrPath, isImage) {
-            const formData = {
-                bizType: 'dorm_hygiene_check_attachment',
-            };
+        handleFileUpload(event) {
+            console.log('文件上传事件触发:', event);
 
+            // 显示用户提示
+            uni.showToast({
+                title: '文件选择成功，开始上传...',
+                icon: 'loading',
+                duration: 2000,
+            });
+
+            // 兼容不同的事件格式
+            let files = [];
+
+            // uview2 upload组件的after-read事件格式
+            if (event.file) {
+                files = Array.isArray(event.file) ? event.file : [event.file];
+                console.log('✅ uview2 upload格式解析结果:', files);
+            }
+            // 直接传递的tempFiles格式（文档上传等）
+            else if (event.tempFiles) {
+                files = event.tempFiles;
+                console.log('✅ tempFiles格式解析结果:', files);
+            }
+            // tempFilePaths格式（兼容旧版本）
+            else if (event.tempFilePaths) {
+                files = event.tempFilePaths.map((path, index) => ({
+                    url: path,
+                    path: path,
+                    tempFilePath: path,
+                    name: `文件${index + 1}`,
+                    type: '',
+                }));
+                console.log('✅ tempFilePaths格式解析结果:', files);
+            }
+            // 单文件格式处理
+            else if (event.url || event.path || event.tempFilePath) {
+                files = [event];
+                console.log('✅ 单文件格式解析结果:', files);
+            }
+
+            console.log('📋 最终解析得到的文件列表:', files);
+
+            if (files.length === 0) {
+                console.error('❌ 没有获取到文件数据');
+                console.error('可能的原因：');
+                console.error('1. u-upload组件事件参数结构发生变化');
+                console.error('2. 选择文件时发生错误');
+                console.error('3. 事件触发异常');
+
+                uni.showToast({
+                    title: '未获取到文件，请重试',
+                    icon: 'none',
+                });
+                return;
+            }
+
+            // 检查文件数量限制
+            if (this.attachmentList.length + files.length > 15) {
+                console.warn('⚠️ 文件数量超过限制');
+                uni.showToast({
+                    title: '最多只能上传15个文件',
+                    icon: 'none',
+                });
+                return;
+            }
+
+            // 检查文件大小限制
+            const validFiles = files.filter((file) => {
+                const isValid = this.checkFileSize(file);
+                console.log(
+                    `文件大小检查 - ${file.name || '未知文件'}:`,
+                    isValid ? '✅ 通过' : '❌ 超限',
+                );
+                return isValid;
+            });
+
+            if (validFiles.length === 0) {
+                console.log('❌ 所有文件都超过大小限制，取消上传');
+                return;
+            }
+
+            if (validFiles.length < files.length) {
+                const filteredCount = files.length - validFiles.length;
+                console.log(`⚠️ 已过滤 ${filteredCount} 个超限文件`);
+                uni.showToast({
+                    title: `已过滤 ${filteredCount} 个超限文件`,
+                    icon: 'none',
+                    duration: 2000,
+                });
+            }
+
+            // 处理有效文件
+            const newFiles = validFiles.map((file, index) => {
+                console.log(`🔍 处理文件 ${index + 1}:`, file);
+                console.log(`🔍 文件对象属性:`, Object.keys(file));
+
+                // uview2 upload组件返回的文件通常有url属性作为临时路径
+                const filePath = file.url || file.tempFilePath || file.path;
+                console.log(`📂 文件路径:`, filePath);
+
+                if (!filePath) {
+                    console.error(`❌ 文件 ${index + 1} 缺少有效路径`);
+                }
+
+                const fileName =
+                    file.name || filePath?.split('/').pop() || `图片${Date.now()}_${index}.jpg`;
+                console.log(`🏷️ 文件名:`, fileName);
+
+                const processedFile = {
+                    ...file,
+                    uid: `upload_${Date.now()}_${index}`,
+                    name: fileName,
+                    url: filePath,
+                    path: filePath, // 确保path属性存在
+                    tempFilePath: filePath, // 确保tempFilePath属性存在
+                    status: 'uploading',
+                    ossId: null,
+                    type: file.type || this.getFileTypeByName(fileName),
+                };
+
+                console.log(`✅ 文件 ${index + 1} 处理完成:`, processedFile);
+                return processedFile;
+            });
+
+            console.log('📊 处理后的新文件数量:', newFiles.length);
+            console.log('📊 处理后的新文件列表:', newFiles);
+
+            // 添加到附件列表
+            console.log('📋 当前attachmentList长度:', this.attachmentList.length);
+            this.attachmentList.push(...newFiles);
+            console.log('📋 添加后attachmentList长度:', this.attachmentList.length);
+
+            // 显示上传提示
+            uni.showToast({
+                title: `开始上传 ${newFiles.length} 个文件`,
+                icon: 'loading',
+                duration: 1500,
+            });
+
+            // 🚀 关键步骤：上传文件到服务器
+            console.log('🚀 开始逐个上传文件到服务器...');
+            newFiles.forEach((file, index) => {
+                console.log(`🚀 准备上传第 ${index + 1} 个文件: ${file.name}`);
+                console.log(`🚀 文件路径: ${file.path || file.url}`);
+
+                // 立即调用上传方法
+                this.uploadFileToServer(file)
+                    .then(() => {
+                        console.log(`✅ 文件 ${file.name} 上传完成`);
+                    })
+                    .catch((error) => {
+                        console.error(`❌ 文件 ${file.name} 上传失败:`, error);
+                    });
+            });
+        },
+
+        // 检查文件大小是否超过限制
+        checkFileSize(file) {
+            const maxSize = 10 * 1024 * 1024; // 10MB
+            const fileSize = file.size || 0;
+
+            console.log('=== 检查文件大小 ===');
+            console.log('文件大小:', fileSize, '字节');
+            console.log('最大限制:', maxSize, '字节');
+            console.log('是否超过限制:', fileSize > maxSize);
+
+            if (fileSize > maxSize) {
+                const fileSizeMB = (fileSize / (1024 * 1024)).toFixed(2);
+                uni.showToast({
+                    title: `文件大小 ${fileSizeMB}MB，超过10MB限制`,
+                    icon: 'none',
+                    duration: 3000,
+                });
+                return false;
+            }
+            return true;
+        },
+
+        // 上传文件到服务器
+        async uploadFileToServer(file) {
             try {
-                uni.showLoading({ title: '上传中...' });
+                console.log('🚀 === 开始上传文件到服务器 ===');
+                console.log('📁 待上传文件对象:', file);
+                console.log('📁 文件对象属性:', Object.keys(file));
 
-                const res = await smartUploadFile('/resource/oss/upload', fileOrPath, formData);
+                // 更新文件状态
+                file.status = 'uploading';
 
-                if (res.code === 200) {
-                    const fileData = {
-                        url: res.data.url,
-                        ossId: res.data.ossId,
-                        name: res.data.originalName || '未知文件',
-                        status: 'success', // 上传成功
-                        uid: res.data.ossId, // 使用ossId作为uid
-                    };
+                // 确定正确的文件路径 - uview2通常使用url属性
+                const filePath = file.url || file.tempFilePath || file.path;
+                console.log('🎯 文件路径优先级选择:', {
+                    url: file.url,
+                    tempFilePath: file.tempFilePath,
+                    path: file.path,
+                    selected: filePath,
+                });
 
-                    this.attachmentList.push(fileData); // 添加到总列表
+                if (!filePath) {
+                    const error = new Error('文件路径不存在');
+                    console.error('❌ 上传失败 - 文件路径为空:', file);
+                    file.status = 'error';
+                    throw error;
+                }
+
+                // 验证文件路径格式
+                console.log('🔍 验证文件路径格式:', filePath);
+                if (
+                    !filePath.startsWith('http') &&
+                    !filePath.startsWith('/') &&
+                    !filePath.startsWith('wxfile://') &&
+                    !filePath.startsWith('file://') &&
+                    !filePath.startsWith('blob:')
+                ) {
+                    console.warn('⚠️ 文件路径格式可能不正确:', filePath);
+                } else {
+                    console.log('✅ 文件路径格式验证通过');
+                }
+
+                // 显示上传进度
+                uni.showLoading({
+                    title: `上传${file.name}...`,
+                    mask: true,
+                });
+                console.log(`💫 开始上传文件: ${file.name}`);
+
+                // 调用智能上传API（自动适配微信环境）
+                console.log('📡 调用智能上传API...');
+                console.log('📡 API参数:', {
+                    url: '/resource/oss/upload',
+                    file: file,
+                    formData: { bizType: 'dorm_hygiene_check_attachment' },
+                    环境检测: {
+                        isWeChat: isWeChat(),
+                        hasBlob: !!file._blob,
+                        isBlobUrl: filePath.startsWith('blob:'),
+                    },
+                });
+
+                // 🚀 使用智能上传方法，自动处理微信环境兼容性问题
+                const response = await smartUploadFile('/resource/oss/upload', file, {
+                    bizType: 'dorm_hygiene_check_attachment',
+                });
+
+                console.log('📡 上传API响应:', response);
+                uni.hideLoading();
+
+                if (response && response.code === 200) {
+                    // 上传成功
+                    file.url = response.data.url;
+                    file.ossId = response.data.ossId;
+                    file.status = 'success';
+
+                    console.log('✅ 文件上传成功:', {
+                        fileName: file.name,
+                        ossId: file.ossId,
+                        url: file.url,
+                    });
 
                     uni.showToast({
                         title: '上传成功',
                         icon: 'success',
+                        duration: 1500,
                     });
+
+                    return response;
                 } else {
-                    throw new Error(res.msg || '上传失败');
+                    // 上传失败
+                    file.status = 'error';
+                    const errorMsg = response?.msg || '上传失败';
+                    console.error('❌ 上传失败 - API返回错误:', {
+                        response: response,
+                        fileName: file.name,
+                        errorMsg: errorMsg,
+                    });
+
+                    uni.showToast({
+                        title: errorMsg,
+                        icon: 'none',
+                        duration: 3000,
+                    });
+
+                    throw new Error(errorMsg);
                 }
             } catch (error) {
-                console.error('文件上传失败:', error);
-                uni.showToast({
-                    title: error.message || '上传失败',
-                    icon: 'none',
+                console.error('❌ uploadFileToServer执行失败:', error);
+                console.error('❌ 错误详情:', {
+                    fileName: file.name,
+                    filePath: file.url || file.tempFilePath || file.path,
+                    errorMessage: error.message,
+                    errorStack: error.stack,
                 });
-            } finally {
+
                 uni.hideLoading();
-            }
-        },
+                file.status = 'error';
 
-        // 预览图片
-        handleImageDownload(image) {
-            if (image.status === 'success') {
-                uni.previewImage({
-                    current: this.imageFiles.findIndex((item) => item.ossId === image.ossId),
-                    urls: this.imageFiles.map((item) => item.url),
-                });
-            }
-        },
+                // 更详细的错误提示
+                let errorMessage = '上传失败';
+                if (error.message) {
+                    if (error.message.includes('file is not present')) {
+                        errorMessage = '文件格式不支持或文件损坏';
+                    } else if (error.message.includes('timeout')) {
+                        errorMessage = '上传超时，请检查网络连接';
+                    } else if (error.message.includes('网络')) {
+                        errorMessage = '网络连接失败，请检查网络';
+                    } else if (error.message.includes('文件路径')) {
+                        errorMessage = '文件选择异常，请重新选择';
+                    } else {
+                        errorMessage = error.message;
+                    }
+                }
 
-        // 图片下载按钮点击处理
-        handleImageDownloadClick(image, event) {
-            event.stopPropagation();
-            this.handleImageDownload(image);
-        },
+                console.error('❌ 最终错误消息:', errorMessage);
 
-        // 下载文档
-        async handleDownloadFile(file) {
-            try {
-                // H5环境下载
-                // #ifdef H5
-                const link = document.createElement('a');
-                link.href = file.url;
-                link.download = file.name;
-                link.click();
-                // #endif
-
-                // 非H5环境
-                // #ifndef H5
-                uni.downloadFile({
-                    url: file.url,
+                uni.showModal({
+                    title: '上传失败',
+                    content: `文件"${file.name}"上传失败：${errorMessage}`,
+                    showCancel: true,
+                    cancelText: '取消',
+                    confirmText: '重试',
                     success: (res) => {
-                        if (res.statusCode === 200) {
-                            uni.openDocument({
-                                filePath: res.tempFilePath,
-                                success: () => {
-                                    console.log('打开文档成功');
-                                },
-                            });
+                        if (res.confirm) {
+                            console.log('🔄 用户选择重试上传');
+                            // 重置状态并重试
+                            file.status = 'pending';
+                            this.uploadFileToServer(file);
+                        } else {
+                            console.log('🚫 用户取消重试');
+                            // 从列表中移除失败的文件
+                            const index = this.attachmentList.findIndex((f) => f.uid === file.uid);
+                            if (index > -1) {
+                                this.attachmentList.splice(index, 1);
+                                console.log('🗑️ 已从附件列表中移除失败文件');
+                            }
                         }
                     },
                 });
-                // #endif
-            } catch (error) {
-                console.error('下载文档失败:', error);
+
+                throw error;
+            }
+        },
+
+        // 图片预览
+        handleImagePreview(image, index) {
+            if (image.status !== 'success') {
                 uni.showToast({
-                    title: '下载失败',
+                    title: '图片尚未上传完成',
                     icon: 'none',
                 });
+                return;
+            }
+
+            // 获取所有成功上传的图片URL
+            const imageUrls = this.imageFiles
+                .filter((file) => file.status === 'success')
+                .map((file) => file.blobUrl || file.url);
+
+            if (imageUrls.length === 0) {
+                uni.showToast({
+                    title: '暂无可预览的图片',
+                    icon: 'none',
+                });
+                return;
+            }
+
+            // 找到当前图片在成功列表中的索引
+            const currentUrl = image.blobUrl || image.url;
+            const currentIndex = imageUrls.findIndex((url) => url === currentUrl);
+
+            uni.previewImage({
+                urls: imageUrls,
+                current: currentIndex >= 0 ? currentIndex : 0,
+                success: () => {
+                    // 预览成功
+                },
+                fail: (error) => {
+                    console.error('图片预览失败:', error);
+                    uni.showToast({
+                        title: '预览失败',
+                        icon: 'none',
+                    });
+                },
+            });
+        },
+
+        // 图片下载（带重试机制）
+        async handleImageDownload(image, event, retryCount = 0) {
+            // 事件阻止已由handleImageDownloadClick方法处理
+
+            if (image.status !== 'success') {
+                uni.showToast({
+                    title: '图片尚未上传完成',
+                    icon: 'none',
+                });
+                return;
+            }
+
+            // 显示下载进度提示
+            uni.showLoading({
+                title: '正在下载图片...',
+                mask: true,
+            });
+
+            try {
+                // 如果有ossId，通过API下载
+                if (image.ossId) {
+                    const downloadUrl = `/resource/oss/download/${image.ossId}`;
+
+                    // 调用下载接口并等待完成
+                    const response = await downloadFile(downloadUrl, image.name);
+
+                    if (response.statusCode === 200) {
+                        uni.hideLoading();
+                        uni.saveFile({
+                            tempFilePath: response.tempFilePath,
+                            success: function (res) {
+                                uni.showToast({
+                                    title: '下载成功',
+                                    icon: 'success',
+                                });
+                            },
+                            fail: function () {
+                                uni.showToast({
+                                    title: '保存失败',
+                                    icon: 'none',
+                                });
+                            },
+                        });
+                    }
+                }
+            } catch (error) {
+                console.error('图片下载过程出错:', error);
+
+                // 确保隐藏loading状态
+                uni.hideLoading();
+
+                // 重试机制（最多重试2次）
+                if (retryCount < 2) {
+                    // 显示重试提示
+                    uni.showToast({
+                        title: `下载失败，正在重试(${retryCount + 1}/2)...`,
+                        icon: 'none',
+                        duration: 1500,
+                    });
+
+                    setTimeout(() => {
+                        this.handleImageDownload(image, event, retryCount + 1);
+                    }, 1500); // 延迟1.5秒后重试
+
+                    return;
+                }
+
+                // 超过重试次数，显示最终错误信息
+                const errorMsg = error.message?.includes('网络')
+                    ? '网络连接失败，请检查网络后重试'
+                    : error.message?.includes('timeout')
+                    ? '下载超时，请重试'
+                    : '下载失败，已重试2次，请检查网络或稍后重试';
+
+                uni.showToast({
+                    title: errorMsg,
+                    icon: 'none',
+                    duration: 3000,
+                });
             }
         },
 
-        // 文件下载按钮点击处理
-        handleDownloadFileClick(file, event) {
-            event.stopPropagation();
-            this.handleDownloadFile(file);
+        // 图片点击处理（智能判断是预览还是操作按钮）
+        handleImageClick(image, index, event) {
+            // 检查点击目标是否是操作按钮区域
+            const target = event.target;
+            const isActionButton =
+                target.closest('.image-actions') ||
+                target.closest('u-button') ||
+                target.tagName === 'BUTTON';
         },
 
-        // 删除图片
-        handleImageDelete(image, index) {
+        // 删除按钮点击处理（更强的事件处理）
+        handleImageDeleteClick(image, index, event) {
+            console.log('删除按钮被点击:', image, index);
+
+            // 强制阻止事件冒泡和默认行为
+            if (event) {
+                event.stopPropagation();
+                event.preventDefault();
+                event.stopImmediatePropagation();
+            }
+
+            // 调用实际的删除方法
+            this.handleImageDelete(image, index);
+        },
+
+        // 图片下载按钮点击处理（更强的事件处理）
+        handleImageDownloadClick(image, event) {
+            // 强制阻止事件冒泡和默认行为
+            if (event) {
+                event.stopPropagation();
+                event.preventDefault();
+                event.stopImmediatePropagation();
+            }
+
+            // 调用实际的下载方法
+            this.handleImageDownload(image, event);
+        },
+
+        // 图片删除
+        handleImageDelete(image, index, event) {
+            // 强制阻止事件冒泡和默认行为
+            if (event) {
+                event.stopPropagation();
+                event.preventDefault();
+            }
+
             uni.showModal({
-                title: '提示',
-                content: '确定要删除此图片吗？',
+                title: '确认删除',
+                content: '确定要删除这张图片吗？删除后无法恢复。',
+                confirmColor: '#ff5722',
                 success: (res) => {
                     if (res.confirm) {
-                        // 从总列表中删除
-                        this.attachmentList = this.attachmentList.filter(
-                            (item) => item.ossId !== image.ossId,
+                        // 从附件列表中删除
+                        const attachmentIndex = this.attachmentList.findIndex(
+                            (file) =>
+                                file.uid === image.uid ||
+                                (file.ossId && file.ossId === image.ossId) ||
+                                (file.url && file.url === image.url),
                         );
+
+                        if (attachmentIndex >= 0) {
+                            this.attachmentList.splice(attachmentIndex, 1);
+                        }
+
+                        // 清理blob URL，防止内存泄漏
+                        if (image.blobUrl && image.blobUrl.startsWith('blob:')) {
+                            URL.revokeObjectURL(image.blobUrl);
+                        }
+
                         uni.showToast({
                             title: '删除成功',
                             icon: 'success',
                         });
                     }
                 },
+                fail: (err) => {
+                    console.error('删除确认对话框显示失败:', err);
+                },
             });
         },
 
-        // 图片删除按钮点击处理
-        handleImageDeleteClick(image, index, event) {
-            event.stopPropagation();
-            this.handleImageDelete(image, index);
+        // 文件下载（微信小程序专用版本）
+        async handleDownloadFile(file, event) {
+            // 事件阻止已由handleDownloadFileClick方法处理
+
+            if (!file.ossId) {
+                uni.showToast({
+                    title: '文件未上传完成',
+                    icon: 'none',
+                });
+                return;
+            }
+
+            try {
+                uni.showLoading({
+                    title: `正在下载${file.name}...`,
+                    mask: true,
+                });
+
+                // 构建下载URL
+                const downloadUrl = `/resource/oss/download/${file.ossId}`;
+
+                if (this.isImageFile(file)) {
+                    // 图片文件：下载并保存到相册
+                    await this.downloadAndSaveImage(downloadUrl, file.name);
+                } else {
+                    // 非图片文件：下载并直接打开预览
+                    await this.downloadAndOpenDocument(downloadUrl, file.name);
+                }
+            } catch (error) {
+                console.error('下载过程发生异常:', error);
+                uni.hideLoading();
+
+                let errorMsg = '下载失败，请重试';
+                if (error.message.includes('timeout')) {
+                    errorMsg = '下载超时，请检查网络后重试';
+                } else if (error.message.includes('network')) {
+                    errorMsg = '网络错误，请检查网络连接';
+                } else if (error.message.includes('404')) {
+                    errorMsg = '文件不存在，请联系管理员';
+                } else if (error.message.includes('500')) {
+                    errorMsg = '服务器错误，请稍后重试';
+                }
+
+                uni.showModal({
+                    title: '下载失败',
+                    content: errorMsg,
+                    showCancel: true,
+                    cancelText: '取消',
+                    confirmText: '重试',
+                    success: (res) => {
+                        if (res.confirm) {
+                            this.handleDownloadFile(file);
+                        }
+                    },
+                });
+            }
+        },
+
+        // 下载图片并保存到相册
+        async downloadAndSaveImage(downloadUrl, fileName) {
+            return new Promise(async (resolve, reject) => {
+                // 调用下载接口并等待完成
+                const response = await downloadFile(downloadUrl, fileName);
+
+                if (response.statusCode === 200) {
+                    uni.hideLoading();
+                    uni.saveFile({
+                        tempFilePath: response.tempFilePath,
+                        success: function (res) {
+                            uni.showToast({
+                                title: '下载成功',
+                                icon: 'success',
+                            });
+                        },
+                        fail: function () {
+                            uni.showToast({
+                                title: '保存失败',
+                                icon: 'none',
+                            });
+                        },
+                    });
+                }
+                uni.hideLoading();
+                resolve();
+                // #endif
+            });
+        },
+
+        // 下载文档并打开预览
+        async downloadAndOpenDocument(downloadUrl, fileName) {
+            return new Promise(async (resolve, reject) => {
+                // 调用下载接口并等待完成
+                const response = await downloadFile(downloadUrl, fileName);
+
+                if (response.statusCode === 200) {
+                    uni.hideLoading();
+                    uni.saveFile({
+                        tempFilePath: response.tempFilePath,
+                        success: function (res) {
+                            uni.showToast({
+                                title: '下载成功',
+                                icon: 'success',
+                            });
+                        },
+                        fail: function () {
+                            uni.showToast({
+                                title: '保存失败',
+                                icon: 'none',
+                            });
+                        },
+                    });
+                }
+                uni.hideLoading();
+                resolve();
+                // #endif
+            });
+        },
+
+        // 文件下载按钮点击处理（更强的事件处理）
+        handleDownloadFileClick(file, event) {
+            // 强制阻止事件冒泡和默认行为
+            if (event) {
+                event.stopPropagation();
+                event.preventDefault();
+                event.stopImmediatePropagation();
+            }
+
+            // 调用实际的下载方法
+            this.handleDownloadFile(file, event);
         },
 
         // 删除文档
         handleRemoveFile(file, index, event) {
             event.stopPropagation();
             uni.showModal({
-                title: '提示',
-                content: '确定要删除此文件吗？',
+                title: '确认删除',
+                content: '确定要删除这个文件吗？',
                 success: (res) => {
                     if (res.confirm) {
-                        // 从总列表中删除
-                        this.attachmentList = this.attachmentList.filter(
-                            (item) => item.ossId !== file.ossId,
-                        );
-                        uni.showToast({
-                            title: '删除成功',
-                            icon: 'success',
-                        });
+                        const fileIndex = this.attachmentList.findIndex((f) => f.uid === file.uid);
+                        if (fileIndex > -1) {
+                            this.attachmentList.splice(fileIndex, 1);
+                            uni.showToast({
+                                title: '文件删除成功',
+                                icon: 'success',
+                            });
+                        }
                     }
                 },
             });
@@ -1494,31 +2431,50 @@ export default {
 
         // 重试上传
         async retryUploadFile(file, event) {
-            event.stopPropagation(); // 阻止 u-picker 的点击事件冒泡
-            uni.showLoading({ title: '上传中...' });
+            console.log('=== 重试上传文件 ===', file);
+
+            // 强制阻止事件冒泡和默认行为
+            if (event) {
+                event.stopPropagation();
+                event.preventDefault();
+            }
+
+            // 重置文件状态
+            file.status = 'uploading';
+            file.progress = 0;
+
             try {
-                const res = await smartUploadFile('/resource/oss/upload', file.url, {
-                    bizType: 'dorm_hygiene_check_attachment',
-                });
-                if (res.code === 200) {
-                    file.url = res.data.url;
-                    file.ossId = res.data.ossId;
-                    file.name = res.data.originalName || '未知文件';
+                // 根据文件来源选择不同的上传方式
+                if (file.source === 'wechat' && file.localId) {
+                    // 微信图片重新上传
+                    const uploadResult = await this.uploadWechatImageToOSS(file.localId);
+
+                    // 更新文件信息
                     file.status = 'success';
-                    uni.hideLoading();
-                    uni.showToast({
-                        title: '重试成功',
-                        icon: 'success',
-                    });
+                    file.ossId = uploadResult.ossId;
+                    file.url = uploadResult.url;
+                    file.name = uploadResult.fileName || file.name;
+                    file.size = uploadResult.fileSize || 0;
+                    file.progress = 100;
                 } else {
-                    throw new Error(res.msg || '重试失败');
+                    // 普通文件重新上传
+                    await this.uploadFileToServer(file);
                 }
+
+                uni.showToast({
+                    title: '重新上传成功',
+                    icon: 'success',
+                    duration: 1500,
+                });
             } catch (error) {
                 console.error('重试上传失败:', error);
-                uni.hideLoading();
+                file.status = 'error';
+                file.progress = 0;
+
                 uni.showToast({
-                    title: error.message || '重试失败',
+                    title: '重试失败，请稍后再试',
                     icon: 'none',
+                    duration: 2000,
                 });
             }
         },
@@ -1581,8 +2537,8 @@ export default {
                 // 调用API
                 const url =
                     this.pageType === 'add'
-                        ? '/dormHygieneCheck/dormHygieneCheck'
-                        : `/dormHygieneCheck/dormHygieneCheck`;
+                        ? '/dormHygieneCheck/dormHygieneCheck/addWithStudentScores'
+                        : `/dormHygieneCheck/dormHygieneCheck/updateWithStudentScores`;
 
                 const res = await request({
                     url: url,
@@ -1625,19 +2581,167 @@ export default {
         // 获取文件名短格式
         getShortFileName(fileName) {
             if (!fileName) return '';
-            const parts = fileName.split('.');
-            if (parts.length > 1) {
-                return `${parts[0]}.${parts[parts.length - 1]}`;
+
+            const lastDotIndex = fileName.lastIndexOf('.');
+            if (lastDotIndex === -1) {
+                // 没有后缀的文件名
+                return fileName.length > 12 ? fileName.substring(0, 12) + '...' : fileName;
             }
-            return fileName;
+
+            const name = fileName.substring(0, lastDotIndex);
+            const ext = fileName.substring(lastDotIndex); // 包含点号的后缀
+
+            if (name.length <= 8) {
+                return fileName; // 文件名较短，直接返回
+            }
+
+            // 文件名较长，缩写中间部分，保留后缀
+            return name.substring(0, 8) + '...' + ext;
         },
 
         // 判断是否为图片文件
         isImageFile(file) {
-            const imageExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp'];
-            const fileName = file.name || file.originalName || '';
-            const lowerCaseName = fileName.toLowerCase();
-            return imageExtensions.some((ext) => lowerCaseName.endsWith(ext));
+            const imageTypes = ['image/jpeg', 'image/png', 'image/gif', 'image/bmp', 'image/webp'];
+
+            // 优先使用文件MIME类型判断
+            if (file.type) {
+                return imageTypes.includes(file.type);
+            }
+
+            // 通过文件名判断
+            const fileName = file.name || file.url || '';
+            return /\.(jpg|jpeg|png|gif|bmp|webp)$/i.test(fileName);
+        },
+
+        // 根据文件名获取文件类型
+        getFileTypeByName(fileName) {
+            if (!fileName) return '';
+            const ext = fileName.split('.').pop()?.toLowerCase();
+            const imageTypes = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp'];
+            if (imageTypes.includes(ext)) {
+                // 修正MIME类型映射
+                const mimeTypeMap = {
+                    jpg: 'image/jpeg',
+                    jpeg: 'image/jpeg',
+                    png: 'image/png',
+                    gif: 'image/gif',
+                    bmp: 'image/bmp',
+                    webp: 'image/webp',
+                };
+                return mimeTypeMap[ext] || `image/${ext}`;
+            }
+            return `file/${ext}`;
+        },
+
+        // 预加载图片以确保能正确显示
+        async preloadImages() {
+            console.log('=== 预加载图片 ===');
+            const imageFiles = this.attachmentList.filter((file) => this.isImageFile(file));
+
+            for (const file of imageFiles) {
+                if (file.url) {
+                    try {
+                        console.log(`预加载图片: ${file.name} - ${file.url}`);
+                        // 创建一个Image对象来预加载图片
+                        const img = new Image();
+                        img.onload = () => {
+                            console.log(`图片预加载成功: ${file.name}`);
+                        };
+                        img.onerror = () => {
+                            console.error(`图片预加载失败: ${file.name} - ${file.url}`);
+                        };
+                        img.src = file.url;
+                    } catch (error) {
+                        console.error(`预加载图片出错: ${file.name}`, error);
+                    }
+                }
+            }
+        },
+
+        // 获取图片的blob数据（用于uview2 upload组件显示）
+        async getImageBlobUrl(imageUrl) {
+            try {
+                console.log(`获取图片blob数据: ${imageUrl}`);
+
+                // 处理图片URL路径
+                let apiUrl = imageUrl;
+                if (imageUrl.startsWith('/api/')) {
+                    // 移除/api前缀，因为request会自动添加baseURL
+                    apiUrl = imageUrl.replace('/api', '');
+                } else if (imageUrl.startsWith('/resource/')) {
+                    // 直接使用相对路径
+                    apiUrl = imageUrl;
+                } else if (imageUrl.startsWith('http')) {
+                    // 完整URL，需要特殊处理
+                    console.log('检测到完整URL，直接返回原URL');
+                    return imageUrl;
+                }
+
+                console.log(`API请求URL: ${apiUrl}`);
+
+                // 使用request方法获取图片数据
+                const response = await request({
+                    url: apiUrl,
+                    method: 'GET',
+                    responseType: 'arraybuffer', // 设置响应类型为arraybuffer
+                    header: {
+                        isToken: true, // 图片请求可能不需要token验证
+                    },
+                });
+
+                // 将arraybuffer转换为blob
+                const blob = new Blob([response], { type: 'image/*' });
+                const blobUrl = URL.createObjectURL(blob);
+
+                console.log(`成功创建blob URL: ${blobUrl}`);
+                return blobUrl;
+            } catch (error) {
+                console.error(`获取图片blob数据失败: ${imageUrl}`, error);
+                // 如果请求失败，返回原始URL作为备用方案
+                return imageUrl;
+            }
+        },
+
+        // 处理图片文件，获取blob数据以确保正确显示
+        async processImageFiles() {
+            console.log('=== 处理图片文件 ===');
+            const imageFiles = this.attachmentList.filter((file) => this.isImageFile(file));
+
+            for (const file of imageFiles) {
+                if (file.url && !file.blobUrl) {
+                    try {
+                        console.log(`处理图片文件: ${file.name}`);
+                        const blobUrl = await this.getImageBlobUrl(file.url);
+                        if (blobUrl) {
+                            // 更新文件对象，添加blob URL，并标记为图片
+                            file.blobUrl = blobUrl;
+                            file.url = blobUrl; // 使用blob URL作为显示URL
+                            file.fileType = 'image';
+                            file.type =
+                                file.type && file.type.startsWith('image') ? file.type : 'image';
+                            file.isImage = true;
+                            console.log(`图片文件处理成功: ${file.name} - ${blobUrl}`);
+                        }
+                    } catch (error) {
+                        console.error(`处理图片文件失败: ${file.name}`, error);
+                    }
+                }
+            }
+        },
+
+        // 清理blob URL，防止内存泄漏
+        cleanupBlobUrls() {
+            console.log('=== 清理blob URL ===');
+            this.attachmentList.forEach((file) => {
+                if (file.blobUrl && file.blobUrl.startsWith('blob:')) {
+                    try {
+                        URL.revokeObjectURL(file.blobUrl);
+                        console.log(`已清理blob URL: ${file.name}`);
+                    } catch (error) {
+                        console.error(`清理blob URL失败: ${file.name}`, error);
+                    }
+                }
+            });
         },
     },
 };
@@ -1782,6 +2886,57 @@ export default {
     border-top: 2rpx dashed #e0e0e0;
 }
 
+// 微信上传区域样式
+.wechat-upload-section {
+    margin-bottom: 20rpx;
+    padding: 20rpx;
+    background: #f0f9ff;
+    border: 2rpx dashed #2979ff;
+    border-radius: 10rpx;
+}
+
+.upload-progress {
+    margin-top: 15rpx;
+}
+
+.progress-text {
+    font-size: 24rpx;
+    color: #666;
+    margin-top: 8rpx;
+    text-align: center;
+    display: block;
+}
+
+// 完善的上传进度条样式
+.upload-progress {
+    margin-top: 20rpx;
+    padding: 20rpx;
+    background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+    border-radius: 12rpx;
+    border: 1px solid #e1e8ed;
+    box-shadow: 0 2px 8px rgba(41, 121, 255, 0.1);
+}
+
+.progress-text {
+    display: block;
+    text-align: center;
+    font-size: 26rpx !important;
+    color: #2979ff !important;
+    font-weight: 500;
+    margin-top: 12rpx;
+    animation: pulse 2s infinite;
+}
+
+@keyframes pulse {
+    0%,
+    100% {
+        opacity: 0.8;
+    }
+    50% {
+        opacity: 1;
+    }
+}
+
 // 图片展示区域样式
 .image-section {
     margin-bottom: 30rpx;
@@ -1809,6 +2964,7 @@ export default {
     overflow: hidden;
     border: 2rpx solid #f0f0f0;
     transition: all 0.3s ease;
+    /* 确保图片容器的点击事件不影响按钮 */
     cursor: pointer;
 }
 
@@ -1891,6 +3047,7 @@ export default {
     border-top: 1rpx solid #f0f0f0;
     flex-wrap: nowrap;
     justify-content: space-between;
+    /* 确保按钮区域能正确处理点击事件 */
     position: relative;
     z-index: 10;
     pointer-events: auto;
@@ -1900,6 +3057,7 @@ export default {
     flex: 1;
     min-width: 60rpx;
     font-size: 24rpx !important;
+    /* 确保按钮可点击 */
     pointer-events: auto;
     position: relative;
     z-index: 11;
@@ -1962,6 +3120,50 @@ export default {
     background: #f8f9fa;
 }
 
+.file-info-card {
+    position: absolute;
+    bottom: 8rpx;
+    left: 8rpx;
+    right: 8rpx;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.file-ext-badge {
+    background: rgba(255, 255, 255, 0.9);
+    color: #333;
+    font-size: 22rpx;
+    font-weight: 600;
+    padding: 4rpx 8rpx;
+    border-radius: 4rpx;
+    backdrop-filter: blur(4rpx);
+}
+
+.file-size {
+    background: rgba(0, 0, 0, 0.6);
+    color: #fff;
+    font-size: 20rpx;
+    padding: 2rpx 6rpx;
+    border-radius: 4rpx;
+}
+
+.file-actions {
+    display: flex;
+    gap: 6rpx;
+    padding: 8rpx 12rpx;
+    background: #fafafa;
+    border-top: 1rpx solid #f0f0f0;
+    flex-wrap: nowrap;
+    justify-content: space-between;
+}
+
+.file-actions .u-button {
+    flex: 1;
+    min-width: 60rpx;
+    font-size: 24rpx !important;
+}
+
 .file-name-display {
     padding: 8rpx 12rpx;
     background: #fff;
@@ -1989,6 +3191,44 @@ export default {
     margin-bottom: 8rpx;
 }
 
+.wechat-tip {
+    color: #2979ff;
+    font-weight: 500;
+}
+
+/* 上传状态样式 */
+.upload-status {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    margin-top: 15rpx;
+    padding: 10rpx;
+    border-radius: 8rpx;
+    font-size: 24rpx;
+    font-weight: 500;
+}
+
+.upload-status.success {
+    color: #19be6b;
+    background-color: rgba(25, 190, 107, 0.1);
+}
+
+.upload-status.error {
+    color: #fa3534;
+    background-color: rgba(250, 53, 52, 0.1);
+}
+
+.upload-progress-small {
+    width: 100%;
+    margin-bottom: 8rpx;
+}
+
+.upload-text {
+    font-size: 22rpx;
+    color: #2979ff;
+    text-align: center;
+}
+
 // 底部操作按钮
 .bottom-actions {
     position: fixed;
@@ -2151,4 +3391,161 @@ export default {
         padding: 6rpx 12rpx;
     }
 }
+
+/* 微信SDK调试样式 */
+.wechat-debug-section {
+    background: #fff;
+    border-radius: 12rpx;
+    padding: 30rpx;
+    margin-bottom: 20rpx;
+    border: 2rpx solid #2979ff;
+}
+
+.debug-controls {
+    display: flex;
+    gap: 10rpx;
+    align-items: center;
+    margin-top: 10rpx;
+    flex-wrap: wrap;
+}
+
+.sdk-status {
+    margin: 20rpx 0;
+    padding: 15rpx;
+    background: #f8f9fa;
+    border-radius: 8rpx;
+}
+
+.status-item {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 10rpx;
+}
+
+.status-label {
+    font-size: 26rpx;
+    color: #666;
+}
+
+.status-value {
+    font-size: 26rpx;
+    font-weight: 500;
+}
+
+.status-value.success {
+    color: #52c41a;
+}
+
+.status-value.error {
+    color: #f5222d;
+}
+
+.debug-logs {
+    margin-top: 20rpx;
+    border: 2rpx solid #e8e8e8;
+    border-radius: 8rpx;
+    background: #fafafa;
+}
+
+.log-content {
+    max-height: 400rpx;
+    padding: 15rpx;
+}
+
+.log-item {
+    margin-bottom: 10rpx;
+    padding: 8rpx 12rpx;
+    border-radius: 6rpx;
+    font-size: 24rpx;
+    line-height: 1.4;
+}
+
+.log-item.info {
+    background: #e6f7ff;
+    border-left: 4rpx solid #1890ff;
+}
+
+.log-item.success {
+    background: #f6ffed;
+    border-left: 4rpx solid #52c41a;
+}
+
+.log-item.warning {
+    background: #fffbe6;
+    border-left: 4rpx solid #faad14;
+}
+
+.log-item.error {
+    background: #fff2f0;
+    border-left: 4rpx solid #f5222d;
+}
+
+.log-time {
+    color: #999;
+    font-size: 22rpx;
+    margin-right: 10rpx;
+}
+
+.log-text {
+    color: #333;
+}
+
+.log-text.info {
+    color: #1890ff;
+}
+
+.log-text.success {
+    color: #52c41a;
+}
+
+.log-text.warning {
+    color: #faad14;
+}
+
+.log-text.error {
+    color: #f5222d;
+}
+
+.log-detail {
+    margin-top: 5rpx;
+    padding: 8rpx;
+    background: rgba(0, 0, 0, 0.03);
+    border-radius: 4rpx;
+}
+
+.detail-text {
+    font-size: 20rpx;
+    color: #666;
+    font-family: monospace;
+    word-break: break-all;
+}
+
+.empty-logs {
+    text-align: center;
+    color: #999;
+    padding: 40rpx 0;
+    font-size: 26rpx;
+}
+
+/* 浮动调试按钮 */
+.debug-fab {
+    position: fixed;
+    right: 30rpx;
+    bottom: 200rpx;
+    width: 80rpx;
+    height: 80rpx;
+    background: #2979ff;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    box-shadow: 0 4rpx 12rpx rgba(41, 121, 255, 0.3);
+    z-index: 999;
+}
+
+.debug-fab:active {
+    background: #1976d2;
+    transform: scale(0.95);
+}
 </style>