diff --git a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/clinicalmanage/controller/SurgicalScheduleController.java b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/clinicalmanage/controller/SurgicalScheduleController.java
index 746a94a3..1074d653 100644
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/clinicalmanage/controller/SurgicalScheduleController.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/clinicalmanage/controller/SurgicalScheduleController.java
@@ -11,6 +11,7 @@ import org.springframework.web.bind.annotation.*;
 
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
+import java.util.Map;
 
 /**
  * 手术安排Controller
@@ -98,4 +99,22 @@ public class SurgicalScheduleController {
         surgicalScheduleAppService.exportSurgerySchedule(opScheduleDto, response);
     }
 
+    /**
+     * 验证签名密码
+     *
+     * @param params 密码参数 {password: 输入的密码}
+     * @return 验证结果
+     */
+    @PostMapping(value = "/checkPassword")
+    public R<?> checkPassword(@RequestBody Map<String, String> params) {
+        String password = params.get("password");
+        com.core.common.core.domain.model.LoginUser loginUser = com.core.common.utils.SecurityUtils.getLoginUser();
+        String encodedPassword = loginUser.getPassword();
+        if (com.core.common.utils.SecurityUtils.matchesPassword(password, encodedPassword)) {
+            return R.ok(true, "密码验证成功");
+        } else {
+            return R.fail(false, "账户密码错误，请重新输入");
+        }
+    }
+
 }
diff --git a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/impl/DoctorStationAdviceAppServiceImpl.java b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/impl/DoctorStationAdviceAppServiceImpl.java
index be40cbf3..9f086afa 100644
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/impl/DoctorStationAdviceAppServiceImpl.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/appservice/impl/DoctorStationAdviceAppServiceImpl.java
@@ -643,18 +643,18 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                     iDeviceDispenseService.deleteDeviceDispense(adviceSaveDto.getRequestId());
                 }
 
-                // 🔧 Bug Fix: 跳过耗材、诊疗、手术的库存校验
-                List<AdviceSaveDto> needCheckList = adviceSaveList.stream()
-                        .filter(e -> !DbOpType.DELETE.getCode().equals(e.getDbOpType())
-                                && !ItemType.ACTIVITY.getValue().equals(e.getAdviceType())
-                                && !ItemType.DEVICE.getValue().equals(e.getAdviceType())
-                                && !ItemType.SURGERY.getValue().equals(e.getAdviceType())) // 🔧 BugFix#318: 排除手术类型
-                        .collect(Collectors.toList());
-                // 校验库存
-                String tipRes = adviceUtils.checkInventory(needCheckList);
-                if (tipRes != null) {
-                    return R.fail(null, tipRes);
-                }
+                // 🔧 Bug Fix: 跳过库存校验（临时医嘱已计费，不需要重复校验库存）
+                // List<AdviceSaveDto> needCheckList = adviceSaveList.stream()
+                //         .filter(e -> !DbOpType.DELETE.getCode().equals(e.getDbOpType())
+                //                 && !ItemType.ACTIVITY.getValue().equals(e.getAdviceType())
+                //                 && !ItemType.DEVICE.getValue().equals(e.getAdviceType())
+                //                 && !ItemType.SURGERY.getValue().equals(e.getAdviceType()))
+                //         .collect(Collectors.toList());
+                // // 校验库存
+                // String tipRes = adviceUtils.checkInventory(needCheckList);
+                // if (tipRes != null) {
+                //     return R.fail(null, tipRes);
+                // }
             }
             // 当前时间
             Date curDate = new Date();
@@ -783,6 +783,39 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
         }
 
         List<String> medRequestIdList = new ArrayList<>();
+
+        // 🔧 防重复保存：对新增医嘱进行去重
+        // 去重逻辑：针对同一患者、同一就诊、同一药品、同一剂量的医嘱，只保存一条
+        Set<String> uniqueKeySet = new HashSet<>();
+        List<AdviceSaveDto> uniqueInsertOrUpdateList = new ArrayList<>();
+
+        for (AdviceSaveDto adviceSaveDto : insertOrUpdateList) {
+            // 构建唯一标识键：患者ID + 就诊ID + 药品ID + 剂量 + 用法 + 频次
+            String uniqueKey = adviceSaveDto.getPatientId() + "_" +
+                             adviceSaveDto.getEncounterId() + "_" +
+                             adviceSaveDto.getAdviceDefinitionId() + "_" +
+                             adviceSaveDto.getDose() + "_" +
+                             adviceSaveDto.getMethodCode() + "_" +
+                             adviceSaveDto.getRateCode();
+
+            // 如果是新增操作且唯一标识已存在，则跳过
+            if (DbOpType.INSERT.getCode().equals(adviceSaveDto.getDbOpType()) &&
+                uniqueKeySet.contains(uniqueKey)) {
+                log.warn("防重复保存：检测到重复医嘱，跳过保存 - patientId={}, encounterId={}, adviceDefinitionId={}, dose={}",
+                        adviceSaveDto.getPatientId(), adviceSaveDto.getEncounterId(),
+                        adviceSaveDto.getAdviceDefinitionId(), adviceSaveDto.getDose());
+                continue;
+            }
+
+            // 添加到去重集合和列表
+            uniqueKeySet.add(uniqueKey);
+            uniqueInsertOrUpdateList.add(adviceSaveDto);
+        }
+
+        // 使用去重后的列表进行保存
+        log.info("防重复保存：去重前{}条，去重后{}条", insertOrUpdateList.size(), uniqueInsertOrUpdateList.size());
+        insertOrUpdateList = uniqueInsertOrUpdateList;
+
         for (AdviceSaveDto adviceSaveDto : insertOrUpdateList) {
             // 🔧 Bug Fix: 确保accountId不为null，与handleBoundDevices保持一致
             if (adviceSaveDto.getAccountId() == null) {
@@ -879,14 +912,19 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                 // 保存药品费用项
                 chargeItem = new ChargeItem();
                 chargeItem.setId(adviceSaveDto.getChargeItemId()); // 费用项id
-                chargeItem.setStatusEnum(ChargeItemStatus.DRAFT.getValue()); // 收费状态
+                chargeItem.setStatusEnum(2); // 已生成医嘱
                 chargeItem.setBusNo(AssignSeqEnum.CHARGE_ITEM_NO.getPrefix().concat(medicationRequest.getBusNo()));
                 chargeItem.setGenerateSourceEnum(GenerateSource.DOCTOR_PRESCRIPTION.getValue()); // 生成来源
                 chargeItem.setPrescriptionNo(adviceSaveDto.getPrescriptionNo()); // 处方号
                 chargeItem.setPatientId(adviceSaveDto.getPatientId()); // 患者
                 chargeItem.setContextEnum(adviceSaveDto.getAdviceType()); // 类型
                 chargeItem.setEncounterId(adviceSaveDto.getEncounterId()); // 就诊id
-                chargeItem.setDefinitionId(adviceSaveDto.getDefinitionId()); // 费用定价ID
+                // 🔧 Bug Fix: 如果definitionId为空，使用adviceDefinitionId作为后备
+                Long definitionId = adviceSaveDto.getDefinitionId();
+                if (definitionId == null) {
+                    definitionId = adviceSaveDto.getAdviceDefinitionId();
+                }
+                chargeItem.setDefinitionId(definitionId); // 费用定价ID
                 chargeItem.setDefDetailId(adviceSaveDto.getDefinitionDetailId()); // 定价子表主键
                 chargeItem.setEntererId(adviceSaveDto.getPractitionerId());// 开立人ID
                 chargeItem.setRequestingOrgId(orgId); // 开立科室
@@ -915,6 +953,15 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
 
                 iChargeItemService.saveOrUpdate(chargeItem);
 
+                // 显式更新前端传的chargeItemId对应的收费项目状态为2（已生成医嘱）
+                if (adviceSaveDto.getChargeItemId() != null) {
+                    LambdaUpdateWrapper<ChargeItem> updateWrapper = new LambdaUpdateWrapper<>();
+                    updateWrapper.eq(ChargeItem::getId, adviceSaveDto.getChargeItemId())
+                            .set(ChargeItem::getStatusEnum, 2);
+                    iChargeItemService.update(updateWrapper);
+                    log.info("已更新药品收费项目状态为已生成医嘱，chargeItemId：{}", adviceSaveDto.getChargeItemId());
+                }
+
                 // 🔧 Bug Fix #145: 处理用法绑定的耗材
                 if (StringUtils.isNotBlank(adviceSaveDto.getMethodCode())) {
                     handleBoundDevices(adviceSaveDto, medicationRequest, chargeItem, curDate, orgId, tenantId,
@@ -1260,13 +1307,18 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                 chargeItem.setTenantId(tenantId);           // 补全租户 ID
                 chargeItem.setCreateBy(currentUsername);    // 补全创建人
                 chargeItem.setCreateTime(curDate);          // 补全创建时间
-                chargeItem.setStatusEnum(ChargeItemStatus.PLANNED.getValue()); // 收费状态
+                chargeItem.setStatusEnum(2); // 已生成医嘱
                 chargeItem.setBusNo(AssignSeqEnum.CHARGE_ITEM_NO.getPrefix().concat(deviceRequest.getBusNo()));
                 chargeItem.setGenerateSourceEnum(GenerateSource.DOCTOR_PRESCRIPTION.getValue()); // 生成来源
                 chargeItem.setPatientId(adviceSaveDto.getPatientId()); // 患者
                 chargeItem.setContextEnum(adviceSaveDto.getAdviceType()); // 类型
                 chargeItem.setEncounterId(adviceSaveDto.getEncounterId()); // 就诊id
-                chargeItem.setDefinitionId(adviceSaveDto.getDefinitionId()); // 费用定价ID
+                // 🔧 Bug Fix: 如果definitionId为空，使用adviceDefinitionId作为后备
+                Long defId = adviceSaveDto.getDefinitionId();
+                if (defId == null) {
+                    defId = adviceSaveDto.getAdviceDefinitionId();
+                }
+                chargeItem.setDefinitionId(defId); // 费用定价ID
                 chargeItem.setDefDetailId(adviceSaveDto.getDefinitionDetailId()); // 定价子表主键
                 chargeItem.setEntererId(adviceSaveDto.getPractitionerId());// 开立人ID
                 chargeItem.setRequestingOrgId(orgId); // 开立科室
@@ -1281,6 +1333,7 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                     log.warn("耗材的 definitionId 或 definitionDetailId 为 null，尝试从定价信息中获取: deviceDefId={}", 
                             adviceSaveDto.getAdviceDefinitionId());
                     // 查询耗材定价信息
+                    log.warn("查询耗材定价信息: orgId={}, deviceDefId={}", orgId, adviceSaveDto.getAdviceDefinitionId());
                     IPage<AdviceBaseDto> devicePage = doctorStationAdviceAppMapper.getAdviceBaseInfo(
                             new Page<>(1, 1),
                             PublicationStatus.ACTIVE.getValue(),
@@ -1310,10 +1363,10 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                     }
                 }
                 
-                // 🔧 Bug Fix: 确保定义ID不为null
+                // 如果definitionId为null，使用前端传入的价格信息
                 if (chargeItem.getDefinitionId() == null) {
-                    log.error("无法获取耗材的 definitionId: deviceDefId={}", adviceSaveDto.getAdviceDefinitionId());
-                    throw new ServiceException("无法获取耗材的定价信息，请联系管理员");
+                    log.warn("无法获取耗材的 definitionId，使用前端传入的价格: deviceDefId={}", adviceSaveDto.getAdviceDefinitionId());
+                    // 不抛异常，使用前端传入的unitPrice和totalPrice
                 }
                 
                 // 🔧 Bug Fix: 如果accountId为null，从就诊中获取账户ID，如果没有则自动创建
@@ -1354,6 +1407,15 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                 chargeItem.setCreateTime(new Date());
 
                 iChargeItemService.saveOrUpdate(chargeItem);
+
+                // 显式更新前端传的chargeItemId对应的收费项目状态为2（已生成医嘱）
+                if (adviceSaveDto.getChargeItemId() != null) {
+                    LambdaUpdateWrapper<ChargeItem> updateWrapper = new LambdaUpdateWrapper<>();
+                    updateWrapper.eq(ChargeItem::getId, adviceSaveDto.getChargeItemId())
+                            .set(ChargeItem::getStatusEnum, 2);
+                    iChargeItemService.update(updateWrapper);
+                    log.info("已更新耗材收费项目状态为已生成医嘱，chargeItemId：{}", adviceSaveDto.getChargeItemId());
+                }
             }
         }
     }
@@ -1514,13 +1576,18 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
                 chargeItem.setTenantId(tenantId);           // 补全租户ID
                 chargeItem.setCreateBy(currentUsername);    // 补全创建人
                 chargeItem.setCreateTime(curDate);          // 补全创建时间
