更新

WXL

2026-03-19 5aa165156994b1b8a601063fa0a1107d1893ea57

 src/views/business/assess/assessInfo.vue

@@ -17,44 +17,38 @@
          assessmentData.caseNo
        }}</el-descriptions-item>
        <el-descriptions-item label="潜在捐献者姓名">{{
          assessmentData.donorName
          assessmentData.name || assessmentData.donorName
        }}</el-descriptions-item>
        <el-descriptions-item label="性别">
          <dict-tag :options="genderOptions" :value="assessmentData.gender" />
          <dict-tag
            :options="dict.type.sys_user_sex"
            :value="assessmentData.sex"
          />
        </el-descriptions-item>
        <el-descriptions-item label="年龄"
          >{{ assessmentData.age }}岁</el-descriptions-item
        >
        <el-descriptions-item label="血型">
          <dict-tag
            :options="bloodTypeOptions"
            :value="assessmentData.bloodType"
          />
          {{ assessmentData.bloodtype }}
        </el-descriptions-item>
        <el-descriptions-item label="证件号码">{{
          assessmentData.idCardNo
          assessmentData.idcardno
        }}</el-descriptions-item>
        <el-descriptions-item label="疾病诊断">{{
          assessmentData.diagnosis
          assessmentData.diagnosisname
        }}</el-descriptions-item>
        <el-descriptions-item label="所在医疗机构">{{
          assessmentData.hospitalName
          assessmentData.treatmenthospitalname
        }}</el-descriptions-item>
        <el-descriptions-item label="主治医生">{{
          assessmentData.doctorName
        <el-descriptions-item label="协调员">{{
          assessmentData.coordinatorName
        }}</el-descriptions-item>
        <el-descriptions-item label="申请评估时间">{{
          assessmentData.applyTime
        <el-descriptions-item label="评估时间">{{
          assessmentData.assessTime
        }}</el-descriptions-item>
        <el-descriptions-item label="评估类型">
          <dict-tag
            :options="assessmentTypeOptions"
            :value="assessmentData.assessmentType"
          />
        </el-descriptions-item>
        <el-descriptions-item label="评估状态">
          <el-tag :type="statusFilter(assessmentData.assessmentStatus)">
            {{ statusTextFilter(assessmentData.assessmentStatus) }}
          <el-tag :type="statusFilter(assessmentData.assessState)">
            {{ statusTextFilter(assessmentData.assessState) }}
          </el-tag>
        </el-descriptions-item>
      </el-descriptions>
@@ -69,6 +63,7 @@
          type="primary"
          size="mini"
          @click="handleCompleteAssessment"
          :loading="saveLoading"
        >
          确认完成评估
        </el-button>
@@ -77,69 +72,303 @@
        </span>
      </div>

      <!-- 捐献决定表单 -->
      <el-form>
        <el-form-item label-width="100px" label="捐献决定">
          <el-checkbox-group
            v-model="organdecisionValues"
            @change="handleOrganDecisionChange"
            :disabled="!isEdit"
          >
            <el-checkbox
              v-for="dict in dict.type.sys_Organ"
              :key="dict.value"
              :label="dict.value"
              >{{ dict.label }}
            </el-checkbox>
          </el-checkbox-group>
          <el-input
            v-if="showOtherInput"
            v-model="organdecisionOther"
            placeholder="请输入其他捐献决定的具体内容"
            style="margin-top: 10px; width: 300px;"
            :readonly="!isEdit"
            @input="handleOtherDecisionInput"
          ></el-input>
        </el-form-item>
      </el-form>

      <!-- 器官评估表格 -->
      <el-table
        :data="organAssessmentList"
        :data="filteredOrganAssessmentList"
        v-loading="assessmentLoading"
        style="width: 100%"
        :row-class-name="getRowClassName"
        :expand-row-keys="expandedRowKeys"
        @expand-change="handleExpandChange"
        row-key="organno"
        empty-text="当前捐献决定下暂无需要评估的器官"
      >
        <el-table-column type="expand">
          <template slot-scope="scope">
            <div class="organ-expand-content" v-if="scope.row.expanded">
              <el-tabs
                v-model="scope.row.activeTab"
                type="card"
                class="organ-detail-tabs"
                @tab-click="handleTabClick(scope.row, $event)"
              >
                <!-- 动态生成评估Tab -->
                <el-tab-pane
                  v-for="(assessment, index) in getOrganAssessments(scope.row)"
                  :key="`${scope.row.organno}_${index}`"
                  :label="`第${index + 1}次评估`"
                  :name="index"
                >
                  <organ-assessment-form
                    :organ-data="scope.row"
                    :assessment-index="index"
                    :readonly="!canAssessOrgan(scope.row)"
                    :current-user="currentUser"
                    @update-assessment="handleUpdateAssessment"
                    @delete-assessment="handleDeleteAssessment"
                    @save-assessment="handleSaveAssessment"
                  />
                </el-tab-pane>

                <!-- 添加评估按钮 -->
                <el-tab-pane
                  name="add"
                  v-if="canAssessOrgan(scope.row) && isEdit"
                >
                  <template slot="label">
                    <el-button
                      type="text"
                      icon="el-icon-plus"
                      @click.stop="handleAddNewAssessment(scope.row)"
                      size="mini"
                    >
                      新增评估
                    </el-button>
                  </template>
                  <div class="add-assessment-prompt">
                    <el-empty description="点击上方按钮添加新的评估"></el-empty>
                  </div>
                </el-tab-pane>

                <!-- 评估汇总Tab -->
              <el-tab-pane label="评估汇总" name="summary">
  <div class="assessment-summary">
    <!-- 基本信息汇总 -->
    <el-descriptions title="基本信息汇总" :column="2" border>
      <el-descriptions-item label="器官类型">
        <span class="summary-item">{{ getOrganLabel(scope.row.organno) }}</span>
      </el-descriptions-item>
      <el-descriptions-item label="获取机构">
        <span class="summary-item">{{ scope.row.gainhospitalname }}</span>
      </el-descriptions-item>
      <el-descriptions-item label="评估次数" :span="2">
        <el-tag type="info" size="medium">
          {{ getAssessmentCount(scope.row) }}次
        </el-tag>
      </el-descriptions-item>
      <el-descriptions-item label="最新评估时间" :span="2">
        <span class="highlight-text">{{ getLatestAssessmentTime(scope.row) || "-" }}</span>
      </el-descriptions-item>
    </el-descriptions>

    <!-- 评估详情汇总 -->
    <el-card header="评估详情列表" style="margin-top: 20px;" class="assessment-detail-card">
      <div v-if="getOrganAssessments(scope.row).length === 0" class="no-assessment">
        <el-empty description="暂无评估记录"></el-empty>
      </div>

      <div v-else>
        <!-- 每次评估详情 -->
        <div v-for="(assessment, index) in getOrganAssessments(scope.row)"
             :key="index"
             class="assessment-item">
          <el-card shadow="hover" class="assessment-card">
            <div slot="header" class="clearfix">
              <span class="assessment-title">第{{ index + 1 }}次评估</span>
              <el-tag
                :type="getAssessmentTagType(assessment.status)"
                size="small"
                class="status-tag"
              >
                {{ getAssessmentStatusText(assessment.status) }}
              </el-tag>
            </div>

            <el-descriptions :column="2" border class="detail-descriptions">
              <el-descriptions-item label="评估时间" :span="2">
                <span class="time-text">{{ assessment.assessmentTime || "-" }}</span>
              </el-descriptions-item>

              <el-descriptions-item label="评估人">
                <el-tag type="info" size="small">
                  {{ assessment.assessor || "未填写" }}
                </el-tag>
              </el-descriptions-item>

              <el-descriptions-item label="功能状态">
                <el-tag
                  :type="getFunctionStatusTagType(assessment.functionStatus)"
                  size="small"
                >
                  {{ getFunctionStatusText(assessment.functionStatus) }}
                </el-tag>
              </el-descriptions-item>

              <el-descriptions-item label="评估意见" :span="2">
                <div class="opinion-content">
                  {{ assessment.assessmentOpinion || "暂无评估意见" }}
                </div>
              </el-descriptions-item>

              <el-descriptions-item label="附件数量" :span="2" v-if="assessment.attachments && assessment.attachments.length > 0">
                <el-tag type="success" size="small">
                  {{ assessment.attachments.length }}个
                </el-tag>
                <el-button
                  type="text"
                  size="mini"
                  @click="showAttachmentList(assessment.attachments, index + 1)"
                  style="margin-left: 10px;"
                >
                  查看附件列表
                </el-button>
              </el-descriptions-item>
            </el-descriptions>
          </el-card>
        </div>
      </div>
    </el-card>

    <!-- 器官基本信息卡片 -->
    <el-card header="器官信息" style="margin-top: 20px;" class="organ-info-card">
      <el-descriptions :column="2" border>
        <el-descriptions-item label="获取前活检">
          <el-tag
            :type="
              scope.row.isbiopsybefore === '1'
                ? 'success'
                : 'info'
            "
            size="small"
          >
            {{ scope.row.isbiopsybefore === "1" ? "是" : "否" }}
          </el-tag>
        </el-descriptions-item>
        <el-descriptions-item label="获取后活检">
          <el-tag
            :type="
              scope.row.isbiopsyafter === '1'
                ? 'success'
                : 'info'
            "
            size="small"
          >
            {{ scope.row.isbiopsyafter === "1" ? "是" : "否" }}
          </el-tag>
        </el-descriptions-item>
        <el-descriptions-item label="边缘器官">
          <el-tag
            :type="
              scope.row.ismarginalorgan === '1'
                ? 'warning'
                : 'info'
            "
            size="small"
          >
            {{
              scope.row.ismarginalorgan === "1" ? "是" : "否"
            }}
          </el-tag>
        </el-descriptions-item>
        <el-descriptions-item label="病原菌阳性">
          <el-tag
            :type="
              scope.row.ispathogenpositive === '1'
                ? 'danger'
                : 'info'
            "
            size="small"
          >
            {{
              scope.row.ispathogenpositive === "1" ? "是" : "否"
            }}
          </el-tag>
        </el-descriptions-item>
      </el-descriptions>
    </el-card>
  </div>
</el-tab-pane>
              </el-tabs>
            </div>
          </template>
        </el-table-column>

        <el-table-column label="器官类型" align="center" prop="organname">
          <template slot-scope="scope">
            {{ getOrganLabel(scope.row.organno) }}
          </template>
        </el-table-column>

        <el-table-column label="器官编号" align="center" prop="organnumber" />

        <el-table-column
          label="器官类型"
          label="获取机构"
          align="center"
          prop="organType"
          prop="gainhospitalname"
          show-overflow-tooltip
        />

        <!-- 动态显示评估状态列 -->
        <el-table-column
          v-for="index in getMaxAssessmentCount()"
          :key="index"
          :label="`第${index}次评估`"
          align="center"
          width="120"
        >
          <template slot-scope="scope">
            <dict-tag
              :options="organTypeOptions"
              :value="scope.row.organType"
            />
          </template>
        </el-table-column>
        <el-table-column
          label="评估科室"
          align="center"
          prop="department"
          width="120"
        />
        <el-table-column
          label="评估人员"
          align="center"
          prop="assessor"
          width="100"
        />
        <el-table-column label="评估状态" align="center" width="100">
          <template slot-scope="scope">
            <el-tag
              :type="scope.row.assessmentStatus === '1' ? 'success' : 'warning'"
              v-if="getOrganAssessments(scope.row)[index - 1]"
              :type="
                getAssessmentTagType(
                  getOrganAssessments(scope.row)[index - 1].status
                )
              "
              size="small"
            >
              {{ scope.row.assessmentStatus === "1" ? "已评估" : "待评估" }}
              {{
                getAssessmentStatusText(
                  getOrganAssessments(scope.row)[index - 1].status
                )
              }}
            </el-tag>
            <el-tag v-else type="info" size="small">未评估</el-tag>
          </template>
        </el-table-column>

        <el-table-column label="整体状态" align="center" width="100">
          <template slot-scope="scope">
            <el-tag
              :type="
                getOrganOverallStatus(scope.row) === 'completed'
                  ? 'success'
                  : getOrganOverallStatus(scope.row) === 'assessing'
                  ? 'primary'
                  : 'warning'
              "
              size="small"
            >
              {{ getOrganOverallStatusText(scope.row) }}
            </el-tag>
          </template>
        </el-table-column>
        <el-table-column label="功能状态" align="center" width="100">
          <template slot-scope="scope">
            <el-tag
              :type="getFunctionStatusType(scope.row.functionStatus)"
              size="small"
            >
              {{ getFunctionStatusText(scope.row.functionStatus) }}
            </el-tag>
          </template>
        </el-table-column>
        <el-table-column
          label="评估意见"
          align="center"
          prop="assessmentOpinion"
          min-width="150"
          show-overflow-tooltip
        />
        <el-table-column label="评估时间" align="center" width="120">
          <template slot-scope="scope">
            <span>{{ scope.row.assessmentTime || "-" }}</span>
          </template>
        </el-table-column>

        <el-table-column
          label="操作"
          align="center"
@@ -148,275 +377,990 @@
        >
          <template slot-scope="scope">
            <el-button
              v-if="canAssessOrgan(scope.row)"
              v-if="canAssessOrgan(scope.row) && isEdit"
              size="mini"
              type="text"
              @click="handleOrganAssess(scope.row)"
              >{{
                scope.row.assessmentStatus === "1" ? "查看/修改" : "评估"
              }}</el-button
              @click="handleToggleExpand(scope.row)"
            >
              {{
                expandedRowKeys.includes(scope.row.organno) ? "收起" : "详情"
              }}
            </el-button>
            <el-button
              v-else-if="!isEdit"
              size="mini"
              type="text"
              @click="handleToggleExpand(scope.row)"
            >
              {{
                expandedRowKeys.includes(scope.row.organno) ? "收起" : "查看"
              }}
            </el-button>
            <el-button v-else size="mini" type="text" disabled
              >无权限</el-button
            >
            <el-button
              v-if="isCoordinator"
              size="mini"
              type="text"
              @click="handleViewOrganDetail(scope.row)"
              >详情</el-button
            >
          </template>
        </el-table-column>
      </el-table>

      <!-- 器官评估详情 -->
     <el-collapse v-model="activeOrgans" accordion class="organ-detail-collapse">
        <el-collapse-item
          v-for="organ in organAssessmentList"
          :key="organ.organType"
          :name="organ.organType"
          :title="getOrganTitle(organ)"
        >
          <div class="organ-detail-header">
            <span class="organ-name">{{ getOrganName(organ.organType) }}评估详情</span>
            <span class="attachment-count" v-if="organ.attachments && organ.attachments.length > 0">
              附件数量: {{ organ.attachments.length }}
            </span>
          </div>
          <organ-assessment-form
            :organ-data="organ"
            :readonly="!canAssessOrgan(organ)"
            @save="handleSaveOrganAssessment"
          />
        </el-collapse-item>
      </el-collapse>
    </el-card>

    <!-- 附件预览弹窗 -->
    <attachment-preview
    <!-- 整体保存按钮 -->
    <div class="footer-actions" v-if="isEdit">
      <el-button type="primary" @click="handleSaveAll" :loading="saveLoading"
        >保存评估表</el-button
      >
      <el-button @click="handleCancel">取消</el-button>
    </div>

    <!-- 文件预览弹窗 -->
    <FilePreviewDialog
      :visible="attachmentVisible"
      :attachment-list="attachmentList"
      :file="currentPreviewFile"
      @close="attachmentVisible = false"
    />
  </div>
</template>

<script>
// import { getAssessment, updateOrganAssessment, completeAssessment } from "@/api/case/assessment";
import {
  getAssessment,
  updateOrganAssessment,
  completeAssessment
} from "./mockAssessmentApi";

import OrganAssessmentForm from "./components/OrganAssessmentForm.vue";
import AttachmentPreview from "./components/AttachmentPreview.vue";
  evaluateBaseInfolist,
  assessedit,
  assessAdd
} from "@/api/businessApi/index";
import FilePreviewDialog from "@/components/FilePreviewDialog";
import OrganAssessmentForm from "@/components/assessInfoComponents/OrganAssessmentForm.vue";

export default {
  name: "AssessmentDetail",
  components: { OrganAssessmentForm, AttachmentPreview },
  components: { OrganAssessmentForm, FilePreviewDialog },
  dicts: ["sys_user_sex", "sys_Organ", "sys_0_1"],
  data() {
    return {
      // 评估ID
      assessmentId: undefined,
      // 评估数据
      assessmentData: {},
      // 器官评估列表
      organAssessmentList: [],
      // 附件列表
      attachmentList: [],
      // 是否编辑模式
      isEdit: false,
      // 加载状态
      assessmentLoading: false,
      // 当前用户信息
      saveLoading: false,
      // 数据ID
      infoid: undefined,
      assessmentId: undefined,
      // 主要数据
      assessmentData: {},
      organAssessmentList: [], // 所有器官数据
      // 展开行相关
      expandedRowKeys: [],
      // 附件相关
      currentPreviewFile: null,
      attachmentVisible: false,
      // 捐献决定相关
      organdecisionValues: [], // 存储字典value
      organdecisionOther: "",
      // 记录捐献决定变化前的值
      prevOrgandecisionValues: [],
      // 器官类型映射关系
      organDecisionMapping: {
        C38: ["C38"], // 心脏 -> 心脏
        C22: ["C22"], // 全肝 -> 全肝
        C22L: ["C22L"], // 左半肝 -> 左半肝
        C22L0: ["C22L0"], // 左外叶 -> 左外叶
        C22R: ["C22R"], // 右半肝 -> 右半肝
        C22R0: ["C22R0"], // 右三叶 -> 右三叶
        C64: ["C64L", "C64R"], // 双肾 -> 左肾, 右肾
        C64L: ["C64L"], // 左肾 -> 左肾
        C64R: ["C64R"], // 右肾 -> 右肾
        C34: ["C34L", "C34R"], // 全肺 -> 左肺, 右肺
        C34L: ["C34L"], // 左肺 -> 左肺
        C34R: ["C34R"], // 右肺 -> 右肺
        C17: ["C17"], // 小肠 -> 小肠
        C25: ["C25"], // 胰腺 -> 胰腺
        C00: [], // 遗体 -> 不映射具体器官（遗体是整体）
        C69L: ["C69L"], // 左眼角膜 -> 左眼角膜
        C69R: ["C69R"], // 右眼角膜 -> 右眼角膜
        C01: [] // 其他 -> 不映射具体器官
      },
      // 用户信息
      currentUser: {
        id: "001",
        name: "张医生",
        department: "心脏外科",
        role: "department" // coordinator: 协调员, department: 科室人员
        department: "心脏科",
        role: "coordinator"
      },
      // 展开的器官
      activeOrgans: [],
      // 附件预览可见性
      attachmentVisible: false,
      // 字典选项
      genderOptions: [
        { value: "0", label: "男" },
        { value: "1", label: "女" }
      ],
      bloodTypeOptions: [
        { value: "A", label: "A型" },
        { value: "B", label: "B型" },
        { value: "O", label: "O型" },
        { value: "AB", label: "AB型" }
      ],
      assessmentTypeOptions: [
        { value: "1", label: "初次评估" },
        { value: "2", label: "最终评估" }
      ],
      organTypeOptions: [
        { value: "heart", label: "心脏" },
        { value: "liver", label: "肝脏" },
        { value: "kidney", label: "肾脏" },
        { value: "lung", label: "肺脏" },
        { value: "pancreas", label: "胰腺" },
        { value: "intestine", label: "肠道" },
        { value: "cornea", label: "角膜" },
        { value: "skin", label: "皮肤" }
      ]
      // 记录被删除的器官评估
      deletedOrganAssessments: [],
      // 用于追踪tab激活状态
      activeTabMap: new Map(),
      // 刷新key
      refreshKey: 0
    };
  },
  computed: {
    // 是否是协调员
    isCoordinator() {
      return this.currentUser.role === "coordinator";
    },
    // 当前科室
    currentDepartment() {
      return this.currentUser.department;
    },
    // 所有器官是否都已评估
    allOrgansAssessed() {
      return this.organAssessmentList.every(
        organ => organ.assessmentStatus === "1"
    // 根据捐献决定过滤后的器官列表
    filteredOrganAssessmentList() {
      if (!this.organdecisionValues || this.organdecisionValues.length === 0) {
        return [];
      }

      const selectedOrgans = new Set();
      this.organdecisionValues.forEach(decision => {
        const organs = this.organDecisionMapping[decision] || [];
        organs.forEach(organ => selectedOrgans.add(organ));
      });

      return this.organAssessmentList.filter(
        organ =>
          selectedOrgans.has(organ.organno) &&
          organ.delFlag !== "1" &&
          !this.deletedOrganAssessments.includes(organ.organno)
      );
    },
    // 检查所有过滤后的器官是否都已评估
    allOrgansAssessed() {
      return this.filteredOrganAssessmentList.every(organ => {
        const assessments = this.getOrganAssessments(organ);
        return (
          assessments &&
          assessments.length > 0 &&
          assessments.every(assessment => assessment.status === "assessed")
        );
      });
    },
    // 获取器官字典
    organDict() {
      return this.dict.type.sys_Organ || [];
    },
    // 判断是否需要显示其他输入框
    showOtherInput() {
      return this.organdecisionValues.includes("C01");
    }
  },
  watch: {
    // 监听捐献决定变化，用于复杂逻辑处理
    organdecisionValues: {
      handler(newVal, oldVal) {
        this.handleComplexDecisionChange(newVal, oldVal);
      },
      deep: true
    }
  },
  created() {
    this.infoid = this.$route.query.infoid;
    this.assessmentId = this.$route.query.id;
    this.isEdit = this.$route.query.assess === "true";
    this.getAssessmentDetail();

  },
  methods: {
    // 获取评估详情 - 使用Mock数据
    getAssessmentDetail() {
      this.assessmentLoading = true;
      getAssessment(this.assessmentId)
        .then(response => {
          if (response.code === 200) {
            this.assessmentData = response.data.caseInfo;
            this.organAssessmentList = response.data.organAssessments || [];
    // 根据字典value获取label
    getOrganLabel(organValue) {
      const dictItem = this.organDict.find(item => item.value === organValue);
      return dictItem ? dictItem.label : organValue;
    },

            // 确保每个器官评估数据都有attachments数组
            this.organAssessmentList.forEach(organ => {
              if (!organ.attachments) {
                organ.attachments = [];
              }
            });
    // Tab点击事件
    handleTabClick(organ, tab) {
      if (tab.name !== "add") {
        this.activeTabMap.set(organ.organno, tab.name);
      }
    },
// 获取功能状态标签类型
  getFunctionStatusTagType(status) {
    const typeMap = {
      "1": "success",  // 正常
      "2": "warning",  // 轻度异常
      "3": "danger",   // 重度异常
      "4": "info"      // 无法评估
    };
    return typeMap[status] || "info";
  },

  // 获取功能状态文本
  getFunctionStatusText(status) {
    const textMap = {
      "1": "正常",
      "2": "轻度异常",
      "3": "重度异常",
      "4": "无法评估"
    };
    return textMap[status] || "未评估";
  },

  // 显示附件列表
  showAttachmentList(attachments, assessmentNumber) {
    if (!attachments || attachments.length === 0) {
      this.$message.info(`第${assessmentNumber}次评估暂无附件`);
      return;
    }

    this.$alert(
      `<div>
        <h4>第${assessmentNumber}次评估附件列表</h4>
        <ul style="list-style: none; padding-left: 0;">
          ${attachments.map((item, index) => `
            <li style="margin: 5px 0; padding: 5px; background: #f5f7fa; border-radius: 4px;">
              <i class="el-icon-document"></i>
              <span style="margin-left: 8px;">${item.fileName}</span>
              <el-button
                type="text"
                size="mini"
                onclick="window.open('${item.path || item.fileUrl}')"
                style="margin-left: 10px;"
              >
                下载
              </el-button>
            </li>
          `).join('')}
        </ul>
      </div>`,
      '附件列表',
      {
        dangerouslyUseHTMLString: true,
        showConfirmButton: false,
        showCancelButton: true,
        cancelButtonText: '关闭'
      }
    );
  },
    // 获取器官的评估列表
    getOrganAssessments(organ) {
      if (!organ.assesscontent) return [];
      try {
        const assessData =
          typeof organ.assesscontent === "string"
            ? JSON.parse(organ.assesscontent)
            : organ.assesscontent;

        if (Array.isArray(assessData)) {
          return assessData.filter(item => item.delFlag !== "1");
        }
        return [];
      } catch (error) {
        console.warn("解析评估内容失败:", error);
        return [];
      }
    },

    // 获取评估数量
    getAssessmentCount(organ) {
      return this.getOrganAssessments(organ).length;
    },

    // 处理评估更新
    handleUpdateAssessment(data) {
      const { organData, assessmentData, assessmentIndex } = data;
      const assessments = this.getOrganAssessments(organData);

      if (assessments[assessmentIndex]) {
        // 创建新的评估数组
        const newAssessments = [...assessments];
        newAssessments[assessmentIndex] = {
          ...assessments[assessmentIndex],
          ...assessmentData
        };

        // 更新 assesscontent
        this.$set(organData, "assesscontent", JSON.stringify(newAssessments));
        this.$forceUpdate();
      }
    },

    // 整体保存方法
    async handleSaveAll() {
      this.saveLoading = true;
      try {
        const saveData = {
          id: this.assessmentData.id || undefined,
          infoid: this.infoid,
          caseNo: this.assessmentData.caseNo,
          donorno: this.assessmentData.donorno,
          treatmenthospitalname: this.assessmentData.treatmenthospitalname,
          treatmenthospitalno: this.assessmentData.treatmenthospitalno,
          sex: this.assessmentData.sex,
          age: this.assessmentData.age,
          bloodtype: this.assessmentData.bloodtype,
          idcardno: this.assessmentData.idcardno,
          diagnosisname: this.assessmentData.diagnosisname,
          coordinatorName: this.assessmentData.coordinatorName,
          assessTime:
            this.assessmentData.assessTime || new Date().toISOString(),
          assessState: this.assessmentData.assessState,
          assessannex: this.assessmentData.assessannex,
          organdecision: this.organdecisionValues.join(","),
          organdecisionOther: this.organdecisionOther,
          serviceMedicalevaluationorganList: this.organAssessmentList.map(
            organ => ({
              id: organ.id,
              infoid: organ.infoid,
              donorno: organ.donorno,
              organno: organ.organno,
              organname: this.getOrganLabel(organ.organno),
              organnumber: organ.organnumber,
              gainhospitalno: organ.gainhospitalno,
              gainhospitalname: organ.gainhospitalname,
              isbiopsybefore: organ.isbiopsybefore,
              isbiopsyafter: organ.isbiopsyafter,
              ismarginalorgan: organ.ismarginalorgan,
              ispathogenpositive: organ.ispathogenpositive,
              ispnf: organ.ispnf,
              isdgf: organ.isdgf,
              delFlag: organ.delFlag || "0",
              assesscontent: organ.assesscontent || "[]"
            })
          )
        };

        const saveMethod = this.assessmentData.id ? assessedit : assessAdd;
        const response = await saveMethod(saveData);

        if (response.code === 200) {
          this.$message.success("评估表保存成功！");
          if (!this.assessmentData.id && response.data && response.data.id) {
            this.assessmentData.id = response.data.id;
          }
          this.assessmentLoading = false;
        })
        .catch(error => {
          console.error("获取评估详情失败:", error);
          this.assessmentLoading = false;
        });
          this.refreshKey += 1; // 触发重新渲染
        } else {
          this.$message.error("保存失败：" + (response.msg || "未知错误"));
        }
      } catch (error) {
        console.error("保存评估表失败:", error);
        this.$message.error("保存失败，请重试");
      } finally {
        this.saveLoading = false;
      }
    },

    // 新增方法：获取器官名称
    getOrganName(organType) {
      const organ = this.organTypeOptions.find(opt => opt.value === organType);
      return organ ? organ.label : organType;
    // 取消按钮事件
    handleCancel() {
      this.$router.go(-1);
    },
    // 状态过滤器
    statusFilter(status) {
      const statusMap = {
        "0": "warning",
        "1": "primary",
        "2": "success",
        "3": "danger"

    // 捐献决定变更处理
    async handleOrganDecisionChange(newDecision) {
      const oldDecision = [...this.prevOrgandecisionValues];
      this.autoHandleDecisionChange(newDecision);

      const removedDecisions = oldDecision.filter(
        item => !newDecision.includes(item)
      );

      for (const decision of removedDecisions) {
        await this.handleRemovedDecision(decision);
      }

      this.prevOrgandecisionValues = [...newDecision];
      this.$forceUpdate();

      if (newDecision.length === 0) {
        this.expandedRowKeys = [];
      }
    },

    // 其他捐献决定输入处理
    handleOtherDecisionInput(value) {
      // 输入时不做单独保存，等待整体保存
    },

    // 自动处理决定变更逻辑
    autoHandleDecisionChange(newDecision) {
      // 如果选择了"双肾"(value: C64)，自动取消单独的"左肾"(value: C64L)和"右肾"(value: C64R)选择
      if (newDecision.includes("C64")) {
        this.organdecisionValues = newDecision.filter(
          item => item !== "C64L" && item !== "C64R"
        );
      }
      // 如果选择了"左肾"或"右肾"，取消"双肾"选择
      else if (newDecision.includes("C64L") || newDecision.includes("C64R")) {
        this.organdecisionValues = newDecision.filter(item => item !== "C64");
      }

      // 如果选择了"全肺"(value: C34)，自动取消单独的"左肺"(value: C34L)和"右肺"(value: C34R)选择
      if (newDecision.includes("C34")) {
        this.organdecisionValues = newDecision.filter(
          item => item !== "C34L" && item !== "C34R"
        );
      }
      // 如果选择了"左肺"或"右肺"，取消"全肺"选择
      else if (newDecision.includes("C34L") || newDecision.includes("C34R")) {
        this.organdecisionValues = newDecision.filter(item => item !== "C34");
      }

      // 处理其他互斥逻辑
      this.handleExclusiveDecisions();
    },

    // 处理互斥的捐献决定
    handleExclusiveDecisions() {
      // 遗体捐献(value: 10)与其他器官捐献互斥（根据业务需求调整）
      if (this.organdecisionValues.includes("10")) {
        // 可以设置只保留遗体捐献，或者根据业务需求处理
      }
    },

    // 复杂决策变化处理
    handleComplexDecisionChange(newVal, oldVal) {
      // 处理新增的选择
      const addedDecisions = newVal.filter(item => !oldVal.includes(item));
      const removedDecisions = oldVal.filter(item => !newVal.includes(item));

      // 对新增加的选择进行特殊处理
      addedDecisions.forEach(decision => {
        this.handleNewDecision(decision);
      });

      // 对移除的选择进行清理
      removedDecisions.forEach(decision => {
        this.handleRemovedDecision(decision);
      });
    },

    // 处理新增的捐献决定
    handleNewDecision(decision) {
      // 根据映射关系自动创建对应的器官评估项
      this.autoCreateOrganAssessments(decision);
    },

    // 自动创建器官评估项
    autoCreateOrganAssessments(decision) {
      const organsToCreate = this.organDecisionMapping[decision];

      if (organsToCreate && organsToCreate.length > 0) {
        organsToCreate.forEach(organValue => {
          this.ensureOrganExists(organValue);
        });

        // 显示创建提示
        if (organsToCreate.length > 0) {
          this.$message.success(
            `已为【${this.getOrganLabel(decision)}】创建${
              organsToCreate.length
            }个评估项`
          );
        }
      } else {
        console.warn(
          `捐献决定【${this.getOrganLabel(decision)}】没有配置器官映射关系`
        );
      }
    },

    // 处理移除的捐献决定
    async handleRemovedDecision(decision) {
      const relatedOrgans = this.organDecisionMapping[decision] || [];

      for (const organValue of relatedOrgans) {
        const organIndex = this.organAssessmentList.findIndex(
          organ => organ.organno === organValue && organ.delFlag !== "1"
        );

        if (organIndex !== -1) {
          const organ = this.organAssessmentList[organIndex];
          const organLabel = this.getOrganLabel(organValue);

          try {
            await this.$confirm(
              `捐献决定"${this.getOrganLabel(
                decision
              )}"已取消，是否删除对应的${organLabel}评估记录？`,
              "确认删除",
              {
                confirmButtonText: "确定",
                cancelButtonText: "取消",
                type: "warning"
              }
            );

            this.$set(this.organAssessmentList[organIndex], "delFlag", "1");
            this.deletedOrganAssessments.push(organValue);

            const keyIndex = this.expandedRowKeys.indexOf(organValue);
            if (keyIndex > -1) {
              this.expandedRowKeys.splice(keyIndex, 1);
            }

            this.$message.success(`${organLabel}评估记录已标记删除`);
          } catch (cancelError) {
            if (!this.organdecisionValues.includes(decision)) {
              this.organdecisionValues.push(decision);
            }
            this.$message.info(`已取消删除${organLabel}评估记录`);
          }
        }
      }
    },

    // 确保器官存在
    ensureOrganExists(organValue) {
      const exists = this.organAssessmentList.some(
        organ => organ.organno === organValue && organ.delFlag !== "1"
      );

      if (!exists) {
        const newOrgan = {
          id: null,
          organno: organValue,
          organname: this.getOrganLabel(organValue),
          gainhospitalname: "待分配机构",
          isbiopsybefore: "0",
          isbiopsyafter: "0",
          ismarginalorgan: "0",
          ispathogenpositive: "0",
          assesscontent: JSON.stringify([this.getDefaultAssessment(0)]),
          activeTab: 0,
          expanded: false,
          createTime: new Date().toISOString(),
          delFlag: "0"
        };

        this.organAssessmentList = [...this.organAssessmentList, newOrgan];
        return true;
      }
      return false;
    },

    // 获取评估详情
    async getAssessmentDetail() {
      this.assessmentLoading = true;
      try {
        const response = await evaluateBaseInfolist({ infoid: this.infoid });

        if (response.code === 200) {
          this.handleResponseData(response);
        } else {
          this.$message.error("获取详情失败：" + (response.msg || "未知错误"));
        }
      } catch (error) {
        console.error("获取评估详情失败:", error);
        this.$message.error("获取详情失败");
      } finally {
        this.assessmentLoading = false;
      }
    },

    // 处理接口响应数据
    handleResponseData(response) {
      let detailData = null;

      if (response.data) {
        if (Array.isArray(response.data)) {
          detailData = response.data[0] || {};
        } else if (response.data.rows && Array.isArray(response.data.rows)) {
          detailData = response.data.rows[0] || {};
        } else if (Array.isArray(response.data.list)) {
          detailData = response.data.list[0] || {};
        } else {
          detailData = response.data;
        }
      } else {
        detailData = response;
      }

      this.assessmentData = {
        id: detailData.id || this.assessmentId,
        infoid: detailData.infoid || this.infoid,
        caseNo: detailData.caseNo || "",
        name: detailData.name || detailData.donorName || "",
        sex: detailData.sex || "",
        age: detailData.age || "",
        bloodtype: detailData.bloodtype || "",
        idcardno: detailData.idcardno || "",
        diagnosisname: detailData.diagnosisname || "",
        treatmenthospitalname: detailData.treatmenthospitalname || "",
        coordinatorName: detailData.coordinatorName || "",
        assessTime: detailData.assessTime || "",
        assessState: detailData.assessState || "1",
        assessannex: detailData.assessannex || ""
      };
      return statusMap[status] || "info";

      if (detailData.organdecision) {
        const decisionArray = Array.isArray(detailData.organdecision)
          ? detailData.organdecision
          : (detailData.organdecision || "").split(",").filter(item => item);

        this.organdecisionValues = decisionArray;
        this.prevOrgandecisionValues = [...decisionArray];
        this.organdecisionOther = detailData.organdecisionOther || "";
      }

      this.processOrganAssessmentData(detailData);
    },
    statusTextFilter(status) {

    // 处理器官评估数据
    processOrganAssessmentData(detailData) {
      let organList = [];

      if (detailData.serviceMedicalevaluationorganList) {
        if (Array.isArray(detailData.serviceMedicalevaluationorganList)) {
          organList = detailData.serviceMedicalevaluationorganList;
        }
      }

      this.organAssessmentList = organList.map(organ => {
        const organno = organ.organno;

        // 如果 assesscontent 是字符串，确保它是有效的 JSON
        if (organ.assesscontent && typeof organ.assesscontent === "string") {
          try {
            JSON.parse(organ.assesscontent);
          } catch (error) {
            console.warn(
              "无效的 assesscontent，重置为空数组:",
              organ.assesscontent
            );
            organ.assesscontent = "[]";
          }
        } else if (!organ.assesscontent) {
          organ.assesscontent = "[]";
        }

        const assessments = this.getOrganAssessments(organ);
        const activeTab = this.activeTabMap.has(organno)
          ? this.activeTabMap.get(organno)
          : assessments.length > 0
          ? 0
          : "summary";

        return {
          ...organ,
          organname: this.getOrganLabel(organ.organno) || organ.organname,
          activeTab: activeTab,
          expanded: false,
          delFlag: organ.delFlag || "0"
        };
      });
    },

    // 获取默认评估数据结构
    getDefaultAssessment(index) {
      return {
        index: index,
        status: "pending",
        assessmentTime: "",
        assessor: "",
        functionStatus: "",
        assessmentOpinion: "",
        clinicalData: {},
        labResults: {},
        createTime: new Date().toISOString(),
        delFlag: "0"
      };
    },

    // 计算最大评估次数
    getMaxAssessmentCount() {
      const maxCount = Math.max(
        ...this.organAssessmentList
          .filter(organ => organ.delFlag !== "1")
          .map(organ => this.getAssessmentCount(organ))
      );
      return Math.max(maxCount, 1);
    },

    // 获取器官整体状态
    getOrganOverallStatus(organ) {
      const assessments = this.getOrganAssessments(organ);
      if (assessments.length === 0) {
        return "pending";
      }

      const validAssessments = assessments.filter(a => a.delFlag !== "1");
      if (validAssessments.length === 0) {
        return "pending";
      }

      const allAssessed = validAssessments.every(
        assessment => assessment.status === "assessed"
      );
      const someAssessed = validAssessments.some(
        assessment => assessment.status === "assessed"
      );

      if (allAssessed) return "completed";
      if (someAssessed) return "assessing";
      return "pending";
    },

    getOrganOverallStatusText(organ) {
      const status = this.getOrganOverallStatus(organ);
      const statusMap = {
        "0": "待评估",
        "1": "评估中",
        "2": "已完成",
        "3": "已关闭"
        pending: "待评估",
        assessing: "评估中",
        completed: "已完成"
      };
      return statusMap[status] || "未知";
    },
    // 获取功能状态类型
    getFunctionStatusType(status) {

    // 切换展开行
    handleToggleExpand(row) {
      const key = row.organno;
      const index = this.expandedRowKeys.indexOf(key);

      if (index > -1) {
        this.expandedRowKeys.splice(index, 1);
        row.expanded = false;
      } else {
        this.expandedRowKeys = [key];
        this.organAssessmentList.forEach(item => {
          item.expanded = item.organno === key;
        });
      }
    },

    // 展开行变化
    handleExpandChange(row, expandedRows) {
      this.expandedRowKeys = expandedRows.map(item => item.organno);
      this.organAssessmentList.forEach(item => {
        item.expanded = this.expandedRowKeys.includes(item.organno);
      });
    },

    // 添加新评估
    handleAddNewAssessment(organ) {
      const assessments = this.getOrganAssessments(organ);
      const newAssessment = {
        ...this.getDefaultAssessment(assessments.length),
        assessor: this.currentUser.name
      };

      const newAssessments = [...assessments, newAssessment];
      this.$set(organ, "assesscontent", JSON.stringify(newAssessments));

      organ.activeTab = assessments.length;
      this.activeTabMap.set(organ.organno, assessments.length);

      this.$message.success("已添加新的评估");
    },

    // 处理删除评估事件
    handleDeleteAssessment(data) {
      const { organData, assessmentIndex } = data;
      this.deleteOrganAssessment(organData, assessmentIndex);
    },
    // 处理评估保存
    handleSaveAssessment(data) {
      const { organData, assessmentData, assessmentIndex } = data;
      const assessments = this.getOrganAssessments(organData);

      console.log("保存评估数据:", data);

      if (assessments[assessmentIndex]) {
        // 创建新的评估数组
        const newAssessments = [...assessments];
        newAssessments[assessmentIndex] = {
          ...assessments[assessmentIndex],
          ...assessmentData,
          status: "assessed", // 标记为已评估
          assessmentTime: new Date().toISOString(), // 设置评估时间
          delFlag: "0" // 确保删除标志
        };

        // 更新 assesscontent
        this.$set(organData, "assesscontent", JSON.stringify(newAssessments));

        // 强制重新渲染
        this.$forceUpdate();

        this.$message.success("评估保存成功");

        // 检查是否需要自动切换到下一个评估
        this.checkAndSwitchTab(organData, assessmentIndex);
      }
    },

    // 检查并自动切换tab
    checkAndSwitchTab(organData, currentIndex) {
      const assessments = this.getOrganAssessments(organData);
      if (currentIndex < assessments.length - 1) {
        // 如果还有下一个评估，自动切换到下一个
        organData.activeTab = currentIndex + 1;
        this.activeTabMap.set(organData.organno, currentIndex + 1);
      } else {
        // 如果没有下一个评估，切换到汇总页
        organData.activeTab = "summary";
        this.activeTabMap.set(organData.organno, "summary");
      }
    },

    // 删除器官评估
    async deleteOrganAssessment(organ, assessmentIndex) {
      try {
        await this.$confirm(
          `确认删除第${assessmentIndex + 1}次评估记录吗？`,
          "确认删除",
          {
            confirmButtonText: "确定",
            cancelButtonText: "取消",
            type: "warning"
          }
        );

        const assessments = this.getOrganAssessments(organ);
        if (assessments[assessmentIndex]) {
          // 标记为删除
          assessments[assessmentIndex].delFlag = "1";

          // 过滤掉已删除的评估
          const newAssessments = assessments.filter(
            item => item.delFlag !== "1"
          );

          // 重新计算评估索引
          newAssessments.forEach((assessment, index) => {
            assessment.index = index;
          });

          // 更新 assesscontent
          this.$set(organ, "assesscontent", JSON.stringify(newAssessments));

          // 处理tab切换
          if (newAssessments.length === 0) {
            organ.activeTab = "summary";
            this.activeTabMap.set(organ.organno, "summary");
          } else if (organ.activeTab === assessmentIndex) {
            const newIndex = Math.max(0, assessmentIndex - 1);
            organ.activeTab = newIndex;
            this.activeTabMap.set(organ.organno, newIndex);
          } else if (organ.activeTab === "summary") {
            this.activeTabMap.set(organ.organno, "summary");
          }

          this.$message.success("评估记录已删除");
          this.$forceUpdate();
        }
      } catch (cancelError) {
        this.$message.info("已取消删除");
      }
    },

    // 获取最新评估时间
    getLatestAssessmentTime(organ) {
      const assessments = this.getOrganAssessments(organ);
      if (assessments.length === 0) return null;

      const assessed = assessments.filter(
        a => a.assessmentTime && a.delFlag !== "1"
      );
      if (assessed.length === 0) return null;

      return assessed.sort(
        (a, b) => new Date(b.assessmentTime) - new Date(a.assessmentTime)
      )[0].assessmentTime;
    },

    // 获取评估状态标签类型
    getAssessmentTagType(status) {
      const typeMap = {
        "1": "success", // 正常
        "2": "warning", // 轻度异常
        "3": "danger", // 重度异常
        "4": "info" // 无法评估
        pending: "warning",
        assessing: "primary",
        assessed: "success"
      };
      return typeMap[status] || "info";
    },
    // 获取功能状态文本
    getFunctionStatusText(status) {

    // 获取评估状态文本
    getAssessmentStatusText(status) {
      const textMap = {
        "1": "正常",
        "2": "轻度异常",
        "3": "重度异常",
        "4": "无法评估"
        pending: "待评估",
        assessing: "评估中",
        assessed: "已评估"
      };
      return textMap[status] || "未知";
    },
    // 检查是否有权限评估该器官

    // 检查评估权限
    canAssessOrgan(organ) {
      if (this.isCoordinator) return true;
      return organ.department === this.currentDepartment;
      if (!this.isEdit) return false;
      return (
        organ.gainhospitalname &&
        organ.gainhospitalname.includes(this.currentDepartment)
      );
    },

    // 获取行类名
    getRowClassName({ row }) {
      return this.canAssessOrgan(row) ? "assessable-row" : "non-assessable-row";
    },
    // 修改方法：更新器官标题显示
    getOrganTitle(organ) {
      const organName = this.getOrganName(organ.organType);
      const attachmentCount = organ.attachments ? organ.attachments.length : 0;
      return `${organName}评估详情（${organ.department}）${attachmentCount > 0 ? ` · ${attachmentCount}个附件` : ''}`;

    // 状态过滤器
    statusFilter(status) {
      const statusMap = {
        "1": "warning",
        "2": "primary",
        "3": "success"
      };
      return statusMap[status] || "info";
    },
    // 器官评估
    handleOrganAssess(organ) {
      this.activeOrgans = [organ.organType];

    statusTextFilter(status) {
      const statusMap = {
        "1": "待评估",
        "2": "评估中",
        "3": "已完成"
      };
      return statusMap[status] || "未知";
    },
    // 查看器官详情
    handleViewOrganDetail(organ) {
      this.activeOrgans = [organ.organType];
    },
    // 保存器官评估 - 使用Mock API
    handleSaveOrganAssessment(organData) {
      updateOrganAssessment(organData)
        .then(response => {
          if (response.code === 200) {
            this.$message.success("评估保存成功");
            // 刷新数据
            this.getAssessmentDetail();
          }
        })
        .catch(error => {
          console.error("保存评估失败:", error);
          this.$message.error("保存失败");
        });
    },
    // 查看附件预览

    // 查看附件
    handleAttachmentPreview() {
      this.attachmentVisible = true;
      if (this.assessmentData.assessannex) {
        try {
          const annexData =
            typeof this.assessmentData.assessannex === "string"
              ? JSON.parse(this.assessmentData.assessannex)
              : this.assessmentData.assessannex;

          if (Array.isArray(annexData) && annexData.length > 0) {
            this.currentPreviewFile = annexData[0];
            this.attachmentVisible = true;
          } else {
            this.$message.info("暂无附件可预览");
          }
        } catch (error) {
          this.$message.info("附件数据格式错误");
        }
      } else {
        this.$message.info("暂无附件");
      }
    },
    // 完成评估 - 使用Mock API
    handleCompleteAssessment() {
      this.$confirm("确认完成所有器官评估吗？完成后将无法修改", "确认操作", {
        confirmButtonText: "确定",
        cancelButtonText: "取消",
        type: "warning"
      }).then(() => {
        completeAssessment(this.assessmentId)
          .then(response => {
            if (response.code === 200) {
              this.$message.success("评估完成确认成功");
              this.getAssessmentDetail();
            }
          })
          .catch(error => {
            console.error("完成评估失败:", error);
            this.$message.error("操作失败");
          });
      });

    // 完成评估
    async handleCompleteAssessment() {
      try {
        await this.$confirm(
          "确认完成所有器官评估吗？完成后将无法修改",
          "确认操作",
          {
            confirmButtonText: "确定",
            cancelButtonText: "取消",
            type: "warning"
          }
        );

        const updateData = {
          ...this.assessmentData,
          assessState: "3",
          assessTime: new Date().toISOString()
        };

        const response = await assessedit(updateData);

        if (response.code === 200) {
          this.$message.success("评估完成确认成功");
          this.assessmentData.assessState = "3";
          this.isEdit = false;
        } else {
          this.$message.error("操作失败：" + (response.msg || "未知错误"));
        }
      } catch (error) {
        if (error !== "cancel") {
          console.error("完成评估失败:", error);
          this.$message.error("操作失败");
        }
      }
    }
  }
};
@@ -435,31 +1379,48 @@
  margin-bottom: 20px;
}

.organ-detail-collapse {
  margin-top: 20px;
}
.organ-detail-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-bottom: 15px;
  padding-bottom: 10px;
  border-bottom: 1px solid #ebeef5;
}

.organ-name {
  font-size: 16px;
  font-weight: bold;
  color: #303133;
}

.attachment-count {
  font-size: 14px;
  color: #409EFF;
  background-color: #ecf5ff;
  padding: 4px 8px;
/* 展开行样式 */
.organ-expand-content {
  padding: 20px;
  background: #fafafa;
  border-radius: 4px;
  margin: 10px 0;
}

.organ-detail-tabs {
  background: white;
  border-radius: 4px;
  padding: 20px;
}

.add-assessment-prompt {
  text-align: center;
  padding: 40px 0;
}

.assessment-summary {
  padding: 10px;
}

/* 底部保存按钮样式 */
.footer-actions {
  margin-top: 20px;
  text-align: center;
  padding: 20px;
  border-top: 1px solid #eaeaea;
}

/* 响应式设计 */
@media (max-width: 768px) {
  .assessment-detail {
    padding: 10px;
  }

  .organ-expand-content {
    padding: 10px;
  }
}

::v-deep .assessable-row {
  background-color: #f0f9ff;
}
@@ -468,6 +1429,24 @@
  background-color: #fafafa;
}

.jstitle {
  float: right;
  font-size: 18px !important;
  font-weight: 600;
  color: #2645f7;
  font-size: 12px;
}

/* 表格展开图标样式 */
::v-deep .el-table__expand-icon {
  cursor: pointer;
}

::v-deep .el-table__expanded-cell {
  padding: 0 !important;
}

/* 确保描述列表标签宽度一致 */
::v-deep .el-descriptions__label {
  width: 120px;
  background-color: #f5f7fa;
@@ -477,11 +1456,210 @@
.fixed-width .el-button {
  margin: 0 2px;
}
.jstitle {
  float: right;
  font-size: 18px !important;
/* 汇总页面样式 */
.assessment-summary {
  padding: 10px;
}

.summary-item {
  font-weight: 500;
  color: #303133;
}

.highlight-text {
  color: #409EFF;
  font-weight: 500;
}

.assessment-detail-card {
  border: 1px solid #e6ebf5;
}

.organ-info-card {
  border: 1px solid #e6ebf5;
  background-color: #fafafa;
}

.no-assessment {
  text-align: center;
  padding: 40px 0;
  color: #909399;
}

.assessment-item {
  margin-bottom: 20px;
}

.assessment-item:last-child {
  margin-bottom: 0;
}

.assessment-card {
  border: 1px solid #dcdfe6;
  border-radius: 8px;
  transition: all 0.3s;
}

.assessment-card:hover {
  box-shadow: 0 2px 12px 0 rgba(0, 0, 0, 0.1);
  border-color: #409EFF;
}

.assessment-title {
  font-size: 16px;
  font-weight: 600;
  color: #2645f7;
  color: #303133;
}

.status-tag {
  float: right;
  margin-right: 0;
}

.time-text {
  color: #67C23A;
  font-weight: 500;
}

.opinion-content {
  padding: 8px 12px;
  background: #f5f7fa;
  border-radius: 4px;
  line-height: 1.5;
  color: #606266;
  white-space: pre-wrap;
  word-break: break-word;
}

.detail-descriptions {
  background: #fff;
}

/* 优化表格样式 */
::v-deep .el-table {
  color: #303133;
  font-size: 14px;
}

::v-deep .el-table th {
  background-color: #f5f7fa;
  color: #303133;
  font-weight: 600;
  padding: 12px 0;
}

::v-deep .el-table tr {
  background-color: #fff;
}

::v-deep .el-table tr:hover {
  background-color: #f5f7fa;
}

::v-deep .el-table .cell {
  padding: 12px 10px;
  line-height: 1.5;
}

::v-deep .el-table--striped .el-table__body tr.el-table__row--striped td {
  background-color: #fafafa;
}

::v-deep .el-table--enable-row-hover .el-table__body tr:hover>td {
  background-color: #ecf5ff;
}

/* 可评估行样式 */
::v-deep .assessable-row {
  background-color: #f0f9ff !important;
}

::v-deep .assessable-row:hover {
  background-color: #d9ecff !important;
}

::v-deep .non-assessable-row {
  background-color: #fafafa !important;
}

/* 描述列表样式优化 */
::v-deep .el-descriptions__label {
  width: 120px;
  background-color: #f5f7fa;
  font-weight: 600;
  color: #303133;
}

::v-deep .el-descriptions__content {
  background-color: #fff;
  color: #606266;
}

::v-deep .el-descriptions__body {
  background-color: #fff;
}

/* 卡片样式优化 */
::v-deep .el-card__header {
  background-color: #f5f7fa;
  border-bottom: 1px solid #e6ebf5;
  padding: 12px 20px;
  font-weight: 600;
  color: #303133;
}

::v-deep .el-card__body {
  padding: 20px;
}

/* 标签样式优化 */
::v-deep .el-tag {
  font-weight: 500;
  border-radius: 12px;
  padding: 0 10px;
  height: 24px;
  line-height: 22px;
}

/* 按钮样式优化 */
::v-deep .el-button--mini {
  padding: 7px 12px;
  font-size: 12px;
  border-radius: 4px;
}

/* Tab样式优化 */
::v-deep .el-tabs__item {
  font-weight: 500;
  color: #606266;
}

::v-deep .el-tabs__item.is-active {
  color: #409EFF;
  font-weight: 600;
}

::v-deep .el-tabs__nav-wrap::after {
  background-color: #e4e7ed;
}

::v-deep .el-tabs--card>.el-tabs__header .el-tabs__item.is-active {
  background-color: #fff;
  border-bottom-color: #fff;
}

/* 响应式设计 */
@media (max-width: 768px) {
  .assessment-summary {
    padding: 5px;
  }

  ::v-deep .el-table .cell {
    padding: 8px 5px;
  }

  .assessment-card {
    margin-bottom: 10px;
  }
}
</style>