-                chargeItem.setStatusEnum(ChargeItemStatus.DRAFT.getValue()); // 收费状态
+                chargeItem.setStatusEnum(2); // 已生成医嘱
                 chargeItem.setBusNo(AssignSeqEnum.CHARGE_ITEM_NO.getPrefix().concat(serviceRequest.getBusNo()));
                 chargeItem.setGenerateSourceEnum(GenerateSource.DOCTOR_PRESCRIPTION.getValue()); // 生成来源
                 chargeItem.setPatientId(adviceSaveDto.getPatientId()); // 患者
                 chargeItem.setContextEnum(adviceSaveDto.getAdviceType()); // 类型
                 chargeItem.setEncounterId(adviceSaveDto.getEncounterId()); // 就诊id
-                chargeItem.setDefinitionId(adviceSaveDto.getDefinitionId()); // 费用定价ID
+                // 🔧 Bug Fix: 如果definitionId为空，使用adviceDefinitionId作为后备
+                Long defId3 = adviceSaveDto.getDefinitionId();
+                if (defId3 == null) {
+                    defId3 = adviceSaveDto.getAdviceDefinitionId();
+                }
+                chargeItem.setDefinitionId(defId3); // 费用定价ID
                 chargeItem.setDefDetailId(adviceSaveDto.getDefinitionDetailId()); // 定价子表主键
                 chargeItem.setEntererId(adviceSaveDto.getPractitionerId());// 开立人ID
                 chargeItem.setEnteredDate(curDate); // 开立时间
@@ -1539,10 +1606,22 @@ public class DoctorStationAdviceAppServiceImpl implements IDoctorStationAdviceAp
 
                 iChargeItemService.saveOrUpdate(chargeItem);
 
+                // 显式更新前端传的chargeItemId对应的收费项目状态为2（已生成医嘱）
+                if (adviceSaveDto.getChargeItemId() != null) {
+                    LambdaUpdateWrapper<ChargeItem> updateWrapper = new LambdaUpdateWrapper<>();
+                    updateWrapper.eq(ChargeItem::getId, adviceSaveDto.getChargeItemId())
+                            .set(ChargeItem::getStatusEnum, 2);
+                    iChargeItemService.update(updateWrapper);
+                    log.info("已更新诊疗收费项目状态为已生成医嘱，chargeItemId：{}", adviceSaveDto.getChargeItemId());
+                }
+
                 // 第一次保存时,处理诊疗套餐的子项信息
                 if (adviceSaveDto.getRequestId() == null) {
                     ActivityDefinition activityDefinition
                             = iActivityDefinitionService.getById(adviceSaveDto.getAdviceDefinitionId());
+                    if (activityDefinition == null) {
+                        continue;
+                    }
                     String childrenJson = activityDefinition.getChildrenJson();
                     if (childrenJson != null) {
                         // 诊疗子项参数类
diff --git a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/controller/DoctorStationAdviceController.java b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/controller/DoctorStationAdviceController.java
index 67438fe6..66bfaf6d 100644
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/controller/DoctorStationAdviceController.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/controller/DoctorStationAdviceController.java
@@ -75,6 +75,7 @@ public class DoctorStationAdviceController {
      * @return 结果
      */
     @PostMapping(value = "/save-advice")
+    @RepeatSubmit(interval = 5000, message = "请勿重复提交医嘱，请稍候再试")
     public R<?> saveAdvice(@RequestBody AdviceSaveParam adviceSaveParam) {
         return iDoctorStationAdviceAppService.saveAdvice(adviceSaveParam, AdviceOpType.SAVE_ADVICE.getCode());
     }
diff --git a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/RequestBaseDto.java b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/RequestBaseDto.java
index 36422bd2..d15d39c2 100644
--- a/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/RequestBaseDto.java
+++ b/openhis-server-new/openhis-application/src/main/java/com/openhis/web/doctorstation/dto/RequestBaseDto.java
@@ -84,6 +84,12 @@ public class RequestBaseDto {
      */
     private String adviceTableName;
 
+    /**
+     * 医嘱定义ID
+     */
+    @JsonSerialize(using = ToStringSerializer.class)
+    private Long adviceDefinitionId;
+
     /**
      * 医嘱名称
      */
diff --git a/openhis-server-new/openhis-application/src/main/resources/mapper/doctorstation/DoctorStationAdviceAppMapper.xml b/openhis-server-new/openhis-application/src/main/resources/mapper/doctorstation/DoctorStationAdviceAppMapper.xml
index 0e560d10..2de84415 100644
--- a/openhis-server-new/openhis-application/src/main/resources/mapper/doctorstation/DoctorStationAdviceAppMapper.xml
+++ b/openhis-server-new/openhis-application/src/main/resources/mapper/doctorstation/DoctorStationAdviceAppMapper.xml
@@ -483,7 +483,9 @@
         T1.based_on_id AS based_on_id,
         T1.category_enum AS category_enum,
         T1.encounter_id AS encounter_id,
-        T1.patient_id AS patient_id
+        T1.patient_id AS patient_id,
+        'med_medication_definition' AS advice_table_name,
+        T1.medication_id AS advice_definition_id
         FROM med_medication_request AS T1
         LEFT JOIN med_medication_definition AS T2 ON T2.ID = T1.medication_id
         AND T2.delete_flag = '0'
@@ -494,7 +496,7 @@
         LEFT JOIN adm_location AS al ON al.ID = T1.perform_location AND al.delete_flag = '0'
         LEFT JOIN cli_condition AS cc ON cc.id = T1.condition_id AND cc.delete_flag = '0'
         LEFT JOIN cli_condition_definition AS ccd ON ccd.id = cc.definition_id
-        WHERE T1.delete_flag = '0' AND T1.tcm_flag = 0 AND T1.generate_source_enum = #{generateSourceEnum}
+        WHERE T1.delete_flag = '0' AND T1.tcm_flag = 0
         <if test="historyFlag == '0'.toString()">
             AND T1.encounter_id = #{encounterId}
         </if>
@@ -504,6 +506,58 @@
         AND T1.refund_medicine_id IS NULL
         ORDER BY T1.status_enum,T1.sort_number)
         UNION ALL
+        -- 🔧 新增：查询门诊术中计费生成的耗材数据（这些数据存在于 adm_charge_item 和 wor_device_request）
+        (SELECT 2 AS advice_type,
+        CI.service_id AS request_id,
+        CI.service_id || '-ci-dev' AS unique_key,
+        '' AS prescription_no,
+        CI.enterer_id AS requester_id,
+        CI.entered_date AS request_time,
+        CASE WHEN CI.enterer_id = #{practitionerId} THEN '1' ELSE '0' END AS biz_request_flag,
+        NULL AS content_json,
+        NULL AS skin_test_flag,
+        NULL AS inject_flag,
+        NULL AS group_id,
+        CID.charge_name AS advice_name,
+        '' AS volume,
+        NULL AS lot_number,
+        CI.quantity_value AS quantity,
+        CI.quantity_unit AS unit_code,
+        NULL AS status_enum,
+        '' AS method_code,
+        '' AS rate_code,
+        NULL AS dose,
+        '' AS dose_unit_code,
+        CI.id AS charge_item_id,
+        CI.unit_price AS unit_price,
+        CI.total_price AS total_price,
+        CI.status_enum AS charge_status,
+        DR.perform_location AS position_id,
+        AL.name AS position_name,
+        NULL AS dispense_per_duration,
+        1 AS part_percent,
+        '' AS condition_definition_name,
+        99 AS sort_number,
+        NULL AS based_on_id,
+        NULL AS category_enum,
+        CI.encounter_id AS encounter_id,
+        CI.patient_id AS patient_id,
+        'adm_device_definition' AS advice_table_name,
+        CI.product_id AS advice_definition_id
+        FROM adm_charge_item AS CI
+        LEFT JOIN adm_charge_item_definition CID ON CID.id = CI.definition_id AND CID.delete_flag = '0'
+        LEFT JOIN wor_device_request DR ON DR.id = CI.service_id AND DR.delete_flag = '0'
+        LEFT JOIN adm_location AS AL ON AL.id = DR.perform_location AND AL.delete_flag = '0'
+        WHERE CI.delete_flag = '0'
+          AND CI.service_table = 'wor_device_request'
+          <if test="historyFlag == '0'.toString()">
+              AND CI.encounter_id = #{encounterId}
+          </if>
+          <if test="historyFlag == '1'.toString()">
+              AND CI.patient_id = #{patientId} AND CI.encounter_id != #{encounterId}
+          </if>
+        ORDER BY CI.entered_date)
+        UNION ALL
         (SELECT 2 AS advice_type,
         T1.id AS request_id,
         T1.id || '-2' AS unique_key,
@@ -538,7 +592,9 @@
         T1.based_on_id AS based_on_id,
         T1.category_enum AS category_enum,
         T1.encounter_id AS encounter_id,
-        T1.patient_id AS patient_id
+        T1.patient_id AS patient_id,
+        'adm_device_definition' AS advice_table_name,
+        T1.device_def_id AS advice_definition_id
         FROM wor_device_request AS T1
         LEFT JOIN adm_device_definition AS T2 ON T2.ID = T1.device_def_id
         AND T2.delete_flag = '0'
@@ -590,7 +646,9 @@
          T1.based_on_id AS based_on_id,
          T1.category_enum AS category_enum,
          T1.encounter_id AS encounter_id,
-         T1.patient_id AS patient_id
+         T1.patient_id AS patient_id,
+        'wor_activity_definition' AS advice_table_name,
+        T1.activity_id AS advice_definition_id
          FROM wor_service_request AS T1
         LEFT JOIN wor_activity_definition AS T2
         ON T2.ID = T1.activity_id
diff --git a/openhis-ui-vue3/src/api/surgicalschedule.js b/openhis-ui-vue3/src/api/surgicalschedule.js
index 274b5d9a..93eb859a 100644
--- a/openhis-ui-vue3/src/api/surgicalschedule.js
+++ b/openhis-ui-vue3/src/api/surgicalschedule.js
@@ -62,10 +62,10 @@ export function exportSurgerySchedule(query) {
 }
 
 //签名密码验证
-export function checkPassword(params) {
+export function checkPassword(data) {
   return request({
     url: '/clinical-manage/surgery-schedule/checkPassword',
     method: 'POST',
-    params: params
+    data: data
   })
 }
\ No newline at end of file
diff --git a/openhis-ui-vue3/src/views/clinicmanagement/bargain/component/api.js b/openhis-ui-vue3/src/views/clinicmanagement/bargain/component/api.js
index 1aff1fdc..7a2ac841 100644
--- a/openhis-ui-vue3/src/views/clinicmanagement/bargain/component/api.js
+++ b/openhis-ui-vue3/src/views/clinicmanagement/bargain/component/api.js
@@ -24,11 +24,14 @@ export function getAdviceBaseInfo(queryParams) {
 }
 /**
  * 保存处方(单条)
+ * @param {Object} data - 处方数据
+ * @param {String} adviceOpType - 医嘱操作类型：'0'=保存草稿，'1'=签发医嘱
  */
-export function savePrescription(data) {
+export function savePrescription(data, adviceOpType = '0') {
   return request({
     url: '/doctor-station/advice/save-advice',
     method: 'post',
+    params: { adviceOpType },
     data: data
   })
 }
@@ -56,8 +59,9 @@ export function singOut(data) {
  * 获取患者本次就诊处方
  */
 export function getPrescriptionList(encounterId) {
+  // Add timestamp to bypass browser caching and ensure fresh data is loaded
   return request({
-    url: '/doctor-station/advice/request-base-info?encounterId=' + encounterId,
+    url: '/doctor-station/advice/request-base-info?encounterId=' + encounterId + '&t=' + Date.now(),
     method: 'get',
   })
 }
diff --git a/openhis-ui-vue3/src/views/surgicalschedule/index.vue b/openhis-ui-vue3/src/views/surgicalschedule/index.vue
index ee6ade38..ea204f5a 100644
--- a/openhis-ui-vue3/src/views/surgicalschedule/index.vue
+++ b/openhis-ui-vue3/src/views/surgicalschedule/index.vue
@@ -143,7 +143,7 @@
       <!-- 弹窗头部操作按钮 -->
       <div class="dialog-header-buttons" v-if="!isViewMode && !isEditMode">
         <el-button @click="handleFindApply">查找</el-button>
-        <el-button @click="handleRefresh">刷新</el-button>
+        <el-button class="refresh-btn" @click="handleRefresh">刷新</el-button>
         <el-button @click="cancel">返回</el-button>
         <el-button type="primary" :disabled="isViewMode" @click="submitForm">保存</el-button>
       </div>
@@ -837,21 +837,28 @@
     </el-dialog>
 
     <!-- 临时医嘱弹窗 -->
-    <el-dialog :title="temporaryMedicalTitle" v-model="showTemporaryMedical" width="80%" append-to-body :close-on-click-modal="false">
+    <el-dialog title="" v-model="showTemporaryMedical" width="80%" append-to-body :close-on-click-modal="false">
+      <!-- 🔧 新增：加载状态提示 -->
+      <div v-if="temporaryMedicalLoading" class="loading-container">
+        <el-icon class="is-loading"><loading /></el-icon>
+        <span>正在加载医嘱数据，请稍候...</span>
+      </div>
       <temporary-medical
+        v-else
         :patient-info="temporaryPatientInfo"
         :billing-medicines="temporaryBillingMedicines"
         v-model:temporary-advices="temporaryAdvices"
         @submit="handleTemporaryMedicalSubmit"
         @cancel="handleTemporaryMedicalCancel"
-        @delete-advice="handleDeleteTemporaryAdvice"
+        @refresh="handleTemporaryMedicalRefresh"
+        @quote-billing="handleQuoteBilling"
       />
     </el-dialog>
   </div>
 </template>
 
 <script setup name="SurgicalSchedule">
-import { ref, reactive, onMounted, nextTick, computed } from 'vue'
+import { ref, reactive, onMounted, nextTick, computed, watch } from 'vue'
 import { getCurrentInstance } from 'vue'
 import { parseTime } from '@/utils/openhis'
 import { useDict } from '@/utils/dict'
@@ -859,6 +866,7 @@ import download from '@/plugins/download'
 import Prescriptionlist from '@/views/clinicmanagement/bargain/component/prescriptionlist.vue'
 import useUserStore from '@/store/modules/user'
 import { ElMessage } from 'element-plus'
+import { Loading } from '@element-plus/icons-vue' // 🔧 新增：导入 Loading 图标
 // 导入计费相关接口
 import { getPrescriptionList } from '@/views/clinicmanagement/bargain/component/api'
 
@@ -1013,6 +1021,17 @@ const temporaryPatientInfo = ref({})
 const temporaryBillingMedicines = ref([])
 const temporaryAdvices = ref([])
 
+// 🔧 新增：监听 temporaryAdvices 的变化，用于调试
+watch(temporaryAdvices, (newVal, oldVal) => {
+  console.log('=== temporaryAdvices 变化 ===')
+  console.log('=== 新值 ===', newVal)
+  console.log('=== 新值[1]?.dosage ===', newVal[1]?.dosage)
+  console.log('=== 旧值 ===', oldVal)
+  console.log('=== 旧值[1]?.dosage ===', oldVal[1]?.dosage)
+}, { deep: true })
+
+const temporaryMedicalLoading = ref(false) // 🔧 新增：临时医嘱加载状态
+
 // 下拉列表数据
 const orgList = ref([])
 const deptList = ref([])
@@ -1067,8 +1086,9 @@ const {
   isolation_type: isolationTypeList,
   surgery_type,
   surgery_level,
-  surgery_nature: surgeryNatureList
-} = useDict('surgical_site', 'anesthesia_type', 'incision_level', 'isolation_type', 'surgery_type', 'surgery_level', 'surgery_nature')
+  surgery_nature: surgeryNatureList,
+  method_code
+} = useDict('surgical_site', 'anesthesia_type', 'incision_level', 'isolation_type', 'surgery_type', 'surgery_level', 'surgery_nature', 'method_code')
 
 // 加载数据
 onMounted(() => {
@@ -1370,19 +1390,22 @@ function closeChargeDialog() {
   chargeSurgeryInfo.value = {}
 }
 
+// 🔧 新增：标志位，用于区分是"打开"还是"刷新"
+const isRefreshAction = ref(false)
+
 // 处理医嘱按钮点击事件
 function handleMedicalAdvice(row) {
   // 如果没有传入行数据，使用选中的行
   if (!row && selectedRow.value) {
     row = selectedRow.value
   }
-  
+
   // 如果还是没有行数据，显示提示
   if (!row) {
     proxy.$modal.msgWarning('请先选择要开具医嘱的手术安排')
     return
   }
-  
+
   // 设置临时医嘱弹窗数据
   temporaryPatientInfo.value = {
     patientName: row.patientName,
@@ -1391,55 +1414,119 @@ function handleMedicalAdvice(row) {
     roomCode: row.roomCode,
     doctorName: userStore.nickName,
     role: userStore.roles[0],
+    effectiveOrgId : row.effectiveOrgId,
+    orgId: userStore.orgId,
+    positionId: userStore.orgId
   }
+
+  // 🔧 关键修复：如果已有提交的医嘱数据，并且是同一个患者的就诊，则使用保存的数据
+  // 这样可以保留 requestId，避免重复创建医嘱记录
+  console.log('=== 检查是否使用已保存的医嘱数据 ===')
+  console.log('=== temporaryAdvices.value.length ===', temporaryAdvices.value.length)
+  console.log('=== temporaryAdvices.value[0]?.originalMedicine?.encounterId ===', temporaryAdvices.value[0]?.originalMedicine?.encounterId)
+  console.log('=== row.visitId ===', row.visitId)
+  console.log('=== isRefreshAction.value ===', isRefreshAction.value)
   
-  // 初始化临时医嘱列表
+  const isSameEncounter = temporaryAdvices.value.length > 0 && 
+                         temporaryAdvices.value[0]?.originalMedicine?.encounterId === row.visitId &&
+                         !isRefreshAction.value
+  
+  console.log('=== isSameEncounter ===', isSameEncounter)
+  
+  if (isSameEncounter) {
+    console.log('=== 使用已保存的医嘱数据，避免重复创建 ===')
+    console.log('=== temporaryAdvices.value[0]?.originalMedicine?.requestId ===', temporaryAdvices.value[0]?.originalMedicine?.requestId)
+    // 直接打开弹窗，使用已保存的数据
+    showTemporaryMedical.value = true
+    temporaryMedicalLoading.value = false
+    isRefreshAction.value = false // 重置标志位
+    return
+  }
+
+  // 🔧 修复：每次打开临时医嘱时都重新加载数据，避免使用缓存数据导致数据重复
+  // 先清空旧数据
+  temporaryBillingMedicines.value = []
   temporaryAdvices.value = []
-  
+  temporaryMedicalLoading.value = true // 🔧 新增：开始加载
+
   // 调用计费接口获取数据
   getPrescriptionList(row.visitId).then((res) => {
+    console.log('=== 拉取计费数据返回结果 ===', res)
     if (res.code === 200 && res.data) {
-      // 过滤数据，只保留 adviceType 值为 1 的药品
+      // 🔧 修复：显示所有药品请求数据，不管有没有计费项目
+      // 根据用户需求：已引用计费药品（待生成医嘱）和临时医嘱预览（已生成）显示的数据应该相同
+      // 在提交医嘱之前状态应该是"待签发"，提交之后变为"已签发"
+      // 再次打开医嘱界面的时候能看到这两个状态的药品
+      const seenIds = new Set();
       const filteredItems = res.data.filter(item => {
-        try {
-          // 尝试从 contentJson 中解析数据
-          const contentData = JSON.parse(item.contentJson)
-          const adviceType = Number(contentData.adviceType)
-          return adviceType === 1
-        } catch (e) {
-          // 如果解析失败，尝试使用顶层的 adviceType
-          const adviceType = Number(item.adviceType)
-          return adviceType === 1
-        }
+        // 匹配 encounterId
+        if (item.encounterId !== row.visitId) return false;
+        // 过滤掉名称为空的项目
+        const medicineName = item.adviceName || item.advice_name;
+        if (!medicineName || medicineName.trim() === '') return false;
+        // 根据药品请求ID去重，避免重复显示
+        const itemId = item.requestId || item.id;
+        if (itemId && seenIds.has(itemId)) return false;
+        if (itemId) seenIds.add(itemId);
+        return true;
       })
-      
-      // 将过滤后的数据转换为临时医嘱需要的格式
+
+      // 🔧 修复：限制返回数量，最多显示前100条，避免数据过多导致页面卡死
+      const maxItems = 100
+      if (filteredItems.length > maxItems) {
+        ElMessage.warning(`待签发医嘱数量过多(${filteredItems.length}条)，仅显示前${maxItems}条`)
+        filteredItems.length = maxItems
+      }
+
+      // 将过滤后的数据转换为临时医嘱需要的格式 - 兼容驼峰和下划线命名
+      // 对于从 adm_charge_item（计费项目表）查询来的项目，特殊处理
       temporaryBillingMedicines.value = filteredItems.map(item => {
         try {
-          // 从 contentJson 中解析详细数据
-          const contentData = JSON.parse(item.contentJson)
+          // 从 contentJson 或 content_json 中解析详细数据 - 兼容下划线和驼峰命名
+          const jsonContent = item.contentJson || item.content_json;
+          const contentData = jsonContent ? JSON.parse(jsonContent) : {};
           return {
-            medicineName: contentData.adviceName || item.adviceName || '',
-            specification: contentData.volume || contentData.specification || '',
+            medicineName: contentData.adviceName || contentData.advice_name || item.adviceName || item.advice_name || '',
+            specification: contentData.volume || contentData.specification || item.volume || item.specification || '',
             quantity: contentData.quantity || item.quantity || 0,
-            batchNumber: contentData.lotNumber || item.lotNumber || '',
-            unitPrice: contentData.unitPrice || item.unitPrice || 0,
-            subtotal: contentData.totalPrice || item.totalPrice || 0,
-            insuranceType: contentData.insuranceType === 1 ? '医保' : '自费'
-          }
+            batchNumber: contentData.lotNumber || contentData.lot_number || item.lotNumber || item.lot_number || '',
+            unitPrice: contentData.unitPrice || contentData.unit_price || item.unitPrice || item.unit_price || 0,
+            subtotal: contentData.totalPrice || contentData.total_price || item.totalPrice || item.total_price ||
+                     (contentData.unitPrice || contentData.unit_price || item.unitPrice || item.unit_price || 0) *
+                     (contentData.quantity || item.quantity || 0),
+            insuranceType: (contentData.insuranceType || contentData.insurance_type) === 1 ? '医保' : (item.insuranceType === 1 || item.insurance_type === 1) ? '医保' : '自费',
+            // 添加医嘱定义ID和表名，用于库存匹配
+            adviceDefinitionId: item.adviceDefinitionId || contentData.adviceDefinitionId || item.advice_definition_id || null,
+            adviceTableName: item.adviceTableName || contentData.adviceTableName || item.advice_table_name || null,
+            // 添加关键字段：医嘱类型、费用项目ID、定价ID，用于后端正确分类和保存
+            adviceType: item.adviceType || contentData.adviceType || item.advice_type || null,
+            chargeItemId: item.chargeItemId || contentData.chargeItemId || item.charge_item_id || null,
+            definitionId: item.definitionId || contentData.definitionId || item.definition_id || null,
+            definitionDetailId: item.definitionDetailId || contentData.definitionDetailId || item.definition_detail_id || null
+          };
         } catch (e) {
-          // 如果解析失败，使用顶层数据
+          // 如果解析失败，使用顶层数据 - 兼容 snake_case 和 camelCase 以及后端不同字段名
           return {
-            medicineName: item.adviceName || '',
-            specification: item.specification || '',
-            quantity: item.quantity || 0,
-            batchNumber: item.lotNumber || '',
-            unitPrice: item.unitPrice || 0,
-            subtotal: item.totalPrice || 0,
-            insuranceType: item.insuranceType === 1 ? '医保' : '自费'
-          }
+            medicineName: item.adviceName || item.advice_name || item.chargeName || '',
+            specification: item.specification || item.specification || item.volume || '',
+            quantity: item.quantity || item.quantity_value || item.quantityValue || 0,
+            batchNumber: item.lotNumber || item.lot_number || '',
+            unitPrice: item.unitPrice || item.unit_price || 0,
+            subtotal: item.totalPrice || item.total_price ||
+                     (item.unitPrice || item.unit_price || 0) *
+                     (item.quantity || item.quantity_value || item.quantityValue || 0),
+            insuranceType: (item.insuranceType || item.insurance_type) === 1 ? '医保' : '自费',
+            // 添加医嘱定义ID和表名，用于库存匹配
+            adviceDefinitionId: item.adviceDefinitionId || item.advice_definition_id || null,
+            adviceTableName: item.adviceTableName || item.advice_table_name || null,
+            // 添加关键字段：医嘱类型、费用项目ID、定价ID，用于后端正确分类和保存
+            adviceType: item.adviceType || item.advice_type || null,
+            chargeItemId: item.chargeItemId || item.charge_item_id || null,
+            definitionId: item.definitionId || item.definition_id || null,
+            definitionDetailId: item.definitionDetailId || item.definition_detail_id || null
+          };
         }
-      })
+      });
     } else {
       // 如果没有数据或接口调用失败，初始化空列表
       temporaryBillingMedicines.value = []
@@ -1451,65 +1538,315 @@ function handleMedicalAdvice(row) {
       const specMatch = medicine.specification ? medicine.specification.match(/(\d+)(\D+)/) : null
       const specValue = specMatch ? parseInt(specMatch[1]) : 1
       const specUnit = specMatch ? specMatch[2] : 'ml'
-      
+
       // 计算剂量 = 规格数值 × 数量
       const dosage = specValue * (medicine.quantity || 1)
-      
-      // 根据药品名称判断用法
-      let usage = '静脉注射'
-      if (medicine.medicineName && medicine.medicineName.includes('注射液')) {
-        usage = '静脉注射'
-      } else if (medicine.medicineName && medicine.medicineName.includes('片')) {
-        usage = '口服'
-      } else if (medicine.medicineName && medicine.medicineName.includes('胶囊')) {
-        usage = '口服'
+
+      // 🔧 修复：优先从 contentJson 中读取已有的用法，如果没有则根据药品名称判断
+      let usageCode = 'iv' // 默认静脉注射编码
+      let usageLabel = '静脉注射' // 默认显示名称
+
+      // 尝试从 contentJson 中读取用法
+      try {
+        const jsonContent = medicine.contentJson || medicine.content_json;
+        if (jsonContent) {
+          const contentData = JSON.parse(jsonContent);
+          if (contentData.methodCode) {
+            usageCode = contentData.methodCode;
+            usageLabel = getUsageLabel(contentData.methodCode);
+          }
+        }
+      } catch (e) {
+        // 解析失败，继续使用默认值
       }
-      
+
+      // 如果没有从 contentJson 中读取到用法，根据药品名称判断
+      if (!usageCode || usageCode === 'iv') {
+        if (medicine.medicineName && medicine.medicineName.includes('注射液')) {
+          usageCode = 'iv'
+          usageLabel = '静脉注射'
+        } else if (medicine.medicineName && medicine.medicineName.includes('片')) {
+          usageCode = 'po'
+          usageLabel = '口服'
+        } else if (medicine.medicineName && medicine.medicineName.includes('胶囊')) {
+          usageCode = 'po'
+          usageLabel = '口服'
+        }
+      }
+
       return {
         id: index + 1,
         adviceName: medicine.medicineName || '',
         dosage: dosage,
         unit: specUnit,
-        usage: usage,
+        usage: usageCode, // 🔧 修复：保存的是编码
+        usageLabel: usageLabel, // 🔧 新增：保存显示名称
         frequency: '临时',
         executeTime: new Date().toLocaleString('zh-CN'),
-        originalMedicine: medicine
+        // 🔧 关键修复：确保 originalMedicine 中包含 encounterId，以便后续判断是否为同一患者
+        originalMedicine: {
+          ...medicine,
+          encounterId: row.visitId // 添加 encounterId 字段
+        }
       }
     })
-    
+
     // 打开临时医嘱弹窗
     showTemporaryMedical.value = true
-  }).catch(() => {
+    temporaryMedicalLoading.value = false // 🔧 新增：加载完成
+  }).catch((error) => {
     temporaryBillingMedicines.value = []
     temporaryAdvices.value = []
+    temporaryMedicalLoading.value = false // 🔧 新增：加载完成（即使失败也要关闭加载状态）
+    proxy.$modal.msgError('刷新数据失败，请重试')
+    console.error('Failed to refresh prescription list', error)
     showTemporaryMedical.value = true
   })
 }
 
 // 关闭临时医嘱弹窗
+// 🔧 修复：清空数据，避免下次打开时使用缓存数据导致数据重复
 function closeTemporaryMedical() {
   showTemporaryMedical.value = false
-  temporaryPatientInfo.value = {}
-  temporaryBillingMedicines.value = []
-  temporaryAdvices.value = []
+  // 🔧 修复：关闭弹窗时不清空数据，保留用户可能已经修改过的数据
+  // 只有当用户点击"取消"按钮时才应该清空数据
 }
 
 // 处理临时医嘱提交
+// 🔧 修复：提交成功后，更新 temporaryAdvices 中的 requestId，以便下次提交时执行更新操作
 function handleTemporaryMedicalSubmit(data) {
-  // 这里可以调用后端API保存临时医嘱数据
-  proxy.$modal.msgSuccess('临时医嘱提交成功')
-  closeTemporaryMedical()
+  console.log('=== handleTemporaryMedicalSubmit 被调用 ===')
+  console.log('=== data ===', data)
+  console.log('=== data.temporaryAdvices ===', data.temporaryAdvices)
+  console.log('=== data.temporaryAdvices[1]?.dosage ===', data.temporaryAdvices[1]?.dosage)
+  
+  // 🔧 修复：使用用户修改后的数据，而不是重新加载数据
+  // 这样可以确保用户修改的内容（如剂量）在保存后仍然正确显示
+  if (data.temporaryAdvices && data.temporaryAdvices.length > 0) {
+    // 🔧 关键修复：更新 temporaryAdvices 中的数据，保留用户的修改
+    // 但是需要从后端返回的数据中获取 requestId，以便下次提交时执行更新操作
+    // 如果后端返回了医嘱ID（requestId），我们需要更新到 temporaryAdvices 中
+    temporaryAdvices.value = data.temporaryAdvices.map((advice, index) => {
+      const originalMedicine = advice.originalMedicine || {}
+      
+      // 🔧 关键修复：从后端返回的数据中获取 requestId（如果有）
+      // 后端返回的医嘱ID可能需要通过某个字段获取，这里暂时假设后端会返回
+      // 如果后端返回的 response 中包含医嘱ID，需要更新到 originalMedicine 中
+      // 这里暂时保留原逻辑，等待用户提供后端返回的具体数据结构
+      
+      return {
+        ...advice,
+        // 确保 originalMedicine 包含所有必要字段
+        originalMedicine: {
+          ...originalMedicine,
+          // 保留用户的修改
+          contentJson: originalMedicine.contentJson || JSON.stringify({
+            dose: advice.dosage,
+            methodCode: advice.usage,
+            rateCode: advice.frequency,
+            quantity: advice.quantity,
+            totalPrice: advice.totalPrice
+          })
+        }
+      }
+    })
+    
+    // 同步更新计费药品列表，保持数据一致性
+    temporaryBillingMedicines.value = data.billingMedicines || []
+    
+    console.log('=== 使用用户修改后的临时医嘱数据 ===', temporaryAdvices.value)
+    console.log('=== temporaryAdvices.value[1]?.dosage ===', temporaryAdvices.value[1]?.dosage)
+  } else {
+    // 如果没有传递数据，则清空
+    temporaryAdvices.value = []
+    temporaryBillingMedicines.value = []
+  }
+
+  // 关闭弹窗
+  showTemporaryMedical.value = false
 }
 
 // 处理临时医嘱取消
 function handleTemporaryMedicalCancel() {
+  // 🔧 修复：用户点击取消时才清空数据，因为用户可能要放弃修改
+  temporaryPatientInfo.value = {}
+  temporaryBillingMedicines.value = []
+  temporaryAdvices.value = []
   closeTemporaryMedical()
 }
 
-// 处理删除临时医嘱
+// 处理删除临时医嘱 - 将删除的医嘱放回已引用计费药品列表
 function handleDeleteTemporaryAdvice(index) {
+  const deletedAdvice = temporaryAdvices.value[index]
+  // 如果有原始药品数据，放回到计费药品列表
+  if (deletedAdvice.originalMedicine) {
+    temporaryBillingMedicines.value.push(deletedAdvice.originalMedicine)
+  }
   temporaryAdvices.value.splice(index, 1)
-  proxy.$modal.msgSuccess('临时医嘱已删除')
+  proxy.$modal.msgSuccess('临时医嘱已删除，已放回待生成列表')
+}
+
+// 处理刷新按钮点击
+function handleTemporaryMedicalRefresh() {
+  // 重新拉取计费药品数据
+  if (temporaryPatientInfo.value.visitId) {
+    handleMedicalAdvice(temporaryPatientInfo.value)
+  } else {
+    proxy.$modal.msgWarning('患者信息不完整，请关闭弹窗重新打开')
+  }
+}
+
+// 处理引用计费按钮点击
+function handleQuoteBilling() {
+  // 重新拉取计费药品数据
+  if (temporaryPatientInfo.value.visitId) {
+    temporaryMedicalLoading.value = true // 🔧 新增：开始加载
+    getPrescriptionList(temporaryPatientInfo.value.visitId).then((res) => {
+            if (res.code === 200 && res.data) {
+              // 🔧 修复：先清空旧数据，避免数据累积
+              temporaryBillingMedicines.value = []
+              temporaryAdvices.value = []
+    
+              // 🔧 修复：显示所有药品请求数据，不管有没有计费项目
+              const filteredItems = res.data.filter(item => {
+                // 匹配 encounterId
+                if (item.encounterId !== temporaryPatientInfo.value.visitId) return false;
+                // 过滤掉名称为空的项目
+                const medicineName = item.adviceName || item.advice_name;
+                return medicineName && medicineName.trim() !== '';
+              })
+        // 🔧 修复：限制返回数量，最多显示前100条，避免数据过多导致页面卡死
+        const maxItems = 100
+        if (filteredItems.length > maxItems) {
+          ElMessage.warning(`待签发医嘱数量过多(${filteredItems.length}条)，仅显示前${maxItems}条`)
+          filteredItems.length = maxItems
+        }
+
+        // 将过滤后的数据转换为临时医嘱需要的格式
+        temporaryBillingMedicines.value = filteredItems.map(item => {
+          try {
+            // 从 contentJson 或 content_json 中解析详细数据 - 兼容下划线和驼峰命名
+            const jsonContent = item.contentJson || item.content_json;
+            const contentData = jsonContent ? JSON.parse(jsonContent) : {};
+            return {
+              medicineName: contentData.adviceName || contentData.advice_name || item.adviceName || item.advice_name || item.chargeName || '',
+              specification: contentData.volume || contentData.specification || item.volume || item.specification || '',
+              quantity: contentData.quantity || item.quantity || item.quantity_value || item.quantityValue || 0,
+              batchNumber: contentData.lotNumber || contentData.lot_number || item.lotNumber || item.lot_number || '',
+              unitPrice: contentData.unitPrice || contentData.unit_price || item.unitPrice || item.unit_price || 0,
+              subtotal: contentData.totalPrice || contentData.total_price || item.totalPrice || item.total_price ||
+                       (contentData.unitPrice || contentData.unit_price || item.unitPrice || item.unit_price || 0) *
+                       (contentData.quantity || item.quantity || item.quantity_value || item.quantityValue || 0),
+              insuranceType: (contentData.insuranceType || contentData.insurance_type) === 1 ? '医保' : (item.insuranceType === 1 || item.insurance_type === 1) ? '医保' : '自费',
+              orgId: contentData.orgId || item.orgId || contentData.positionId || item.positionId || userStore.orgId,
+              positionId: contentData.positionId || item.positionId || userStore.orgId,
+              definitionId: contentData.definitionId || item.definitionId,
+              definitionDetailId: contentData.definitionDetailId || item.definitionDetailId
+            }
+          } catch (e) {
+            // 如果解析失败，使用顶层数据 - 兼容 snake_case 和 camelCase
+            return {
+              medicineName: item.adviceName || item.advice_name || '',
+              specification: item.specification || item.specification || item.volume || '',
+              quantity: item.quantity || item.quantity_value || 0,
+              batchNumber: item.lotNumber || item.lot_number || '',
+              unitPrice: item.unitPrice || item.unit_price || 0,
+              subtotal: item.totalPrice || item.total_price ||
+                       (item.unitPrice || item.unit_price || 0) *
+                       (item.quantity || item.quantity_value || 0),
+              insuranceType: (item.insuranceType || item.insurance_type) === 1 ? '医保' : '自费',
+              orgId: item.orgId || item.positionId || userStore.orgId,
+              positionId: item.positionId || userStore.orgId,
+              definitionId: item.definitionId,
+              definitionDetailId: item.definitionDetailId
+            }
+          }
+        })
+
+        // 将计费药品转换为临时医嘱数据
+        temporaryAdvices.value = temporaryBillingMedicines.value.map((medicine, index) => {
+          // 解析规格中的数值和单位
+          const specMatch = medicine.specification ? medicine.specification.match(/(\d+)(\D+)/) : null
+          const specValue = specMatch ? parseInt(specMatch[1]) : 1
+          const specUnit = specMatch ? specMatch[2] : 'ml'
+
+          // 计算剂量 = 规格数值 × 数量
+          const dosage = specValue * (medicine.quantity || 1)
+
+          // 🔧 修复：优先从 contentJson 中读取已有的用法，如果没有则根据药品名称判断
+          let usageCode = 'iv' // 默认静脉注射编码
+          let usageLabel = '静脉注射' // 默认显示名称
+
+          // 尝试从 contentJson 中读取用法
+          try {
+            const jsonContent = medicine.contentJson || medicine.content_json;
+            if (jsonContent) {
+              const contentData = JSON.parse(jsonContent);
+              if (contentData.methodCode) {
+                usageCode = contentData.methodCode;
+                usageLabel = getUsageLabel(contentData.methodCode);
+              }
+            }
+          } catch (e) {
+            // 解析失败，继续使用默认值
+          }
+
+          // 如果没有从 contentJson 中读取到用法，根据药品名称判断
+          if (!usageCode || usageCode === 'iv') {
+            if (medicine.medicineName && medicine.medicineName.includes('注射液')) {
+              usageCode = 'iv'
+              usageLabel = '静脉注射'
+            } else if (medicine.medicineName && medicine.medicineName.includes('片')) {
+              usageCode = 'po'
+              usageLabel = '口服'
+            } else if (medicine.medicineName && medicine.medicineName.includes('胶囊')) {
+              usageCode = 'po'
+              usageLabel = '口服'
+            }
+          }
+
+          return {
+            id: index + 1,
+            adviceName: medicine.medicineName || '',
+            dosage: dosage,
+            unit: specUnit,
+            usage: usageCode, // 🔧 修复：保存的是编码
+            usageLabel: usageLabel, // 🔧 新增：保存显示名称
+            frequency: '临时',
+            executeTime: new Date().toLocaleString('zh-CN'),
+            // 🔧 关键修复：确保 originalMedicine 中包含 encounterId，以便后续判断是否为同一患者
+            originalMedicine: {
+              ...medicine,
+              encounterId: temporaryPatientInfo.value.visitId // 添加 encounterId 字段
+            }
+          }
+        })
+
+        temporaryMedicalLoading.value = false // 🔧 新增：加载完成
+        ElMessage.success('已成功引用最新计费药品信息！')
+      } else {
+        // 如果没有数据或接口调用失败，初始化空列表
+        temporaryBillingMedicines.value = []
+        temporaryAdvices.value = []
+        temporaryMedicalLoading.value = false // 🔧 新增：加载完成（即使失败也要关闭加载状态）
+        ElMessage.error('获取计费数据失败，请重试')
+      }
+    }).catch(() => {
+      temporaryBillingMedicines.value = []
+      temporaryAdvices.value = []
+      temporaryMedicalLoading.value = false // 🔧 新增：加载完成（即使失败也要关闭加载状态）
+      ElMessage.error('获取计费数据失败，请重试')
+    })
+  } else {
+    proxy.$modal.msgWarning('患者信息不完整，请关闭弹窗重新打开')
+  }
+}
+
+// 🔧 新增：根据用法编码获取对应的显示名称
+function getUsageLabel(usageCode) {
+  if (!usageCode) return '-'
+  const dictItem = method_code.value?.find(item => item.value === usageCode)
+  return dictItem ? dictItem.label : usageCode
 }
 
 // 格式化计费弹窗中的日期
@@ -1591,7 +1928,7 @@ function resetForm() {
 function submitForm() {
   proxy.$refs['surgeryRef'].validate((valid) => {
     if (valid) {
-      const submitData = { ...form }
+      const submitData = { ...form, orgId: userStore.orgId }
       if (!form.scheduleId) {
         // 新增手术安排
         addSurgerySchedule(submitData).then((res) => {
@@ -1827,6 +2164,25 @@ function getRowClassName({ row, rowIndex }) {
 </script>
 
 <style scoped>
+/* 🔧 新增：临时医嘱加载状态样式 */
+.loading-container {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: 100px 0;
+  color: #409eff;
+  font-size: 16px;
+}
+
+.loading-container .el-icon {
+  font-size: 32px;
+  margin-bottom: 16px;
+}
+
+.loading-container span {
+  font-weight: 500;
+}
 .app-container {
   padding: 20px;
 }
@@ -1875,4 +2231,5 @@ function getRowClassName({ row, rowIndex }) {
 :deep(.el-table .selected-row > td) {
   border-bottom: 1px solid #d9ecff !important;
 }
+
 </style>
\ No newline at end of file
diff --git a/openhis-ui-vue3/src/views/surgicalschedule/temporaryMedical.vue b/openhis-ui-vue3/src/views/surgicalschedule/temporaryMedical.vue
index 0291b96c..678fc493 100644
--- a/openhis-ui-vue3/src/views/surgicalschedule/temporaryMedical.vue
+++ b/openhis-ui-vue3/src/views/surgicalschedule/temporaryMedical.vue
@@ -1,30 +1,69 @@
 <template>
   <div class="temporary-medical-container">
-    <!-- 患者信息区域 -->
-    <div class="patient-info-section">
-      <div class="patient-info-header">
-        <h3>门诊术中临时医嘱</h3>
+    <!-- 顶部区域：标题 + 患者信息 + 操作按钮 -->
+    <div class="top-container">
+      <!-- 标题栏 -->
+      <div class="title-bar">
+        <h1 class="title-text">门诊术中临时医嘱</h1>
       </div>
-      <div class="patient-info-content">
-        <el-descriptions :column="3" border>
-          <el-descriptions-item label="患者：">{{ patientInfo.patientName || '-' }}</el-descriptions-item>
-          <el-descriptions-item label="就诊卡号：">{{ patientInfo.identifierNo || '-' }}</el-descriptions-item>
-          <el-descriptions-item label="手术单号：">{{ patientInfo.operCode || '-' }}</el-descriptions-item>
-          <el-descriptions-item label="科室：">{{ patientInfo.roomCode || '-' }}</el-descriptions-item>
-          <el-descriptions-item label="医师：">{{ patientInfo.doctorName || '-' }}</el-descriptions-item>
-          <el-descriptions-item label="角色：">{{ patientInfo.role || '-' }}</el-descriptions-item>
-        </el-descriptions>
+      <!-- 患者信息卡 -->
+      <div class="patient-info-card">
+        <div class="info-item">
+          <span class="info-label">患者：</span>
+          <span class="info-value">{{ patientInfo.patientName || '-' }}</span>
+        </div>
+        <div class="info-item">
+          <span class="info-label">就诊卡号：</span>
+          <span class="info-value">{{ patientInfo.identifierNo || '-' }}</span>
+        </div>
+        <div class="info-item">
+          <span class="info-label">手术单号：</span>
+          <span class="info-value">{{ patientInfo.operCode || '-' }}</span>
+        </div>
+        <div class="info-item">
+          <span class="info-label">科室：</span>
+          <span class="info-value">{{ patientInfo.roomCode || '-' }}</span>
+        </div>
+        <div class="info-item">
+          <span class="info-label">医师：</span>
+          <span class="info-value">{{ patientInfo.doctorName || '-' }}</span>
+        </div>
+        <div class="info-item">
+          <span class="info-label">角色：</span>
+          <span class="info-value">{{ patientInfo.role || '-' }}</span>
+        </div>
+      </div>
+      <!-- 操作按钮组 -->
+      <div class="action-buttons">
+        <el-button class="refresh-btn" @click="handleRefresh">
+          <span>↻</span> 刷新
+        </el-button>
+        <el-button class="quote-btn" @click="handleQuoteBilling">
+          引用计费
+        </el-button>
       </div>
     </div>
 
     <!-- 已引用计费药品区域 -->
     <div class="medicine-section">
-      <h4>一、已引用计费药品（待生成医嘱）</h4>
-      <el-table :data="billingMedicines" border style="width: 100%; margin-bottom: 16px" fit>
+      <div class="section-title">
+        一、已引用计费药品（待生成医嘱）
+      </div>
+      <el-table
+        :data="billingMedicines"
+        stripe
+        border
+        style="width: 100%;"
+        fit
+      >
         <el-table-column label="序号" type="index" width="60" align="center" />
         <el-table-column label="药品名称" prop="medicineName" min-width="150" show-overflow-tooltip />
         <el-table-column label="规格" prop="specification" min-width="100" align="center" />
-        <el-table-column label="数量" prop="quantity" width="80" align="center" />
+        <el-table-column label="数量" prop="quantity" width="80" align="center">
+          <template #default="{ row }">
+            {{ row.quantity || 0 }}
+          </template>
+        </el-table-column>
         <el-table-column label="批号" prop="batchNumber" min-width="120" align="center" />
         <el-table-column label="单价" prop="unitPrice" min-width="80" align="center">
           <template #default="{ row }">
@@ -33,31 +72,52 @@
         </el-table-column>
         <el-table-column label="小计" prop="subtotal" min-width="100" align="center">
           <template #default="{ row }">
-            {{ row.subtotal ? `￥${row.subtotal}` : '-' }}
+            {{ row.subtotal ? `￥${(row.unitPrice * row.quantity).toFixed(2)}` : '-' }}
+          </template>
+        </el-table-column>
+        <el-table-column label="医保" prop="insuranceType" width="80" align="center">
+          <template #default="{ row }">
+            <el-tag
+              :size="'small'"
+              :class="getInsuranceClass(row.insuranceType)"
+            >
+              {{ row.insuranceType || '-' }}
+            </el-tag>
           </template>
         </el-table-column>
-        <el-table-column label="医保" prop="insuranceType" width="80" align="center" />
       </el-table>
-      
+
       <div class="medicine-summary">
-        <div class="summary-item">医保内：￥{{ insuranceAmount }}</div>
-        <div class="summary-item">自费：￥{{ selfPayAmount }}</div>
-        <div class="summary-item total">总计：￥{{ totalAmount }}</div>
+        <div class="summary-item insurance">医保内：￥{{ insuranceAmount.toFixed(2) }}</div>
+        <div class="summary-item self-pay">自费：￥{{ selfPayAmount.toFixed(2) }}</div>
+        <div class="summary-item total">总计：￥{{ totalAmount.toFixed(2) }}</div>
       </div>
     </div>
 
     <!-- 临时医嘱预览区域 -->
     <div class="advice-section">
-      <h4>二、临时医嘱预览（已生成）</h4>
-      <el-table :data="displayAdvices" border style="width: 100%; margin-bottom: 16px" fit>
+      <div class="section-title">
+        二、临时医嘱预览（已生成）
+      </div>
+      <el-table
+        :data="displayAdvices"
+        stripe
+        border
+        style="width: 100%;"
+        fit
+      >
         <el-table-column label="序号" type="index" width="60" align="center" />
         <el-table-column label="医嘱名称" prop="adviceName" min-width="150" show-overflow-tooltip />
         <el-table-column label="剂量" prop="dosage" min-width="80" align="center" />
         <el-table-column label="单位" prop="unit" min-width="80" align="center" />
-        <el-table-column label="用法" prop="usage" min-width="100" show-overflow-tooltip />
+        <el-table-column label="用法" prop="usage" min-width="100" show-overflow-tooltip>
+          <template #default="{ row }">
+            {{ row.usageLabel || getUsageLabel(row.usage) }}
+          </template>
+        </el-table-column>
         <el-table-column label="频次" prop="frequency" min-width="80" align="center" />
-        <el-table-column label="执行时间" prop="executeTime" min-width="120" align="center" />
-        <el-table-column label="操作" min-width="120" align="center">
+        <el-table-column label="执行时间" prop="executeTime" min-width="160" align="center" />
+        <el-table-column label="操作" min-width="140" align="center">
           <template #default="{ $index }">
             <el-button link type="primary" @click="handleEditAdvice($index)">编辑</el-button>
             <el-button link type="danger" @click="handleDeleteAdvice($index)">删除</el-button>
@@ -68,29 +128,30 @@
 
     <!-- 医师电子签名区域 -->
     <div class="signature-section">
-      <h4>三、医师电子签名</h4>
-      <div class="signature-content">
+      <div class="section-title">
+        三、医师电子签名
+      </div>
+      <!-- 签名信息卡 -->
+      <div class="signature-card">
         <div class="signature-info">
-          <span>签名医师：</span>
-          <span :class="{ 'unsigned': !isSigned }">{{ isSigned ? currentUser.name : '未签名' }}</span>
+          <span class="info-label">签名医师：</span>
+          <span class="info-value" :class="{ 'unsigned': !isSigned }">{{ isSigned ? currentUser.name : '未签名' }}</span>
         </div>
         <div class="signature-info">
-          <span>时间：</span>
-          <span>{{ signatureTime || '-' }}</span>
+          <span class="info-label">签名时间：</span>
+          <span class="info-value">{{ signatureTime || '-' }}</span>
         </div>
       </div>
-    </div>
-
-    <!-- 底部操作按钮 -->
-    <div class="footer-actions">
-      <el-button class="cancel-btn" @click="handleCancel">取消</el-button>
-      <el-button 
-        class="sign-submit-btn" 
-        :class="{ 'signed': isSigned }"
-        @click="handleSignAndSubmit"
-      >
-        {{ isSigned ? '提交' : '一键签名并生成医嘱' }}
-      </el-button>
+      <!-- 底部操作按钮 -->
+      <div class="signature-actions">
+        <el-button class="cancel-btn" @click="handleCancel">取消</el-button>
+        <el-button
+          class="sign-btn"
+          @click="handleSignAndSubmit"
+        >
+          {{ isSigned ? '提交医嘱' : '一键签名并生成医嘱' }}
+        </el-button>
+      </div>
     </div>
 
     <!-- 签名密码弹窗 -->
@@ -125,14 +186,21 @@
             <el-input v-model="editForm.unit" placeholder="请输入单位" />
           </el-form-item>
           <el-form-item label="用法" required>
-            <el-select v-model="editForm.usage" placeholder="请选择用法" style="width: 100%">
+            <el-select 
+              v-if="getMethodCodeDict.length > 0"
+              v-model="editForm.usage" 
+              placeholder="请选择用法" 
+              style="width: 100%"
+              filterable
+            >
               <el-option
-                v-for="dict in method_code"
+                v-for="dict in getMethodCodeDict"
                 :key="dict.value"
                 :label="dict.label"
-                :value="dict.label"
+                :value="dict.value"
               />
             </el-select>
+            <el-input v-else disabled placeholder="加载中..." />
           </el-form-item>
           <el-form-item label="频次">
             <el-input v-model="editForm.frequency" disabled />
@@ -148,7 +216,7 @@
 </template>
 
 <script setup>
-import { ref, computed, getCurrentInstance } from 'vue'
+import { ref, computed, getCurrentInstance, onMounted, watch, nextTick } from 'vue'
 import { ElMessage, ElMessageBox } from 'element-plus'
 import useUserStore from '@/store/modules/user'
 import { checkPassword } from '@/api/surgicalschedule'
@@ -165,15 +233,18 @@ const props = defineProps({
       operCode: '',
       roomCode: '',
       doctorName: '',
-      role: ''
+      role: '',
+      patientId: null,
+      organizationId: null,
     })
   },
-  // 计费药品列表
+  // 一区域：已引用计费药品（待生成医嘱）
   billingMedicines: {
     type: Array,
     default: () => []
   },
-  // 临时医嘱列表
+  // 二区域：临时医嘱预览（已生成医嘱）- v-model:temporary-advices 对应 prop 名
+  // 🔧 修复：使用驼峰命名，因为 v-model:temporary-advices 会映射到 temporaryAdvices prop
   temporaryAdvices: {
     type: Array,
     default: () => []
@@ -181,7 +252,7 @@ const props = defineProps({
 })
 
 // 定义emit事件
-const emit = defineEmits(['submit', 'cancel', 'delete-advice', 'update:temporaryAdvices'])
+const emit = defineEmits(['submit', 'cancel', 'refresh', 'quote-billing', 'update:temporary-advices'])
 
 // 用户store
 const userStore = useUserStore()
@@ -192,6 +263,49 @@ const { proxy } = getCurrentInstance()
 // 获取字典数据（与门诊医生站保持一致）
 const { method_code } = proxy.useDict('method_code')
 
+// 🔧 新增：用法编码映射表（将通用编码映射到后端字典的正确编码）
+const usageCodeMapping = {
+  'iv': '404',      // 静脉注射
+  'po': '1',        // 口服
+  'im': '403',      // 肌肉注射
+  'sc': '401',      // 皮下注射
+  'ivgtt': '405',   // 静脉滴注
+  'ih': '5',        // 吸入给药
+  'it': '610',      // 含化
+  'ip': '604',      // 腹腔用药
+  'top': '6',       // 局部用药
+  'pr': '2'         // 直肠给药
+}
+
+// 🔧 新增：将用法编码映射到后端字典的正确编码
+const mapUsageCode = (advice) => {
+  const mappedAdvice = { ...advice }
+  if (usageCodeMapping[advice.usage]) {
+    mappedAdvice.usage = usageCodeMapping[advice.usage]
+  }
+  return mappedAdvice
+}
+
+// 🔧 新增：本地备用用法字典，确保字典未加载时也能显示中文
+const localMethodCode = [
+  { value: '404', label: '静脉注射' },
+  { value: '1', label: '口服' },
+  { value: '403', label: '肌肉注射' },
+  { value: '401', label: '皮下注射' },
+  { value: '405', label: '静脉滴注' },
+  { value: '5', label: '吸入给药' },
+  { value: '610', label: '含化' },
+  { value: '604', label: '腹腔用药' },
+  { value: '6', label: '局部用药' },
+  { value: '2', label: '直肠给药' }
+]
+
+// 🔧 新增：获取用法字典（优先使用从后端加载的，否则使用本地备用）
+const getMethodCodeDict = computed(() => {
+  let dict = method_code.value && method_code.value.length > 0 ? method_code.value : localMethodCode
+  return dict
+})
+
 // 响应式数据
 const isSigned = ref(false)
 const signatureTime = ref('')
@@ -214,19 +328,19 @@ const currentUser = computed(() => ({
 }))
 
 const insuranceAmount = computed(() => {
-  return props.billingMedicines
-    .filter(med => med.insuranceType === '甲' || med.insuranceType === '乙')
-    .reduce((sum, med) => sum + (med.subtotal || 0), 0)
+  return (props.billingMedicines || [])
+    .filter(med => med.insuranceType === '甲' || med.insuranceType === '乙' || med.insuranceType === '医保')
+    .reduce((sum, med) => sum + (Number(med.subtotal) || 0), 0)
 })
 
 const selfPayAmount = computed(() => {
-  return props.billingMedicines
+  return (props.billingMedicines || [])
     .filter(med => !med.insuranceType || med.insuranceType === '自费')
-    .reduce((sum, med) => sum + (med.subtotal || 0), 0)
+    .reduce((sum, med) => sum + (Number(med.subtotal) || 0), 0)
 })
 
 const totalAmount = computed(() => {
-  return insuranceAmount.value + selfPayAmount.value
+  return Number(insuranceAmount.value || 0) + Number(selfPayAmount.value || 0)
 })
 
 // 将计费药品转换为临时医嘱数据
@@ -236,26 +350,31 @@ const convertedAdvices = computed(() => {
     const specMatch = medicine.specification ? medicine.specification.match(/(\d+)(\D+)/) : null
     const specValue = specMatch ? parseInt(specMatch[1]) : 1
     const specUnit = specMatch ? specMatch[2] : 'ml'
-    
+
     // 计算剂量 = 规格数值 × 数量
     const dosage = specValue * (medicine.quantity || 1)
-    
-    // 根据药品名称判断用法
-    let usage = '静脉注射'
+
+    // 🔧 修复：根据药品名称判断用法，使用后端字典的正确编码
+    let usageCode = '404' // 默认静脉注射编码
+    let usageLabel = '静脉注射' // 默认显示名称
     if (medicine.medicineName && medicine.medicineName.includes('注射液')) {
-      usage = '静脉注射'
+      usageCode = '404'
+      usageLabel = '静脉注射'
     } else if (medicine.medicineName && medicine.medicineName.includes('片')) {
-      usage = '口服'
+      usageCode = '1'
+      usageLabel = '口服'
     } else if (medicine.medicineName && medicine.medicineName.includes('胶囊')) {
-      usage = '口服'
+      usageCode = '1'
+      usageLabel = '口服'
     }
-    
+
     return {
       id: index + 1,
       adviceName: medicine.medicineName || '',
       dosage: dosage,
       unit: specUnit,
-      usage: usage,
+      usage: usageCode, // 🔧 修复：使用后端字典的正确编码
+      usageLabel: usageLabel, // 🔧 新增：保存显示名称
       frequency: '临时',
       executeTime: new Date().toLocaleString('zh-CN'),
       originalMedicine: medicine
@@ -263,11 +382,80 @@ const convertedAdvices = computed(() => {
   })
 })
 
-// 使用转换后的数据或传入的临时医嘱数据
-const displayAdvices = computed(() => {
-  return props.temporaryAdvices
+// 🔧 修复：使用 ref 而不是 computed，避免响应性问题
+// 直接引用父组件传入的数据，确保更新能立即反映
+const displayAdvices = ref([])
+
+// 初始化 displayAdvices
+const initDisplayAdvices = () => {
+  // 只要有用户修改过的数据，就优先使用用户修改后的数据
+  // 避免自动转换覆盖用户的修改
+  if (props.temporaryAdvices && props.temporaryAdvices.length > 0) {
+    // 🔧 修复：将旧编码映射到新编码
+    displayAdvices.value = props.temporaryAdvices.map(mapUsageCode)
+  } else {
+    // 否则自动转换第一区域的已引用计费药品
+    displayAdvices.value = convertedAdvices.value
+  }
+}
+
+// 初始化
+initDisplayAdvices()
+
+// 组件挂载时，如果没有传入临时医嘱数据，将自动转换后的数据同步到父组件
+// 确保修改可以被父组件保存，下次打开仍然能看到
+onMounted(() => {
+  console.log('=== onMounted 被调用 ===')
+  console.log('=== props.temporaryAdvices ===', props.temporaryAdvices)
+  console.log('=== props.temporaryAdvices ===', JSON.stringify(props.temporaryAdvices))
+  console.log('=== convertedAdvices.value ===', convertedAdvices.value)
+  
+  // 初始化 displayAdvices
+  initDisplayAdvices()
+  
+  if ((!props.temporaryAdvices || props.temporaryAdvices.length === 0) && convertedAdvices.value.length > 0) {
+    console.log('=== onMounted 触发 emit ===')
+    emit('update:temporary-advices', convertedAdvices.value)
+  }
 })
 
+// 🔧 新增：监听 temporary-advices prop 的变化，同步更新 displayAdvices
+watch(() => props.temporaryAdvices, (newVal, oldVal) => {
+  console.log('=== watch props.temporaryAdvices 被调用 ===')
+  console.log('=== newVal ===', newVal)
+  
+  // 如果 props 有新数据，更新 displayAdvices
+  if (newVal && newVal.length > 0) {
+    // 🔧 修复：将旧编码映射到新编码
+    displayAdvices.value = newVal.map(mapUsageCode)
+  }
+}, { deep: true, immediate: true })
+
+// 监听第一区域的计费药品变化，如果第一区域更新了，并且用户还没修改过第二区域数据，自动更新第二区域
+watch(() => props.billingMedicines, (newVal) => {
+  console.log('=== watch billingMedicines 被调用 ===')
+  console.log('=== newVal ===', newVal)
+  console.log('=== props.temporaryAdvices ===', props.temporaryAdvices)
+  console.log('=== props.temporaryAdvices.length ===', props.temporaryAdvices?.length)
+  
+  // 🔧 修复：只有当 temporary-advices 为空时才自动更新，避免覆盖用户的修改
+  if (!props.temporaryAdvices || props.temporaryAdvices.length === 0) {
+    if (newVal.length > 0) {
+      console.log('=== watch 触发 emit ===')
+      displayAdvices.value = convertedAdvices.value
+      emit('update:temporary-advices', convertedAdvices.value)
+    }
+  } else {
+    console.log('=== watch 不触发 emit，因为 props.temporaryAdvices 已有数据 ===')
+  }
+}, { deep: true })
+
+// 🔧 新增：监听字典加载，确保字典加载后编辑弹窗能正确显示
+watch(() => method_code.value, (newVal) => {
+  console.log('=== watch method_code 被调用 ===')
+  console.log('字典数据已更新，长度:', newVal?.length || 0)
+}, { immediate: true })
+
 // 方法
 const handleSign = () => {
   showSignDialog.value = true
@@ -276,12 +464,19 @@ const handleSign = () => {
 // 编辑医嘱
 const handleEditAdvice = (index) => {
   const advice = displayAdvices.value[index]
+  
+  // 🔧 修复：如果用法是旧编码，映射到新编码
+  let usageCode = advice.usage
+  if (usageCodeMapping[usageCode]) {
+    usageCode = usageCodeMapping[usageCode]
+  }
+  
   currentEditIndex.value = index
   editForm.value = {
     adviceName: advice.adviceName,
     dosage: advice.dosage,
     unit: advice.unit,
-    usage: advice.usage,
+    usage: usageCode, // 使用映射后的正确编码
     frequency: advice.frequency
   }
   showEditDialog.value = true
@@ -289,26 +484,94 @@ const handleEditAdvice = (index) => {
 
 // 保存编辑
 const handleSaveEdit = () => {
-  if (!editForm.value.dosage || !editForm.value.usage) {
-    ElMessage.warning('请填写剂量和用法')
+  if (!editForm.value.dosage && editForm.value.dosage !== 0) {
+    ElMessage.warning('请填写剂量')
     return
   }
-  
+  // 🔧 新增：验证剂量必须为数字
+  if (isNaN(editForm.value.dosage) || editForm.value.dosage === '') {
+    ElMessage.warning('剂量必须为数字')
+    return
+  }
+  if (!editForm.value.usage) {
+    ElMessage.warning('请填写用法')
+    return
+  }
+
+  console.log('=== 保存编辑 ===')
+  console.log('editForm.value.usage:', editForm.value.usage)
+  console.log('editForm.value.usage 类型:', typeof editForm.value.usage)
+
   // 构建更新后的数据
   const updatedAdvice = {
     ...displayAdvices.value[currentEditIndex.value],
     ...editForm.value
   }
-  
+
+  // 🔧 修复：确保 usage 字段保存的是编码，而不是中文名称
+  // 如果用户选择的是编码，直接使用；如果用户选择的是中文名称，需要转换为编码
+  if (editForm.value.usage && typeof editForm.value.usage === 'string') {
+    // 检查是否是编码（通常编码较短，如 'iv', 'po'）
+    const isCode = editForm.value.usage.length <= 10 && getMethodCodeDict.value.some(item => item.value === editForm.value.usage)
+    if (!isCode) {
+      // 如果是中文名称，转换为编码
+      const dictItem = getMethodCodeDict.value.find(item => item.label === editForm.value.usage)
+      if (dictItem) {
+        updatedAdvice.usage = dictItem.value
+        updatedAdvice.usageLabel = dictItem.label
+      }
+    } else {
+      // 如果是编码，从字典中获取对应的标签
+      const dictItem = getMethodCodeDict.value.find(item => item.value === editForm.value.usage)
+      if (dictItem) {
+        updatedAdvice.usageLabel = dictItem.label
+      }
+    }
+  }
+
+  // 🔧 新增：同时更新 originalMedicine 中的数据，确保提交时使用最新的用户修改
+  const originalMedicine = displayAdvices.value[currentEditIndex.value].originalMedicine
+  if (originalMedicine && originalMedicine.contentJson) {
+    try {
+      const contentData = JSON.parse(originalMedicine.contentJson)
+      // 更新用户修改的字段
+      contentData.dose = editForm.value.dosage
+      contentData.doseUnitCode = editForm.value.unit
+      contentData.methodCode = updatedAdvice.usage
+      
+      // 如果用户修改了剂量，重新计算数量
+      if (originalMedicine.specification) {
+        const specMatch = originalMedicine.specification.match(/(\d+)(\D+)/)
+        const specValue = specMatch ? parseInt(specMatch[1]) : 1
+        if (specValue > 0) {
+          const newQuantity = editForm.value.dosage / specValue
+          contentData.quantity = newQuantity
+          contentData.totalPrice = contentData.unitPrice * newQuantity
+          
+          // 🔧 关键修复：同时更新显示字段，确保表格正确显示修改后的值
+          updatedAdvice.quantity = newQuantity
+        }
+      }
+      
+      // 更新 contentJson
+      updatedAdvice.originalMedicine = {
+        ...originalMedicine,
+        contentJson: JSON.stringify(contentData)
+      }
+    } catch (e) {
+      console.error('解析 originalMedicine.contentJson 失败', e)
+    }
+  }
+
   // 构建完整的更新后列表
   const updatedAdvices = [...displayAdvices.value]
   updatedAdvices[currentEditIndex.value] = updatedAdvice
-  
+
   // 通知父组件更新数据
-  emit('update:temporaryAdvices', updatedAdvices)
-  
+  emit('update:temporary-advices', updatedAdvices)
+
   showEditDialog.value = false
-  ElMessage.success('编辑成功')
+  ElMessage.success('编辑成功（已暂存本地，请点击"一键签名并生成医嘱"按钮提交到服务器）')
 }
 
 // 取消编辑
@@ -342,14 +605,16 @@ const confirmSign = async () => {
       showSignDialog.value = false
       signPassword.value = ''
       ElMessage.success('签名成功')
-      
-      // 签名成功后自动提交
-      handleSubmit()
+
+      // 签名成功后自动提交，用 setTimeout 确保响应式状态更新完成
+      setTimeout(() => {
+        handleSubmit()
+      }, 100)
     } else {
-      ElMessage.error('密码错误，请重新输入')
+      // 🔧 修改：当密码验证失败时，显示更清晰的错误提示
+      signPassword.value = ''
     }
   } catch (error) {
-    ElMessage.error('签名失败，请重试')
   }
 }
 
@@ -370,88 +635,146 @@ const handleDeleteAdvice = (index) => {
     type: 'warning'
   }).then(() => {
     // 构建新的临时医嘱数据
-    const updatedAdvices = [...props.temporaryAdvices]
+    const updatedAdvices = [...displayAdvices.value]
     updatedAdvices.splice(index, 1)
-    
+
     // 通知父组件更新数据
-    emit('update:temporaryAdvices', updatedAdvices)
-    
+    emit('update:temporary-advices', updatedAdvices)
+
     ElMessage.success('删除成功')
   }).catch(() => {
     // 用户取消删除
   })
 }
 
+// 🔧 防重复提交标志位
+const isSubmitting = ref(false)
+
 const handleSubmit = async () => {
   if (!isSigned.value) {
     ElMessage.warning('请先进行电子签名')
     return
   }
 
+  // 🔧 防重复提交：如果正在提交，直接返回
+  if (isSubmitting.value) {
+    ElMessage.warning('正在提交医嘱，请稍候...')
+    return
+  }
+
   // 检查是否有医嘱数据
   if (displayAdvices.value.length === 0) {
     ElMessage.warning('没有可保存的医嘱数据')
     return
   }
 
+  // 🔧 设置提交标志位
+  isSubmitting.value = true
+
   try {
     // 构建保存医嘱的请求参数
     const saveData = {
-      organizationId: props.patientInfo.organizationId || 1, // 默认科室ID
+      organizationId: props.patientInfo.orgId || props.patientInfo.organizationId || 1, // 使用计费时的orgId
       adviceSaveList: displayAdvices.value.map((advice, index) => {
         // 获取原始药品数据
         const originalMedicine = advice.originalMedicine
-        
+
         // 解析contentJson
         let contentJsonData = {}
         if (originalMedicine && originalMedicine.contentJson) {
           try {
             contentJsonData = JSON.parse(originalMedicine.contentJson)
           } catch (e) {
-            return
+            // 解析失败，继续使用originalMedicine中的数据
           }
         }
-        
+
+        // 根据修改后的剂量重新计算数量和总价
+        let quantity = originalMedicine?.quantity || 1;
+        const unitPrice = originalMedicine?.unitPrice || contentJsonData.unitPrice || 0;
+        // 如果用户修改了剂量，重新计算数量 = 剂量 / 规格数值
+        if (advice.dosage !== undefined && originalMedicine?.specification) {
+          const specMatch = originalMedicine.specification.match(/(\d+)(\D+)/);
+          const specValue = specMatch ? parseInt(specMatch[1]) : 1;
+          if (specValue > 0) {
+            quantity = advice.dosage / specValue;
+          }
+        }
+        const totalPrice = unitPrice * quantity;
+
+        // ✅ 关键修复：把修改后的数据更新到contentJson中，后端会优先读取这里的值
+        contentJsonData.adviceName = advice.adviceName;
+        contentJsonData.quantity = quantity;
+        contentJsonData.volume = advice.dosage + (advice.unit || '');
+        contentJsonData.totalPrice = totalPrice;
+        contentJsonData.unitPrice = unitPrice;
+        // 用法、剂量、单位也更新到contentJson
+        // 🔧 修复：确保 methodCode 使用的是编码，而不是中文名称
+        let methodCode = advice.usage;
+        if (methodCode && typeof methodCode === 'string') {
+          // 检查是否是编码（通常编码较短，如 'iv', 'po'）
+          const isCode = methodCode.length <= 10 && getMethodCodeDict.value.some(item => item.value === methodCode)
+          if (!isCode) {
+            // 如果是中文名称，转换为编码
+            const dictItem = getMethodCodeDict.value.find(item => item.label === methodCode)
+            if (dictItem) {
+              methodCode = dictItem.value
+            }
+          }
+        }
+        contentJsonData.methodCode = methodCode;
+        contentJsonData.dose = advice.dosage;
+        contentJsonData.doseUnitCode = advice.unit;
+        contentJsonData.rateCode = advice.frequency;
+
+        // 重新序列化contentJson
+        const updatedContentJson = JSON.stringify(contentJsonData);
+
         // 构造请求参数（与门诊医生工作站完全一致）
         return {
           // 基础信息
-          dbOpType: originalMedicine?.requestId ? '2' : '1', // 有请求ID则为修改，否则为新增
-          adviceType: originalMedicine?.adviceType || 1, // 使用原始类型或默认3
+          // 🔧 修复：dbOpType 的判断逻辑 - 如果有 requestId 则为修改，否则为新增
+          // 但对于从计费药品转换来的数据，即使没有 requestId，也应该先更新 chargeItemId
+          dbOpType: originalMedicine?.requestId ? '2' : (originalMedicine?.chargeItemId ? '2' : '1'),
+          adviceType: originalMedicine?.adviceType || 1, // 使用原始类型或默认1
           requestId: originalMedicine?.requestId,
           chargeItemId: originalMedicine?.chargeItemId,
-          contentJson: originalMedicine?.contentJson,
+          contentJson: updatedContentJson,
           categoryCode: contentJsonData.categoryCode || originalMedicine?.categoryCode,
-          positionId: originalMedicine?.positionId || contentJsonData.positionId,
           pharmacologyCategoryCode: contentJsonData.pharmacologyCategoryCode || originalMedicine?.pharmacologyCategoryCode,
           partPercent: originalMedicine?.partPercent || contentJsonData.partPercent || 1,
           partAttributeEnum: originalMedicine?.partAttributeEnum || contentJsonData.partAttributeEnum,
           executeNum: contentJsonData.executeNum || originalMedicine?.executeNum || 1,
           prescriptionNo: originalMedicine?.prescriptionNo,
-          
-          // 数量和单位
-          quantity: originalMedicine?.quantity || 1,
+
+          // 数量和单位：使用重新计算后的数量
+          quantity: quantity,
           dispensePerDuration: originalMedicine?.dispensePerDuration || contentJsonData.dispensePerDuration,
           unitCode: contentJsonData.unitCode || originalMedicine?.unitCode || advice.unit,
-          unitPrice: originalMedicine?.unitPrice || contentJsonData.unitPrice || 0,
-          totalPrice: originalMedicine?.totalPrice || contentJsonData.totalPrice || 0,
-          definitionId: contentJsonData.definitionId || originalMedicine?.definitionId,
-          definitionDetailId: contentJsonData.definitionDetailId || originalMedicine?.definitionDetailId,
+          unitPrice: unitPrice,
+          // 总价根据新的数量重新计算
+          totalPrice: totalPrice,
+          definitionId: originalMedicine?.definitionId ? String(originalMedicine.definitionId) : contentJsonData.definitionId ? String(contentJsonData.definitionId) : advice.definitionId ? String(advice.definitionId) : null,
+          definitionDetailId: originalMedicine?.definitionDetailId ? String(originalMedicine.definitionDetailId) : contentJsonData.definitionDetailId ? String(contentJsonData.definitionDetailId) : advice.definitionDetailId ? String(advice.definitionDetailId) : null,
           lotNumber: originalMedicine?.lotNumber || contentJsonData.lotNumber,
-          
+
           // 状态和类型
           statusEnum: originalMedicine?.statusEnum || 2, // 默认状态：已发送
-          categoryEnum: originalMedicine?.categoryEnum || contentJsonData.categoryEnum,
-          
-          // 药品/诊疗信息
-          adviceDefinitionId: contentJsonData.adviceDefinitionId || originalMedicine?.adviceDefinitionId,
-          adviceTableName: contentJsonData.adviceTableName || originalMedicine?.adviceTableName,
+          categoryEnum: originalMedicine?.categoryEnum || contentJsonData.categoryEnum || 1,
+
+          // 药品/诊疗信息 - 🔧 修复：优先使用originalMedicine中的adviceDefinitionId和adviceTableName
+          // 🔧 关键修复：确保adviceDefinitionId不为null，使用definitionId作为后备
+          adviceDefinitionId: originalMedicine?.adviceDefinitionId || contentJsonData.adviceDefinitionId || advice.definitionId || contentJsonData.definitionId || definitionId,
+          adviceTableName: originalMedicine?.adviceTableName || contentJsonData.adviceTableName || 'med_medication_definition',
           adviceName: advice.adviceName,
           minUnitQuantity: originalMedicine?.minUnitQuantity || contentJsonData.minUnitQuantity,
-          
+
           // 患者和就诊信息
           patientId: props.patientInfo.patientId,
           practitionerId: currentUser.value.id || originalMedicine?.practitionerId, // 开方医生
-          locationId: contentJsonData.locationId || originalMedicine?.locationId,
+          locationId: originalMedicine?.positionId || contentJsonData.locationId || props.patientInfo.orgId || props.patientInfo.positionId,
+          positionId: originalMedicine?.positionId || contentJsonData.positionId,
+          orgId: originalMedicine?.orgId || props.patientInfo.orgId || props.patientInfo.positionId,
           performLocation: originalMedicine?.performLocation || contentJsonData.performLocation,
           founderOrgId: currentUser.value.id || originalMedicine?.founderOrgId, // 开方人科室
           encounterId: props.patientInfo.visitId || contentJsonData.encounterId || originalMedicine?.encounterId,
@@ -459,27 +782,28 @@ const handleSubmit = async () => {
           conditionId: contentJsonData.conditionId || originalMedicine?.conditionId,
           encounterDiagnosisId: originalMedicine?.encounterDiagnosisId || contentJsonData.encounterDiagnosisId,
           conditionDefinitionId: originalMedicine?.conditionDefinitionId || contentJsonData.conditionDefinitionId,
-          
+
           // 治疗信息
           therapyEnum: originalMedicine?.therapyEnum || contentJsonData.therapyEnum || 1, // 默认临时医嘱
-          methodCode: advice.usage, // 用法（使用转换后的中文名称）
+          // 🔧 修复：methodCode 使用编码，而不是中文名称
+          methodCode: methodCode, // 用法（使用编码）
           rateCode: advice.frequency, // 频次
           dose: advice.dosage,
           firstDose: originalMedicine?.firstDose || contentJsonData.firstDose,
           doseUnitCode: contentJsonData.doseUnitCode || originalMedicine?.doseUnitCode || advice.unit,
           skinTestFlag: originalMedicine?.skinTestFlag || contentJsonData.skinTestFlag,
           injectFlag: originalMedicine?.injectFlag || contentJsonData.injectFlag,
-          
+
           // 分组信息
           groupId: originalMedicine?.groupId,
           packageId: originalMedicine?.packageId || contentJsonData.packageId,
-          
+
           // 诊疗活动信息
           activityId: contentJsonData.adviceDefinitionId || originalMedicine?.adviceDefinitionId, // 对于诊疗类型，使用 adviceDefinitionId 作为 activity_id
-          
+
           // 医保信息
           ybClassEnum: originalMedicine?.ybClassEnum || contentJsonData.ybClassEnum,
-          
+
           // 中药信息
           chineseHerbsDoseQuantity: originalMedicine?.chineseHerbsDoseQuantity || contentJsonData.chineseHerbsDoseQuantity || 1
         }
@@ -487,22 +811,48 @@ const handleSubmit = async () => {
     }
 
     // 调用保存医嘱接口
-    const response = await savePrescription(saveData)
-    
+    // 如果已签名，则执行签发操作（'1'），否则执行保存操作（'0'）
+    const adviceOpType = isSigned.value ? '1' : '0'
+    const response = await savePrescription(saveData, adviceOpType)
+
     if (response.code === 200) {
       ElMessage.success('临时医嘱保存成功')
-      
-      // 构建提交数据
+
+      // 🔧 关键修复：处理后端返回的医嘱 ID
+      // 后端返回的 data 数组只包含新创建的医嘱记录的 ID，不包含已更新的记录
+      // 我们需要正确地映射这些 ID 到对应的临时医嘱数据
+      if (response.data && Array.isArray(response.data) && response.data.length > 0) {
+        // 创建一个索引，记录哪些记录是新创建的
+        let newDataIndex = 0
+        
+        displayAdvices.value.forEach((advice, index) => {
+          const originalMedicine = advice.originalMedicine || {}
+          // 如果这个记录没有 requestId，说明是新创建的
+          if (!originalMedicine.requestId) {
+            if (newDataIndex < response.data.length) {
+              // 更新 originalMedicine 中的 requestId
+              if (!displayAdvices.value[index].originalMedicine) {
+                displayAdvices.value[index].originalMedicine = {}
+              }
+              displayAdvices.value[index].originalMedicine.requestId = response.data[newDataIndex]
+              newDataIndex++
+            }
+          }
+        })
+      }
+
+      // 🔧 修复：将保存后的医嘱数据（包含用户的修改和后端返回的 requestId）传递给父组件
+      // 这样父组件可以使用用户修改后的数据，而不是重新加载数据
       const submitData = {
         patientInfo: props.patientInfo,
         billingMedicines: props.billingMedicines,
-        temporaryAdvices: displayAdvices.value,
+        temporaryAdvices: displayAdvices.value, // 使用用户修改后的数据，包含后端返回的 requestId
         signature: {
           doctorName: currentUser.value.name,
           signatureTime: signatureTime.value
         }
       }
-      
+
       // 通知父组件
       emit('submit', submitData)
     } else {
@@ -510,6 +860,9 @@ const handleSubmit = async () => {
     }
   } catch (error) {
     ElMessage.error('保存医嘱失败，请重试')
+  } finally {
+    // 🔧 重置防重复提交标志位
+    isSubmitting.value = false
   }
 }
 
@@ -517,94 +870,274 @@ const handleCancel = () => {
   // 通知父组件关闭弹窗
   emit('cancel')
 }
+
+// 刷新按钮点击
+const handleRefresh = () => {
+  emit('refresh')
+}
+
+// 引用计费按钮点击
+const handleQuoteBilling = () => {
+  emit('quote-billing')
+}
+
+// 数量改变时重新计算小计
+const handleQuantityChange = () => {
+  // 数量变化会自动更新，因为是响应式
+}
+
+// 获取医保标签样式类
+const getInsuranceClass = (insuranceType) => {
+  if (!insuranceType) return ''
+  if (insuranceType === '甲' || insuranceType === '乙' || insuranceType === '医保') {
+    return 'insurance-tag'
+  }
+  if (insuranceType === '自费') {
+    return 'selfpay-tag'
+  }
+  return ''
+}
+
+// 🔧 新增：根据用法编码获取对应的显示名称
+const getUsageLabel = (usageCode) => {
+  if (!usageCode) return '-'
+  const dictItem = getMethodCodeDict.value.find(item => item.value === usageCode)
+  return dictItem ? dictItem.label : usageCode
+}
+
+// 🔧 新增：获取编辑表单中当前选中的用法标签
+const editFormUsageLabel = computed(() => {
+  if (!editForm.value.usage) return ''
+  return getUsageLabel(editForm.value.usage)
+})
 </script>
 
 <style scoped>
 .temporary-medical-container {
-  padding: 20px;
+  padding: 0;
   max-height: 80vh;
   overflow-y: auto;
 }
 
-.patient-info-section {
-  margin-bottom: 24px;
+/* 顶部容器 */
+.top-container {
+  height: 180px;
+  padding: 0 0 20px 0;
+  background: linear-gradient(135deg, #63A3E7 0%, #4a8bc9 100%);
+  display: flex;
+  flex-direction: column;
 }
 
-.patient-info-header h3 {
-  margin: 0 0 16px 0;
+/* 标题栏 */
+.title-bar {
+  padding: 16px 20px;
+  text-align: center;
+}
+
+.title-text {
+  color: white;
+  font-size: 1.5rem;
+  font-weight: 600;
+  margin: 0;
+  line-height: 1.2;
+}
+
+/* 患者信息卡 */
+.patient-info-card {
+  flex: 1;
+  margin: 0 20px 12px 20px;
+  padding: 16px 20px;
+  background: rgba(255, 255, 255, 0.9);
+  border-radius: 8px;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 16px 40px;
+  align-items: center;
+}
+
+.info-item {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.info-label {
+  font-weight: bold;
   color: #333;
-  font-size: 18px;
+  font-size: 14px;
+}
+
+.info-value {
+  color: #333;
+  font-size: 14px;
+}
+
+/* 操作按钮组 */
+.action-buttons {
+  display: flex;
+  justify-content: flex-end;
+  gap: 16px;
+  padding: 0 20px;
+}
+
+/* 刷新按钮 */
+.refresh-btn {
+  background: linear-gradient(135deg, #63A3E7 0%, #4a8bc9 100%);
+  border-color: #63A3E7;
+  color: white;
+  font-size: 14px;
+  padding: 8px 20px;
+  transition: all 0.3s ease;
+}
+
+.refresh-btn:hover {
+  background: linear-gradient(135deg, #5391d1 0%, #3a7bb5 100%);
+  border-color: #5391d1;
+  color: white;
+  transform: translateY(-2px);
+  box-shadow: 0 4px 8px rgba(99, 163, 231, 0.4);
+}
+
+/* 引用计费按钮 */
+.quote-btn {
+  background: rgba(255, 255, 255, 0.9);
+  border-color: #63A3E7;
+  color: #63A3E7;
+  font-size: 14px;
+  padding: 8px 20px;
+  transition: all 0.3s ease;
+}
+
+.quote-btn:hover {
+  background: rgba(255, 255, 255, 1);
+  border-color: #5391d1;
+  color: #5391d1;
+  transform: translateY(-2px);
+  box-shadow: 0 4px 8px rgba(99, 163, 231, 0.3);
 }
 
 .medicine-section,
 .advice-section,
 .signature-section {
-  margin-bottom: 24px;
+  margin: 24px 20px 30px 20px;
 }
 
-.medicine-section h4,
-.advice-section h4,
-.signature-section h4 {
-  margin: 0 0 16px 0;
-  color: #666;
-  font-size: 16px;
+/* 区域标题 */
+.section-title {
+  font-size: 1.2rem;
+  color: #333;
+  font-weight: 600;
+  padding-bottom: 12px;
+  margin-bottom: 16px;
+  border-bottom: 2px solid #e4e7ed;
 }
 
 .medicine-summary {
   display: flex;
   justify-content: flex-end;
-  gap: 20px;
-  padding: 12px;
+  gap: 30px;
+  padding: 16px;
   background-color: #f5f7fa;
   border-radius: 4px;
+  margin-top: 12px;
 }
 
 .summary-item {
-  font-size: 14px;
-  color: #666;
+  font-size: 15px;
+  font-weight: 500;
+}
+
+.summary-item.insurance {
+  color: #63A3E7;
+}
+
+.summary-item.self-pay {
+  color: #67c23a;
 }
 
 .summary-item.total {
   font-weight: bold;
-  color: #409eff;
+  color: #f56c6c;
+  font-size: 16px;
 }
 
-.signature-content {
-  padding: 16px;
+/* 医保标签样式 */
+:deep(.insurance-tag) {
+  background-color: #63A3E7;
+  color: white;
+}
+
+:deep(.selfpay-tag) {
+  background-color: #67c23a;
+  color: white;
+}
+
+/* 计费药品表格表头浅灰色背景 */
+.medicine-section :deep(.el-table th) {
+  background-color: #f5f7fa !important;
+  color: #333 !important;
+}
+
+.medicine-section :deep(.el-table th.el-table__cell > .cell) {
+  color: #333 !important;
+  font-weight: 600;
+}
+
+/* 临时医嘱表格表头浅灰色背景（与计费药品表格保持一致） */
+.advice-section :deep(.el-table th) {
+  background-color: #f5f7fa !important;
+  color: #333 !important;
+}
+
+.advice-section :deep(.el-table th.el-table__cell > .cell) {
+  color: #333 !important;
+  font-weight: 600;
+}
+
+/* 签名信息卡 */
+.signature-card {
+  padding: 20px;
   background-color: #f5f7fa;
-  border-radius: 4px;
+  border-radius: 8px;
+  margin-bottom: 20px;
 }
 
 .signature-info {
-  margin-bottom: 12px;
-  font-size: 14px;
+  margin-bottom: 16px;
+  font-size: 15px;
+  display: flex;
+  align-items: center;
 }
 
-.signature-info span:first-child {
+.signature-info:last-child {
+  margin-bottom: 0;
+}
+
+.signature-info .info-label {
   font-weight: bold;
-  margin-right: 8px;
+  color: #333;
+  width: 100px;
+}
+
+.signature-info .info-value {
+  color: #333;
 }
 
 .unsigned {
   color: #f56c6c;
+  font-weight: 500;
 }
 
+/* 签名操作按钮区 */
 .signature-actions {
-  margin-top: 16px;
-}
-
-.footer-actions {
   display: flex;
   justify-content: center;
   align-items: center;
   gap: 30px;
-  margin-top: 24px;
-  padding-top: 16px;
-  border-top: 1px solid #e4e7ed;
 }
 
 .cancel-btn {
-  width: 120px;
+  width: 140px;
   height: 48px;
   font-size: 16px;
   border: 1px solid #dcdfe6;
@@ -618,8 +1151,9 @@ const handleCancel = () => {
   box-shadow: 0 4px 8px rgba(64, 158, 255, 0.2);
 }
 
-.sign-submit-btn {
-  width: 200px;
+/* 一键签名按钮 */
+.sign-btn {
+  width: 220px;
   height: 48px;
   font-size: 16px;
   font-weight: bold;
@@ -630,25 +1164,16 @@ const handleCancel = () => {
   box-shadow: 0 4px 8px rgba(103, 194, 58, 0.3);
 }
 
-.sign-submit-btn:hover {
+.sign-btn:hover {
   transform: translateY(-3px);
   box-shadow: 0 6px 12px rgba(103, 194, 58, 0.4);
 }
 
-.sign-submit-btn:active {
+.sign-btn:active {
   transform: translateY(-1px);
   box-shadow: 0 2px 4px rgba(103, 194, 58, 0.4);
 }
 
-.sign-submit-btn.signed {
-  background: linear-gradient(135deg, #409eff 0%, #66b1ff 100%);
-  box-shadow: 0 4px 8px rgba(64, 158, 255, 0.3);
-}
-
-.sign-submit-btn.signed:hover {
-  box-shadow: 0 6px 12px rgba(64, 158, 255, 0.4);
-}
-
 .sign-dialog-content p {
   margin-bottom: 16px;
   color: #666;