refactor: 移除所有薪酬服务列表查询中的自动计算逻辑

- 移除9个薪酬服务列表查询方法中的自动计算工资逻辑 - 列表查询现在只负责查询已存在的工资数据 - 工资计算功能需要单独调用计算接口 - 新增健康师工资核算规则说明文档 - 新增员工门店归属变更问题分析与解决方案文档 - 新增员工门店归属快照表方案详细设计文档涉及服务： 1. LqSalaryService (健康师工资) 2. LqTechTeacherSalaryService (科技部老师工资) 3. LqAssistantSalaryService (店助工资) 4. LqStoreManagerSalaryService (店长工资) 5. LqDirectorSalaryService (主任工资) 6. LqMajorProjectTeacherSalaryService (大项目老师工资) 7. LqMajorProjectDirectorSalaryService (大项目主管工资) 8. LqTechGeneralManagerSalaryService (科技部总经理工资) 9. LqBusinessUnitManagerSalaryService (事业部总经理工资)

refactor: 移除所有薪酬服务列表查询中的自动计算逻辑
- 移除9个薪酬服务列表查询方法中的自动计算工资逻辑 - 列表查询现在只负责查询已存在的工资数据 - 工资计算功能需要单独调用计算接口 - 新增健康师工资核算规则说明文档 - 新增员工门店归属变更问题分析与解决方案文档 - 新增员工门店归属快照表方案详细设计文档涉及服务： 1. LqSalaryService (健康师工资) 2. LqTechTeacherSalaryService (科技部老师工资) 3. LqAssistantSalaryService (店助工资) 4. LqStoreManagerSalaryService (店长工资) 5. LqDirectorSalaryService (主任工资) 6. LqMajorProjectTeacherSalaryService (大项目老师工资) 7. LqMajorProjectDirectorSalaryService (大项目主管工资) 8. LqTechGeneralManagerSalaryService (科技部总经理工资) 9. LqBusinessUnitManagerSalaryService (事业部总经理工资)
“wangming”
1 parent 3d57a288
Showing 12 changed files with 7122 additions and 151 deletions
docs/健康师工资核算规则说明.md
docs/员工门店归属变更问题分析与解决方案.md
docs/员工门店归属快照表方案详细设计.md
netcore/src/Modularity/Extend/NCC.Extend/LqAssistantSalaryService.cs
netcore/src/Modularity/Extend/NCC.Extend/LqBusinessUnitManagerSalaryService.cs
netcore/src/Modularity/Extend/NCC.Extend/LqDirectorSalaryService.cs
netcore/src/Modularity/Extend/NCC.Extend/LqMajorProjectDirectorSalaryService.cs
netcore/src/Modularity/Extend/NCC.Extend/LqMajorProjectTeacherSalaryService.cs
netcore/src/Modularity/Extend/NCC.Extend/LqSalaryService.cs
netcore/src/Modularity/Extend/NCC.Extend/LqStoreManagerSalaryService.cs
netcore/src/Modularity/Extend/NCC.Extend/LqTechGeneralManagerSalaryService.cs
netcore/src/Modularity/Extend/NCC.Extend/LqTechTeacherSalaryService.cs
+# 健康师工资核算规则说明
+
+## 一、适用范围
+
+本规则适用于所有岗位为"健康师"的员工。
+
+## 二、工资构成
+
+健康师工资 = **底薪** + **提成** + **手工费** + **补贴合计** - **扣款合计**
+
+---
+
+## 三、底薪计算规则
+
+### 3.1 底薪档位标准（按日均计算）
+
+底薪按**日均消耗**和**日均项目数**两项指标评定星级，取两项指标中的较低星级作为最终星级。
+
+**日均标准计算方式：**
+- 一星标准：月消耗 10,000元 ÷ 当月天数，项目数 96个 ÷ 当月天数
+- 二星标准：月消耗 20,000元 ÷ 当月天数，项目数 126个 ÷ 当月天数
+- 三星标准：月消耗 40,000元 ÷ 当月天数，项目数 156个 ÷ 当月天数
+
+**星级评定规则：**
+- **0星**：两项指标均未达标 → 底薪 1,800元
+- **1星**：日均消耗 ≥ 一星标准 且 日均项目数 ≥ 一星标准 → 底薪 2,000元
+- **2星**：日均消耗 ≥ 二星标准 且 日均项目数 ≥ 二星标准 → 底薪 2,200元
+- **3星**：日均消耗 ≥ 三星标准 且 日均项目数 ≥ 三星标准 → 底薪 2,400元
+
+**特殊规则：**
+1. **单项达标保护**：如果消耗和项目数中仅一项未达标（达到0星），底薪按1星（2,000元）计算
+2. **新店保底**：新店底薪最低为1星（2,000元），即使不满足1星标准也按1星计算
+
+### 3.2 底薪按在店天数计算
+
+**最终底薪 = （档位底薪 ÷ 当月天数）× 在店天数**
+
+**在店天数说明：**
+- 从考勤数据中获取，仅统计有效工作日
+- 不包含请假天数
+
+---
+
+## 四、业绩数据说明
+
+### 4.1 业绩分类
+
+- **基础业绩**：基础项目的开单业绩
+- **合作业绩**：合作项目的开单业绩
+- **总业绩**：基础业绩 + 合作业绩
+- **新客业绩**：首次到店客户的开单业绩
+- **升单业绩**：非首次到店客户的开单业绩
+
+### 4.2 业绩扣除
+
+- 所有业绩需扣除对应的退款金额
+- 基础业绩扣除基础业绩退款
+- 合作业绩扣除合作业绩退款
+- 总业绩扣除所有退款
+
+### 4.3 实际基础业绩计算
+
+**实际基础业绩 = 基础业绩 - 基础奖励业绩 + 其他业绩加 - 其他业绩减**
+
+**新店特殊规则：**
+- **第一阶段**：实际基础业绩 = 基础业绩 - 基础奖励业绩 + 其他业绩加 - 其他业绩减 - 新客业绩
+- **第二阶段**：实际基础业绩 = 基础业绩 - 基础奖励业绩 + 其他业绩加 - 其他业绩减 - 升单业绩
+- **第三阶段**：无特殊扣除
+
+### 4.4 实际合作业绩计算
+
+**实际合作业绩 = 合作业绩 - 合作奖励业绩**
+
+---
+
+## 五、提成计算规则
+
+### 5.1 提成前提条件
+
+**战队成员提成门槛：**
+- 如果健康师属于战队成员，个人总业绩必须 ≥ 6,000元（按日均计算）
+- 日均业绩门槛 = （6,000元 ÷ 当月天数）× 在店天数
+- 如果个人总业绩低于门槛，所有提成为0
+
+**单人提成门槛：**
+- 单人无此门槛限制
+
+### 5.2 提成点确定规则
+
+#### 5.2.1 战队成员（3人及以上）
+
+根据战队总业绩确定提成点（不按日均考核）：
+
+| 战队总业绩 | 提成点 |
+|-----------|--------|
+| ≥ 15万元 | 7% |
+| ≥ 12万元 | 6% |
+| ≥ 9万元  | 5% |
+| ≥ 6万元  | 4% |
+| ≥ 3万元  | 3% |
+| < 3万元  | 0% |
+
+#### 5.2.2 战队成员（2人）
+
+根据战队总业绩确定提成点（不按日均考核）：
+
+| 战队总业绩 | 提成点 |
+|-----------|--------|
+| ≥ 8万元  | 6% |
+| ≥ 6万元  | 5% |
+| ≥ 4万元  | 4% |
+| ≥ 2万元  | 3% |
+| < 2万元  | 0% |
+
+#### 5.2.3 单人（或被剔除出战队）
+
+根据个人总业绩确定提成点（**按日均考核**）：
+
+日均业绩门槛 = 标准门槛 ÷ 当月天数 × 在店天数
+
+| 日均业绩 | 提成点 |
+|---------|--------|
+| ≥ 6万元日均 | 6% |
+| ≥ 4万元日均 | 5% |
+| ≥ 2万元日均 | 4% |
+| ≥ 1万元日均 | 3% |
+| < 1万元日均 | 0% |
+
+### 5.3 基础业绩提成
+
+**基础业绩提成 = 实际基础业绩 × 0.95 × 提成点**
+
+### 5.4 合作业绩提成
+
+**合作业绩提成 = 实际合作业绩 × 0.95 × 0.65 × 提成点**
+
+### 5.5 新客转化率提成（仅新店第一阶段）
+
+**适用范围：** 新店第一阶段
+
+**提成比例：**
+
+| 新客转化率 | 提成比例 |
+|-----------|---------|
+| ≥ 50% | 20% |
+| ≥ 45% | 15% |
+| ≥ 35% | 10% |
+| ≥ 0%  | 6% |
+
+**计算公式：**
+新客转化率提成 = 新客业绩 × 提成比例 × 0.95
+
+### 5.6 升单人头提成（仅新店第二阶段）
+
+**适用范围：** 新店第二阶段
+
+**提成比例：**
+
+| 升单人头数 | 提成比例 |
+|----------|---------|
+| ≥ 10人 | 12% |
+| 7-9人   | 10% |
+| 4-6人   | 7% |
+| < 4人   | 0% |
+
+**计算公式：**
+升单人头提成 = 升单业绩 × 提成比例 × 0.95
+
+### 5.7 顾问提成
+
+**适用范围：** 仅战队队长（岗位为"顾问"）
+
+**前提条件：**
+- 战队人数必须 ≥ 2人
+- 单人战队无顾问提成
+
+**3人及以上战队规则：**
+- 战队总业绩 ≥ 6万元
+- 组员业绩（除顾问外的其他成员业绩总和）≥ 战队总业绩 × 40%
+- 整组消耗 ≥ 6万元（新店不考核消耗）
+- **提成金额 = 战队总业绩 × 0.8%**
+
+**2人战队规则：**
+- 战队总业绩 ≥ 4万元
+- 组员业绩（除顾问外的其他成员业绩总和）≥ 战队总业绩 × 30%
+- 整组消耗 ≥ 4万元（新店不考核消耗）
+- **提成金额 = 战队总业绩 × 0.3%**
+
+**说明：**
+- "组员业绩"指除顾问外的其他成员业绩总和
+- 只统计有效战队成员（考勤≥20天，未被剔除的成员）
+- 新店不考核消耗条件
+
+### 5.8 门店T区提成
+
+**适用范围：** 姓名包含"T区"的员工
+
+**计算公式：**
+门店T区提成 = 门店总业绩 × 0.05 × 0.05
+
+**特殊规则：**
+- T区人员仅核算提成，其他项（底薪、手工费、基础提成、合作提成、顾问提成、新客提成、升单提成、补贴、扣款）全部归零
+
+### 5.9 提成合计
+
+**提成合计 = 基础业绩提成 + 合作业绩提成 + 顾问提成 + 新客转化率提成 + 升单人头提成 + 门店T区提成**
+
+---
+
+## 六、战队规则说明
+
+### 6.1 战队成员资格
+
+- 健康师需要被分配到战队（金三角战队）
+- 战队成员共享战队总业绩
+
+### 6.2 考勤要求
+
+- **有效战队成员**：在店天数 ≥ 20天
+- **无效成员处理**：在店天数 < 20天的成员，将被剔除出战队，按单人计算
+  - 移除战队标识
+  - 战队业绩 = 个人总业绩
+  - 岗位降级为"健康师"（如果是顾问，则降级）
+
+### 6.3 岗位说明
+
+- **健康师**：普通战队成员或单人
+- **顾问**：战队队长（需在战队配置中设置为队长）
+  - 单人战队或被剔除出战队后，顾问自动降级为健康师
+  - 顾问可享受顾问提成
+
+---
+
+## 七、新店规则说明
+
+### 7.1 新店识别
+
+- 根据门店新店保护配置表判断
+- 统计月份的第一天在保护期内，则视为新店
+
+### 7.2 新店阶段
+
+新店分为三个阶段，不同阶段有不同的业绩扣除和提成规则：
+
+- **第一阶段**：扣除新客业绩，计算新客转化率提成
+- **第二阶段**：扣除升单业绩，计算升单人头提成
+- **第三阶段**：无特殊扣除，不计算新客/升单提成
+
+### 7.3 新店特殊规则
+
+1. **底薪保底**：新店底薪最低为1星（2,000元）
+2. **顾问提成**：新店顾问不考核消耗条件
+3. **新客/升单提成**：仅在新店的第一阶段和第二阶段计算，且需乘以0.95系数
+
+---
+
+## 八、其他说明
+
+### 8.1 手工费
+
+- 从消耗记录中统计
+- 按实际产生的手工费金额计算
+
+### 8.2 最终工资计算
+
+**实发工资 = 底薪 + 提成合计 + 手工费 + 补贴合计 - 扣款合计**
+
+### 8.3 数据来源
+
+- **业绩数据**：开单记录表（lq_kd_jksyj）
+- **退款数据**：退款记录表（lq_hytk_jksyj）
+- **消耗数据**：消耗记录表（lq_xh_jksyj）
+- **考勤数据**：考勤汇总表（lq_attendance_summary）
+- **战队信息**：战队成员表（lq_jinsanjiao_user）
+- **新店信息**：门店新店保护表（lq_md_xdbhsj）
+- **额外计算数据**：健康师工资额外计算表（lq_salary_extra_calculation）
+
+### 8.4 注意事项
+
+1. 所有金额计算保留2位小数
+2. 在店天数必须 > 0，否则底薪为0
+3. 业绩和消耗数据仅统计有效记录（IsEffective = 1）
+4. 退款金额从总业绩中扣除
+5. 提成计算使用实际业绩（扣除奖励业绩和其他调整后的业绩）
+6. 战队成员按战队总业绩确定提成点，单人按个人总业绩确定提成点
+7. 单人提成点按日均考核，战队成员提成点不按日均考核
+
+---
+
+## 九、核算流程建议
+
+1. **数据准备**
+   - 确认当月天数
+   - 确认新店保护配置
+   - 确认战队成员配置
+   - 确认考勤数据完整
+
+2. **底薪核算**
+   - 计算日均消耗和日均项目数
+   - 评定星级
+   - 计算最终底薪
+
+3. **业绩统计**
+   - 统计个人业绩（基础、合作、新客、升单）
+   - 扣除退款
+   - 计算实际业绩
+
+4. **提成核算**
+   - 判断是否满足提成门槛
+   - 确定提成点
+   - 计算各项提成
+   - 汇总提成合计
+
+5. **最终核算**
+   - 汇总底薪、提成、手工费
+   - 加上补贴
+   - 扣除扣款
+   - 得出实发工资
+
+---
+
+## 十、常见问题
+
+**Q1：如果健康师在店天数为0，底薪是多少？**
+A：在店天数为0时，底薪为0。
+
+**Q2：战队成员如果个人业绩低于6,000元，是否还有提成？**
+A：如果个人总业绩低于6,000元（按日均计算的门槛），所有提成为0。
+
+**Q3：新店三个阶段如何区分？**
+A：根据门店新店保护配置表中的阶段字段（Stage）区分：1=第一阶段，2=第二阶段，3=第三阶段。
+
+**Q4：顾问提成如何计算？**
+A：顾问提成基于战队总业绩，需要满足业绩、组员业绩占比、消耗（新店不考核）等条件，具体比例见"5.7 顾问提成"章节。
+
+**Q5：T区人员如何核算？**
+A：T区人员仅核算门店T区提成（门店总业绩 × 0.05 × 0.05），其他所有项目（底薪、手工费、其他提成等）均为0。
+
+---
+
+**文档版本：** v1.0  
+**最后更新：** 2026-01-09  
+**适用范围：** 健康师工资核算
+# 员工门店归属变更问题分析与解决方案
+
+## 📋 问题描述
+
+### 业务场景
+员工每个月的归属门店可能会发生变化。当发生改变后，在以下场景中会遇到门店归属问题：
+
+1. **工资计算场景**：
+   - 员工A在1月在门店A工作
+   - 2月调到门店B（`BASE_USER.F_Mdid` 更新为门店B）
+   - 计算1月工资时，如何确定该员工1月的归属门店？
+
+2. **数据补录场景**：
+   - 员工A在1月在门店A产生开单/消耗数据
+   - 2月调到门店B
+   - 如果1月的某些开单/消耗数据在2月补录，这些数据应该归属到哪个门店？
+
+### 核心矛盾
+- **时间维度**：数据应该按照实际发生时间归属门店
+- **当前归属**：`BASE_USER.F_Mdid` 只记录当前门店归属，无法追溯历史
+- **数据完整性**：补录的历史数据需要正确的门店归属
+
+---
+
+## 🔍 现状分析
+
+### 当前数据存储情况
+
+1. **员工门店归属**：
+   - 存储位置：`BASE_USER.F_Mdid`
+   - 特点：只有一个字段，记录当前门店ID
+   - 问题：无法追溯历史门店归属
+
+2. **开单/消耗数据**：
+   - 开单业绩表 `lq_kd_jksyj`：有 `F_StoreId` 字段（记录开单时的门店）
+   - 消耗表 `lq_xh_jksyj`：有 `F_StoreId` 字段（记录消耗时的门店）
+   - 开单主表 `lq_kd_kdjlb`：有 `djmd` 字段（单据门店）
+
+3. **工资计算逻辑**（以健康师工资为例）：
+   ```csharp
+   // 当前逻辑：
+   // 1. 优先从业绩数据中获取门店（performanceData中的StoreId）
+   // 2. 如果没有，从消耗数据中获取门店
+   // 3. 如果还没有，使用 BASE_USER.F_Mdid
+   ```
+
+### 存在的问题
+
+1. **门店归属判断不准确**：
+   - 如果业务数据（开单/消耗）中没有门店信息，会回退到使用 `BASE_USER.F_Mdid`
+   - 但 `BASE_USER.F_Mdid` 是当前门店，不是历史门店
+
+2. **补录数据归属问题**：
+   - 补录历史数据时，如果没有明确的门店信息，可能被错误归属
+
+3. **工资计算偏差**：
+   - 计算历史月份工资时，可能使用了错误的门店归属
+   - 影响门店统计、新店判断等逻辑
+
+---
+
+## 💡 解决方案思路
+
+### 方案一：时间维度优先 + 门店归属快照表（推荐）
+
+#### 核心思路
+以**时间维度**为唯一标准，通过门店归属快照表记录员工每月的门店归属。
+
+#### 实现方案
+
+1. **创建门店归属快照表**
+   ```
+   表名：lq_employee_store_assignment（员工门店归属表）
+   
+   字段：
+   - F_Id：主键ID
+   - F_EmployeeId：员工ID
+   - F_StoreId：门店ID
+   - F_StoreName：门店名称（冗余字段，便于查询）
+   - F_Year：年份
+   - F_Month：月份
+   - F_StatisticsMonth：统计月份（YYYYMM格式）
+   - F_StartDate：归属开始日期（精确到天，用于处理月中调店）
+   - F_EndDate：归属结束日期（可为空，表示当前）
+   - F_CreateTime：创建时间
+   - F_UpdateTime：更新时间
+   - F_CreateUser：创建人
+   ```
+
+2. **门店归属维护机制**
+   - 在员工调店时，自动创建/更新归属记录
+   - 支持月中调店（一个员工一个月可能归属多个门店）
+   - 支持批量导入历史归属数据
+
+3. **工资计算逻辑调整**
+   ```
+   工资计算时：
+   1. 根据统计月份（YYYYMM）查询门店归属快照表
+   2. 如果一个月有多个门店，按时间范围拆分计算
+   3. 如果查询不到归属记录，再回退到当前逻辑
+   ```
+
+4. **数据补录逻辑**
+   ```
+   补录数据时：
+   1. 根据数据实际发生时间（Yjsj）确定月份
+   2. 查询该月份的门店归属快照
+   3. 将数据的StoreId设置为归属门店
+   ```
+
+#### 优点
+- ✅ 时间维度清晰，历史可追溯
+- ✅ 支持月中调店场景
+- ✅ 不影响现有数据结构
+- ✅ 工资计算和数据补录都基于时间维度
+
+#### 缺点
+- ⚠️ 需要维护额外的归属表
+- ⚠️ 需要迁移历史数据
+
+---
+
+### 方案二：业务数据中强制记录门店信息
+
+#### 核心思路
+在开单/消耗数据录入时，强制要求记录门店信息，工资计算完全依赖业务数据中的门店。
+
+#### 实现方案
+
+1. **数据录入规则**
+   - 开单/消耗数据必须包含门店信息（StoreId）
+   - 补录数据时，根据数据发生时间，查询当时的门店归属
+   - 如果无法确定，要求用户手动选择门店
+
+2. **工资计算逻辑**
+   ```
+   工资计算时：
+   1. 只从业务数据（开单/消耗）中获取门店信息
+   2. 如果业务数据中没有门店信息，报错或跳过
+   3. 不再使用 BASE_USER.F_Mdid 作为回退
+   ```
+
+#### 优点
+- ✅ 数据来源单一，逻辑清晰
+- ✅ 不需要额外的表结构
+
+#### 缺点
+- ❌ 如果业务数据中没有门店信息，无法计算工资
+- ❌ 补录历史数据时，需要手动确定门店归属
+- ❌ 数据完整性要求高
+
+---
+
+### 方案三：BASE_USER表增加门店归属历史字段
+
+#### 核心思路
+在 `BASE_USER` 表中增加字段，记录门店归属历史（JSON格式或关联表）。
+
+#### 实现方案
+
+1. **字段设计**
+   ```
+   方案A：JSON字段
+   F_StoreAssignmentHistory：JSON格式存储历史归属
+   {
+     "202501": "store_id_1",
+     "202502": "store_id_2",
+     ...
+   }
+   
+   方案B：关联表
+   创建 BASE_USER_STORE_HISTORY 表
+   记录员工每个月的门店归属
+   ```
+
+2. **维护机制**
+   - 员工调店时，更新历史记录
+   - 支持批量导入历史数据
+
+#### 优点
+- ✅ 数据集中管理
+- ✅ 查询方便
+
+#### 缺点
+- ⚠️ 修改核心用户表，影响面大
+- ⚠️ JSON字段查询性能较差
+- ⚠️ 关联表方案与方案一类似
+
+---
+
+### 方案四：工资统计表记录门店归属
+
+#### 核心思路
+在工资统计表中记录门店归属，计算工资时使用该记录，但首次计算需要确定归属。
+
+#### 实现方案
+
+1. **工资统计表已有字段**
+   - `F_StoreId`：门店ID
+   - `F_StoreName`：门店名称
+   - 这些字段已经记录了工资计算时的门店归属
+
+2. **逻辑调整**
+   ```
+   工资计算时：
+   1. 查询历史工资统计记录
+   2. 如果存在记录，使用记录中的门店归属
+   3. 如果不存在，使用当前逻辑确定门店归属
+   ```
+
+#### 优点
+- ✅ 不需要额外的表结构
+- ✅ 工资记录本身就是历史快照
+
+#### 缺点
+- ❌ 首次计算工资时，门店归属判断仍有问题
+- ❌ 数据补录时，无法确定门店归属
+- ❌ 不能解决数据补录的问题
+
+---
+
+## 🎯 推荐方案
+
+### 推荐：方案一（门店归属快照表）
+
+#### 理由
+1. **时间维度清晰**：以时间维度为唯一标准，符合业务逻辑
+2. **完整解决**：同时解决工资计算和数据补录的问题
+3. **扩展性好**：支持月中调店、批量导入等场景
+4. **影响面小**：新增表结构，不影响现有逻辑
+
+#### 实施步骤建议
+
+1. **第一阶段：数据准备**
+   - 创建门店归属快照表
+   - 整理历史员工门店归属数据
+   - 批量导入历史归属数据
+
+2. **第二阶段：功能开发**
+   - 开发门店归属维护功能（调店时自动创建记录）
+   - 调整工资计算逻辑（优先使用快照表）
+   - 调整数据补录逻辑（根据时间查询归属）
+
+3. **第三阶段：数据迁移**
+   - 迁移历史数据
+   - 验证数据准确性
+   - 逐步切换到新逻辑
+
+4. **第四阶段：优化**
+   - 性能优化
+   - 用户体验优化
+   - 监控和告警
+
+---
+
+## 📊 方案对比
+
+| 方案 | 实施难度 | 数据完整性 | 可追溯性 | 扩展性 | 推荐度 |
+|------|---------|-----------|---------|--------|--------|
+| 方案一：快照表 | 中等 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
+| 方案二：业务数据强制 | 低 | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ |
+| 方案三：BASE_USER扩展 | 高 | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ |
+| 方案四：工资表记录 | 低 | ⭐⭐ | ⭐⭐⭐ | ⭐⭐ | ⭐⭐ |
+
+---
+
+## 🔧 技术实现要点
+
+### 1. 门店归属快照表设计
+
+```sql
+CREATE TABLE lq_employee_store_assignment (
+    F_Id VARCHAR(50) PRIMARY KEY,
+    F_EmployeeId VARCHAR(50) NOT NULL COMMENT '员工ID',
+    F_StoreId VARCHAR(50) NOT NULL COMMENT '门店ID',
+    F_StoreName VARCHAR(200) COMMENT '门店名称',
+    F_Year INT NOT NULL COMMENT '年份',
+    F_Month INT NOT NULL COMMENT '月份',
+    F_StatisticsMonth VARCHAR(6) NOT NULL COMMENT '统计月份YYYYMM',
+    F_StartDate DATE COMMENT '归属开始日期',
+    F_EndDate DATE COMMENT '归属结束日期',
+    F_CreateTime DATETIME,
+    F_UpdateTime DATETIME,
+    F_CreateUser VARCHAR(50),
+    INDEX idx_employee_month (F_EmployeeId, F_StatisticsMonth),
+    INDEX idx_store_month (F_StoreId, F_StatisticsMonth)
+) COMMENT '员工门店归属表';
+```
+
+### 2. 工资计算逻辑调整要点
+
+```csharp
+// 伪代码示例
+public async Task CalculateSalary(int year, int month)
+{
+    var monthStr = $"{year}{month:D2}";
+    
+    // 1. 查询员工门店归属（优先使用快照表）
+    var storeAssignments = await _db.Queryable<EmployeeStoreAssignmentEntity>()
+        .Where(x => x.StatisticsMonth == monthStr)
+        .ToListAsync();
+    
+    // 2. 如果没有快照记录，使用当前逻辑（回退方案）
+    if (!storeAssignments.Any())
+    {
+        // 使用现有逻辑：从业务数据或BASE_USER获取
+    }
+    
+    // 3. 按门店归属计算工资
+    foreach (var assignment in storeAssignments)
+    {
+        // 查询该员工在该门店的业绩数据
+        // 计算工资
+    }
+}
+```
+
+### 3. 数据补录逻辑调整要点
+
+```csharp
+// 伪代码示例
+public async Task ImportBillingData(DateTime billingDate, string employeeId)
+{
+    var monthStr = $"{billingDate.Year}{billingDate.Month:D2}";
+    
+    // 1. 查询该月份的门店归属
+    var assignment = await _db.Queryable<EmployeeStoreAssignmentEntity>()
+        .Where(x => x.EmployeeId == employeeId && x.StatisticsMonth == monthStr)
+        .Where(x => billingDate >= x.StartDate && (x.EndDate == null || billingDate <= x.EndDate))
+        .FirstAsync();
+    
+    // 2. 设置数据的门店ID
+    billingRecord.StoreId = assignment?.StoreId ?? GetStoreIdByCurrentLogic();
+}
+```
+
+---
+
+## ⚠️ 注意事项
+
+1. **数据一致性**
+   - 门店归属快照表的数据必须准确
+   - 需要定期检查和校验
+
+2. **性能考虑**
+   - 门店归属查询需要建立合适的索引
+   - 工资计算时批量查询，避免N+1问题
+
+3. **回退方案**
+   - 如果快照表中没有记录，需要有回退逻辑
+   - 回退逻辑可以使用现有逻辑（业务数据或BASE_USER）
+
+4. **月中调店处理**
+   - 如果一个员工一个月内调店，需要创建多条记录
+   - 工资计算时，需要按时间范围拆分计算
+
+5. **历史数据迁移**
+   - 需要整理历史员工门店归属数据
+   - 可能需要手动确认部分数据
+
+---
+
+## 📝 总结
+
+员工门店归属变更问题的核心是**时间维度与当前归属的矛盾**。
+
+**推荐使用方案一（门店归属快照表）**，理由：
+- 以时间维度为唯一标准，符合业务逻辑
+- 完整解决工资计算和数据补录的问题
+- 扩展性好，支持复杂场景
+- 实施难度适中，影响面可控
+
+实施时需要重点关注：
+- 数据准确性（门店归属快照表）
+- 性能优化（索引、批量查询）
+- 回退方案（数据缺失时的处理）
+- 历史数据迁移（数据整理和导入）
+
+---
+
+**文档版本：** v1.0  
+**创建日期：** 2026-01-09  
+**文档性质：** 问题分析与方案设计（仅思考，不修改代码）
+# 员工门店归属快照表方案详细设计
+
+## 📋 方案概述
+
+通过创建门店归属快照表，记录员工每个月的门店归属历史，以时间维度为唯一标准，解决工资计算和数据补录中的门店归属问题。
+
+---
+
+## 🗄️ 数据模型设计
+
+### 1. 核心表设计
+
+#### 表名：`lq_employee_store_assignment`（员工门店归属表）
+
+#### 字段设计
+
+| 字段名 | 类型 | 说明 | 约束 | 备注 |
+|--------|------|------|------|------|
+| F_Id | VARCHAR(50) | 主键ID | PRIMARY KEY | 使用YitIdHelper生成 |
+| F_EmployeeId | VARCHAR(50) | 员工ID | NOT NULL | 关联BASE_USER.F_Id |
+| F_StoreId | VARCHAR(50) | 门店ID | NOT NULL | 关联lq_mdxx.F_Id |
+| F_StoreName | VARCHAR(200) | 门店名称 | | 冗余字段，便于查询和显示 |
+| F_Year | INT | 年份 | NOT NULL | 如：2025 |
+| F_Month | INT | 月份 | NOT NULL | 1-12 |
+| F_StatisticsMonth | VARCHAR(6) | 统计月份 | NOT NULL | YYYYMM格式，如：202501 |
+| F_StartDate | DATE | 归属开始日期 | NOT NULL | 精确到天，用于月中调店 |
+| F_EndDate | DATE | 归属结束日期 | NULL | 为空表示当前仍在归属，精确到天 |
+| F_CreateTime | DATETIME | 创建时间 | | |
+| F_UpdateTime | DATETIME | 更新时间 | | |
+| F_CreateUser | VARCHAR(50) | 创建人 | | |
+| F_UpdateUser | VARCHAR(50) | 更新人 | | |
+| F_IsEffective | INT | 是否有效 | DEFAULT 1 | 1=有效，0=无效（软删除） |
+| F_Remark | VARCHAR(500) | 备注 | | 记录调店原因等 |
+
+#### 索引设计
+
+```sql
+-- 主键索引（自动创建）
+PRIMARY KEY (F_Id)
+
+-- 员工+月份查询索引（最常用）
+INDEX idx_employee_month (F_EmployeeId, F_StatisticsMonth, F_IsEffective)
+
+-- 门店+月份查询索引（用于门店维度统计）
+INDEX idx_store_month (F_StoreId, F_StatisticsMonth, F_IsEffective)
+
+-- 日期范围查询索引（用于精确查询某天的归属）
+INDEX idx_employee_date (F_EmployeeId, F_StartDate, F_EndDate)
+
+-- 时间范围查询索引（用于查询某个时间点的归属）
+INDEX idx_date_range (F_StartDate, F_EndDate, F_IsEffective)
+```
+
+#### 唯一约束
+
+**重要考虑：是否允许一个员工在一个月内归属多个门店？**
+
+**建议：允许**（支持月中调店场景）
+
+**唯一约束设计：**
+- 不设置唯一约束（允许一个员工一个月有多条记录）
+- 通过业务逻辑保证：同一个员工的同一天只能有一条有效记录
+- 通过应用层校验：插入/更新时检查是否有日期重叠
+
+---
+
+### 2. 数据关系图
+
+```
+BASE_USER (员工表)
+    ↓ F_Id
+lq_employee_store_assignment (门店归属表)
+    ↓ F_StoreId
+lq_mdxx (门店表)
+    ↓
+lq_salary_statistics (工资统计表) - 使用归属表的门店信息
+lq_kd_jksyj (开单业绩表) - 使用归属表的门店信息
+lq_xh_jksyj (消耗业绩表) - 使用归属表的门店信息
+```
+
+---
+
+## 📐 业务规则设计
+
+### 1. 基础规则
+
+#### 1.1 时间维度原则
+- **唯一标准**：以数据实际发生的时间（年、月、日）作为门店归属的判断标准
+- **不可变更**：历史归属记录一旦创建，原则上不允许修改（可通过软删除+新增的方式调整）
+
+#### 1.2 归属记录创建规则
+
+**场景A：月初调店（整月归属一个门店）**
+- 员工在1月1日从门店A调到门店B
+- 创建两条记录：
+  - 记录1：1月，门店A，开始日期：1月1日，结束日期：1月1日（或空，如果跨月）
+  - 记录2：1月，门店B，开始日期：1月2日，结束日期：空（或1月31日）
+
+**场景B：月中调店（一个月归属两个门店）**
+- 员工在1月15日从门店A调到门店B
+- 创建两条记录：
+  - 记录1：1月，门店A，开始日期：1月1日，结束日期：1月14日
+  - 记录2：1月，门店B，开始日期：1月15日，结束日期：1月31日（或空）
+
+**场景C：整月归属一个门店**
+- 员工整个月都在门店A
+- 创建一条记录：
+  - 记录：1月，门店A，开始日期：1月1日，结束日期：1月31日（或空）
+
+#### 1.3 归属记录查询规则
+
+**查询某员工某月的所有门店归属：**
+```sql
+SELECT * FROM lq_employee_store_assignment
+WHERE F_EmployeeId = @EmployeeId
+  AND F_StatisticsMonth = @StatisticsMonth
+  AND F_IsEffective = 1
+ORDER BY F_StartDate
+```
+
+**查询某员工某天的门店归属：**
+```sql
+SELECT * FROM lq_employee_store_assignment
+WHERE F_EmployeeId = @EmployeeId
+  AND F_StartDate <= @Date
+  AND (F_EndDate >= @Date OR F_EndDate IS NULL)
+  AND F_IsEffective = 1
+ORDER BY F_StartDate DESC
+LIMIT 1
+```
+
+**查询某门店某月的所有员工：**
+```sql
+SELECT DISTINCT F_EmployeeId FROM lq_employee_store_assignment
+WHERE F_StoreId = @StoreId
+  AND F_StatisticsMonth = @StatisticsMonth
+  AND F_IsEffective = 1
+```
+
+### 2. 数据维护规则
+
+#### 2.1 自动维护机制
+
+**触发时机：员工调店时**
+
+**操作步骤：**
+1. 用户在前端操作：员工从门店A调到门店B（选择调店日期）
+2. 后端处理逻辑：
+   - 查询当前员工的有效归属记录（结束日期为空的记录）
+   - 如果存在，将结束日期设置为调店日期的前一天
+   - 创建新的归属记录：开始日期为调店日期，结束日期为空
+   - 如果调店日期是月初，更新统计月份；如果是月中，保持原月份，新增记录
+
+#### 2.2 手动维护机制
+
+**适用场景：**
+- 历史数据补录
+- 数据修正
+- 批量导入
+
+**操作方式：**
+- 提供管理界面：员工门店归属管理
+- 支持批量导入Excel
+- 支持手动添加/编辑/删除（软删除）
+
+#### 2.3 数据校验规则
+
+**插入/更新时的校验：**
+1. **日期范围校验**：
+   - 开始日期不能大于结束日期
+   - 开始日期和结束日期必须在同一个月内（或跨月但统计月份相同）
+
+2. **重叠校验**：
+   - 同一个员工，同一天不能有多条有效记录
+   - 如果存在重叠，需要先处理旧记录（结束或删除）
+
+3. **完整性校验**：
+   - 员工ID、门店ID必须存在
+   - 统计月份格式正确（YYYYMM）
+
+4. **业务逻辑校验**：
+   - 门店必须有效（未删除）
+   - 员工必须有效（未删除、已启用）
+
+---
+
+## 🔄 与现有系统集成
+
+### 1. 工资计算集成
+
+#### 1.1 健康师工资计算
+
+**当前逻辑：**
+```csharp
+// 1. 优先从业绩数据中获取门店（performanceData中的StoreId）
+// 2. 如果没有，从消耗数据中获取门店
+// 3. 如果还没有，使用 BASE_USER.F_Mdid
+```
+
+**调整后逻辑：**
+```csharp
+// 1. 查询门店归属快照表（按统计月份）
+var storeAssignments = await QueryStoreAssignment(employeeId, statisticsMonth);
+
+// 2. 如果快照表有记录，使用快照表的门店归属
+if (storeAssignments.Any())
+{
+    // 按时间范围拆分计算（如果一个月有多个门店）
+    foreach (var assignment in storeAssignments)
+    {
+        // 查询该员工在该门店、该时间范围内的业绩数据
+        // 计算该部分工资
+    }
+}
+// 3. 如果快照表没有记录，使用当前逻辑（回退方案）
+else
+{
+    // 使用现有逻辑：从业务数据或BASE_USER获取
+}
+```
+
+**特殊处理：月中调店**
+- 如果一个月有多个门店归属，需要按时间范围拆分计算
+- 每个时间段的业绩数据单独统计
+- 工资计算结果需要合并（一个员工一个月可能有多条工资记录？还是合并为一条？）
+
+**建议：合并为一条记录**
+- 工资统计表仍然是一个员工一个月一条记录
+- 但需要记录主要门店（归属时间最长的门店，或业绩最多的门店）
+
+#### 1.2 其他岗位工资计算
+
+**店长工资：**
+- 店长通常是固定门店，但也要支持调店
+- 计算逻辑与健康师类似
+
+**主任工资：**
+- 类似逻辑
+
+**其他岗位：**
+- 统一使用快照表逻辑
+
+### 2. 数据补录集成
+
+#### 2.1 开单数据补录
+
+**当前问题：**
+- 补录历史数据时，如果没有门店信息，可能使用当前门店（BASE_USER.F_Mdid）
+
+**调整后逻辑：**
+```csharp
+// 补录开单数据时
+public async Task ImportBillingData(BillingRecord record)
+{
+    var billingDate = record.BillingDate; // 开单日期
+    var employeeId = record.EmployeeId;   // 健康师ID
+    var statisticsMonth = $"{billingDate.Year}{billingDate.Month:D2}";
+    
+    // 1. 查询该日期该员工的门店归属
+    var assignment = await QueryStoreAssignmentByDate(employeeId, billingDate);
+    
+    // 2. 设置门店ID
+    if (assignment != null)
+    {
+        record.StoreId = assignment.StoreId;
+    }
+    else
+    {
+        // 回退方案：使用当前逻辑
+        record.StoreId = GetStoreIdByCurrentLogic(employeeId);
+        
+        // 可选：记录警告日志，提示需要维护门店归属
+        _logger.LogWarning($"员工{employeeId}在{billingDate}的门店归属未找到，使用当前门店");
+    }
+    
+    // 3. 保存数据
+    await SaveBillingRecord(record);
+}
+```
+
+#### 2.2 消耗数据补录
+
+**类似逻辑：**
+- 根据消耗日期（Yjsj）查询门店归属
+- 设置消耗记录的StoreId
+
+### 3. 数据查询集成
+
+#### 3.1 员工列表查询
+
+**当前逻辑：**
+- 直接从BASE_USER表查询，显示F_Mdid对应的门店
+
+**调整后逻辑：**
+- 如果要显示历史门店，需要关联查询快照表
+- 当前门店：BASE_USER.F_Mdid（实时）
+- 历史门店：从快照表查询
+
+#### 3.2 门店员工列表查询
+
+**场景：查询某门店某月的所有员工**
+
+**当前逻辑：**
+- 查询BASE_USER表，F_Mdid = 门店ID
+
+**调整后逻辑：**
+```sql
+-- 查询某门店某月的所有员工
+SELECT DISTINCT esa.F_EmployeeId, u.F_RealName
+FROM lq_employee_store_assignment esa
+INNER JOIN BASE_USER u ON esa.F_EmployeeId = u.F_Id
+WHERE esa.F_StoreId = @StoreId
+  AND esa.F_StatisticsMonth = @StatisticsMonth
+  AND esa.F_IsEffective = 1
+  AND u.F_DeleteMark IS NULL
+  AND u.F_EnabledMark = 1
+```
+
+---
+
+## 📊 数据迁移策略
+
+### 1. 历史数据来源
+
+#### 1.1 数据来源分析
+
+**可能的数据来源：**
+1. **工资统计表（lq_salary_statistics等）**
+   - 已有历史工资记录
+   - 工资记录中有门店ID（F_StoreId）
+   - 可以反向推导：员工+月份 → 门店
+
+2. **业务数据（开单/消耗表）**
+   - 开单业绩表（lq_kd_jksyj）有门店ID（F_StoreId）
+   - 消耗表（lq_xh_jksyj）有门店ID（F_StoreId）
+   - 可以统计：员工+月份 → 门店（取出现最多的门店）
+
+3. **BASE_USER表的变更日志（如果有）**
+   - 如果系统有记录用户表变更日志，可以追溯
+
+4. **人工确认**
+   - 对于无法确定的数据，需要人工确认
+
+#### 1.2 数据迁移优先级
+
+**优先级1：工资统计表（最可靠）**
+- 理由：工资记录是最终结果，门店归属相对准确
+- 方法：从工资统计表提取：员工ID + 统计月份 + 门店ID
+- 时间范围：最近2年的数据（或更长时间，根据业务需要）
+
+**优先级2：业务数据统计（补充）**
+- 理由：对于没有工资记录的月份，从业务数据推断
+- 方法：统计每个员工每个月的业绩数据，取门店出现最多的
+- 注意：可能存在一个月有多个门店的情况（月中调店）
+
+**优先级3：BASE_USER当前门店（兜底）**
+- 理由：对于完全没有数据的员工，使用当前门店
+- 方法：BASE_USER.F_Mdid作为最后兜底
+
+### 2. 数据迁移步骤
+
+#### 步骤1：数据提取
+
+```sql
+-- 从工资统计表提取（健康师工资）
+INSERT INTO lq_employee_store_assignment 
+(F_Id, F_EmployeeId, F_StoreId, F_StoreName, F_Year, F_Month, F_StatisticsMonth, F_StartDate, F_EndDate, ...)
+SELECT 
+    YitIdHelper.NextId(),
+    F_EmployeeId,
+    F_StoreId,
+    (SELECT F_Dm FROM lq_mdxx WHERE F_Id = F_StoreId),
+    YEAR(STR_TO_DATE(CONCAT(F_StatisticsMonth, '01'), '%Y%m%d')),
+    MONTH(STR_TO_DATE(CONCAT(F_StatisticsMonth, '01'), '%Y%m%d')),
+    F_StatisticsMonth,
+    STR_TO_DATE(CONCAT(F_StatisticsMonth, '01'), '%Y%m%d'), -- 开始日期：月初
+    LAST_DAY(STR_TO_DATE(CONCAT(F_StatisticsMonth, '01'), '%Y%m%d')), -- 结束日期：月末
+    NOW(),
+    NOW(),
+    'System',
+    'System',
+    1
+FROM lq_salary_statistics
+WHERE F_StoreId IS NOT NULL AND F_StoreId != ''
+GROUP BY F_EmployeeId, F_StatisticsMonth, F_StoreId
+```
+
+#### 步骤2：数据清洗
+
+**处理重复记录：**
+- 如果一个员工一个月有多条记录（可能是数据异常，也可能是月中调店）
+- 需要人工确认：是数据异常还是确实调店
+
+**处理缺失数据：**
+- 对于没有工资记录但可能有业务数据的员工
+- 从业务数据统计推断
+
+#### 步骤3：数据验证
+
+**验证规则：**
+1. 每个员工每个月至少有一条记录（如果有业务数据）
+2. 门店ID必须存在
+3. 统计月份格式正确
+4. 日期范围合理
+
+**验证方法：**
+- 抽样检查：随机抽取一定比例的数据，人工验证
+- 逻辑检查：检查是否有明显异常（如同一员工同一天多个门店）
+
+#### 步骤4：数据导入
+
+**导入方式：**
+- 批量导入（使用事务保证一致性）
+- 分批次导入（避免锁表时间过长）
+- 记录导入日志（成功/失败记录）
+
+### 3. 数据迁移时间窗口
+
+**建议：**
+- 选择业务低峰期（如夜间或周末）
+- 分批次迁移（先迁移最近3个月，验证无误后再迁移更多）
+- 保留回滚方案（如果迁移失败，可以删除导入的数据）
+
+---
+
+## 🎯 边界情况处理
+
+### 1. 月中调店
+
+**场景：** 员工在1月15日从门店A调到门店B
+
+**处理方案：**
+- 创建两条归属记录
+- 工资计算时，按时间范围拆分计算
+- 最终工资记录合并为一条（记录主要门店）
+
+**问题：**
+- 工资统计表中的门店ID如何设置？
+  - 方案A：设置为主要门店（归属时间最长的门店，或业绩最多的门店）
+  - 方案B：设置为空，或记录为"多门店"
+  - **建议：方案A**，记录为主要门店，在备注或明细中说明
+
+### 2. 数据缺失
+
+**场景：** 快照表中没有某员工某月的归属记录
+
+**处理方案：**
+- 回退到现有逻辑（从业务数据或BASE_USER获取）
+- 记录警告日志，提示需要维护门店归属
+- 可选：自动创建一条归属记录（使用当前门店或推断的门店）
+
+### 3. 数据冲突
+
+**场景：** 同一个员工同一天有多条归属记录（数据异常）
+
+**处理方案：**
+- 数据校验时发现冲突，不允许插入/更新
+- 提示用户先处理冲突记录
+- 提供数据修正工具
+
+### 4. 跨月调店
+
+**场景：** 员工在1月31日调到门店B，实际在2月1日生效
+
+**处理方案：**
+- 记录1月：门店A，结束日期：1月31日
+- 记录2月：门店B，开始日期：2月1日
+- 如果调店日期是月末最后一天，可以考虑归属到下个月
+
+### 5. 离职员工
+
+**场景：** 员工在月中离职
+
+**处理方案：**
+- 创建归属记录：结束日期设置为离职日期
+- 如果离职日期是月中，归属记录只到离职日期
+- 工资计算时，只计算到离职日期
+
+### 6. 新员工入职
+
+**场景：** 新员工在月中入职
+
+**处理方案：**
+- 创建归属记录：开始日期为入职日期
+- 如果入职日期是月中，从入职日期开始归属
+
+---
+
+## ⚡ 性能考虑
+
+### 1. 查询性能优化
+
+#### 1.1 索引优化
+- 已设计多个索引（见索引设计部分）
+- 定期分析索引使用情况，优化索引
+
+#### 1.2 查询优化
+
+**批量查询：**
+- 工资计算时，批量查询所有员工的归属记录，避免N+1查询
+```csharp
+// 批量查询
+var employeeIds = salaryList.Select(s => s.EmployeeId).Distinct().ToList();
+var assignments = await _db.Queryable<EmployeeStoreAssignmentEntity>()
+    .Where(x => employeeIds.Contains(x.EmployeeId) && x.StatisticsMonth == monthStr)
+    .ToListAsync();
+var assignmentDict = assignments.GroupBy(x => x.EmployeeId).ToDictionary(g => g.Key, g => g.ToList());
+```
+
+**缓存策略：**
+- 对于频繁查询的数据（如当前月的归属记录），可以使用缓存
+- 缓存失效策略：归属记录更新时，清除相关缓存
+
+### 2. 写入性能优化
+
+#### 2.1 批量插入
+- 数据迁移时，使用批量插入（如每次插入1000条）
+- 使用事务保证一致性
+
+#### 2.2 异步处理
+- 数据迁移可以异步处理
+- 员工调店时，归属记录的创建可以异步处理（如果对实时性要求不高）
+
+### 3. 表分区考虑
+
+**是否需要分区？**
+- 如果数据量很大（如10年历史数据，每月几千员工），可以考虑按年份或月份分区
+- 当前阶段可能不需要，但设计时要考虑扩展性
+
+---
+
+## 🔒 数据一致性保证
+
+### 1. 事务处理
+
+**关键操作使用事务：**
+- 员工调店时：更新旧记录 + 创建新记录（在一个事务中）
+- 数据迁移：批量导入使用事务
+
+### 2. 数据校验
+
+**应用层校验：**
+- 插入/更新前校验数据完整性和业务逻辑
+- 防止数据冲突
+
+**数据库层约束：**
+- 外键约束（如果MySQL支持，但通常不使用外键，使用应用层保证）
+- 非空约束、唯一约束（根据业务需要）
+
+### 3. 数据同步
+
+**与BASE_USER表同步：**
+- 员工调店时，同时更新BASE_USER.F_Mdid和归属表
+- 或者：归属表作为数据源，BASE_USER.F_Mdid从归属表计算（当前月份的主要门店）
+
+**建议：**
+- BASE_USER.F_Mdid保持为当前门店（实时）
+- 归属表记录历史归属
+- 两者可以不一致（BASE_USER是当前状态，归属表是历史记录）
+
+---
+
+## 👤 用户体验设计
+
+### 1. 管理界面
+
+#### 1.1 员工门店归属管理页面
+
+**功能：**
+- 列表展示：员工、门店、月份、时间范围
+- 查询：按员工、门店、月份查询
+- 添加：手动添加归属记录
+- 编辑：修改归属记录（需要校验）
+- 删除：软删除归属记录
+- 批量导入：Excel导入
+
+#### 1.2 员工调店操作
+
+**操作流程：**
+1. 选择员工
+2. 选择目标门店
+3. 选择调店日期（默认今天）
+4. 系统自动：
+   - 查询当前有效归属记录
+   - 更新旧记录结束日期
+   - 创建新记录开始日期
+5. 确认保存
+
+### 2. 数据展示
+
+#### 2.1 员工详情页
+
+**显示：**
+- 当前门店：BASE_USER.F_Mdid（实时）
+- 历史归属：从归属表查询，列表展示
+
+#### 2.2 工资计算页面
+
+**显示：**
+- 如果使用了快照表的门店，显示来源标识
+- 如果使用了回退逻辑，显示警告提示
+
+---
+
+## 🔮 扩展性考虑
+
+### 1. 未来可能的业务变化
+
+#### 1.1 多门店归属
+**场景：** 一个员工可能同时归属多个门店（兼职）
+
+**扩展方案：**
+- 当前设计已经支持（一个员工一个月可以有多条记录）
+- 需要调整业务逻辑：工资计算时，如何分配业绩到不同门店
+
+#### 1.2 部门归属
+**场景：** 不仅记录门店归属，还要记录部门归属
+
+**扩展方案：**
+- 可以增加字段：F_DepartmentId（部门ID）
+- 或者创建新的表：员工部门归属表
+
+#### 1.3 岗位变更
+**场景：** 记录员工岗位变更历史
+
+**扩展方案：**
+- 类似设计：员工岗位归属表
+- 或者：在归属表中增加字段：F_Position（岗位）
+
+### 2. 性能扩展
+
+#### 2.1 数据归档
+- 历史数据（如3年前的数据）可以归档到历史表
+- 当前表只保留最近2-3年的数据
+
+#### 2.2 读写分离
+- 如果查询压力大，可以考虑读写分离
+- 归属表主要是查询操作，可以放到只读库
+
+---
+
+## ⚠️ 风险点与应对措施
+
+### 1. 数据准确性风险
+
+**风险：** 历史数据迁移可能不准确
+
+**应对：**
+- 多数据源验证（工资表、业务数据、人工确认）
+- 分批次迁移，每批验证
+- 提供数据修正工具
+
+### 2. 性能风险
+
+**风险：** 查询性能可能下降
+
+**应对：**
+- 合理设计索引
+- 使用缓存
+- 监控查询性能，及时优化
+
+### 3. 数据一致性风险
+
+**风险：** 归属表与BASE_USER表可能不一致
+
+**应对：**
+- 明确两者的作用：BASE_USER是当前状态，归属表是历史记录
+- 提供数据同步工具（可选）
+- 在关键操作时校验一致性
+
+### 4. 业务复杂度风险
+
+**风险：** 月中调店等复杂场景增加业务复杂度
+
+**应对：**
+- 提供清晰的业务规则文档
+- 在管理界面提供操作指引
+- 提供数据校验和提示
+
+---
+
+## 📋 实施 Checklist
+
+### 阶段一：数据准备
+- [ ] 创建归属表结构
+- [ ] 设计索引
+- [ ] 编写数据迁移脚本
+- [ ] 准备测试数据
+
+### 阶段二：功能开发
+- [ ] 开发归属记录管理功能（CRUD）
+- [ ] 开发员工调店功能（自动创建归属记录）
+- [ ] 调整工资计算逻辑（集成快照表）
+- [ ] 调整数据补录逻辑（集成快照表）
+- [ ] 开发数据校验逻辑
+
+### 阶段三：数据迁移
+- [ ] 备份现有数据
+- [ ] 执行数据迁移（小批量测试）
+- [ ] 验证数据准确性
+- [ ] 全量数据迁移
+- [ ] 数据验证和修正
+
+### 阶段四：测试验证
+- [ ] 单元测试
+- [ ] 集成测试
+- [ ] 性能测试
+- [ ] 用户验收测试
+
+### 阶段五：上线部署
+- [ ] 部署到测试环境
+- [ ] 测试环境验证
+- [ ] 部署到生产环境
+- [ ] 监控运行情况
+- [ ] 数据修正和支持
+
+---
+
+## 🔍 参考现有系统设计
+
+### 1. 现有归属表分析
+
+系统中已经存在类似的归属表设计，可以参考其设计思路：
+
+#### 1.1 大项目部老师归属表（lq_md_major_project_teacher_assignment）
+
+**设计特点：**
+- 只记录月份级别（Year + Month），不记录日期范围
+- 唯一约束：门店 + 年份 + 月份 + 老师ID
+- 一个老师一个月只能有一条记录（不支持月中调店）
+
+**适用场景：**
+- 大项目部老师通常是整月归属一个门店
+- 如果需要月中调店，需要拆分月份处理
+
+#### 1.2 总经理门店归属表（lq_md_general_manager_lifeline）
+
+**设计特点：**
+- 记录月份级别（Month，YYYYMM格式）
+- 唯一约束：门店 + 月份 + 总经理ID
+- 一个总经理一个月在一个门店只能有一条记录
+- 但一个总经理可以管理多个门店（通过多条记录实现）
+
+**适用场景：**
+- 总经理/经理通常管理多个门店
+- 整月归属，不涉及月中调店
+
+### 2. 设计对比与选择
+
+#### 方案A：按月设计（参考现有归属表）
+
+**特点：**
+- 只记录月份级别（Year + Month）
+- 一个员工一个月只能有一条记录
+- 不支持月中调店（如果需要调店，需要拆分月份）
+
+**优点：**
+- 设计简单，与现有归属表一致
+- 查询逻辑简单
+- 性能好（数据量少）
+
+**缺点：**
+- 不支持月中调店场景
+- 如果员工在月中调店，需要手动拆分月份
+
+#### 方案B：按日期范围设计（推荐方案）
+
+**特点：**
+- 记录日期范围（StartDate + EndDate）
+- 一个员工一个月可以有多条记录
+- 支持月中调店
+
+**优点：**
+- 支持月中调店等复杂场景
+- 时间维度精确
+- 更灵活
+
+**缺点：**
+- 设计相对复杂
+- 查询逻辑需要处理日期范围
+- 数据量可能更多
+
+### 3. 推荐方案
+
+**建议采用方案B（按日期范围设计）**，理由：
+
+1. **业务需求**：健康师等岗位确实存在月中调店的场景
+2. **数据准确性**：日期范围设计更精确，能准确反映实际归属情况
+3. **扩展性**：未来如果有更细粒度的需求，日期范围设计更容易扩展
+4. **兼容性**：可以与现有按月设计的归属表共存，互不影响
+
+**但是要注意：**
+- 如果某些岗位（如大项目部老师、总经理）不需要支持月中调店，可以继续使用现有的按月设计
+- 门店归属快照表主要用于健康师、店助、店长等需要精确时间范围的岗位
+
+---
+
+## 💭 额外思考点
+
+### 1. 数据一致性策略
+
+#### 1.1 BASE_USER.F_Mdid 与归属表的关系
+
+**问题：** BASE_USER.F_Mdid 应该如何处理？
+
+**方案A：保持独立**
+- BASE_USER.F_Mdid 保持为当前门店（实时状态）
+- 归属表记录历史归属
+- 两者可以不一致（BASE_USER是当前状态，归属表是历史记录）
+
+**方案B：同步更新**
+- 员工调店时，同时更新 BASE_USER.F_Mdid 和归属表
+- 保持一致
+
+**方案C：BASE_USER.F_Mdid 从归属表计算**
+- BASE_USER.F_Mdid 不再手动维护
+- 从归属表计算当前月份的主要门店
+- 查询时实时计算或定期同步
+
+**推荐：方案A**
+- 理由：BASE_USER.F_Mdid 是实时状态，归属表是历史记录，用途不同
+- BASE_USER.F_Mdid 用于当前业务查询（如：查询当前门店的员工）
+- 归属表用于历史数据查询（如：计算历史月份工资）
+- 两者可以不一致，但需要明确各自的作用
+
+#### 1.2 数据同步策略
+
+**如果采用方案A，需要考虑：**
+- 员工调店时，BASE_USER.F_Mdid 和归属表的更新是否需要在同一个事务中？
+- 建议：在同一个事务中更新，保证一致性
+
+### 2. 数据维护的便利性
+
+#### 2.1 自动维护 vs 手动维护
+
+**自动维护：**
+- 员工调店时，自动创建归属记录
+- 优点：减少人工操作，数据准确
+- 缺点：如果调店操作本身有问题，归属记录也会有问题
+
+**手动维护：**
+- 需要手动创建/编辑归属记录
+- 优点：可控性强
+- 缺点：增加操作复杂度，可能遗漏
+
+**推荐：混合模式**
+- 员工调店时，自动创建归属记录（默认）
+- 提供手动维护界面，可以修改/补录
+- 支持批量导入历史数据
+
+#### 2.2 数据修正机制
+
+**场景：发现历史归属数据有误**
+
+**处理方案：**
+1. **不允许修改历史数据**（严格模式）
+   - 如果需要修正，只能删除（软删除）+ 新增
+   - 优点：保持数据可追溯性
+   - 缺点：操作复杂
+
+2. **允许修改历史数据**（灵活模式）
+   - 可以直接修改历史记录
+   - 优点：操作简单
+   - 缺点：无法追溯修改历史
+
+**推荐：方案1（严格模式）**
+- 历史数据一旦创建，不允许直接修改
+- 需要修正时，软删除旧记录，创建新记录
+- 记录修正原因和操作人
+
+### 3. 查询性能优化
+
+#### 3.1 批量查询优化
+
+**场景：计算某月所有员工的工资**
+
+**优化策略：**
+```csharp
+// 一次性查询所有员工的归属记录
+var employeeIds = allEmployees.Select(e => e.Id).ToList();
+var assignments = await _db.Queryable<EmployeeStoreAssignmentEntity>()
+    .Where(x => employeeIds.Contains(x.EmployeeId) && x.StatisticsMonth == monthStr)
+    .ToListAsync();
+
+// 转换为字典，便于快速查找
+var assignmentDict = assignments
+    .GroupBy(x => x.EmployeeId)
+    .ToDictionary(g => g.Key, g => g.OrderBy(x => x.StartDate).ToList());
+```
+
+#### 3.2 缓存策略
+
+**缓存哪些数据？**
+- 当前月的归属记录（变化较少）
+- 员工当前门店（BASE_USER.F_Mdid）
+
+**缓存失效策略：**
+- 归属记录更新时，清除相关缓存
+- 定时刷新（如每天凌晨）
+
+#### 3.3 数据分区考虑
+
+**是否需要分区？**
+- 如果数据量很大（如10年历史，每月几千员工），可以考虑按年份分区
+- 当前阶段可能不需要，但设计时要考虑扩展性
+
+### 4. 异常情况处理
+
+#### 4.1 数据冲突检测
+
+**场景：同一个员工同一天有多条归属记录**
+
+**检测时机：**
+- 插入/更新归属记录时
+- 数据迁移时
+
+**处理方案：**
+- 应用层校验：插入前检查是否有日期重叠
+- 如果发现冲突，拒绝操作，提示用户处理
+
+**校验SQL示例：**
+```sql
+-- 检查是否存在日期重叠
+SELECT COUNT(*) 
+FROM lq_employee_store_assignment
+WHERE F_EmployeeId = @EmployeeId
+  AND F_IsEffective = 1
+  AND (
+    (F_StartDate <= @EndDate AND F_EndDate >= @StartDate)
+    OR (F_StartDate IS NULL AND F_EndDate IS NULL)
+  )
+```
+
+#### 4.2 数据缺失处理
+
+**场景：快照表中没有某员工某月的归属记录**
+
+**处理方案：**
+1. **回退到现有逻辑**（推荐）
+   - 从业务数据或BASE_USER获取
+   - 记录警告日志
+   - 可选：自动创建一条归属记录（使用当前门店或推断的门店）
+
+2. **报错处理**
+   - 如果快照表没有记录，直接报错
+   - 要求用户先维护归属记录
+
+**推荐：方案1**
+- 保持系统的容错性
+- 记录警告，便于后续补录数据
+
+### 5. 与现有系统的兼容性
+
+#### 5.1 渐进式迁移
+
+**迁移策略：**
+1. **第一阶段：新建表，不影响现有逻辑**
+   - 创建归属表
+   - 数据迁移
+   - 但工资计算仍使用现有逻辑
+
+2. **第二阶段：双写模式**
+   - 工资计算时，同时使用新逻辑和旧逻辑
+   - 对比结果，验证新逻辑的正确性
+
+3. **第三阶段：切换到新逻辑**
+   - 新逻辑验证无误后，切换到新逻辑
+   - 保留旧逻辑作为回退方案
+
+4. **第四阶段：移除旧逻辑**
+   - 新逻辑稳定运行一段时间后，移除旧逻辑
+
+#### 5.2 数据迁移的准确性
+
+**迁移数据来源优先级：**
+1. 工资统计表（最可靠）
+2. 业务数据统计（补充）
+3. BASE_USER当前门店（兜底）
+
+**迁移后的验证：**
+- 抽样检查：随机抽取一定比例的数据，人工验证
+- 逻辑检查：检查是否有明显异常
+- 对比验证：对比迁移前后的工资计算结果
+
+### 6. 未来扩展性
+
+#### 6.1 多门店归属
+
+**场景：一个员工同时归属多个门店（兼职）**
+
+**扩展方案：**
+- 当前设计已经支持（一个员工一个月可以有多条记录）
+- 需要调整工资计算逻辑：如何分配业绩到不同门店
+- 可能需要增加字段：业绩分配比例
+
+#### 6.2 部门归属
+
+**场景：不仅记录门店归属，还要记录部门归属**
+
+**扩展方案：**
+- 可以增加字段：F_DepartmentId（部门ID）
+- 或者创建新表：员工部门归属表
+- 或者：在归属表中增加字段：F_DepartmentId（如果需要同时记录门店和部门）
+
+#### 6.3 岗位变更历史
+
+**场景：记录员工岗位变更历史**
+
+**扩展方案：**
+- 可以创建新表：员工岗位归属表（类似设计）
+- 或者：在归属表中增加字段：F_Position（岗位）
+
+#### 6.4 其他业务属性
+
+**场景：需要记录其他业务属性（如：职级、薪资等级等）**
+
+**扩展方案：**
+- 可以在归属表中增加字段
+- 或者创建关联表
+
+**设计原则：**
+- 优先考虑在归属表中增加字段（如果属性是时间相关的）
+- 如果属性与门店归属无关，考虑创建新表
+
+---
+
+## 📝 总结
+
+门店归属快照表方案是一个相对完善的解决方案，能够：
+
+1. **解决核心问题**：以时间维度为唯一标准，准确记录历史门店归属
+2. **支持复杂场景**：月中调店、跨月调店等
+3. **保证数据完整性**：通过多数据源验证和数据校验
+4. **考虑性能**：合理设计索引和查询优化
+5. **易于扩展**：设计时考虑了未来的业务变化
+
+**关键成功因素：**
+- 数据迁移的准确性
+- 业务规则的清晰性
+- 用户操作的简便性
+- 系统性能的稳定性
+
+---
+
+**文档版本：** v1.0  
+**创建日期：** 2026-01-09  
+**文档性质：** 详细设计方案（仅思考，不修改代码）
 using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
 using NCC.Common.Filter;
 using NCC.Common.Helper;
 using NCC.Dependency;
 using NCC.DynamicApiController;
 using NCC.Extend.Entitys.Dto.LqAssistantSalary;
+using NCC.Extend.Entitys.Dto.LqSalary;
 using NCC.Extend.Entitys.lq_assistant_salary_statistics;
 using NCC.Extend.Entitys.lq_attendance_summary;
 using NCC.Extend.Entitys.lq_hytk_hytk;
@@ -14,10 +17,13 @@ using NCC.Extend.Entitys.lq_md_xdbhsj;
 using NCC.Extend.Entitys.lq_mdxx;
 using NCC.Extend.Entitys.lq_xh_hyhk;
 using NCC.Extend.Entitys.lq_xh_jksyj;
+using NCC.FriendlyException;
 using NCC.System.Entitys.Permission;
 using SqlSugar;
 using System;
 using System.Collections.Generic;
+using System.Data;
+using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using Yitter.IdGenerator;
@@ -32,13 +38,15 @@ namespace NCC.Extend
     public class LqAssistantSalaryService : IDynamicApiController, ITransient
     {
         private readonly ISqlSugarClient _db;
+        private readonly ILogger<LqAssistantSalaryService> _logger;
  
         /// <summary>
         /// 初始化一个<see cref="LqAssistantSalaryService"/>类型的新实例
         /// </summary>
-        public LqAssistantSalaryService(ISqlSugarClient db)
+        public LqAssistantSalaryService(ISqlSugarClient db, ILogger<LqAssistantSalaryService> logger)
         {
             _db = db;
+            _logger = logger;
         }
  
         /// <summary>
@@ -51,17 +59,7 @@ namespace NCC.Extend
         {
             var monthStr = $"{input.Year}{input.Month:D2}";
  
-            // 1. 检查当月是否已生成工资数据
-            var exists = await _db.Queryable<LqAssistantSalaryStatisticsEntity>()
-                .AnyAsync(x => x.StatisticsMonth == monthStr);
-
-            // 2. 如果没有数据，则进行计算
-            if (!exists)
-            {
-                await CalculateAssistantSalary(input.Year, input.Month);
-            }
-
-            // 3. 查询数据
+            // 查询数据
             var query = _db.Queryable<LqAssistantSalaryStatisticsEntity>()
                 .Where(x => x.StatisticsMonth == monthStr);
  
@@ -125,6 +123,69 @@ namespace NCC.Extend
         }
  
         /// <summary>
+        /// 通过月份和员工ID查询工资
+        /// </summary>
+        [HttpGet("query-by-employee")]
+        public async Task<AssistantSalaryOutput> GetSalaryByEmployee([FromQuery] SalaryQueryByEmployeeInput input)
+        {
+            if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+                throw NCCException.Oh("年份和月份参数不正确");
+            if (string.IsNullOrWhiteSpace(input.EmployeeId))
+                throw NCCException.Oh("员工ID不能为空");
+            var monthStr = $"{input.Year}{input.Month:D2}";
+            var salary = await _db.Queryable<LqAssistantSalaryStatisticsEntity>()
+                .Where(x => x.StatisticsMonth == monthStr && x.EmployeeId == input.EmployeeId)
+                .Select(x => new AssistantSalaryOutput
+                {
+                    Id = x.Id,
+                    StoreName = x.StoreName,
+                    EmployeeName = x.EmployeeName,
+                    Position = x.Position,
+                    StoreTotalPerformance = x.StoreTotalPerformance,
+                    StoreBillingPerformance = x.StoreBillingPerformance,
+                    StoreRefundPerformance = x.StoreRefundPerformance,
+                    StoreLifeline = x.StoreLifeline,
+                    PerformanceCompletionRate = x.PerformanceCompletionRate,
+                    CommissionRate = x.CommissionRate,
+                    CommissionAmount = x.CommissionAmount,
+                    HeadCount = x.HeadCount,
+                    Stage1TargetHeadCount = x.Stage1TargetHeadCount,
+                    Stage2TargetHeadCount = x.Stage2TargetHeadCount,
+                    ReachedStage1 = x.ReachedStage1,
+                    ReachedStage2 = x.ReachedStage2,
+                    StageRewardAmount = x.StageRewardAmount,
+                    Stage1Reward = x.Stage1Reward,
+                    Stage2Reward = x.Stage2Reward,
+                    BaseSalary = x.BaseSalary,
+                    PhoneManagementFee = x.PhoneManagementFee,
+                    WorkingDays = x.WorkingDays,
+                    LeaveDays = x.LeaveDays,
+                    GrossSalary = x.GrossSalary,
+                    ActualSalary = x.ActualSalary,
+                    TotalDeduction = x.TotalDeduction,
+                    TotalSubsidy = x.TotalSubsidy,
+                    Bonus = x.Bonus,
+                    ReturnPhoneDeposit = x.ReturnPhoneDeposit,
+                    ReturnAccommodationDeposit = x.ReturnAccommodationDeposit,
+                    MonthlyPaymentStatus = x.MonthlyPaymentStatus,
+                    PaidAmount = x.PaidAmount,
+                    PendingAmount = x.PendingAmount,
+                    LastMonthSupplement = x.LastMonthSupplement,
+                    MonthlyTotalPayment = x.MonthlyTotalPayment,
+                    IsLocked = x.IsLocked,
+                    UpdateTime = x.UpdateTime,
+                    StoreType = x.StoreType,
+                    StoreCategory = x.StoreCategory,
+                    IsNewStore = x.IsNewStore,
+                    NewStoreProtectionStage = x.NewStoreProtectionStage
+                })
+                .FirstAsync();
+            if (salary == null)
+                throw NCCException.Oh($"未找到员工{input.EmployeeId}在{input.Year}年{input.Month}月的工资记录");
+            return salary;
+        }
+
+        /// <summary>
         /// 计算店助工资
         /// </summary>
         /// <param name="year">年份</param>
@@ -356,7 +417,7 @@ namespace NCC.Extend
                         //    - 100%以上部分：0.6%
                         totalCommission = CalculateAssistantCommission(salary.StoreTotalPerformance, salary.StoreLifeline);
                     }
-                    
+
                     // 计算平均提成比例（用于显示）
                     if (salary.StoreTotalPerformance > 0)
                     {
@@ -465,7 +526,7 @@ namespace NCC.Extend
                     {
                         storeTotalCommission = CalculateAssistantCommission(salary.StoreTotalPerformance, salary.StoreLifeline);
                     }
-                    
+
                     // 按比例计算提成：门店总提成 / 当月天数 × 在店天数
                     salary.CommissionAmount = storeTotalCommission / daysInMonth * workingDays;
  
@@ -540,12 +601,71 @@ namespace NCC.Extend
             // 3. 保存数据
             if (assistantSalaryList.Any())
             {
-                // 先删除当月旧数据 (防止重复)
-                await _db.Deleteable<LqAssistantSalaryStatisticsEntity>()
+                // 查询当月已存在的记录（用于检查是否已锁定或已确认）
+                var existingRecords = await _db.Queryable<LqAssistantSalaryStatisticsEntity>()
                     .Where(x => x.StatisticsMonth == monthStr)
-                    .ExecuteCommandAsync();
+                    .ToListAsync();
+
+                var existingDict = existingRecords
+                    .Where(x => !string.IsNullOrEmpty(x.EmployeeId))
+                    .GroupBy(x => x.EmployeeId)
+                    .ToDictionary(g => g.Key, g => g.First());
+
+                // 分离需要插入的新记录和需要更新的记录，以及需要跳过的记录
+                var recordsToInsert = new List<LqAssistantSalaryStatisticsEntity>();
+                var recordsToUpdate = new List<LqAssistantSalaryStatisticsEntity>();
+                var skippedCount = 0;
  
-                await _db.Insertable(assistantSalaryList).ExecuteCommandAsync();
+                foreach (var salary in assistantSalaryList)
+                {
+                    if (existingDict.ContainsKey(salary.EmployeeId))
+                    {
+                        var existing = existingDict[salary.EmployeeId];
+                        // 如果已锁定或已确认，则跳过，不更新
+                        if (existing.IsLocked == 1 || existing.EmployeeConfirmStatus == 1)
+                        {
+                            skippedCount++;
+                            continue; // 跳过，不更新
+                        }
+
+                        // 更新现有记录（保留确认状态相关字段）
+                        salary.Id = existing.Id;
+                        salary.EmployeeConfirmStatus = existing.EmployeeConfirmStatus;
+                        salary.EmployeeConfirmTime = existing.EmployeeConfirmTime;
+                        salary.EmployeeConfirmRemark = existing.EmployeeConfirmRemark;
+                        salary.IsLocked = existing.IsLocked; // 保留锁定状态
+                        salary.CreateTime = existing.CreateTime;
+                        salary.CreateUser = existing.CreateUser;
+                        recordsToUpdate.Add(salary);
+                    }
+                    else
+                    {
+                        // 新记录
+                        salary.Id = YitIdHelper.NextId().ToString();
+                        salary.EmployeeConfirmStatus = 0;
+                        salary.IsLocked = 0;
+                        salary.CreateTime = DateTime.Now;
+                        salary.CreateUser = ""; // 新记录，创建人为空或系统
+                        recordsToInsert.Add(salary);
+                    }
+                }
+
+                // 批量插入新记录
+                if (recordsToInsert.Any())
+                {
+                    await _db.Insertable(recordsToInsert).ExecuteCommandAsync();
+                }
+
+                // 批量更新现有记录
+                if (recordsToUpdate.Any())
+                {
+                    await _db.Updateable(recordsToUpdate).ExecuteCommandAsync();
+                }
+
+                if (skippedCount > 0)
+                {
+                    _logger.LogWarning($"计算工资时跳过了 {skippedCount} 条已锁定或已确认的记录（月份：{monthStr}）");
+                }
             }
         }
  
@@ -666,6 +786,487 @@ namespace NCC.Extend
             };
         }
  
+        #region 员工工资确认
+
+        /// <summary>
+        /// 员工确认工资条
+        /// </summary>
+        /// <remarks>
+        /// 员工确认自己的工资条，确认后工资数据不可再修改
+        /// 
+        /// 示例请求：
+        /// <code>
+        /// {
+        ///   "id": "工资记录ID",
+        ///   "employeeId": "员工ID",
+        ///   "remark": "确认备注（可选）"
+        /// }
+        /// </code>
+        /// 
+        /// 参数说明：
+        /// - id: 工资记录ID（必填）
+        /// - employeeId: 员工ID（必填）
+        /// - remark: 确认备注（可选）
+        /// 
+        /// 注意事项：
+        /// - 只能确认自己的工资条
+        /// - 只能确认已锁定的工资条（IsLocked = 1）
+        /// - 已确认的工资条不能重复确认
+        /// </remarks>
+        /// <param name="input">确认参数</param>
+        /// <returns>操作结果</returns>
+        /// <response code="200">确认成功</response>
+        /// <response code="400">参数错误或记录不存在</response>
+        [HttpPost("confirm")]
+        public async Task<string> ConfirmSalary([FromBody] SalaryConfirmInput input)
+        {
+            try
+            {
+                if (string.IsNullOrWhiteSpace(input.Id))
+                {
+                    throw NCCException.Oh("工资记录ID不能为空");
+                }
+
+                if (string.IsNullOrWhiteSpace(input.EmployeeId))
+                {
+                    throw NCCException.Oh("员工ID不能为空");
+                }
+
+                var salary = await _db.Queryable<LqAssistantSalaryStatisticsEntity>()
+                    .Where(s => s.Id == input.Id && s.EmployeeId == input.EmployeeId)
+                    .FirstAsync();
+
+                if (salary == null)
+                {
+                    throw NCCException.Oh("工资记录不存在或不属于该员工");
+                }
+
+                if (salary.EmployeeConfirmStatus == 1)
+                {
+                    throw NCCException.Oh("该工资条已确认，不能重复确认");
+                }
+
+                if (salary.IsLocked != 1)
+                {
+                    throw NCCException.Oh("该工资条尚未锁定，请等待管理员锁定后再确认");
+                }
+
+                salary.EmployeeConfirmStatus = 1;
+                salary.EmployeeConfirmTime = DateTime.Now;
+                salary.EmployeeConfirmRemark = input.Remark;
+                salary.UpdateTime = DateTime.Now;
+
+                await _db.Updateable(salary).ExecuteCommandAsync();
+
+                return "确认成功";
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"确认工资条失败: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        #region 工资锁定/解锁
+
+        /// <summary>
+        /// 批量锁定/解锁工资条
+        /// </summary>
+        [HttpPost("lock")]
+        public async Task<string> LockSalary([FromBody] SalaryLockInput input)
+        {
+            try
+            {
+                if (input == null || input.Ids == null || !input.Ids.Any())
+                    throw NCCException.Oh("工资记录ID列表不能为空");
+                var salaries = await _db.Queryable<LqAssistantSalaryStatisticsEntity>()
+                    .Where(s => input.Ids.Contains(s.Id))
+                    .ToListAsync();
+                if (!salaries.Any())
+                    throw NCCException.Oh("未找到指定的工资记录");
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+                foreach (var salary in salaries)
+                {
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+                    if (input.IsLocked) lockedCount++; else unlockedCount++;
+                }
+                await _db.Updateable(salaries).ExecuteCommandAsync();
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+                if (skippedCount > 0)
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+                return message;
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"锁定/解锁工资条失败: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// 批量锁定当月所有工资
+        /// </summary>
+        /// <param name="input">批量锁定输入参数</param>
+        /// <returns>锁定结果</returns>
+        [HttpPost("lock-by-month")]
+        public async Task<dynamic> LockSalaryByMonth([FromBody] SalaryLockByMonthInput input)
+        {
+            try
+            {
+                if (input == null)
+                    throw NCCException.Oh("参数不能为空");
+
+                if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+                    throw NCCException.Oh("年份和月份参数不正确");
+
+                var monthStr = $"{input.Year}{input.Month:D2}";
+
+                var salaries = await _db.Queryable<LqAssistantSalaryStatisticsEntity>()
+                    .Where(s => s.StatisticsMonth == monthStr)
+                    .ToListAsync();
+
+                if (!salaries.Any())
+                    throw NCCException.Oh($"未找到{input.Year}年{input.Month}月的工资记录");
+
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+                var alreadyLockedCount = 0;
+
+                foreach (var salary in salaries)
+                {
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+
+                    if (salary.IsLocked == 1 && input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    if (salary.IsLocked == 0 && !input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+
+                    if (input.IsLocked)
+                        lockedCount++;
+                    else
+                        unlockedCount++;
+                }
+
+                if (lockedCount > 0 || unlockedCount > 0)
+                {
+                    var salariesToUpdate = salaries.Where(s =>
+                        (input.IsLocked && s.IsLocked == 0) ||
+                        (!input.IsLocked && s.IsLocked == 1 && s.EmployeeConfirmStatus != 1)
+                    ).ToList();
+
+                    if (salariesToUpdate.Any())
+                    {
+                        await _db.Updateable(salariesToUpdate)
+                            .UpdateColumns(s => new { s.IsLocked, s.UpdateTime })
+                            .ExecuteCommandAsync();
+                    }
+                }
+
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+
+                if (alreadyLockedCount > 0)
+                    message += $"，跳过{alreadyLockedCount}条（已是{action}状态）";
+
+                if (skippedCount > 0)
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+
+                return new
+                {
+                    success = true,
+                    message = message,
+                    total = salaries.Count,
+                    locked = lockedCount,
+                    unlocked = unlockedCount,
+                    skipped = skippedCount,
+                    alreadyLocked = alreadyLockedCount
+                };
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "批量锁定当月工资失败");
+                var action = input?.IsLocked == true ? "锁定" : "解锁";
+                throw NCCException.Oh($"批量{action}当月工资失败: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        #region 导入工资
+
+        /// <summary>
+        /// 从Excel导入店助工资数据
+        /// </summary>
+        /// <param name="file">Excel文件</param>
+        /// <returns>导入结果</returns>
+        [HttpPost("import")]
+        public async Task<dynamic> ImportSalaryFromExcel(IFormFile file)
+        {
+            try
+            {
+                if (file == null || file.Length == 0)
+                    throw NCCException.Oh("请选择要上传的Excel文件");
+
+                var allowedExtensions = new[] { ".xlsx", ".xls" };
+                var fileExtension = Path.GetExtension(file.FileName).ToLowerInvariant();
+                if (!allowedExtensions.Contains(fileExtension))
+                    throw NCCException.Oh("只支持.xlsx和.xls格式的Excel文件");
+
+                var recordsToInsert = new List<LqAssistantSalaryStatisticsEntity>();
+                var recordsToUpdate = new List<LqAssistantSalaryStatisticsEntity>();
+                var errorMessages = new List<string>();
+                var successCount = 0;
+                var failCount = 0;
+                var skippedCount = 0;
+
+                var tempFilePath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + Path.GetExtension(file.FileName));
+                try
+                {
+                    using (var stream = new FileStream(tempFilePath, FileMode.Create))
+                    {
+                        await file.CopyToAsync(stream);
+                    }
+
+                    var dataTable = ExcelImportHelper.ToDataTable(tempFilePath, 0, 0);
+                    if (dataTable.Rows.Count == 0)
+                        throw NCCException.Oh("Excel文件中没有数据行");
+
+                    Func<string, decimal> ParseDecimal = (str) =>
+                    {
+                        if (string.IsNullOrWhiteSpace(str)) return 0;
+                        var cleaned = str.Trim().Replace(",", "").Replace("，", "").Replace("￥", "").Replace("$", "").Replace("元", "").Replace("%", "").Replace(" ", "");
+                        return decimal.TryParse(cleaned, out decimal result) ? result : 0;
+                    };
+
+                    Func<string, int> ParseInt = (str) =>
+                    {
+                        if (string.IsNullOrWhiteSpace(str)) return 0;
+                        var cleaned = str.Trim().Replace(",", "").Replace("，", "").Replace(" ", "");
+                        return int.TryParse(cleaned, out int result) ? result : 0;
+                    };
+
+                    for (int i = 1; i < dataTable.Rows.Count; i++)
+                    {
+                        try
+                        {
+                            var row = dataTable.Rows[i];
+                            Func<int, string> GetColumnValue = (colIndex) => colIndex < row.ItemArray.Length && row[colIndex] != null ? row[colIndex].ToString().Trim() : "";
+
+                            var firstColumnValue = GetColumnValue(0);
+                            bool isOldFormat = !string.IsNullOrWhiteSpace(firstColumnValue) && (firstColumnValue == "门店名称" || (!long.TryParse(firstColumnValue, out _) && firstColumnValue.Length > 20));
+
+                            int storeNameIndex = isOldFormat ? 0 : 1;
+                            int employeeNameIndex = isOldFormat ? 1 : 2;
+                            int offset = isOldFormat ? 0 : 1;
+
+                            var id = isOldFormat ? "" : GetColumnValue(0);
+                            var employeeName = GetColumnValue(employeeNameIndex);
+                            var storeName = GetColumnValue(storeNameIndex);
+
+                            if (string.IsNullOrWhiteSpace(id) && string.IsNullOrWhiteSpace(employeeName))
+                                continue;
+
+                            if (string.IsNullOrWhiteSpace(id) && !string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                var matchedRecord = await _db.Queryable<LqAssistantSalaryStatisticsEntity>()
+                                    .Where(x => x.EmployeeName == employeeName)
+                                    .WhereIF(!string.IsNullOrWhiteSpace(storeName), x => x.StoreName == storeName)
+                                    .OrderBy(x => x.CreateTime, OrderByType.Desc)
+                                    .FirstAsync();
+                                if (matchedRecord != null) id = matchedRecord.Id;
+                            }
+
+                            if (string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                errorMessages.Add($"第{i + 1}行：员工姓名不能为空");
+                                failCount++;
+                                continue;
+                            }
+
+                            LqAssistantSalaryStatisticsEntity existing = null;
+                            if (!string.IsNullOrWhiteSpace(id))
+                            {
+                                existing = await _db.Queryable<LqAssistantSalaryStatisticsEntity>()
+                                    .Where(x => x.Id == id).FirstAsync();
+
+                                if (existing != null && (existing.IsLocked == 1 || existing.EmployeeConfirmStatus == 1))
+                                {
+                                    skippedCount++;
+                                    failCount++;
+                                    continue;
+                                }
+                            }
+
+                            var entity = existing ?? new LqAssistantSalaryStatisticsEntity
+                            {
+                                Id = string.IsNullOrWhiteSpace(id) ? YitIdHelper.NextId().ToString() : id,
+                                EmployeeConfirmStatus = 0,
+                                IsLocked = 0,
+                                CreateTime = DateTime.Now,
+                                CreateUser = ""
+                            };
+
+                            entity.StoreName = storeName;
+                            entity.EmployeeName = employeeName;
+                            entity.Position = GetColumnValue(2 + offset);
+                            entity.StoreTotalPerformance = ParseDecimal(GetColumnValue(3 + offset));
+                            entity.StoreBillingPerformance = ParseDecimal(GetColumnValue(4 + offset));
+                            entity.StoreRefundPerformance = ParseDecimal(GetColumnValue(5 + offset));
+                            entity.StoreLifeline = ParseDecimal(GetColumnValue(6 + offset));
+                            entity.PerformanceCompletionRate = ParseDecimal(GetColumnValue(7 + offset));
+                            entity.CommissionRate = ParseDecimal(GetColumnValue(8 + offset));
+                            entity.CommissionAmount = ParseDecimal(GetColumnValue(9 + offset));
+                            entity.HeadCount = ParseInt(GetColumnValue(10 + offset));
+                            entity.Stage1TargetHeadCount = ParseInt(GetColumnValue(11 + offset));
+                            entity.Stage2TargetHeadCount = ParseInt(GetColumnValue(12 + offset));
+                            entity.ReachedStage1 = GetColumnValue(13 + offset);
+                            entity.ReachedStage2 = GetColumnValue(14 + offset);
+                            entity.StageRewardAmount = ParseDecimal(GetColumnValue(15 + offset));
+                            entity.Stage1Reward = ParseDecimal(GetColumnValue(16 + offset));
+                            entity.Stage2Reward = ParseDecimal(GetColumnValue(17 + offset));
+                            entity.BaseSalary = ParseDecimal(GetColumnValue(18 + offset));
+                            entity.PhoneManagementFee = ParseDecimal(GetColumnValue(19 + offset));
+                            entity.WorkingDays = ParseInt(GetColumnValue(20 + offset));
+                            entity.LeaveDays = ParseInt(GetColumnValue(21 + offset));
+                            entity.GrossSalary = ParseDecimal(GetColumnValue(22 + offset));
+                            entity.ActualSalary = ParseDecimal(GetColumnValue(23 + offset));
+                            entity.TotalDeduction = ParseDecimal(GetColumnValue(24 + offset));
+                            entity.TotalSubsidy = ParseDecimal(GetColumnValue(25 + offset));
+                            entity.Bonus = ParseDecimal(GetColumnValue(26 + offset));
+                            entity.ReturnPhoneDeposit = ParseDecimal(GetColumnValue(27 + offset));
+                            entity.ReturnAccommodationDeposit = ParseDecimal(GetColumnValue(28 + offset));
+                            entity.LastMonthSupplement = ParseDecimal(GetColumnValue(29 + offset));
+                            entity.MonthlyPaymentStatus = GetColumnValue(30 + offset);
+                            entity.PaidAmount = ParseDecimal(GetColumnValue(31 + offset));
+                            entity.PendingAmount = ParseDecimal(GetColumnValue(32 + offset));
+                            entity.MonthlyTotalPayment = ParseDecimal(GetColumnValue(33 + offset));
+                            entity.IsNewStore = GetColumnValue(34 + offset) == "是" ? "是" : "否";
+                            entity.NewStoreProtectionStage = ParseInt(GetColumnValue(35 + offset));
+
+                            if (existing != null)
+                            {
+                                entity.StoreId = existing.StoreId;
+                                entity.EmployeeId = existing.EmployeeId;
+                                entity.StatisticsMonth = existing.StatisticsMonth;
+                            }
+                            else
+                            {
+                                // 对于新记录，尝试通过员工姓名和门店名称匹配已有记录以获取统计月份
+                                LqAssistantSalaryStatisticsEntity matchedRecord = null;
+                                if (!string.IsNullOrWhiteSpace(employeeName))
+                                {
+                                    var user = await _db.Queryable<UserEntity>()
+                                        .Where(u => u.RealName == employeeName).FirstAsync();
+                                    if (user != null)
+                                    {
+                                        entity.EmployeeId = user.Id;
+                                        if (!string.IsNullOrEmpty(user.Mdid) && string.IsNullOrWhiteSpace(storeName))
+                                            entity.StoreId = user.Mdid;
+
+                                        // 尝试通过员工ID匹配已有记录获取统计月份
+                                        matchedRecord = await _db.Queryable<LqAssistantSalaryStatisticsEntity>()
+                                            .Where(x => x.EmployeeId == user.Id)
+                                            .WhereIF(!string.IsNullOrWhiteSpace(storeName), x => x.StoreName == storeName)
+                                            .OrderBy(x => x.CreateTime, OrderByType.Desc)
+                                            .FirstAsync();
+                                    }
+
+                                    if (!string.IsNullOrWhiteSpace(storeName) && string.IsNullOrEmpty(entity.StoreId))
+                                    {
+                                        var store = await _db.Queryable<LqMdxxEntity>()
+                                            .Where(s => s.Dm == storeName).FirstAsync();
+                                        if (store != null)
+                                        {
+                                            entity.StoreId = store.Id;
+                                            // 如果没有匹配到记录，再通过门店ID尝试
+                                            if (matchedRecord == null)
+                                            {
+                                                matchedRecord = await _db.Queryable<LqAssistantSalaryStatisticsEntity>()
+                                                    .Where(x => x.StoreId == store.Id)
+                                                    .WhereIF(!string.IsNullOrWhiteSpace(employeeName), x => x.EmployeeName == employeeName)
+                                                    .OrderBy(x => x.CreateTime, OrderByType.Desc)
+                                                    .FirstAsync();
+                                            }
+                                        }
+                                    }
+                                }
+
+                                // 如果有匹配的记录，使用其统计月份；否则使用当前年月作为默认值
+                                if (matchedRecord != null && !string.IsNullOrWhiteSpace(matchedRecord.StatisticsMonth))
+                                {
+                                    entity.StatisticsMonth = matchedRecord.StatisticsMonth;
+                                }
+                                else
+                                {
+                                    // 如果没有匹配记录，使用当前年月（YYYYMM格式）
+                                    var now = DateTime.Now;
+                                    entity.StatisticsMonth = $"{now.Year}{now.Month:D2}";
+                                }
+                            }
+
+                            entity.UpdateTime = DateTime.Now;
+                            if (existing != null) recordsToUpdate.Add(entity);
+                            else recordsToInsert.Add(entity);
+                            successCount++;
+                        }
+                        catch (Exception ex)
+                        {
+                            errorMessages.Add($"第{i + 1}行数据处理失败: {ex.Message}");
+                            failCount++;
+                        }
+                    }
+                }
+                finally
+                {
+                    if (File.Exists(tempFilePath)) File.Delete(tempFilePath);
+                }
+
+                if (recordsToInsert.Any()) await _db.Insertable(recordsToInsert).ExecuteCommandAsync();
+                if (recordsToUpdate.Any()) await _db.Updateable(recordsToUpdate).ExecuteCommandAsync();
+
+                return new
+                {
+                    success = true,
+                    message = $"导入完成：成功 {successCount} 条，失败 {failCount} 条，跳过 {skippedCount} 条（已锁定或已确认）",
+                    successCount,
+                    failCount,
+                    skippedCount,
+                    errors = errorMessages
+                };
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"导入店助工资数据失败: {ex.Message}");
+            }
+        }
+
+        #endregion
     }
 }
  
@@ -62,17 +62,7 @@ namespace NCC.Extend
         {
             var monthStr = $"{input.Year}{input.Month:D2}";
  
-            // 1. 检查当月是否已生成工资数据
-            var exists = await _db.Queryable<LqBusinessUnitManagerSalaryStatisticsEntity>()
-                .AnyAsync(x => x.StatisticsMonth == monthStr);
-
-            // 2. 如果没有数据，则进行计算
-            if (!exists)
-            {
-                await CalculateBusinessUnitManagerSalary(input.Year, input.Month);
-            }
-
-            // 3. 查询数据
+            // 查询数据
             var query = _db.Queryable<LqBusinessUnitManagerSalaryStatisticsEntity>()
                 .Where(x => x.StatisticsMonth == monthStr);
  
@@ -141,6 +131,74 @@ namespace NCC.Extend
         }
  
         /// <summary>
+        /// 通过月份和员工ID查询工资
+        /// </summary>
+        [HttpGet("query-by-employee")]
+        public async Task<BusinessUnitManagerSalaryOutput> GetSalaryByEmployee([FromQuery] SalaryQueryByEmployeeInput input)
+        {
+            if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+                throw NCCException.Oh("年份和月份参数不正确");
+            if (string.IsNullOrWhiteSpace(input.EmployeeId))
+                throw NCCException.Oh("员工ID不能为空");
+            var monthStr = $"{input.Year}{input.Month:D2}";
+            var salary = await _db.Queryable<LqBusinessUnitManagerSalaryStatisticsEntity>()
+                .Where(x => x.StatisticsMonth == monthStr && x.EmployeeId == input.EmployeeId)
+                .Select(x => new BusinessUnitManagerSalaryOutput
+                {
+                    Id = x.Id,
+                    StatisticsMonth = x.StatisticsMonth,
+                    Position = x.Position,
+                    EmployeeName = x.EmployeeName,
+                    EmployeeId = x.EmployeeId,
+                    EmployeeAccount = x.EmployeeAccount,
+                    ManagerType = x.ManagerType,
+                    IsTerminated = x.IsTerminated,
+                    StorePerformanceDetail = x.StorePerformanceDetail,
+                    SalesPerformance = x.SalesPerformance,
+                    ProductMaterial = x.ProductMaterial,
+                    CooperationCost = x.CooperationCost,
+                    StoreExpense = x.StoreExpense,
+                    LaundryCost = x.LaundryCost,
+                    GrossProfit = x.GrossProfit,
+                    BaseSalary = x.BaseSalary,
+                    TotalCommission = x.TotalCommission,
+                    WorkingDays = x.WorkingDays,
+                    LeaveDays = x.LeaveDays,
+                    CalculatedGrossSalary = x.CalculatedGrossSalary,
+                    FinalGrossSalary = x.FinalGrossSalary,
+                    MonthlyTrainingSubsidy = x.MonthlyTrainingSubsidy,
+                    MonthlyTransportSubsidy = x.MonthlyTransportSubsidy,
+                    LastMonthTrainingSubsidy = x.LastMonthTrainingSubsidy,
+                    LastMonthTransportSubsidy = x.LastMonthTransportSubsidy,
+                    TotalSubsidy = x.TotalSubsidy,
+                    MissingCard = x.MissingCard,
+                    LateArrival = x.LateArrival,
+                    LeaveDeduction = x.LeaveDeduction,
+                    SocialInsuranceDeduction = x.SocialInsuranceDeduction,
+                    RewardDeduction = x.RewardDeduction,
+                    AccommodationDeduction = x.AccommodationDeduction,
+                    StudyPeriodDeduction = x.StudyPeriodDeduction,
+                    WorkClothesDeduction = x.WorkClothesDeduction,
+                    TotalDeduction = x.TotalDeduction,
+                    Bonus = x.Bonus,
+                    ReturnPhoneDeposit = x.ReturnPhoneDeposit,
+                    ReturnAccommodationDeposit = x.ReturnAccommodationDeposit,
+                    ActualSalary = x.ActualSalary,
+                    MonthlyPaymentStatus = x.MonthlyPaymentStatus,
+                    PaidAmount = x.PaidAmount,
+                    PendingAmount = x.PendingAmount,
+                    LastMonthSupplement = x.LastMonthSupplement,
+                    MonthlyTotalPayment = x.MonthlyTotalPayment,
+                    IsLocked = x.IsLocked,
+                    UpdateTime = x.UpdateTime
+                })
+                .FirstAsync();
+            if (salary == null)
+                throw NCCException.Oh($"未找到员工{input.EmployeeId}在{input.Year}年{input.Month}月的工资记录");
+            return salary;
+        }
+
+        /// <summary>
         /// 计算事业部总经理/经理工资
         /// </summary>
         /// <param name="year">年份</param>
@@ -635,6 +693,35 @@ namespace NCC.Extend
  
         #region 员工工资确认
  
+        /// <summary>
+        /// 员工确认工资条
+        /// </summary>
+        /// <remarks>
+        /// 员工确认自己的工资条，确认后工资数据不可再修改
+        /// 
+        /// 示例请求：
+        /// <code>
+        /// {
+        ///   "id": "工资记录ID",
+        ///   "employeeId": "员工ID",
+        ///   "remark": "确认备注（可选）"
+        /// }
+        /// </code>
+        /// 
+        /// 参数说明：
+        /// - id: 工资记录ID（必填）
+        /// - employeeId: 员工ID（必填）
+        /// - remark: 确认备注（可选）
+        /// 
+        /// 注意事项：
+        /// - 只能确认自己的工资条
+        /// - 只能确认已锁定的工资条（IsLocked = 1）
+        /// - 已确认的工资条不能重复确认
+        /// </remarks>
+        /// <param name="input">确认参数</param>
+        /// <returns>操作结果</returns>
+        /// <response code="200">确认成功</response>
+        /// <response code="400">参数错误或记录不存在</response>
         [HttpPost("confirm")]
         public async Task<string> ConfirmSalary([FromBody] SalaryConfirmInput input)
         {
@@ -662,6 +749,156 @@ namespace NCC.Extend
  
         #endregion
  
+        #region 工资锁定/解锁
+
+        /// <summary>
+        /// 批量锁定/解锁工资条
+        /// </summary>
+        [HttpPost("lock")]
+        public async Task<string> LockSalary([FromBody] SalaryLockInput input)
+        {
+            try
+            {
+                if (input == null || input.Ids == null || !input.Ids.Any())
+                    throw NCCException.Oh("工资记录ID列表不能为空");
+                var salaries = await _db.Queryable<LqBusinessUnitManagerSalaryStatisticsEntity>()
+                    .Where(s => input.Ids.Contains(s.Id))
+                    .ToListAsync();
+                if (!salaries.Any())
+                    throw NCCException.Oh("未找到指定的工资记录");
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+                foreach (var salary in salaries)
+                {
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+                    if (input.IsLocked) lockedCount++; else unlockedCount++;
+                }
+                await _db.Updateable(salaries).ExecuteCommandAsync();
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+                if (skippedCount > 0)
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+                return message;
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"锁定/解锁工资条失败: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// 批量锁定当月所有工资
+        /// </summary>
+        /// <param name="input">批量锁定输入参数</param>
+        /// <returns>锁定结果</returns>
+        [HttpPost("lock-by-month")]
+        public async Task<dynamic> LockSalaryByMonth([FromBody] SalaryLockByMonthInput input)
+        {
+            try
+            {
+                if (input == null)
+                    throw NCCException.Oh("参数不能为空");
+
+                if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+                    throw NCCException.Oh("年份和月份参数不正确");
+
+                var monthStr = $"{input.Year}{input.Month:D2}";
+
+                var salaries = await _db.Queryable<LqBusinessUnitManagerSalaryStatisticsEntity>()
+                    .Where(s => s.StatisticsMonth == monthStr)
+                    .ToListAsync();
+
+                if (!salaries.Any())
+                    throw NCCException.Oh($"未找到{input.Year}年{input.Month}月的工资记录");
+
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+                var alreadyLockedCount = 0;
+
+                foreach (var salary in salaries)
+                {
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+
+                    if (salary.IsLocked == 1 && input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    if (salary.IsLocked == 0 && !input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+
+                    if (input.IsLocked)
+                        lockedCount++;
+                    else
+                        unlockedCount++;
+                }
+
+                if (lockedCount > 0 || unlockedCount > 0)
+                {
+                    var salariesToUpdate = salaries.Where(s => 
+                        (input.IsLocked && s.IsLocked == 0) || 
+                        (!input.IsLocked && s.IsLocked == 1 && s.EmployeeConfirmStatus != 1)
+                    ).ToList();
+                    
+                    if (salariesToUpdate.Any())
+                    {
+                        await _db.Updateable(salariesToUpdate)
+                            .UpdateColumns(s => new { s.IsLocked, s.UpdateTime })
+                            .ExecuteCommandAsync();
+                    }
+                }
+
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+                
+                if (alreadyLockedCount > 0)
+                    message += $"，跳过{alreadyLockedCount}条（已是{action}状态）";
+                
+                if (skippedCount > 0)
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+
+                return new
+                {
+                    success = true,
+                    message = message,
+                    total = salaries.Count,
+                    locked = lockedCount,
+                    unlocked = unlockedCount,
+                    skipped = skippedCount,
+                    alreadyLocked = alreadyLockedCount
+                };
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "批量锁定当月工资失败");
+                var action = input?.IsLocked == true ? "锁定" : "解锁";
+                throw NCCException.Oh($"批量{action}当月工资失败: {ex.Message}");
+            }
+        }
+
+        #endregion
+
         #region 导入工资
  
         /// <summary>
 using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
 using NCC.Common.Filter;
 using NCC.Common.Helper;
 using NCC.Dependency;
 using NCC.DynamicApiController;
 using NCC.Extend.Entitys.Dto.LqDirectorSalary;
+using NCC.Extend.Entitys.Dto.LqSalary;
 using NCC.Extend.Entitys.Enum;
 using NCC.Extend.Entitys.lq_attendance_summary;
 using NCC.Extend.Entitys.lq_cooperation_cost;
@@ -18,10 +21,13 @@ using NCC.Extend.Entitys.lq_mdxx;
 using NCC.Extend.Entitys.lq_store_expense;
 using NCC.Extend.Entitys.lq_xh_hyhk;
 using NCC.Extend.Entitys.lq_xh_jksyj;
+using NCC.FriendlyException;
 using NCC.System.Entitys.Permission;
 using SqlSugar;
 using System;
 using System.Collections.Generic;
+using System.Data;
+using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using Yitter.IdGenerator;
@@ -36,13 +42,15 @@ namespace NCC.Extend
     public class LqDirectorSalaryService : IDynamicApiController, ITransient
     {
         private readonly ISqlSugarClient _db;
+        private readonly ILogger<LqDirectorSalaryService> _logger;
  
         /// <summary>
         /// 初始化一个<see cref="LqDirectorSalaryService"/>类型的新实例
         /// </summary>
-        public LqDirectorSalaryService(ISqlSugarClient db)
+        public LqDirectorSalaryService(ISqlSugarClient db, ILogger<LqDirectorSalaryService> logger)
         {
             _db = db;
+            _logger = logger;
         }
  
         /// <summary>
@@ -55,17 +63,7 @@ namespace NCC.Extend
         {
             var monthStr = $"{input.Year}{input.Month:D2}";
  
-            // 1. 检查当月是否已生成工资数据
-            var exists = await _db.Queryable<LqDirectorSalaryStatisticsEntity>()
-                .AnyAsync(x => x.StatisticsMonth == monthStr);
-
-            // 2. 如果没有数据，则进行计算
-            if (!exists)
-            {
-                await CalculateDirectorSalary(input.Year, input.Month);
-            }
-
-            // 3. 查询数据
+            // 查询数据
             var query = _db.Queryable<LqDirectorSalaryStatisticsEntity>()
                 .Where(x => x.StatisticsMonth == monthStr);
  
@@ -133,6 +131,59 @@ namespace NCC.Extend
         }
  
         /// <summary>
+        /// 通过月份和员工ID查询工资
+        /// </summary>
+        [HttpGet("query-by-employee")]
+        public async Task<DirectorSalaryOutput> GetSalaryByEmployee([FromQuery] SalaryQueryByEmployeeInput input)
+        {
+            if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+                throw NCCException.Oh("年份和月份参数不正确");
+            if (string.IsNullOrWhiteSpace(input.EmployeeId))
+                throw NCCException.Oh("员工ID不能为空");
+            var monthStr = $"{input.Year}{input.Month:D2}";
+            var salary = await _db.Queryable<LqDirectorSalaryStatisticsEntity>()
+                .Where(x => x.StatisticsMonth == monthStr && x.EmployeeId == input.EmployeeId)
+                .Select(x => new DirectorSalaryOutput
+                {
+                    Id = x.Id,
+                    StoreName = x.StoreName,
+                    EmployeeName = x.EmployeeName,
+                    Position = x.Position,
+                    StoreTotalPerformance = x.StoreTotalPerformance,
+                    StoreBillingPerformance = x.StoreBillingPerformance,
+                    StoreRefundPerformance = x.StoreRefundPerformance,
+                    StoreLifeline = x.StoreLifeline,
+                    PerformanceCompletionRate = x.PerformanceCompletionRate,
+                    CommissionRateBelowLifeline = x.CommissionRateBelowLifeline,
+                    CommissionRateAboveLifeline = x.CommissionRateAboveLifeline,
+                    CommissionAmountBelowLifeline = x.CommissionAmountBelowLifeline,
+                    CommissionAmountAboveLifeline = x.CommissionAmountAboveLifeline,
+                    TotalCommissionAmount = x.TotalCommissionAmount,
+                    BaseSalary = x.BaseSalary,
+                    WorkingDays = x.WorkingDays,
+                    LeaveDays = x.LeaveDays,
+                    GrossSalary = x.GrossSalary,
+                    ActualSalary = x.ActualSalary,
+                    TotalDeduction = x.TotalDeduction,
+                    TotalSubsidy = x.TotalSubsidy,
+                    Bonus = x.Bonus,
+                    MonthlyPaymentStatus = x.MonthlyPaymentStatus,
+                    PaidAmount = x.PaidAmount,
+                    PendingAmount = x.PendingAmount,
+                    IsLocked = x.IsLocked,
+                    StoreType = x.StoreType,
+                    StoreCategory = x.StoreCategory,
+                    IsNewStore = x.IsNewStore,
+                    NewStoreProtectionStage = x.NewStoreProtectionStage,
+                    UpdateTime = x.UpdateTime
+                })
+                .FirstAsync();
+            if (salary == null)
+                throw NCCException.Oh($"未找到员工{input.EmployeeId}在{input.Year}年{input.Month}月的工资记录");
+            return salary;
+        }
+
+        /// <summary>
         /// 计算主任工资
         /// </summary>
         /// <param name="year">年份</param>
@@ -552,12 +603,42 @@ namespace NCC.Extend
             // 3. 保存数据
             if (directorSalaryList.Any())
             {
-                // 先删除当月旧数据 (防止重复)
-                await _db.Deleteable<LqDirectorSalaryStatisticsEntity>()
+                var existingRecords = await _db.Queryable<LqDirectorSalaryStatisticsEntity>()
                     .Where(x => x.StatisticsMonth == monthStr)
-                    .ExecuteCommandAsync();
-
-                await _db.Insertable(directorSalaryList).ExecuteCommandAsync();
+                    .ToListAsync();
+                var existingDict = existingRecords.Where(x => !string.IsNullOrEmpty(x.EmployeeId))
+                    .GroupBy(x => x.EmployeeId).ToDictionary(g => g.Key, g => g.First());
+                var recordsToInsert = new List<LqDirectorSalaryStatisticsEntity>();
+                var recordsToUpdate = new List<LqDirectorSalaryStatisticsEntity>();
+                var skippedCount = 0;
+                foreach (var salary in directorSalaryList)
+                {
+                    if (existingDict.ContainsKey(salary.EmployeeId))
+                    {
+                        var existing = existingDict[salary.EmployeeId];
+                        if (existing.IsLocked == 1 || existing.EmployeeConfirmStatus == 1) { skippedCount++; continue; }
+                        salary.Id = existing.Id;
+                        salary.EmployeeConfirmStatus = existing.EmployeeConfirmStatus;
+                        salary.EmployeeConfirmTime = existing.EmployeeConfirmTime;
+                        salary.EmployeeConfirmRemark = existing.EmployeeConfirmRemark;
+                        salary.IsLocked = existing.IsLocked;
+                        salary.CreateTime = existing.CreateTime;
+                        salary.CreateUser = existing.CreateUser;
+                        recordsToUpdate.Add(salary);
+                    }
+                    else
+                    {
+                        salary.Id = YitIdHelper.NextId().ToString();
+                        salary.EmployeeConfirmStatus = 0;
+                        salary.IsLocked = 0;
+                        salary.CreateTime = DateTime.Now;
+                        salary.CreateUser = "";
+                        recordsToInsert.Add(salary);
+                    }
+                }
+                if (recordsToInsert.Any()) await _db.Insertable(recordsToInsert).ExecuteCommandAsync();
+                if (recordsToUpdate.Any()) await _db.Updateable(recordsToUpdate).ExecuteCommandAsync();
+                if (skippedCount > 0) _logger.LogWarning($"计算工资时跳过了 {skippedCount} 条已锁定或已确认的记录（月份：{monthStr}）");
             }
         }
  
@@ -649,6 +730,448 @@ namespace NCC.Extend
  
             salary.TotalCommissionAmount = salary.CommissionAmountBelowLifeline + salary.CommissionAmountAboveLifeline;
         }
+
+        #region 员工工资确认
+
+        /// <summary>
+        /// 员工确认工资条
+        /// </summary>
+        /// <remarks>
+        /// 员工确认自己的工资条，确认后工资数据不可再修改
+        /// 
+        /// 示例请求：
+        /// <code>
+        /// {
+        ///   "id": "工资记录ID",
+        ///   "employeeId": "员工ID",
+        ///   "remark": "确认备注（可选）"
+        /// }
+        /// </code>
+        /// 
+        /// 参数说明：
+        /// - id: 工资记录ID（必填）
+        /// - employeeId: 员工ID（必填）
+        /// - remark: 确认备注（可选）
+        /// 
+        /// 注意事项：
+        /// - 只能确认自己的工资条
+        /// - 只能确认已锁定的工资条（IsLocked = 1）
+        /// - 已确认的工资条不能重复确认
+        /// </remarks>
+        /// <param name="input">确认参数</param>
+        /// <returns>操作结果</returns>
+        /// <response code="200">确认成功</response>
+        /// <response code="400">参数错误或记录不存在</response>
+        [HttpPost("confirm")]
+        public async Task<string> ConfirmSalary([FromBody] SalaryConfirmInput input)
+        {
+            try
+            {
+                if (string.IsNullOrWhiteSpace(input.Id) || string.IsNullOrWhiteSpace(input.EmployeeId))
+                    throw NCCException.Oh("工资记录ID和员工ID不能为空");
+                var salary = await _db.Queryable<LqDirectorSalaryStatisticsEntity>()
+                    .Where(s => s.Id == input.Id && s.EmployeeId == input.EmployeeId).FirstAsync();
+                if (salary == null) throw NCCException.Oh("工资记录不存在或不属于该员工");
+                if (salary.EmployeeConfirmStatus == 1) throw NCCException.Oh("该工资条已确认，不能重复确认");
+                if (salary.IsLocked != 1) throw NCCException.Oh("该工资条尚未锁定，请等待管理员锁定后再确认");
+                salary.EmployeeConfirmStatus = 1;
+                salary.EmployeeConfirmTime = DateTime.Now;
+                salary.EmployeeConfirmRemark = input.Remark;
+                salary.UpdateTime = DateTime.Now;
+                await _db.Updateable(salary).ExecuteCommandAsync();
+                return "确认成功";
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"确认工资条失败: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        #region 工资锁定/解锁
+
+        /// <summary>
+        /// 批量锁定/解锁工资条
+        /// </summary>
+        [HttpPost("lock")]
+        public async Task<string> LockSalary([FromBody] SalaryLockInput input)
+        {
+            try
+            {
+                if (input == null || input.Ids == null || !input.Ids.Any())
+                    throw NCCException.Oh("工资记录ID列表不能为空");
+                var salaries = await _db.Queryable<LqDirectorSalaryStatisticsEntity>()
+                    .Where(s => input.Ids.Contains(s.Id))
+                    .ToListAsync();
+                if (!salaries.Any())
+                    throw NCCException.Oh("未找到指定的工资记录");
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+                foreach (var salary in salaries)
+                {
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+                    if (input.IsLocked) lockedCount++; else unlockedCount++;
+                }
+                await _db.Updateable(salaries).ExecuteCommandAsync();
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+                if (skippedCount > 0)
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+                return message;
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"锁定/解锁工资条失败: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// 批量锁定当月所有工资
+        /// </summary>
+        /// <param name="input">批量锁定输入参数</param>
+        /// <returns>锁定结果</returns>
+        [HttpPost("lock-by-month")]
+        public async Task<dynamic> LockSalaryByMonth([FromBody] SalaryLockByMonthInput input)
+        {
+            try
+            {
+                if (input == null)
+                    throw NCCException.Oh("参数不能为空");
+
+                if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+                    throw NCCException.Oh("年份和月份参数不正确");
+
+                var monthStr = $"{input.Year}{input.Month:D2}";
+
+                var salaries = await _db.Queryable<LqDirectorSalaryStatisticsEntity>()
+                    .Where(s => s.StatisticsMonth == monthStr)
+                    .ToListAsync();
+
+                if (!salaries.Any())
+                    throw NCCException.Oh($"未找到{input.Year}年{input.Month}月的工资记录");
+
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+                var alreadyLockedCount = 0;
+
+                foreach (var salary in salaries)
+                {
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+
+                    if (salary.IsLocked == 1 && input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    if (salary.IsLocked == 0 && !input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+
+                    if (input.IsLocked)
+                        lockedCount++;
+                    else
+                        unlockedCount++;
+                }
+
+                if (lockedCount > 0 || unlockedCount > 0)
+                {
+                    var salariesToUpdate = salaries.Where(s => 
+                        (input.IsLocked && s.IsLocked == 0) || 
+                        (!input.IsLocked && s.IsLocked == 1 && s.EmployeeConfirmStatus != 1)
+                    ).ToList();
+                    
+                    if (salariesToUpdate.Any())
+                    {
+                        await _db.Updateable(salariesToUpdate)
+                            .UpdateColumns(s => new { s.IsLocked, s.UpdateTime })
+                            .ExecuteCommandAsync();
+                    }
+                }
+
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+                
+                if (alreadyLockedCount > 0)
+                    message += $"，跳过{alreadyLockedCount}条（已是{action}状态）";
+                
+                if (skippedCount > 0)
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+
+                return new
+                {
+                    success = true,
+                    message = message,
+                    total = salaries.Count,
+                    locked = lockedCount,
+                    unlocked = unlockedCount,
+                    skipped = skippedCount,
+                    alreadyLocked = alreadyLockedCount
+                };
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "批量锁定当月工资失败");
+                var action = input?.IsLocked == true ? "锁定" : "解锁";
+                throw NCCException.Oh($"批量{action}当月工资失败: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        #region 导入工资
+
+        /// <summary>
+        /// 从Excel导入主任工资数据
+        /// </summary>
+        /// <param name="file">Excel文件</param>
+        /// <returns>导入结果</returns>
+        [HttpPost("import")]
+        public async Task<dynamic> ImportSalaryFromExcel(IFormFile file)
+        {
+            try
+            {
+                if (file == null || file.Length == 0)
+                    throw NCCException.Oh("请选择要上传的Excel文件");
+                
+                var allowedExtensions = new[] { ".xlsx", ".xls" };
+                var fileExtension = Path.GetExtension(file.FileName).ToLowerInvariant();
+                if (!allowedExtensions.Contains(fileExtension))
+                    throw NCCException.Oh("只支持.xlsx和.xls格式的Excel文件");
+
+                var recordsToInsert = new List<LqDirectorSalaryStatisticsEntity>();
+                var recordsToUpdate = new List<LqDirectorSalaryStatisticsEntity>();
+                var errorMessages = new List<string>();
+                var successCount = 0;
+                var failCount = 0;
+                var skippedCount = 0;
+
+                var tempFilePath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + Path.GetExtension(file.FileName));
+                try
+                {
+                    using (var stream = new FileStream(tempFilePath, FileMode.Create))
+                    {
+                        await file.CopyToAsync(stream);
+                    }
+
+                    var dataTable = ExcelImportHelper.ToDataTable(tempFilePath, 0, 0);
+                    if (dataTable.Rows.Count == 0)
+                        throw NCCException.Oh("Excel文件中没有数据行");
+
+                    Func<string, decimal> ParseDecimal = (str) =>
+                    {
+                        if (string.IsNullOrWhiteSpace(str)) return 0;
+                        var cleaned = str.Trim().Replace(",", "").Replace("，", "").Replace("￥", "").Replace("$", "").Replace("元", "").Replace("%", "").Replace(" ", "");
+                        return decimal.TryParse(cleaned, out decimal result) ? result : 0;
+                    };
+
+                    Func<string, int> ParseInt = (str) =>
+                    {
+                        if (string.IsNullOrWhiteSpace(str)) return 0;
+                        var cleaned = str.Trim().Replace(",", "").Replace("，", "").Replace(" ", "");
+                        return int.TryParse(cleaned, out int result) ? result : 0;
+                    };
+
+                    for (int i = 1; i < dataTable.Rows.Count; i++)
+                    {
+                        try
+                        {
+                            var row = dataTable.Rows[i];
+                            Func<int, string> GetColumnValue = (colIndex) => colIndex < row.ItemArray.Length && row[colIndex] != null ? row[colIndex].ToString().Trim() : "";
+
+                            var firstColumnValue = GetColumnValue(0);
+                            bool isOldFormat = !string.IsNullOrWhiteSpace(firstColumnValue) && (firstColumnValue == "门店名称" || (!long.TryParse(firstColumnValue, out _) && firstColumnValue.Length > 20));
+                            
+                            int storeNameIndex = isOldFormat ? 0 : 1;
+                            int employeeNameIndex = isOldFormat ? 1 : 2;
+                            int offset = isOldFormat ? 0 : 1;
+
+                            var id = isOldFormat ? "" : GetColumnValue(0);
+                            var employeeName = GetColumnValue(employeeNameIndex);
+                            var storeName = GetColumnValue(storeNameIndex);
+
+                            if (string.IsNullOrWhiteSpace(id) && string.IsNullOrWhiteSpace(employeeName))
+                                continue;
+
+                            if (string.IsNullOrWhiteSpace(id) && !string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                var matchedRecord = await _db.Queryable<LqDirectorSalaryStatisticsEntity>()
+                                    .Where(x => x.EmployeeName == employeeName)
+                                    .WhereIF(!string.IsNullOrWhiteSpace(storeName), x => x.StoreName == storeName)
+                                    .OrderBy(x => x.CreateTime, OrderByType.Desc)
+                                    .FirstAsync();
+                                if (matchedRecord != null) id = matchedRecord.Id;
+                            }
+
+                            if (string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                errorMessages.Add($"第{i + 1}行：员工姓名不能为空");
+                                failCount++;
+                                continue;
+                            }
+
+                            LqDirectorSalaryStatisticsEntity existing = null;
+                            if (!string.IsNullOrWhiteSpace(id))
+                            {
+                                existing = await _db.Queryable<LqDirectorSalaryStatisticsEntity>()
+                                    .Where(x => x.Id == id).FirstAsync();
+                                
+                                if (existing != null && (existing.IsLocked == 1 || existing.EmployeeConfirmStatus == 1))
+                                {
+                                    skippedCount++;
+                                    failCount++;
+                                    continue;
+                                }
+                            }
+
+                            var entity = existing ?? new LqDirectorSalaryStatisticsEntity
+                            {
+                                Id = string.IsNullOrWhiteSpace(id) ? YitIdHelper.NextId().ToString() : id,
+                                EmployeeConfirmStatus = 0,
+                                IsLocked = 0,
+                                CreateTime = DateTime.Now,
+                                CreateUser = ""
+                            };
+
+                            // Excel字段映射（主任工资43列，Excel顺序：门店名称,员工姓名,岗位,实发工资,补贴合计,扣款合计,是否锁定,是否新店,新店保护阶段,门店总业绩...）
+                            entity.StoreName = storeName;
+                            entity.EmployeeName = employeeName;
+                            entity.Position = GetColumnValue(2 + offset);
+                            entity.ActualSalary = ParseDecimal(GetColumnValue(3 + offset));
+                            entity.TotalSubsidy = ParseDecimal(GetColumnValue(4 + offset));
+                            entity.TotalDeduction = ParseDecimal(GetColumnValue(5 + offset));
+                            // 跳过"是否锁定"字段（第7列），在最后处理
+                            entity.IsNewStore = GetColumnValue(7 + offset) == "是" ? "是" : "否";
+                            entity.NewStoreProtectionStage = ParseInt(GetColumnValue(8 + offset));
+                            entity.StoreTotalPerformance = ParseDecimal(GetColumnValue(9 + offset));
+                            entity.StoreBillingPerformance = ParseDecimal(GetColumnValue(10 + offset));
+                            entity.StoreRefundPerformance = ParseDecimal(GetColumnValue(11 + offset));
+                            entity.StoreLifeline = ParseDecimal(GetColumnValue(12 + offset));
+                            entity.PerformanceCompletionRate = ParseDecimal(GetColumnValue(13 + offset));
+                            entity.PerformanceReached = GetColumnValue(14 + offset);
+                            entity.HeadCountReached = GetColumnValue(15 + offset);
+                            entity.ConsumeReached = GetColumnValue(16 + offset);
+                            entity.AssessmentDeduction = ParseDecimal(GetColumnValue(17 + offset));
+                            entity.UnreachedIndicatorCount = ParseInt(GetColumnValue(18 + offset));
+                            entity.HeadCount = ParseInt(GetColumnValue(19 + offset));
+                            entity.TargetHeadCount = ParseDecimal(GetColumnValue(20 + offset));
+                            entity.StoreConsume = ParseDecimal(GetColumnValue(21 + offset));
+                            entity.TargetConsume = ParseDecimal(GetColumnValue(22 + offset));
+                            entity.CommissionRateBelowLifeline = ParseDecimal(GetColumnValue(23 + offset));
+                            entity.CommissionRateAboveLifeline = ParseDecimal(GetColumnValue(24 + offset));
+                            entity.CommissionAmountBelowLifeline = ParseDecimal(GetColumnValue(25 + offset));
+                            entity.CommissionAmountAboveLifeline = ParseDecimal(GetColumnValue(26 + offset));
+                            entity.TotalCommissionAmount = ParseDecimal(GetColumnValue(27 + offset));
+                            entity.BaseSalary = ParseDecimal(GetColumnValue(28 + offset));
+                            entity.ActualBaseSalary = ParseDecimal(GetColumnValue(29 + offset));
+                            entity.WorkingDays = ParseInt(GetColumnValue(30 + offset));
+                            entity.LeaveDays = ParseInt(GetColumnValue(31 + offset));
+                            entity.GrossSalary = ParseDecimal(GetColumnValue(32 + offset));
+                            entity.Bonus = ParseDecimal(GetColumnValue(33 + offset));
+                            entity.ReturnPhoneDeposit = ParseDecimal(GetColumnValue(34 + offset));
+                            entity.ReturnAccommodationDeposit = ParseDecimal(GetColumnValue(35 + offset));
+                            entity.MonthlyPaymentStatus = GetColumnValue(36 + offset);
+                            entity.PaidAmount = ParseDecimal(GetColumnValue(37 + offset));
+                            entity.PendingAmount = ParseDecimal(GetColumnValue(38 + offset));
+                            entity.LastMonthSupplement = ParseDecimal(GetColumnValue(39 + offset));
+                            entity.MonthlyTotalPayment = ParseDecimal(GetColumnValue(40 + offset));
+                            // 处理门店类型和类别
+                            var storeTypeStr = GetColumnValue(41 + offset);
+                            if (!string.IsNullOrWhiteSpace(storeTypeStr) && int.TryParse(storeTypeStr, out int storeType))
+                                entity.StoreType = storeType;
+                            var storeCategoryStr = GetColumnValue(42 + offset);
+                            if (!string.IsNullOrWhiteSpace(storeCategoryStr) && int.TryParse(storeCategoryStr, out int storeCategory))
+                                entity.StoreCategory = storeCategory;
+                            // 处理锁定状态（第7列）
+                            var isLockedStr = GetColumnValue(6 + offset);
+                            if (isLockedStr == "已锁定" || isLockedStr == "1" || isLockedStr == "锁定") entity.IsLocked = 1;
+                            else entity.IsLocked = 0;
+
+                            if (existing != null)
+                            {
+                                entity.StoreId = existing.StoreId;
+                                entity.EmployeeId = existing.EmployeeId;
+                                entity.StatisticsMonth = existing.StatisticsMonth;
+                            }
+                            else
+                            {
+                                if (!string.IsNullOrWhiteSpace(employeeName))
+                                {
+                                    var user = await _db.Queryable<UserEntity>()
+                                        .Where(u => u.RealName == employeeName).FirstAsync();
+                                    if (user != null)
+                                    {
+                                        entity.EmployeeId = user.Id;
+                                        if (!string.IsNullOrEmpty(user.Mdid) && string.IsNullOrWhiteSpace(storeName))
+                                            entity.StoreId = user.Mdid;
+                                    }
+                                    
+                                    if (!string.IsNullOrWhiteSpace(storeName) && string.IsNullOrEmpty(entity.StoreId))
+                                    {
+                                        var store = await _db.Queryable<LqMdxxEntity>()
+                                            .Where(s => s.Dm == storeName).FirstAsync();
+                                        if (store != null) entity.StoreId = store.Id;
+                                    }
+                                }
+                            }
+                            
+                            entity.UpdateTime = DateTime.Now;
+                            if (existing != null) recordsToUpdate.Add(entity);
+                            else recordsToInsert.Add(entity);
+                            successCount++;
+                        }
+                        catch (Exception ex)
+                        {
+                            errorMessages.Add($"第{i + 1}行数据处理失败: {ex.Message}");
+                            failCount++;
+                        }
+                    }
+                }
+                finally
+                {
+                    if (File.Exists(tempFilePath)) File.Delete(tempFilePath);
+                }
+
+                if (recordsToInsert.Any()) await _db.Insertable(recordsToInsert).ExecuteCommandAsync();
+                if (recordsToUpdate.Any()) await _db.Updateable(recordsToUpdate).ExecuteCommandAsync();
+
+                return new
+                {
+                    success = true,
+                    message = $"导入完成：成功 {successCount} 条，失败 {failCount} 条，跳过 {skippedCount} 条（已锁定或已确认）",
+                    successCount,
+                    failCount,
+                    skippedCount,
+                    errors = errorMessages
+                };
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"导入主任工资数据失败: {ex.Message}");
+            }
+        }
+
+        #endregion
     }
 }
  
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
 using NCC.Common.Filter;
 using NCC.Common.Helper;
 using NCC.Dependency;
 using NCC.DynamicApiController;
 using NCC.Extend.Entitys.Dto.LqMajorProjectDirectorSalary;
+using NCC.Extend.Entitys.Dto.LqSalary;
 using NCC.Extend.Entitys.lq_attendance_summary;
 using NCC.Extend.Entitys.lq_hytk_hytk;
 using NCC.Extend.Entitys.lq_hytk_mx;
@@ -14,14 +16,18 @@ using NCC.Extend.Entitys.lq_kd_jksyj;
 using NCC.Extend.Entitys.lq_md_target;
 using NCC.Extend.Entitys.lq_mdxx;
 using NCC.Extend.Entitys.lq_major_project_director_salary_statistics;
+using NCC.FriendlyException;
 using NCC.System.Entitys.Permission;
 using SqlSugar;
 using System;
 using System.Collections.Generic;
+using System.Data;
+using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using Yitter.IdGenerator;
 using Newtonsoft.Json;
+using Microsoft.AspNetCore.Http;
  
 namespace NCC.Extend
 {
@@ -33,13 +39,15 @@ namespace NCC.Extend
     public class LqMajorProjectDirectorSalaryService : IDynamicApiController, ITransient
     {
         private readonly ISqlSugarClient _db;
+        private readonly ILogger<LqMajorProjectDirectorSalaryService> _logger;
  
         /// <summary>
         /// 初始化一个<see cref="LqMajorProjectDirectorSalaryService"/>类型的新实例
         /// </summary>
-        public LqMajorProjectDirectorSalaryService(ISqlSugarClient db)
+        public LqMajorProjectDirectorSalaryService(ISqlSugarClient db, ILogger<LqMajorProjectDirectorSalaryService> logger)
         {
             _db = db;
+            _logger = logger;
         }
  
         /// <summary>
@@ -52,17 +60,7 @@ namespace NCC.Extend
         {
             var monthStr = $"{input.Year}{input.Month:D2}";
  
-            // 1. 检查当月是否已生成工资数据
-            var exists = await _db.Queryable<LqMajorProjectDirectorSalaryStatisticsEntity>()
-                .AnyAsync(x => x.StatisticsMonth == monthStr);
-
-            // 2. 如果没有数据，则进行计算
-            if (!exists)
-            {
-                await CalculateMajorProjectDirectorSalary(input.Year, input.Month);
-            }
-
-            // 3. 查询数据
+            // 查询数据
             var query = _db.Queryable<LqMajorProjectDirectorSalaryStatisticsEntity>()
                 .Where(x => x.StatisticsMonth == monthStr);
  
@@ -128,6 +126,71 @@ namespace NCC.Extend
         }
  
         /// <summary>
+        /// 通过月份和员工ID查询工资
+        /// </summary>
+        [HttpGet("query-by-employee")]
+        public async Task<MajorProjectDirectorSalaryOutput> GetSalaryByEmployee([FromQuery] SalaryQueryByEmployeeInput input)
+        {
+            if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+                throw NCCException.Oh("年份和月份参数不正确");
+            if (string.IsNullOrWhiteSpace(input.EmployeeId))
+                throw NCCException.Oh("员工ID不能为空");
+            var monthStr = $"{input.Year}{input.Month:D2}";
+            var salary = await _db.Queryable<LqMajorProjectDirectorSalaryStatisticsEntity>()
+                .Where(x => x.StatisticsMonth == monthStr && x.EmployeeId == input.EmployeeId)
+                .Select(x => new MajorProjectDirectorSalaryOutput
+                {
+                    Id = x.Id,
+                    StatisticsMonth = x.StatisticsMonth,
+                    Position = x.Position,
+                    EmployeeName = x.EmployeeName,
+                    EmployeeId = x.EmployeeId,
+                    EmployeeAccount = x.EmployeeAccount,
+                    IsTerminated = x.IsTerminated,
+                    StoreDetail = x.StoreDetail,
+                    TotalPerformance = x.TotalPerformance,
+                    BillingAmount = x.BillingAmount,
+                    RefundAmount = x.RefundAmount,
+                    BaseSalary = x.BaseSalary,
+                    CommissionRate = x.CommissionRate,
+                    CommissionAmount = x.CommissionAmount,
+                    WorkingDays = x.WorkingDays,
+                    LeaveDays = x.LeaveDays,
+                    CalculatedGrossSalary = x.CalculatedGrossSalary,
+                    FinalGrossSalary = x.FinalGrossSalary,
+                    MonthlyTrainingSubsidy = x.MonthlyTrainingSubsidy,
+                    MonthlyTransportSubsidy = x.MonthlyTransportSubsidy,
+                    LastMonthTrainingSubsidy = x.LastMonthTrainingSubsidy,
+                    LastMonthTransportSubsidy = x.LastMonthTransportSubsidy,
+                    TotalSubsidy = x.TotalSubsidy,
+                    MissingCard = x.MissingCard,
+                    LateArrival = x.LateArrival,
+                    LeaveDeduction = x.LeaveDeduction,
+                    SocialInsuranceDeduction = x.SocialInsuranceDeduction,
+                    RewardDeduction = x.RewardDeduction,
+                    AccommodationDeduction = x.AccommodationDeduction,
+                    StudyPeriodDeduction = x.StudyPeriodDeduction,
+                    WorkClothesDeduction = x.WorkClothesDeduction,
+                    TotalDeduction = x.TotalDeduction,
+                    Bonus = x.Bonus,
+                    ReturnPhoneDeposit = x.ReturnPhoneDeposit,
+                    ReturnAccommodationDeposit = x.ReturnAccommodationDeposit,
+                    ActualSalary = x.ActualSalary,
+                    MonthlyPaymentStatus = x.MonthlyPaymentStatus,
+                    PaidAmount = x.PaidAmount,
+                    PendingAmount = x.PendingAmount,
+                    LastMonthSupplement = x.LastMonthSupplement,
+                    MonthlyTotalPayment = x.MonthlyTotalPayment,
+                    IsLocked = x.IsLocked,
+                    UpdateTime = x.UpdateTime
+                })
+                .FirstAsync();
+            if (salary == null)
+                throw NCCException.Oh($"未找到员工{input.EmployeeId}在{input.Year}年{input.Month}月的工资记录");
+            return salary;
+        }
+
+        /// <summary>
         /// 计算大项目主管工资
         /// </summary>
         /// <param name="year">年份</param>
@@ -362,12 +425,41 @@ namespace NCC.Extend
             // 3. 保存数据
             if (directorStats.Any())
             {
-                // 先删除当月旧数据 (防止重复)
-                await _db.Deleteable<LqMajorProjectDirectorSalaryStatisticsEntity>()
-                    .Where(x => x.StatisticsMonth == monthStr)
-                    .ExecuteCommandAsync();
-
-                await _db.Insertable(directorStats.Values.ToList()).ExecuteCommandAsync();
+                var existingRecords = await _db.Queryable<LqMajorProjectDirectorSalaryStatisticsEntity>()
+                    .Where(x => x.StatisticsMonth == monthStr).ToListAsync();
+                var existingDict = existingRecords.Where(x => !string.IsNullOrEmpty(x.EmployeeId))
+                    .GroupBy(x => x.EmployeeId).ToDictionary(g => g.Key, g => g.First());
+                var recordsToInsert = new List<LqMajorProjectDirectorSalaryStatisticsEntity>();
+                var recordsToUpdate = new List<LqMajorProjectDirectorSalaryStatisticsEntity>();
+                var skippedCount = 0;
+                foreach (var salary in directorStats.Values)
+                {
+                    if (existingDict.ContainsKey(salary.EmployeeId))
+                    {
+                        var existing = existingDict[salary.EmployeeId];
+                        if (existing.IsLocked == 1 || existing.EmployeeConfirmStatus == 1) { skippedCount++; continue; }
+                        salary.Id = existing.Id;
+                        salary.EmployeeConfirmStatus = existing.EmployeeConfirmStatus;
+                        salary.EmployeeConfirmTime = existing.EmployeeConfirmTime;
+                        salary.EmployeeConfirmRemark = existing.EmployeeConfirmRemark;
+                        salary.IsLocked = existing.IsLocked;
+                        salary.CreateTime = existing.CreateTime;
+                        salary.CreateUser = existing.CreateUser;
+                        recordsToUpdate.Add(salary);
+                    }
+                    else
+                    {
+                        salary.Id = YitIdHelper.NextId().ToString();
+                        salary.EmployeeConfirmStatus = 0;
+                        salary.IsLocked = 0;
+                        salary.CreateTime = DateTime.Now;
+                        salary.CreateUser = "";
+                        recordsToInsert.Add(salary);
+                    }
+                }
+                if (recordsToInsert.Any()) await _db.Insertable(recordsToInsert).ExecuteCommandAsync();
+                if (recordsToUpdate.Any()) await _db.Updateable(recordsToUpdate).ExecuteCommandAsync();
+                if (skippedCount > 0) _logger.LogWarning($"计算工资时跳过了 {skippedCount} 条已锁定或已确认的记录（月份：{monthStr}）");
             }
         }
  
@@ -442,6 +534,420 @@ namespace NCC.Extend
             public decimal RefundAmount { get; set; }
             public decimal TotalPerformance { get; set; }
         }
+
+        #region 员工工资确认
+
+        /// <summary>
+        /// 员工确认工资条
+        /// </summary>
+        /// <remarks>
+        /// 员工确认自己的工资条，确认后工资数据不可再修改
+        /// 
+        /// 示例请求：
+        /// <code>
+        /// {
+        ///   "id": "工资记录ID",
+        ///   "employeeId": "员工ID",
+        ///   "remark": "确认备注（可选）"
+        /// }
+        /// </code>
+        /// 
+        /// 参数说明：
+        /// - id: 工资记录ID（必填）
+        /// - employeeId: 员工ID（必填）
+        /// - remark: 确认备注（可选）
+        /// 
+        /// 注意事项：
+        /// - 只能确认自己的工资条
+        /// - 只能确认已锁定的工资条（IsLocked = 1）
+        /// - 已确认的工资条不能重复确认
+        /// </remarks>
+        /// <param name="input">确认参数</param>
+        /// <returns>操作结果</returns>
+        /// <response code="200">确认成功</response>
+        /// <response code="400">参数错误或记录不存在</response>
+        [HttpPost("confirm")]
+        public async Task<string> ConfirmSalary([FromBody] SalaryConfirmInput input)
+        {
+            try
+            {
+                if (string.IsNullOrWhiteSpace(input.Id) || string.IsNullOrWhiteSpace(input.EmployeeId))
+                    throw NCCException.Oh("工资记录ID和员工ID不能为空");
+                var salary = await _db.Queryable<LqMajorProjectDirectorSalaryStatisticsEntity>()
+                    .Where(s => s.Id == input.Id && s.EmployeeId == input.EmployeeId).FirstAsync();
+                if (salary == null) throw NCCException.Oh("工资记录不存在或不属于该员工");
+                if (salary.EmployeeConfirmStatus == 1) throw NCCException.Oh("该工资条已确认，不能重复确认");
+                if (salary.IsLocked != 1) throw NCCException.Oh("该工资条尚未锁定，请等待管理员锁定后再确认");
+                salary.EmployeeConfirmStatus = 1;
+                salary.EmployeeConfirmTime = DateTime.Now;
+                salary.EmployeeConfirmRemark = input.Remark;
+                salary.UpdateTime = DateTime.Now;
+                await _db.Updateable(salary).ExecuteCommandAsync();
+                return "确认成功";
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"确认工资条失败: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        #region 工资锁定/解锁
+
+        /// <summary>
+        /// 批量锁定/解锁工资条
+        /// </summary>
+        [HttpPost("lock")]
+        public async Task<string> LockSalary([FromBody] SalaryLockInput input)
+        {
+            try
+            {
+                if (input == null || input.Ids == null || !input.Ids.Any())
+                    throw NCCException.Oh("工资记录ID列表不能为空");
+                var salaries = await _db.Queryable<LqMajorProjectDirectorSalaryStatisticsEntity>()
+                    .Where(s => input.Ids.Contains(s.Id))
+                    .ToListAsync();
+                if (!salaries.Any())
+                    throw NCCException.Oh("未找到指定的工资记录");
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+                foreach (var salary in salaries)
+                {
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+                    if (input.IsLocked) lockedCount++; else unlockedCount++;
+                }
+                await _db.Updateable(salaries).ExecuteCommandAsync();
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+                if (skippedCount > 0)
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+                return message;
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"锁定/解锁工资条失败: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// 批量锁定当月所有工资
+        /// </summary>
+        /// <param name="input">批量锁定输入参数</param>
+        /// <returns>锁定结果</returns>
+        [HttpPost("lock-by-month")]
+        public async Task<dynamic> LockSalaryByMonth([FromBody] SalaryLockByMonthInput input)
+        {
+            try
+            {
+                if (input == null)
+                    throw NCCException.Oh("参数不能为空");
+
+                if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+                    throw NCCException.Oh("年份和月份参数不正确");
+
+                var monthStr = $"{input.Year}{input.Month:D2}";
+
+                var salaries = await _db.Queryable<LqMajorProjectDirectorSalaryStatisticsEntity>()
+                    .Where(s => s.StatisticsMonth == monthStr)
+                    .ToListAsync();
+
+                if (!salaries.Any())
+                    throw NCCException.Oh($"未找到{input.Year}年{input.Month}月的工资记录");
+
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+                var alreadyLockedCount = 0;
+
+                foreach (var salary in salaries)
+                {
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+
+                    if (salary.IsLocked == 1 && input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    if (salary.IsLocked == 0 && !input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+
+                    if (input.IsLocked)
+                        lockedCount++;
+                    else
+                        unlockedCount++;
+                }
+
+                if (lockedCount > 0 || unlockedCount > 0)
+                {
+                    var salariesToUpdate = salaries.Where(s => 
+                        (input.IsLocked && s.IsLocked == 0) || 
+                        (!input.IsLocked && s.IsLocked == 1 && s.EmployeeConfirmStatus != 1)
+                    ).ToList();
+                    
+                    if (salariesToUpdate.Any())
+                    {
+                        await _db.Updateable(salariesToUpdate)
+                            .UpdateColumns(s => new { s.IsLocked, s.UpdateTime })
+                            .ExecuteCommandAsync();
+                    }
+                }
+
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+                
+                if (alreadyLockedCount > 0)
+                    message += $"，跳过{alreadyLockedCount}条（已是{action}状态）";
+                
+                if (skippedCount > 0)
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+
+                return new
+                {
+                    success = true,
+                    message = message,
+                    total = salaries.Count,
+                    locked = lockedCount,
+                    unlocked = unlockedCount,
+                    skipped = skippedCount,
+                    alreadyLocked = alreadyLockedCount
+                };
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "批量锁定当月工资失败");
+                var action = input?.IsLocked == true ? "锁定" : "解锁";
+                throw NCCException.Oh($"批量{action}当月工资失败: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        #region 导入工资
+
+        /// <summary>
+        /// 从Excel导入大项目主管工资数据
+        /// </summary>
+        /// <param name="file">Excel文件</param>
+        /// <returns>导入结果</returns>
+        [HttpPost("import")]
+        public async Task<dynamic> ImportSalaryFromExcel(IFormFile file)
+        {
+            try
+            {
+                if (file == null || file.Length == 0)
+                    throw NCCException.Oh("请选择要上传的Excel文件");
+                
+                var allowedExtensions = new[] { ".xlsx", ".xls" };
+                var fileExtension = Path.GetExtension(file.FileName).ToLowerInvariant();
+                if (!allowedExtensions.Contains(fileExtension))
+                    throw NCCException.Oh("只支持.xlsx和.xls格式的Excel文件");
+
+                var recordsToInsert = new List<LqMajorProjectDirectorSalaryStatisticsEntity>();
+                var recordsToUpdate = new List<LqMajorProjectDirectorSalaryStatisticsEntity>();
+                var errorMessages = new List<string>();
+                var successCount = 0;
+                var failCount = 0;
+                var skippedCount = 0;
+
+                var tempFilePath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + Path.GetExtension(file.FileName));
+                try
+                {
+                    using (var stream = new FileStream(tempFilePath, FileMode.Create))
+                    {
+                        await file.CopyToAsync(stream);
+                    }
+
+                    var dataTable = ExcelImportHelper.ToDataTable(tempFilePath, 0, 0);
+                    if (dataTable.Rows.Count == 0)
+                        throw NCCException.Oh("Excel文件中没有数据行");
+
+                    Func<string, decimal> ParseDecimal = (str) =>
+                    {
+                        if (string.IsNullOrWhiteSpace(str)) return 0;
+                        var cleaned = str.Trim().Replace(",", "").Replace("，", "").Replace("￥", "").Replace("$", "").Replace("元", "").Replace("%", "").Replace(" ", "");
+                        return decimal.TryParse(cleaned, out decimal result) ? result : 0;
+                    };
+
+                    Func<string, int> ParseInt = (str) =>
+                    {
+                        if (string.IsNullOrWhiteSpace(str)) return 0;
+                        var cleaned = str.Trim().Replace(",", "").Replace("，", "").Replace(" ", "");
+                        return int.TryParse(cleaned, out int result) ? result : 0;
+                    };
+
+                    for (int i = 1; i < dataTable.Rows.Count; i++)
+                    {
+                        try
+                        {
+                            var row = dataTable.Rows[i];
+                            Func<int, string> GetColumnValue = (colIndex) => colIndex < row.ItemArray.Length && row[colIndex] != null ? row[colIndex].ToString().Trim() : "";
+
+                            var firstColumnValue = GetColumnValue(0);
+                            bool isOldFormat = !string.IsNullOrWhiteSpace(firstColumnValue) && (firstColumnValue == "员工姓名" || (!long.TryParse(firstColumnValue, out _) && firstColumnValue.Length > 20));
+                            
+                            int employeeNameIndex = isOldFormat ? 0 : 1;
+                            int offset = isOldFormat ? 0 : 1;
+
+                            var id = isOldFormat ? "" : GetColumnValue(0);
+                            var employeeName = GetColumnValue(employeeNameIndex);
+
+                            if (string.IsNullOrWhiteSpace(id) && string.IsNullOrWhiteSpace(employeeName))
+                                continue;
+
+                            if (string.IsNullOrWhiteSpace(id) && !string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                var matchedRecord = await _db.Queryable<LqMajorProjectDirectorSalaryStatisticsEntity>()
+                                    .Where(x => x.EmployeeName == employeeName)
+                                    .OrderBy(x => x.CreateTime, OrderByType.Desc)
+                                    .FirstAsync();
+                                if (matchedRecord != null) id = matchedRecord.Id;
+                            }
+
+                            if (string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                errorMessages.Add($"第{i + 1}行：员工姓名不能为空");
+                                failCount++;
+                                continue;
+                            }
+
+                            LqMajorProjectDirectorSalaryStatisticsEntity existing = null;
+                            if (!string.IsNullOrWhiteSpace(id))
+                            {
+                                existing = await _db.Queryable<LqMajorProjectDirectorSalaryStatisticsEntity>()
+                                    .Where(x => x.Id == id).FirstAsync();
+                                
+                                if (existing != null && (existing.IsLocked == 1 || existing.EmployeeConfirmStatus == 1))
+                                {
+                                    skippedCount++;
+                                    failCount++;
+                                    continue;
+                                }
+                            }
+
+                            var entity = existing ?? new LqMajorProjectDirectorSalaryStatisticsEntity
+                            {
+                                Id = string.IsNullOrWhiteSpace(id) ? YitIdHelper.NextId().ToString() : id,
+                                EmployeeConfirmStatus = 0,
+                                IsLocked = 0,
+                                CreateTime = DateTime.Now,
+                                CreateUser = ""
+                            };
+
+                            // Excel字段映射（大项目主管工资39列：员工姓名,员工账号,核算岗位,统计月份,是否离职,开单金额,退卡金额,总业绩,底薪,提成比例,提成金额...）
+                            entity.EmployeeName = employeeName;
+                            entity.EmployeeAccount = GetColumnValue(1 + offset);
+                            entity.Position = GetColumnValue(2 + offset);
+                            entity.StatisticsMonth = GetColumnValue(3 + offset);
+                            entity.IsTerminated = GetColumnValue(4 + offset) == "离职" || GetColumnValue(4 + offset) == "1" ? 1 : 0;
+                            entity.BillingAmount = ParseDecimal(GetColumnValue(5 + offset));
+                            entity.RefundAmount = ParseDecimal(GetColumnValue(6 + offset));
+                            entity.TotalPerformance = ParseDecimal(GetColumnValue(7 + offset));
+                            entity.BaseSalary = ParseDecimal(GetColumnValue(8 + offset));
+                            entity.CommissionRate = ParseDecimal(GetColumnValue(9 + offset));
+                            entity.CommissionAmount = ParseDecimal(GetColumnValue(10 + offset));
+                            entity.WorkingDays = ParseDecimal(GetColumnValue(11 + offset));
+                            entity.LeaveDays = ParseDecimal(GetColumnValue(12 + offset));
+                            entity.CalculatedGrossSalary = ParseDecimal(GetColumnValue(13 + offset));
+                            entity.FinalGrossSalary = ParseDecimal(GetColumnValue(14 + offset));
+                            entity.MonthlyTrainingSubsidy = ParseDecimal(GetColumnValue(15 + offset));
+                            entity.MonthlyTransportSubsidy = ParseDecimal(GetColumnValue(16 + offset));
+                            entity.LastMonthTrainingSubsidy = ParseDecimal(GetColumnValue(17 + offset));
+                            entity.LastMonthTransportSubsidy = ParseDecimal(GetColumnValue(18 + offset));
+                            entity.TotalSubsidy = ParseDecimal(GetColumnValue(19 + offset));
+                            entity.MissingCard = ParseDecimal(GetColumnValue(20 + offset));
+                            entity.LateArrival = ParseDecimal(GetColumnValue(21 + offset));
+                            entity.LeaveDeduction = ParseDecimal(GetColumnValue(22 + offset));
+                            entity.SocialInsuranceDeduction = ParseDecimal(GetColumnValue(23 + offset));
+                            entity.RewardDeduction = ParseDecimal(GetColumnValue(24 + offset));
+                            entity.AccommodationDeduction = ParseDecimal(GetColumnValue(25 + offset));
+                            entity.StudyPeriodDeduction = ParseDecimal(GetColumnValue(26 + offset));
+                            entity.WorkClothesDeduction = ParseDecimal(GetColumnValue(27 + offset));
+                            entity.TotalDeduction = ParseDecimal(GetColumnValue(28 + offset));
+                            entity.Bonus = ParseDecimal(GetColumnValue(29 + offset));
+                            entity.ReturnPhoneDeposit = ParseDecimal(GetColumnValue(30 + offset));
+                            entity.ReturnAccommodationDeposit = ParseDecimal(GetColumnValue(31 + offset));
+                            entity.LastMonthSupplement = ParseDecimal(GetColumnValue(32 + offset));
+                            entity.ActualSalary = ParseDecimal(GetColumnValue(33 + offset));
+                            entity.MonthlyPaymentStatus = GetColumnValue(34 + offset);
+                            entity.PaidAmount = ParseDecimal(GetColumnValue(35 + offset));
+                            entity.PendingAmount = ParseDecimal(GetColumnValue(36 + offset));
+                            entity.MonthlyTotalPayment = ParseDecimal(GetColumnValue(37 + offset));
+                            var isLockedStr = GetColumnValue(38 + offset);
+                            entity.IsLocked = isLockedStr == "已锁定" || isLockedStr == "1" || isLockedStr == "锁定" ? 1 : 0;
+
+                            if (existing != null)
+                            {
+                                entity.EmployeeId = existing.EmployeeId;
+                                entity.StoreDetail = existing.StoreDetail;
+                            }
+                            else
+                            {
+                                if (!string.IsNullOrWhiteSpace(employeeName))
+                                {
+                                    var user = await _db.Queryable<UserEntity>()
+                                        .Where(u => u.RealName == employeeName).FirstAsync();
+                                    if (user != null) entity.EmployeeId = user.Id;
+                                }
+                            }
+                            
+                            entity.UpdateTime = DateTime.Now;
+                            if (existing != null) recordsToUpdate.Add(entity);
+                            else recordsToInsert.Add(entity);
+                            successCount++;
+                        }
+                        catch (Exception ex)
+                        {
+                            errorMessages.Add($"第{i + 1}行数据处理失败: {ex.Message}");
+                            failCount++;
+                        }
+                    }
+                }
+                finally
+                {
+                    if (File.Exists(tempFilePath)) File.Delete(tempFilePath);
+                }
+
+                if (recordsToInsert.Any()) await _db.Insertable(recordsToInsert).ExecuteCommandAsync();
+                if (recordsToUpdate.Any()) await _db.Updateable(recordsToUpdate).ExecuteCommandAsync();
+
+                return new
+                {
+                    success = true,
+                    message = $"导入完成：成功 {successCount} 条，失败 {failCount} 条，跳过 {skippedCount} 条（已锁定或已确认）",
+                    successCount,
+                    failCount,
+                    skippedCount,
+                    errors = errorMessages
+                };
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"导入大项目主管工资数据失败: {ex.Message}");
+            }
+        }
+
+        #endregion
     }
 }
  
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
 using NCC.Common.Filter;
 using NCC.Common.Helper;
 using NCC.Dependency;
 using NCC.DynamicApiController;
 using NCC.Extend.Entitys.Dto.LqMajorProjectTeacherSalary;
+using NCC.Extend.Entitys.Dto.LqSalary;
 using NCC.Extend.Entitys.lq_attendance_summary;
 using NCC.Extend.Entitys.lq_hytk_hytk;
 using NCC.Extend.Entitys.lq_hytk_mx;
@@ -15,13 +17,17 @@ using NCC.Extend.Entitys.lq_md_major_project_teacher_assignment;
 using NCC.Extend.Entitys.lq_md_xdbhsj;
 using NCC.Extend.Entitys.lq_mdxx;
 using NCC.Extend.Entitys.lq_major_project_teacher_salary_statistics;
+using NCC.FriendlyException;
 using NCC.System.Entitys.Permission;
 using SqlSugar;
 using System;
 using System.Collections.Generic;
+using System.Data;
+using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using Yitter.IdGenerator;
+using Microsoft.AspNetCore.Http;
  
 namespace NCC.Extend
 {
@@ -33,13 +39,15 @@ namespace NCC.Extend
     public class LqMajorProjectTeacherSalaryService : IDynamicApiController, ITransient
     {
         private readonly ISqlSugarClient _db;
+        private readonly ILogger<LqMajorProjectTeacherSalaryService> _logger;
  
         /// <summary>
         /// 初始化一个<see cref="LqMajorProjectTeacherSalaryService"/>类型的新实例
         /// </summary>
-        public LqMajorProjectTeacherSalaryService(ISqlSugarClient db)
+        public LqMajorProjectTeacherSalaryService(ISqlSugarClient db, ILogger<LqMajorProjectTeacherSalaryService> logger)
         {
             _db = db;
+            _logger = logger;
         }
  
         /// <summary>
@@ -52,17 +60,7 @@ namespace NCC.Extend
         {
             var monthStr = $"{input.Year}{input.Month:D2}";
  
-            // 1. 检查当月是否已生成工资数据
-            var exists = await _db.Queryable<LqMajorProjectTeacherSalaryStatisticsEntity>()
-                .AnyAsync(x => x.StatisticsMonth == monthStr);
-
-            // 2. 如果没有数据，则进行计算
-            if (!exists)
-            {
-                await CalculateMajorProjectTeacherSalary(input.Year, input.Month);
-            }
-
-            // 3. 查询数据
+            // 查询数据
             var query = _db.Queryable<LqMajorProjectTeacherSalaryStatisticsEntity>()
                 .Where(x => x.StatisticsMonth == monthStr);
  
@@ -143,6 +141,86 @@ namespace NCC.Extend
         }
  
         /// <summary>
+        /// 通过月份和员工ID查询工资
+        /// </summary>
+        [HttpGet("query-by-employee")]
+        public async Task<MajorProjectTeacherSalaryOutput> GetSalaryByEmployee([FromQuery] SalaryQueryByEmployeeInput input)
+        {
+            if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+                throw NCCException.Oh("年份和月份参数不正确");
+            if (string.IsNullOrWhiteSpace(input.EmployeeId))
+                throw NCCException.Oh("员工ID不能为空");
+            var monthStr = $"{input.Year}{input.Month:D2}";
+            var salary = await _db.Queryable<LqMajorProjectTeacherSalaryStatisticsEntity>()
+                .Where(x => x.StatisticsMonth == monthStr && x.EmployeeId == input.EmployeeId)
+                .Select(x => new MajorProjectTeacherSalaryOutput
+                {
+                    Id = x.Id,
+                    StatisticsMonth = x.StatisticsMonth,
+                    StoreId = x.StoreId,
+                    StoreName = x.StoreName,
+                    Position = x.Position,
+                    EmployeeName = x.EmployeeName,
+                    EmployeeId = x.EmployeeId,
+                    EmployeeAccount = x.EmployeeAccount,
+                    OrderAchievement = x.OrderAchievement,
+                    ConsumeAchievement = x.ConsumeAchievement,
+                    RefundAchievement = x.RefundAchievement,
+                    TotalPerformance = x.TotalPerformance,
+                    BaseSalary = x.BaseSalary,
+                    PerformanceCommissionRate = x.PerformanceCommissionRate,
+                    PerformanceCommissionAmount = x.PerformanceCommissionAmount,
+                    TotalCommission = x.TotalCommission,
+                    HandworkFee = x.HandworkFee,
+                    WorkingDays = x.WorkingDays,
+                    LeaveDays = x.LeaveDays,
+                    TransportationAllowance = x.TransportationAllowance,
+                    LessRest = x.LessRest,
+                    FullAttendance = x.FullAttendance,
+                    CalculatedGrossSalary = x.CalculatedGrossSalary,
+                    GuaranteedSalary = x.GuaranteedSalary,
+                    GuaranteedLeaveDeduction = x.GuaranteedLeaveDeduction,
+                    GuaranteedBaseSalary = x.GuaranteedBaseSalary,
+                    GuaranteedSupplement = x.GuaranteedSupplement,
+                    FinalGrossSalary = x.FinalGrossSalary,
+                    MonthlyTrainingSubsidy = x.MonthlyTrainingSubsidy,
+                    MonthlyTransportSubsidy = x.MonthlyTransportSubsidy,
+                    LastMonthTrainingSubsidy = x.LastMonthTrainingSubsidy,
+                    LastMonthTransportSubsidy = x.LastMonthTransportSubsidy,
+                    TotalSubsidy = x.TotalSubsidy,
+                    MissingCard = x.MissingCard,
+                    LateArrival = x.LateArrival,
+                    LeaveDeduction = x.LeaveDeduction,
+                    SocialInsuranceDeduction = x.SocialInsuranceDeduction,
+                    RewardDeduction = x.RewardDeduction,
+                    AccommodationDeduction = x.AccommodationDeduction,
+                    StudyPeriodDeduction = x.StudyPeriodDeduction,
+                    WorkClothesDeduction = x.WorkClothesDeduction,
+                    TotalDeduction = x.TotalDeduction,
+                    Bonus = x.Bonus,
+                    ReturnPhoneDeposit = x.ReturnPhoneDeposit,
+                    ReturnAccommodationDeposit = x.ReturnAccommodationDeposit,
+                    ActualSalary = x.ActualSalary,
+                    MonthlyPaymentStatus = x.MonthlyPaymentStatus,
+                    PaidAmount = x.PaidAmount,
+                    PendingAmount = x.PendingAmount,
+                    LastMonthSupplement = x.LastMonthSupplement,
+                    MonthlyTotalPayment = x.MonthlyTotalPayment,
+                    IsLocked = x.IsLocked,
+                    IsTerminated = x.IsTerminated,
+                    UpdateTime = x.UpdateTime,
+                    StoreType = x.StoreType,
+                    StoreCategory = x.StoreCategory,
+                    IsNewStore = x.IsNewStore,
+                    NewStoreProtectionStage = x.NewStoreProtectionStage
+                })
+                .FirstAsync();
+            if (salary == null)
+                throw NCCException.Oh($"未找到员工{input.EmployeeId}在{input.Year}年{input.Month}月的工资记录");
+            return salary;
+        }
+
+        /// <summary>
         /// 计算大项目部老师工资
         /// </summary>
         /// <param name="year">年份</param>
@@ -418,12 +496,41 @@ namespace NCC.Extend
             // 5. 保存数据
             if (teacherStats.Any())
             {
-                // 先删除当月旧数据 (防止重复)
-                await _db.Deleteable<LqMajorProjectTeacherSalaryStatisticsEntity>()
-                    .Where(x => x.StatisticsMonth == monthStr)
-                    .ExecuteCommandAsync();
-
-                await _db.Insertable(teacherStats.Values.ToList()).ExecuteCommandAsync();
+                var existingRecords = await _db.Queryable<LqMajorProjectTeacherSalaryStatisticsEntity>()
+                    .Where(x => x.StatisticsMonth == monthStr).ToListAsync();
+                var existingDict = existingRecords.Where(x => !string.IsNullOrEmpty(x.EmployeeId))
+                    .GroupBy(x => x.EmployeeId).ToDictionary(g => g.Key, g => g.First());
+                var recordsToInsert = new List<LqMajorProjectTeacherSalaryStatisticsEntity>();
+                var recordsToUpdate = new List<LqMajorProjectTeacherSalaryStatisticsEntity>();
+                var skippedCount = 0;
+                foreach (var salary in teacherStats.Values)
+                {
+                    if (existingDict.ContainsKey(salary.EmployeeId))
+                    {
+                        var existing = existingDict[salary.EmployeeId];
+                        if (existing.IsLocked == 1 || existing.EmployeeConfirmStatus == 1) { skippedCount++; continue; }
+                        salary.Id = existing.Id;
+                        salary.EmployeeConfirmStatus = existing.EmployeeConfirmStatus;
+                        salary.EmployeeConfirmTime = existing.EmployeeConfirmTime;
+                        salary.EmployeeConfirmRemark = existing.EmployeeConfirmRemark;
+                        salary.IsLocked = existing.IsLocked;
+                        salary.CreateTime = existing.CreateTime;
+                        salary.CreateUser = existing.CreateUser;
+                        recordsToUpdate.Add(salary);
+                    }
+                    else
+                    {
+                        salary.Id = YitIdHelper.NextId().ToString();
+                        salary.EmployeeConfirmStatus = 0;
+                        salary.IsLocked = 0;
+                        salary.CreateTime = DateTime.Now;
+                        salary.CreateUser = "";
+                        recordsToInsert.Add(salary);
+                    }
+                }
+                if (recordsToInsert.Any()) await _db.Insertable(recordsToInsert).ExecuteCommandAsync();
+                if (recordsToUpdate.Any()) await _db.Updateable(recordsToUpdate).ExecuteCommandAsync();
+                if (skippedCount > 0) _logger.LogWarning($"计算工资时跳过了 {skippedCount} 条已锁定或已确认的记录（月份：{monthStr}）");
             }
         }
  
@@ -450,6 +557,445 @@ namespace NCC.Extend
                 return (2.5m, totalPerformance * 0.025m);
             }
         }
+
+        #region 员工工资确认
+
+        /// <summary>
+        /// 员工确认工资条
+        /// </summary>
+        /// <remarks>
+        /// 员工确认自己的工资条，确认后工资数据不可再修改
+        /// 
+        /// 示例请求：
+        /// <code>
+        /// {
+        ///   "id": "工资记录ID",
+        ///   "employeeId": "员工ID",
+        ///   "remark": "确认备注（可选）"
+        /// }
+        /// </code>
+        /// 
+        /// 参数说明：
+        /// - id: 工资记录ID（必填）
+        /// - employeeId: 员工ID（必填）
+        /// - remark: 确认备注（可选）
+        /// 
+        /// 注意事项：
+        /// - 只能确认自己的工资条
+        /// - 只能确认已锁定的工资条（IsLocked = 1）
+        /// - 已确认的工资条不能重复确认
+        /// </remarks>
+        /// <param name="input">确认参数</param>
+        /// <returns>操作结果</returns>
+        /// <response code="200">确认成功</response>
+        /// <response code="400">参数错误或记录不存在</response>
+        [HttpPost("confirm")]
+        public async Task<string> ConfirmSalary([FromBody] SalaryConfirmInput input)
+        {
+            try
+            {
+                if (string.IsNullOrWhiteSpace(input.Id) || string.IsNullOrWhiteSpace(input.EmployeeId))
+                    throw NCCException.Oh("工资记录ID和员工ID不能为空");
+                var salary = await _db.Queryable<LqMajorProjectTeacherSalaryStatisticsEntity>()
+                    .Where(s => s.Id == input.Id && s.EmployeeId == input.EmployeeId).FirstAsync();
+                if (salary == null) throw NCCException.Oh("工资记录不存在或不属于该员工");
+                if (salary.EmployeeConfirmStatus == 1) throw NCCException.Oh("该工资条已确认，不能重复确认");
+                if (salary.IsLocked != 1) throw NCCException.Oh("该工资条尚未锁定，请等待管理员锁定后再确认");
+                salary.EmployeeConfirmStatus = 1;
+                salary.EmployeeConfirmTime = DateTime.Now;
+                salary.EmployeeConfirmRemark = input.Remark;
+                salary.UpdateTime = DateTime.Now;
+                await _db.Updateable(salary).ExecuteCommandAsync();
+                return "确认成功";
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"确认工资条失败: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        #region 工资锁定/解锁
+
+        /// <summary>
+        /// 批量锁定/解锁工资条
+        /// </summary>
+        [HttpPost("lock")]
+        public async Task<string> LockSalary([FromBody] SalaryLockInput input)
+        {
+            try
+            {
+                if (input == null || input.Ids == null || !input.Ids.Any())
+                    throw NCCException.Oh("工资记录ID列表不能为空");
+                var salaries = await _db.Queryable<LqMajorProjectTeacherSalaryStatisticsEntity>()
+                    .Where(s => input.Ids.Contains(s.Id))
+                    .ToListAsync();
+                if (!salaries.Any())
+                    throw NCCException.Oh("未找到指定的工资记录");
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+                foreach (var salary in salaries)
+                {
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+                    if (input.IsLocked) lockedCount++; else unlockedCount++;
+                }
+                await _db.Updateable(salaries).ExecuteCommandAsync();
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+                if (skippedCount > 0)
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+                return message;
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"锁定/解锁工资条失败: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// 批量锁定当月所有工资
+        /// </summary>
+        /// <param name="input">批量锁定输入参数</param>
+        /// <returns>锁定结果</returns>
+        [HttpPost("lock-by-month")]
+        public async Task<dynamic> LockSalaryByMonth([FromBody] SalaryLockByMonthInput input)
+        {
+            try
+            {
+                if (input == null)
+                    throw NCCException.Oh("参数不能为空");
+
+                if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+                    throw NCCException.Oh("年份和月份参数不正确");
+
+                var monthStr = $"{input.Year}{input.Month:D2}";
+
+                var salaries = await _db.Queryable<LqMajorProjectTeacherSalaryStatisticsEntity>()
+                    .Where(s => s.StatisticsMonth == monthStr)
+                    .ToListAsync();
+
+                if (!salaries.Any())
+                    throw NCCException.Oh($"未找到{input.Year}年{input.Month}月的工资记录");
+
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+                var alreadyLockedCount = 0;
+
+                foreach (var salary in salaries)
+                {
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+
+                    if (salary.IsLocked == 1 && input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    if (salary.IsLocked == 0 && !input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+
+                    if (input.IsLocked)
+                        lockedCount++;
+                    else
+                        unlockedCount++;
+                }
+
+                if (lockedCount > 0 || unlockedCount > 0)
+                {
+                    var salariesToUpdate = salaries.Where(s => 
+                        (input.IsLocked && s.IsLocked == 0) || 
+                        (!input.IsLocked && s.IsLocked == 1 && s.EmployeeConfirmStatus != 1)
+                    ).ToList();
+                    
+                    if (salariesToUpdate.Any())
+                    {
+                        await _db.Updateable(salariesToUpdate)
+                            .UpdateColumns(s => new { s.IsLocked, s.UpdateTime })
+                            .ExecuteCommandAsync();
+                    }
+                }
+
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+                
+                if (alreadyLockedCount > 0)
+                    message += $"，跳过{alreadyLockedCount}条（已是{action}状态）";
+                
+                if (skippedCount > 0)
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+
+                return new
+                {
+                    success = true,
+                    message = message,
+                    total = salaries.Count,
+                    locked = lockedCount,
+                    unlocked = unlockedCount,
+                    skipped = skippedCount,
+                    alreadyLocked = alreadyLockedCount
+                };
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "批量锁定当月工资失败");
+                var action = input?.IsLocked == true ? "锁定" : "解锁";
+                throw NCCException.Oh($"批量{action}当月工资失败: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        #region 导入工资
+
+        /// <summary>
+        /// 从Excel导入大项目老师工资数据
+        /// </summary>
+        /// <param name="file">Excel文件</param>
+        /// <returns>导入结果</returns>
+        [HttpPost("import")]
+        public async Task<dynamic> ImportSalaryFromExcel(IFormFile file)
+        {
+            try
+            {
+                if (file == null || file.Length == 0)
+                    throw NCCException.Oh("请选择要上传的Excel文件");
+
+                var allowedExtensions = new[] { ".xlsx", ".xls" };
+                var fileExtension = Path.GetExtension(file.FileName).ToLowerInvariant();
+                if (!allowedExtensions.Contains(fileExtension))
+                    throw NCCException.Oh("只支持.xlsx和.xls格式的Excel文件");
+
+                var recordsToInsert = new List<LqMajorProjectTeacherSalaryStatisticsEntity>();
+                var recordsToUpdate = new List<LqMajorProjectTeacherSalaryStatisticsEntity>();
+                var errorMessages = new List<string>();
+                var successCount = 0;
+                var failCount = 0;
+                var skippedCount = 0;
+
+                var tempFilePath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + Path.GetExtension(file.FileName));
+                try
+                {
+                    using (var stream = new FileStream(tempFilePath, FileMode.Create))
+                    {
+                        await file.CopyToAsync(stream);
+                    }
+
+                    var dataTable = ExcelImportHelper.ToDataTable(tempFilePath, 0, 0);
+                    if (dataTable.Rows.Count == 0)
+                        throw NCCException.Oh("Excel文件中没有数据行");
+
+                    Func<string, decimal> ParseDecimal = (str) =>
+                    {
+                        if (string.IsNullOrWhiteSpace(str)) return 0;
+                        var cleaned = str.Trim().Replace(",", "").Replace("，", "").Replace("￥", "").Replace("$", "").Replace("元", "").Replace("%", "").Replace(" ", "");
+                        return decimal.TryParse(cleaned, out decimal result) ? result : 0;
+                    };
+
+                    Func<string, int> ParseInt = (str) =>
+                    {
+                        if (string.IsNullOrWhiteSpace(str)) return 0;
+                        var cleaned = str.Trim().Replace(",", "").Replace("，", "").Replace(" ", "");
+                        return int.TryParse(cleaned, out int result) ? result : 0;
+                    };
+
+                    for (int i = 1; i < dataTable.Rows.Count; i++)
+                    {
+                        try
+                        {
+                            var row = dataTable.Rows[i];
+                            Func<int, string> GetColumnValue = (colIndex) => colIndex < row.ItemArray.Length && row[colIndex] != null ? row[colIndex].ToString().Trim() : "";
+
+                            var firstColumnValue = GetColumnValue(0);
+                            bool isOldFormat = !string.IsNullOrWhiteSpace(firstColumnValue) && (firstColumnValue == "门店名称" || (!long.TryParse(firstColumnValue, out _) && firstColumnValue.Length > 20));
+
+                            int storeNameIndex = isOldFormat ? 0 : 1;
+                            int employeeNameIndex = isOldFormat ? 1 : 2;
+                            int offset = isOldFormat ? 0 : 1;
+
+                            var id = isOldFormat ? "" : GetColumnValue(0);
+                            var employeeName = GetColumnValue(employeeNameIndex);
+                            var storeName = GetColumnValue(storeNameIndex);
+
+                            if (string.IsNullOrWhiteSpace(id) && string.IsNullOrWhiteSpace(employeeName))
+                                continue;
+
+                            if (string.IsNullOrWhiteSpace(id) && !string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                var matchedRecord = await _db.Queryable<LqMajorProjectTeacherSalaryStatisticsEntity>()
+                                    .Where(x => x.EmployeeName == employeeName)
+                                    .WhereIF(!string.IsNullOrWhiteSpace(storeName), x => x.StoreName == storeName)
+                                    .OrderBy(x => x.CreateTime, OrderByType.Desc)
+                                    .FirstAsync();
+                                if (matchedRecord != null) id = matchedRecord.Id;
+                            }
+
+                            if (string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                errorMessages.Add($"第{i + 1}行：员工姓名不能为空");
+                                failCount++;
+                                continue;
+                            }
+
+                            LqMajorProjectTeacherSalaryStatisticsEntity existing = null;
+                            if (!string.IsNullOrWhiteSpace(id))
+                            {
+                                existing = await _db.Queryable<LqMajorProjectTeacherSalaryStatisticsEntity>()
+                                    .Where(x => x.Id == id).FirstAsync();
+
+                                if (existing != null && (existing.IsLocked == 1 || existing.EmployeeConfirmStatus == 1))
+                                {
+                                    skippedCount++;
+                                    failCount++;
+                                    continue;
+                                }
+                            }
+
+                            var entity = existing ?? new LqMajorProjectTeacherSalaryStatisticsEntity
+                            {
+                                Id = string.IsNullOrWhiteSpace(id) ? YitIdHelper.NextId().ToString() : id,
+                                EmployeeConfirmStatus = 0,
+                                IsLocked = 0,
+                                CreateTime = DateTime.Now,
+                                CreateUser = ""
+                            };
+
+                            // Excel字段映射（大项目老师工资49列：门店名称,员工姓名,岗位,员工账号,开单业绩,消耗业绩,退卡业绩,总业绩,业绩提成比例,业绩提成金额,提成合计,手工费,底薪...）
+                            entity.StoreName = storeName;
+                            entity.EmployeeName = employeeName;
+                            entity.Position = GetColumnValue(2 + offset);
+                            entity.EmployeeAccount = GetColumnValue(3 + offset);
+                            entity.OrderAchievement = ParseDecimal(GetColumnValue(4 + offset));
+                            entity.ConsumeAchievement = ParseDecimal(GetColumnValue(5 + offset));
+                            entity.RefundAchievement = ParseDecimal(GetColumnValue(6 + offset));
+                            entity.TotalPerformance = ParseDecimal(GetColumnValue(7 + offset));
+                            entity.PerformanceCommissionRate = ParseDecimal(GetColumnValue(8 + offset));
+                            entity.PerformanceCommissionAmount = ParseDecimal(GetColumnValue(9 + offset));
+                            entity.TotalCommission = ParseDecimal(GetColumnValue(10 + offset));
+                            entity.HandworkFee = ParseDecimal(GetColumnValue(11 + offset));
+                            entity.BaseSalary = ParseDecimal(GetColumnValue(12 + offset));
+                            entity.WorkingDays = ParseDecimal(GetColumnValue(13 + offset));
+                            entity.LeaveDays = ParseDecimal(GetColumnValue(14 + offset));
+                            entity.TransportationAllowance = ParseDecimal(GetColumnValue(15 + offset));
+                            entity.LessRest = ParseDecimal(GetColumnValue(16 + offset));
+                            entity.FullAttendance = ParseDecimal(GetColumnValue(17 + offset));
+                            entity.CalculatedGrossSalary = ParseDecimal(GetColumnValue(18 + offset));
+                            entity.GuaranteedSalary = ParseDecimal(GetColumnValue(19 + offset));
+                            entity.GuaranteedLeaveDeduction = ParseDecimal(GetColumnValue(20 + offset));
+                            entity.GuaranteedBaseSalary = ParseDecimal(GetColumnValue(21 + offset));
+                            entity.GuaranteedSupplement = ParseDecimal(GetColumnValue(22 + offset));
+                            entity.FinalGrossSalary = ParseDecimal(GetColumnValue(23 + offset));
+                            entity.MonthlyTrainingSubsidy = ParseDecimal(GetColumnValue(24 + offset));
+                            entity.MonthlyTransportSubsidy = ParseDecimal(GetColumnValue(25 + offset));
+                            entity.LastMonthTrainingSubsidy = ParseDecimal(GetColumnValue(26 + offset));
+                            entity.LastMonthTransportSubsidy = ParseDecimal(GetColumnValue(27 + offset));
+                            entity.TotalSubsidy = ParseDecimal(GetColumnValue(28 + offset));
+                            entity.MissingCard = ParseDecimal(GetColumnValue(29 + offset));
+                            entity.LateArrival = ParseDecimal(GetColumnValue(30 + offset));
+                            entity.LeaveDeduction = ParseDecimal(GetColumnValue(31 + offset));
+                            entity.SocialInsuranceDeduction = ParseDecimal(GetColumnValue(32 + offset));
+                            entity.RewardDeduction = ParseDecimal(GetColumnValue(33 + offset));
+                            entity.AccommodationDeduction = ParseDecimal(GetColumnValue(34 + offset));
+                            entity.StudyPeriodDeduction = ParseDecimal(GetColumnValue(35 + offset));
+                            entity.WorkClothesDeduction = ParseDecimal(GetColumnValue(36 + offset));
+                            entity.TotalDeduction = ParseDecimal(GetColumnValue(37 + offset));
+                            entity.Bonus = ParseDecimal(GetColumnValue(38 + offset));
+                            entity.ReturnPhoneDeposit = ParseDecimal(GetColumnValue(39 + offset));
+                            entity.ReturnAccommodationDeposit = ParseDecimal(GetColumnValue(40 + offset));
+                            entity.LastMonthSupplement = ParseDecimal(GetColumnValue(41 + offset));
+                            entity.ActualSalary = ParseDecimal(GetColumnValue(42 + offset));
+                            entity.MonthlyPaymentStatus = GetColumnValue(43 + offset);
+                            entity.PaidAmount = ParseDecimal(GetColumnValue(44 + offset));
+                            entity.PendingAmount = ParseDecimal(GetColumnValue(45 + offset));
+                            entity.MonthlyTotalPayment = ParseDecimal(GetColumnValue(46 + offset));
+                            entity.IsNewStore = GetColumnValue(47 + offset) == "是" ? "是" : "否";
+                            entity.NewStoreProtectionStage = ParseInt(GetColumnValue(48 + offset));
+
+                            if (existing != null)
+                            {
+                                entity.StoreId = existing.StoreId;
+                                entity.EmployeeId = existing.EmployeeId;
+                                entity.StatisticsMonth = existing.StatisticsMonth;
+                            }
+                            else
+                            {
+                                if (!string.IsNullOrWhiteSpace(employeeName))
+                                {
+                                    var user = await _db.Queryable<UserEntity>()
+                                        .Where(u => u.RealName == employeeName).FirstAsync();
+                                    if (user != null)
+                                    {
+                                        entity.EmployeeId = user.Id;
+                                        if (!string.IsNullOrEmpty(user.Mdid) && string.IsNullOrWhiteSpace(storeName))
+                                            entity.StoreId = user.Mdid;
+                                    }
+
+                                    if (!string.IsNullOrWhiteSpace(storeName) && string.IsNullOrEmpty(entity.StoreId))
+                                    {
+                                        var store = await _db.Queryable<LqMdxxEntity>()
+                                            .Where(s => s.Dm == storeName).FirstAsync();
+                                        if (store != null) entity.StoreId = store.Id;
+                                    }
+                                }
+                            }
+
+                            entity.UpdateTime = DateTime.Now;
+                            if (existing != null) recordsToUpdate.Add(entity);
+                            else recordsToInsert.Add(entity);
+                            successCount++;
+                        }
+                        catch (Exception ex)
+                        {
+                            errorMessages.Add($"第{i + 1}行数据处理失败: {ex.Message}");
+                            failCount++;
+                        }
+                    }
+                }
+                finally
+                {
+                    if (File.Exists(tempFilePath)) File.Delete(tempFilePath);
+                }
+
+                if (recordsToInsert.Any()) await _db.Insertable(recordsToInsert).ExecuteCommandAsync();
+                if (recordsToUpdate.Any()) await _db.Updateable(recordsToUpdate).ExecuteCommandAsync();
+
+                return new
+                {
+                    success = true,
+                    message = $"导入完成：成功 {successCount} 条，失败 {failCount} 条，跳过 {skippedCount} 条（已锁定或已确认）",
+                    successCount,
+                    failCount,
+                    skippedCount,
+                    errors = errorMessages
+                };
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"导入大项目老师工资数据失败: {ex.Message}");
+            }
+        }
+
+        #endregion
     }
 }
  
 using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
 using NCC.Common.Enum;
 using NCC.Common.Filter;
 using NCC.Common.Helper;
 using NCC.Dependency;
 using NCC.DynamicApiController;
 using NCC.Extend.Entitys.Dto.LqSalary;
+using NCC.FriendlyException;
+using System.IO;
 using Yitter.IdGenerator;
 using NCC.Extend.Entitys.lq_attendance_summary;
 using NCC.Extend.Entitys.lq_jinsanjiao_user;
@@ -38,13 +42,15 @@ namespace NCC.Extend
     public class LqSalaryService : IDynamicApiController, ITransient
     {
         private readonly ISqlSugarClient _db;
+        private readonly ILogger<LqSalaryService> _logger;
  
         /// <summary>
         /// 初始化一个<see cref="LqSalaryService"/>类型的新实例
         /// </summary>
-        public LqSalaryService(ISqlSugarClient db)
+        public LqSalaryService(ISqlSugarClient db, ILogger<LqSalaryService> logger)
         {
             _db = db;
+            _logger = logger;
         }
  
         /// <summary>
@@ -57,17 +63,7 @@ namespace NCC.Extend
         {
             var monthStr = $"{input.Year}{input.Month:D2}";
  
-            // 1. 检查当月是否已生成工资数据
-            var exists = await _db.Queryable<LqSalaryStatisticsEntity>()
-                .AnyAsync(x => x.StatisticsMonth == monthStr);
-
-            // 2. 如果没有数据，则进行计算
-            if (!exists)
-            {
-                await CalculateHealthCoachSalary(input.Year, input.Month);
-            }
-
-            // 3. 查询数据
+            // 查询数据
             var query = _db.Queryable<LqSalaryStatisticsEntity>()
                 .Where(x => x.StatisticsMonth == monthStr);
  
@@ -178,6 +174,146 @@ namespace NCC.Extend
         }
  
         /// <summary>
+        /// 通过月份和员工ID查询工资
+        /// </summary>
+        /// <remarks>
+        /// 根据年份、月份和员工ID查询对应员工的工资记录
+        /// 
+        /// 示例请求：
+        /// ```
+        /// GET /api/Extend/lqsalary/query-by-employee?Year=2026&amp;Month=1&amp;EmployeeId=员工ID
+        /// ```
+        /// 
+        /// 参数说明：
+        /// - Year: 年份（必填）
+        /// - Month: 月份（必填）
+        /// - EmployeeId: 员工ID（必填）
+        /// </remarks>
+        /// <param name="input">查询参数</param>
+        /// <returns>工资记录详情</returns>
+        /// <response code="200">查询成功，返回工资记录</response>
+        /// <response code="404">未找到对应的工资记录</response>
+        [HttpGet("query-by-employee")]
+        public async Task<HealthCoachSalaryOutput> GetSalaryByEmployee([FromQuery] SalaryQueryByEmployeeInput input)
+        {
+            if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+            {
+                throw NCCException.Oh("年份和月份参数不正确");
+            }
+
+            if (string.IsNullOrWhiteSpace(input.EmployeeId))
+            {
+                throw NCCException.Oh("员工ID不能为空");
+            }
+
+            var monthStr = $"{input.Year}{input.Month:D2}";
+
+            var salary = await _db.Queryable<LqSalaryStatisticsEntity>()
+                .Where(x => x.StatisticsMonth == monthStr && x.EmployeeId == input.EmployeeId)
+                .Select(x => new HealthCoachSalaryOutput
+                {
+                    Id = x.Id,
+                    StoreId = x.StoreId,
+                    StoreName = x.StoreName,
+                    EmployeeId = x.EmployeeId,
+                    EmployeeName = x.EmployeeName,
+                    Position = x.Position,
+                    GoldTriangleId = x.GoldTriangleId,
+                    GoldTriangleTeam = x.GoldTriangleTeam,
+                    TotalPerformance = x.TotalPerformance,
+                    BasePerformance = x.BasePerformance,
+                    CooperationPerformance = x.CooperationPerformance,
+                    BaseRewardPerformance = x.BaseRewardPerformance,
+                    CooperationRewardPerformance = x.CooperationRewardPerformance,
+                    ActualBasePerformance = x.ActualBasePerformance,
+                    ActualCooperationPerformance = x.ActualCooperationPerformance,
+                    RewardPerformance = x.RewardPerformance,
+                    StoreTotalPerformance = x.StoreTotalPerformance,
+                    TeamPerformance = x.TeamPerformance,
+                    Percentage = x.Percentage,
+                    NewCustomerPerformance = x.NewCustomerPerformance,
+                    NewCustomerConversionRate = x.NewCustomerConversionRate,
+                    NewCustomerPoint = x.NewCustomerPoint,
+                    UpgradeCustomerCount = x.UpgradeCustomerCount,
+                    UpgradePerformance = x.UpgradePerformance,
+                    UpgradePoint = x.UpgradePoint,
+                    NewCustomerCommission = x.NewCustomerPerformanceCommission,
+                    UpgradeCommission = x.UpgradePerformanceCommission,
+                    OtherPerformanceAdd = x.OtherPerformanceAdd,
+                    OtherPerformanceSubtract = x.OtherPerformanceSubtract,
+                    Consumption = x.Consumption,
+                    ProjectCount = x.ProjectCount,
+                    CustomerCount = x.CustomerCount,
+                    WorkingDays = x.WorkingDays,
+                    LeaveDays = x.LeaveDays,
+                    CommissionPoint = x.CommissionPoint,
+                    BasePerformanceCommission = x.BasePerformanceCommission,
+                    CooperationPerformanceCommission = x.CooperationPerformanceCommission,
+                    ConsultantCommission = x.ConsultantCommission,
+                    StoreTZoneCommission = x.StoreTZoneCommission,
+                    TotalCommission = x.TotalCommission,
+                    HealthCoachBaseSalary = x.HealthCoachBaseSalary,
+                    HandworkFee = x.HandworkFee,
+                    OutherHandworkFee = x.OutherHandworkFee,
+                    TransportationAllowance = x.TransportationAllowance,
+                    LessRest = x.LessRest,
+                    FullAttendance = x.FullAttendance,
+                    CalculatedGrossSalary = x.CalculatedGrossSalary,
+                    GuaranteedSalary = x.GuaranteedSalary,
+                    GuaranteedLeaveDeduction = x.GuaranteedLeaveDeduction,
+                    GuaranteedBaseSalary = x.GuaranteedBaseSalary,
+                    GuaranteedSupplement = x.GuaranteedSupplement,
+                    FinalGrossSalary = x.FinalGrossSalary,
+                    MonthlyTrainingSubsidy = x.MonthlyTrainingSubsidy,
+                    MonthlyTransportSubsidy = x.MonthlyTransportSubsidy,
+                    LastMonthTrainingSubsidy = x.LastMonthTrainingSubsidy,
+                    LastMonthTransportSubsidy = x.LastMonthTransportSubsidy,
+                    TotalSubsidy = x.TotalSubsidy,
+                    MissingCard = x.MissingCard,
+                    LateArrival = x.LateArrival,
+                    LeaveDeduction = x.LeaveDeduction,
+                    SocialInsuranceDeduction = x.SocialInsuranceDeduction,
+                    RewardDeduction = x.RewardDeduction,
+                    AccommodationDeduction = x.AccommodationDeduction,
+                    StudyPeriodDeduction = x.StudyPeriodDeduction,
+                    WorkClothesDeduction = x.WorkClothesDeduction,
+                    TotalDeduction = x.TotalDeduction,
+                    Bonus = x.Bonus,
+                    ReturnPhoneDeposit = x.ReturnPhoneDeposit,
+                    ReturnAccommodationDeposit = x.ReturnAccommodationDeposit,
+                    ActualSalary = x.ActualSalary,
+                    MonthlyPaymentStatus = x.MonthlyPaymentStatus,
+                    PaidAmount = x.PaidAmount,
+                    PendingAmount = x.PendingAmount,
+                    LastMonthSupplement = x.LastMonthSupplement,
+                    MonthlyTotalPayment = x.MonthlyTotalPayment,
+                    StatisticsMonth = x.StatisticsMonth,
+                    IsLocked = x.IsLocked,
+                    CreateTime = x.CreateTime,
+                    CreateUser = x.CreateUser,
+                    UpdateTime = x.UpdateTime,
+                    UpdateUser = x.UpdateUser,
+                    IsNewStore = x.IsNewStore,
+                    NewStoreProtectionStage = x.NewStoreProtectionStage,
+                    StoreType = x.StoreType,
+                    StoreCategory = x.StoreCategory,
+                    DailyAverageConsumption = x.DailyAverageConsumption,
+                    DailyAverageProjectCount = x.DailyAverageProjectCount,
+                    TeamTotalConsumption = x.TeamTotalConsumption
+                })
+                .FirstAsync();
+
+            if (salary == null)
+            {
+                throw NCCException.Oh($"未找到员工{input.EmployeeId}在{input.Year}年{input.Month}月的工资记录");
+            }
+
+            return salary;
+        }
+
+        #region 计算工资
+
+        /// <summary>
         /// 计算健康师工资
         /// </summary>
         /// <param name="year">年份</param>
@@ -710,7 +846,7 @@ namespace NCC.Extend
                         // 获取战队人数
                         var teamMemberList = employeeStats.Values.Where(x => x.GoldTriangleId == salary.GoldTriangleId).ToList();
                         var teamMemberCount = teamMemberList.Count;
-                        
+
                         // 单人或者一个人的战队就没有顾问
                         if (teamMemberCount > 1)
                         {
@@ -769,13 +905,789 @@ namespace NCC.Extend
             // 5. 保存数据
             if (employeeStats.Any())
             {
-                // 先删除当月旧数据 (防止重复)
-                await _db.Deleteable<LqSalaryStatisticsEntity>().Where(x => x.StatisticsMonth == monthStr).ExecuteCommandAsync();
-                await _db.Insertable(employeeStats.Values.ToList()).ExecuteCommandAsync();
+                // 查询当月已存在的记录（用于检查是否已锁定或已确认）
+                var existingRecords = await _db.Queryable<LqSalaryStatisticsEntity>()
+                    .Where(x => x.StatisticsMonth == monthStr)
+                    .ToListAsync();
+
+                var existingDict = existingRecords
+                    .Where(x => !string.IsNullOrEmpty(x.EmployeeId))
+                    .GroupBy(x => x.EmployeeId)
+                    .ToDictionary(g => g.Key, g => g.First());
+
+                // 分离需要插入的新记录和需要更新的记录，以及需要跳过的记录
+                var recordsToInsert = new List<LqSalaryStatisticsEntity>();
+                var recordsToUpdate = new List<LqSalaryStatisticsEntity>();
+                var skippedCount = 0;
+
+                foreach (var salary in employeeStats.Values)
+                {
+                    if (existingDict.ContainsKey(salary.EmployeeId))
+                    {
+                        var existing = existingDict[salary.EmployeeId];
+                        // 如果已锁定或已确认，则跳过，不更新
+                        if (existing.IsLocked == 1 || existing.EmployeeConfirmStatus == 1)
+                        {
+                            skippedCount++;
+                            continue;
+                        }
+
+                        // 更新现有记录（保留确认状态相关字段）
+                        salary.Id = existing.Id;
+                        salary.EmployeeConfirmStatus = existing.EmployeeConfirmStatus;
+                        salary.EmployeeConfirmTime = existing.EmployeeConfirmTime;
+                        salary.EmployeeConfirmRemark = existing.EmployeeConfirmRemark;
+                        salary.IsLocked = existing.IsLocked; // 保留锁定状态
+                        salary.CreateTime = existing.CreateTime;
+                        salary.CreateUser = existing.CreateUser;
+                        recordsToUpdate.Add(salary);
+                    }
+                    else
+                    {
+                        // 新记录
+                        salary.Id = YitIdHelper.NextId().ToString();
+                        salary.EmployeeConfirmStatus = 0;
+                        salary.IsLocked = 0;
+                        salary.CreateTime = DateTime.Now;
+                        salary.CreateUser = ""; // 新记录，创建人为空或系统
+                        recordsToInsert.Add(salary);
+                    }
+                }
+
+                // 批量插入新记录
+                if (recordsToInsert.Any())
+                {
+                    await _db.Insertable(recordsToInsert).ExecuteCommandAsync();
+                }
+
+                // 批量更新现有记录
+                if (recordsToUpdate.Any())
+                {
+                    await _db.Updateable(recordsToUpdate).ExecuteCommandAsync();
+                }
+
+                if (skippedCount > 0)
+                {
+                    _logger.LogWarning($"计算工资时跳过了 {skippedCount} 条已锁定或已确认的记录（月份：{monthStr}）");
+                }
+            }
+        }
+
+        #endregion
+
+        #region 员工工资确认
+
+        /// <summary>
+        /// 员工确认工资条
+        /// </summary>
+        /// <remarks>
+        /// 员工确认自己的工资条，确认后工资数据不可再修改
+        /// 
+        /// 示例请求：
+        /// <code>
+        /// {
+        ///   "id": "工资记录ID",
+        ///   "employeeId": "员工ID",
+        ///   "remark": "确认备注（可选）"
+        /// }
+        /// </code>
+        /// 
+        /// 参数说明：
+        /// - id: 工资记录ID（必填）
+        /// - employeeId: 员工ID（必填）
+        /// - remark: 确认备注（可选）
+        /// 
+        /// 注意事项：
+        /// - 只能确认自己的工资条
+        /// - 只能确认已锁定的工资条（IsLocked = 1）
+        /// - 已确认的工资条不能重复确认
+        /// </remarks>
+        /// <param name="input">确认参数</param>
+        /// <returns>操作结果</returns>
+        /// <response code="200">确认成功</response>
+        /// <response code="400">参数错误或记录不存在</response>
+        [HttpPost("confirm")]
+        public async Task<string> ConfirmSalary([FromBody] SalaryConfirmInput input)
+        {
+            try
+            {
+                if (string.IsNullOrWhiteSpace(input.Id))
+                {
+                    throw NCCException.Oh("工资记录ID不能为空");
+                }
+
+                if (string.IsNullOrWhiteSpace(input.EmployeeId))
+                {
+                    throw NCCException.Oh("员工ID不能为空");
+                }
+
+                // 查询工资记录
+                var salary = await _db.Queryable<LqSalaryStatisticsEntity>()
+                    .Where(s => s.Id == input.Id && s.EmployeeId == input.EmployeeId)
+                    .FirstAsync();
+
+                if (salary == null)
+                {
+                    throw NCCException.Oh("工资记录不存在或不属于该员工");
+                }
+
+                // 检查是否已确认
+                if (salary.EmployeeConfirmStatus == 1)
+                {
+                    throw NCCException.Oh("该工资条已确认，不能重复确认");
+                }
+
+                // 检查是否已锁定（员工只能确认已锁定的工资条）
+                if (salary.IsLocked != 1)
+                {
+                    throw NCCException.Oh("该工资条尚未锁定，请等待管理员锁定后再确认");
+                }
+
+                // 更新确认状态
+                salary.EmployeeConfirmStatus = 1;
+                salary.EmployeeConfirmTime = DateTime.Now;
+                salary.EmployeeConfirmRemark = input.Remark;
+                // 注意：IsLocked 保持为 1（因为本来就是管理员锁定的）
+                salary.UpdateTime = DateTime.Now;
+
+                await _db.Updateable(salary).ExecuteCommandAsync();
+
+                return "确认成功";
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"确认工资条失败: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        #region 工资锁定/解锁
+
+        /// <summary>
+        /// 批量锁定/解锁工资条
+        /// </summary>
+        /// <remarks>
+        /// 管理员批量锁定或解锁工资条
+        /// 
+        /// 示例请求：
+        /// ```json
+        /// {
+        ///   "ids": ["工资记录ID1", "工资记录ID2"],
+        ///   "isLocked": true
+        /// }
+        /// ```
+        /// 
+        /// 参数说明：
+        /// - ids: 工资记录ID列表（必填）
+        /// - isLocked: 是否锁定（true=锁定，false=解锁）
+        /// </remarks>
+        /// <param name="input">锁定参数</param>
+        /// <returns>操作结果</returns>
+        /// <response code="200">锁定/解锁成功</response>
+        /// <response code="400">参数错误或记录不存在</response>
+        [HttpPost("lock")]
+        public async Task<string> LockSalary([FromBody] SalaryLockInput input)
+        {
+            try
+            {
+                if (input == null || input.Ids == null || !input.Ids.Any())
+                {
+                    throw NCCException.Oh("工资记录ID列表不能为空");
+                }
+
+                // 查询工资记录
+                var salaries = await _db.Queryable<LqSalaryStatisticsEntity>()
+                    .Where(s => input.Ids.Contains(s.Id))
+                    .ToListAsync();
+
+                if (!salaries.Any())
+                {
+                    throw NCCException.Oh("未找到指定的工资记录");
+                }
+
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+
+                foreach (var salary in salaries)
+                {
+                    // 如果已确认，不能解锁
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+
+                    if (input.IsLocked)
+                    {
+                        lockedCount++;
+                    }
+                    else
+                    {
+                        unlockedCount++;
+                    }
+                }
+
+                // 批量更新
+                await _db.Updateable(salaries).ExecuteCommandAsync();
+
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+                if (skippedCount > 0)
+                {
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+                }
+
+                return message;
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"锁定/解锁工资条失败: {ex.Message}");
             }
         }
  
         /// <summary>
+        /// 批量锁定当月所有工资
+        /// </summary>
+        /// <remarks>
+        /// 批量锁定指定月份的所有健康师工资记录
+        /// 
+        /// 示例请求：
+        /// ```json
+        /// {
+        ///   "year": 2025,
+        ///   "month": 12,
+        ///   "isLocked": true
+        /// }
+        /// ```
+        /// </remarks>
+        /// <param name="input">批量锁定输入参数</param>
+        /// <returns>锁定结果</returns>
+        [HttpPost("lock-by-month")]
+        public async Task<dynamic> LockSalaryByMonth([FromBody] SalaryLockByMonthInput input)
+        {
+            try
+            {
+                if (input == null)
+                    throw NCCException.Oh("参数不能为空");
+
+                if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+                    throw NCCException.Oh("年份和月份参数不正确");
+
+                var monthStr = $"{input.Year}{input.Month:D2}";
+
+                var salaries = await _db.Queryable<LqSalaryStatisticsEntity>()
+                    .Where(s => s.StatisticsMonth == monthStr)
+                    .ToListAsync();
+
+                if (!salaries.Any())
+                    throw NCCException.Oh($"未找到{input.Year}年{input.Month}月的工资记录");
+
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+                var alreadyLockedCount = 0;
+
+                foreach (var salary in salaries)
+                {
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+
+                    if (salary.IsLocked == 1 && input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    if (salary.IsLocked == 0 && !input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+
+                    if (input.IsLocked)
+                        lockedCount++;
+                    else
+                        unlockedCount++;
+                }
+
+                if (lockedCount > 0 || unlockedCount > 0)
+                {
+                    var salariesToUpdate = salaries.Where(s =>
+                        (input.IsLocked && s.IsLocked == 0) ||
+                        (!input.IsLocked && s.IsLocked == 1 && s.EmployeeConfirmStatus != 1)
+                    ).ToList();
+
+                    if (salariesToUpdate.Any())
+                    {
+                        await _db.Updateable(salariesToUpdate)
+                            .UpdateColumns(s => new { s.IsLocked, s.UpdateTime })
+                            .ExecuteCommandAsync();
+                    }
+                }
+
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+
+                if (alreadyLockedCount > 0)
+                    message += $"，跳过{alreadyLockedCount}条（已是{action}状态）";
+
+                if (skippedCount > 0)
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+
+                return new
+                {
+                    success = true,
+                    message = message,
+                    total = salaries.Count,
+                    locked = lockedCount,
+                    unlocked = unlockedCount,
+                    skipped = skippedCount,
+                    alreadyLocked = alreadyLockedCount
+                };
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "批量锁定当月工资失败");
+                var action = input?.IsLocked == true ? "锁定" : "解锁";
+                throw NCCException.Oh($"批量{action}当月工资失败: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        #region 导入工资
+
+        /// <summary>
+        /// 从Excel导入健康师工资数据
+        /// </summary>
+        /// <remarks>
+        /// 从Excel文件导入健康师工资数据，Excel第一列必须是ID（主键）
+        /// 
+        /// 导入规则：
+        /// 1. Excel第一列是ID（主键），如果为空则自动生成新ID
+        /// 2. 如果ID在数据库中存在，则更新记录（需检查是否已锁定或已确认）
+        /// 3. 如果ID在数据库中不存在，则新增记录
+        /// 4. 已锁定（IsLocked=1）或已确认（EmployeeConfirmStatus=1）的记录不能导入覆盖
+        /// 
+        /// Excel字段顺序（第一列为ID）：
+        /// ID, 门店名称, 员工姓名, 岗位, 金三角战队, ...（共77列）
+        /// </remarks>
+        /// <param name="file">Excel文件</param>
+        /// <returns>导入结果</returns>
+        /// <response code="200">导入成功</response>
+        /// <response code="400">文件格式错误或数据验证失败</response>
+        [HttpPost("import")]
+        public async Task<dynamic> ImportSalaryFromExcel(IFormFile file)
+        {
+            try
+            {
+                if (file == null || file.Length == 0)
+                {
+                    throw NCCException.Oh("请选择要上传的Excel文件");
+                }
+
+                // 检查文件格式
+                var allowedExtensions = new[] { ".xlsx", ".xls" };
+                var fileExtension = Path.GetExtension(file.FileName).ToLowerInvariant();
+                if (!allowedExtensions.Contains(fileExtension))
+                {
+                    throw NCCException.Oh("只支持.xlsx和.xls格式的Excel文件");
+                }
+
+                var recordsToInsert = new List<LqSalaryStatisticsEntity>();
+                var recordsToUpdate = new List<LqSalaryStatisticsEntity>();
+                var errorMessages = new List<string>();
+                var successCount = 0;
+                var failCount = 0;
+                var skippedCount = 0;
+
+                // 保存临时文件
+                var tempFilePath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + Path.GetExtension(file.FileName));
+                try
+                {
+                    using (var stream = new FileStream(tempFilePath, FileMode.Create))
+                    {
+                        await file.CopyToAsync(stream);
+                    }
+
+                    // 使用ExcelImportHelper读取Excel文件
+                    // 参数说明：0表示第一个工作表，0表示第一行是标题行
+                    var dataTable = ExcelImportHelper.ToDataTable(tempFilePath, 0, 0);
+
+                    if (dataTable.Rows.Count == 0)
+                    {
+                        throw NCCException.Oh("Excel文件中没有数据行");
+                    }
+
+                    // Excel第一列是ID，第二列开始是业务字段
+                    // 从第1行开始读取数据（跳过标题行）
+                    for (int i = 1; i < dataTable.Rows.Count; i++)
+                    {
+                        try
+                        {
+                            var row = dataTable.Rows[i];
+
+                            // 安全获取列值
+                            Func<int, string> GetColumnValue = (colIndex) =>
+                            {
+                                if (colIndex < row.ItemArray.Length)
+                                {
+                                    return row[colIndex]?.ToString()?.Trim() ?? "";
+                                }
+                                return "";
+                            };
+
+                            // 第一列是ID（Excel第一列应该是ID）
+                            var id = GetColumnValue(0);
+
+                            // 判断Excel格式：如果第一列是"门店名称"等中文，说明是旧格式（没有ID列）
+                            var firstColumnValue = GetColumnValue(0);
+                            bool isOldFormat = false;
+                            if (!string.IsNullOrWhiteSpace(firstColumnValue) &&
+                                (firstColumnValue == "门店名称" || firstColumnValue.Contains("门店") || (!string.IsNullOrWhiteSpace(firstColumnValue) && !long.TryParse(firstColumnValue, out _) && firstColumnValue.Length > 20)))
+                            {
+                                // 旧格式：第一列是"门店名称"标题行或数据，不是ID
+                                isOldFormat = true;
+                                id = ""; // ID为空，需要根据员工姓名和门店名称匹配
+                            }
+
+                            // 根据Excel格式确定字段索引
+                            int storeNameIndex = isOldFormat ? 0 : 1; // 门店名称索引
+                            int employeeNameIndex = isOldFormat ? 1 : 2; // 员工姓名索引
+
+                            // 跳过空行（ID、员工姓名都为空）
+                            var employeeName = GetColumnValue(employeeNameIndex);
+                            var storeName = GetColumnValue(storeNameIndex);
+
+                            if (string.IsNullOrWhiteSpace(id) && string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                continue;
+                            }
+
+                            // 如果ID为空，尝试根据员工姓名和门店名称匹配现有记录的ID
+                            if (string.IsNullOrWhiteSpace(id) && !string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                var matchedRecord = await _db.Queryable<LqSalaryStatisticsEntity>()
+                                    .Where(x => x.EmployeeName == employeeName)
+                                    .WhereIF(!string.IsNullOrWhiteSpace(storeName), x => x.StoreName == storeName)
+                                    .OrderBy(x => x.CreateTime, OrderByType.Desc)
+                                    .FirstAsync();
+
+                                if (matchedRecord != null)
+                                {
+                                    id = matchedRecord.Id;
+                                }
+                            }
+
+                            // 验证必填字段
+                            if (string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                errorMessages.Add($"第{i + 1}行：员工姓名不能为空");
+                                failCount++;
+                                continue;
+                            }
+
+                            // 辅助方法：清理数值字符串
+                            Func<string, decimal> ParseDecimal = (str) =>
+                            {
+                                if (string.IsNullOrWhiteSpace(str))
+                                    return 0;
+                                var cleaned = str.Trim()
+                                    .Replace(",", "")
+                                    .Replace("，", "")
+                                    .Replace("￥", "")
+                                    .Replace("$", "")
+                                    .Replace("元", "")
+                                    .Replace("%", "")
+                                    .Replace(" ", "");
+                                if (decimal.TryParse(cleaned, out decimal result))
+                                    return result;
+                                return 0;
+                            };
+
+                            Func<string, int> ParseInt = (str) =>
+                            {
+                                if (string.IsNullOrWhiteSpace(str))
+                                    return 0;
+                                var cleaned = str.Trim().Replace(",", "").Replace("，", "").Replace(" ", "");
+                                if (int.TryParse(cleaned, out int result))
+                                    return result;
+                                return 0;
+                            };
+
+                            // 如果Excel中有ID，查找现有记录
+                            LqSalaryStatisticsEntity existing = null;
+                            if (!string.IsNullOrWhiteSpace(id))
+                            {
+                                existing = await _db.Queryable<LqSalaryStatisticsEntity>()
+                                    .Where(x => x.Id == id)
+                                    .FirstAsync();
+
+                                if (existing != null)
+                                {
+                                    // 检查是否已锁定或已确认
+                                    if (existing.IsLocked == 1)
+                                    {
+                                        errorMessages.Add($"第{i + 1}行：员工 {existing.EmployeeName} (ID: {id}) 的工资已锁定，不能导入覆盖");
+                                        skippedCount++;
+                                        failCount++;
+                                        continue;
+                                    }
+
+                                    if (existing.EmployeeConfirmStatus == 1)
+                                    {
+                                        errorMessages.Add($"第{i + 1}行：员工 {existing.EmployeeName} (ID: {id}) 的工资已确认，不能导入覆盖");
+                                        skippedCount++;
+                                        failCount++;
+                                        continue;
+                                    }
+                                }
+                            }
+
+                            // 创建或更新实体
+                            LqSalaryStatisticsEntity entity;
+                            if (existing != null)
+                            {
+                                // 更新现有记录
+                                entity = existing;
+
+                                // 导入后重置确认状态（如果被覆盖）
+                                entity.EmployeeConfirmStatus = 0;
+                                entity.EmployeeConfirmTime = null;
+                                entity.EmployeeConfirmRemark = null;
+                            }
+                            else
+                            {
+                                // 新增记录
+                                entity = new LqSalaryStatisticsEntity
+                                {
+                                    Id = string.IsNullOrWhiteSpace(id) ? YitIdHelper.NextId().ToString() : id,
+                                    EmployeeConfirmStatus = 0,
+                                    IsLocked = 0,
+                                    CreateTime = DateTime.Now,
+                                    UpdateTime = DateTime.Now
+                                };
+                            }
+
+                            // 映射Excel字段到实体属性（根据Excel列顺序）
+                            // 注意：Excel第一列是ID（索引0），第二列是门店名称（索引1），第三列是员工姓名（索引2）...
+                            entity.StoreName = storeName;
+                            entity.EmployeeName = employeeName;
+                            entity.Position = GetColumnValue(2); // Excel第3列（索引2）
+                            entity.GoldTriangleTeam = GetColumnValue(3); // Excel第4列（索引3）
+                            // 根据Excel格式计算字段索引偏移量
+                            int offset = isOldFormat ? 0 : 1; // 如果是新格式（第一列是ID），所有业务字段索引+1
+
+                            // 映射Excel字段到实体属性
+                            // Excel列顺序（新格式）：ID, 门店名称, 员工姓名, 岗位, 金三角战队, 总业绩(5+offset), ...
+                            entity.Position = GetColumnValue(2 + offset); // 岗位
+                            entity.GoldTriangleTeam = GetColumnValue(3 + offset); // 金三角战队
+                            entity.TotalPerformance = ParseDecimal(GetColumnValue(4 + offset)); // 总业绩
+                            entity.BasePerformance = ParseDecimal(GetColumnValue(5 + offset));
+                            entity.CooperationPerformance = ParseDecimal(GetColumnValue(6 + offset));
+                            // 跳过索引7+offset（奖励业绩），实际基础业绩和实际合作业绩在索引8+offset和9+offset
+                            entity.ActualBasePerformance = ParseDecimal(GetColumnValue(8 + offset));
+                            entity.ActualCooperationPerformance = ParseDecimal(GetColumnValue(9 + offset));
+                            entity.NewCustomerPerformance = ParseDecimal(GetColumnValue(10 + offset));
+                            entity.UpgradePerformance = ParseDecimal(GetColumnValue(11 + offset));
+                            entity.BaseRewardPerformance = ParseDecimal(GetColumnValue(12 + offset));
+                            entity.CooperationRewardPerformance = ParseDecimal(GetColumnValue(13 + offset));
+                            entity.OtherPerformanceAdd = ParseDecimal(GetColumnValue(14 + offset));
+                            entity.OtherPerformanceSubtract = ParseDecimal(GetColumnValue(15 + offset));
+                            entity.StoreTotalPerformance = ParseDecimal(GetColumnValue(16 + offset));
+                            entity.TeamPerformance = ParseDecimal(GetColumnValue(17 + offset));
+                            entity.Percentage = ParseDecimal(GetColumnValue(18 + offset));
+                            entity.Consumption = ParseDecimal(GetColumnValue(19 + offset));
+                            entity.ProjectCount = ParseInt(GetColumnValue(20 + offset));
+                            entity.CustomerCount = ParseInt(GetColumnValue(21 + offset));
+                            entity.WorkingDays = ParseDecimal(GetColumnValue(22 + offset));
+                            entity.LeaveDays = ParseDecimal(GetColumnValue(23 + offset));
+                            entity.DailyAverageConsumption = ParseDecimal(GetColumnValue(24 + offset));
+                            entity.DailyAverageProjectCount = ParseDecimal(GetColumnValue(25 + offset));
+                            entity.TeamTotalConsumption = ParseDecimal(GetColumnValue(26 + offset));
+                            entity.NewCustomerConversionRate = ParseDecimal(GetColumnValue(27 + offset));
+                            entity.NewCustomerPoint = ParseDecimal(GetColumnValue(28 + offset));
+                            entity.NewCustomerPerformanceCommission = ParseDecimal(GetColumnValue(29 + offset));
+                            entity.UpgradeCustomerCount = ParseInt(GetColumnValue(30 + offset));
+                            entity.UpgradePoint = ParseDecimal(GetColumnValue(31 + offset));
+                            entity.UpgradePerformanceCommission = ParseDecimal(GetColumnValue(32 + offset));
+                            entity.CommissionPoint = ParseDecimal(GetColumnValue(33 + offset));
+                            entity.BasePerformanceCommission = ParseDecimal(GetColumnValue(34 + offset));
+                            entity.CooperationPerformanceCommission = ParseDecimal(GetColumnValue(35 + offset));
+                            entity.ConsultantCommission = ParseDecimal(GetColumnValue(36 + offset));
+                            entity.StoreTZoneCommission = ParseDecimal(GetColumnValue(37 + offset));
+                            entity.TotalCommission = ParseDecimal(GetColumnValue(38 + offset));
+                            entity.HealthCoachBaseSalary = ParseDecimal(GetColumnValue(39 + offset));
+                            entity.HandworkFee = ParseDecimal(GetColumnValue(40 + offset));
+                            entity.OutherHandworkFee = ParseDecimal(GetColumnValue(41 + offset));
+                            entity.CalculatedGrossSalary = ParseDecimal(GetColumnValue(42 + offset));
+                            entity.GuaranteedSalary = ParseDecimal(GetColumnValue(43 + offset));
+                            entity.GuaranteedLeaveDeduction = ParseDecimal(GetColumnValue(44 + offset));
+                            entity.GuaranteedBaseSalary = ParseDecimal(GetColumnValue(45 + offset));
+                            entity.GuaranteedSupplement = ParseDecimal(GetColumnValue(46 + offset));
+                            entity.FinalGrossSalary = ParseDecimal(GetColumnValue(47 + offset));
+                            entity.TransportationAllowance = ParseDecimal(GetColumnValue(48 + offset));
+                            entity.LessRest = ParseDecimal(GetColumnValue(49 + offset));
+                            entity.FullAttendance = ParseDecimal(GetColumnValue(50 + offset));
+                            entity.MonthlyTrainingSubsidy = ParseDecimal(GetColumnValue(51 + offset));
+                            entity.MonthlyTransportSubsidy = ParseDecimal(GetColumnValue(52 + offset));
+                            entity.LastMonthTrainingSubsidy = ParseDecimal(GetColumnValue(53 + offset));
+                            entity.LastMonthTransportSubsidy = ParseDecimal(GetColumnValue(54 + offset));
+                            entity.TotalSubsidy = ParseDecimal(GetColumnValue(55 + offset));
+                            entity.MissingCard = ParseDecimal(GetColumnValue(56 + offset));
+                            entity.LateArrival = ParseDecimal(GetColumnValue(57 + offset));
+                            entity.LeaveDeduction = ParseDecimal(GetColumnValue(58 + offset));
+                            entity.SocialInsuranceDeduction = ParseDecimal(GetColumnValue(59 + offset));
+                            entity.RewardDeduction = ParseDecimal(GetColumnValue(60 + offset));
+                            entity.AccommodationDeduction = ParseDecimal(GetColumnValue(61 + offset));
+                            entity.StudyPeriodDeduction = ParseDecimal(GetColumnValue(62 + offset));
+                            entity.WorkClothesDeduction = ParseDecimal(GetColumnValue(63 + offset));
+                            entity.TotalDeduction = ParseDecimal(GetColumnValue(64 + offset));
+                            entity.Bonus = ParseDecimal(GetColumnValue(65 + offset));
+                            entity.ReturnPhoneDeposit = ParseDecimal(GetColumnValue(66 + offset));
+                            entity.ReturnAccommodationDeposit = ParseDecimal(GetColumnValue(67 + offset));
+                            entity.LastMonthSupplement = ParseDecimal(GetColumnValue(68 + offset));
+                            entity.ActualSalary = ParseDecimal(GetColumnValue(69 + offset));
+                            entity.MonthlyPaymentStatus = GetColumnValue(70 + offset);
+                            entity.PaidAmount = ParseDecimal(GetColumnValue(71 + offset));
+                            entity.PendingAmount = ParseDecimal(GetColumnValue(72 + offset));
+                            entity.MonthlyTotalPayment = ParseDecimal(GetColumnValue(73 + offset));
+
+                            // 处理"是否新店"字段
+                            var isNewStoreStr = GetColumnValue(74 + offset);
+                            entity.IsNewStore = (isNewStoreStr == "是" || isNewStoreStr == "1" || isNewStoreStr.ToLower() == "true") ? "是" : "否";
+
+                            // 处理"新店保护阶段"字段
+                            var newStoreProtectionStageStr = GetColumnValue(75 + offset);
+                            if (int.TryParse(newStoreProtectionStageStr, out int protectionStage))
+                            {
+                                entity.NewStoreProtectionStage = protectionStage;
+                            }
+
+                            // 注意：Excel中的"锁定状态"字段不应该从Excel导入，因为锁定状态应该由管理员操作
+                            // 导入时只读取，但不更新到数据库
+
+                            // 处理Excel中没有的字段：StoreId、EmployeeId、StatisticsMonth等
+                            if (existing != null)
+                            {
+                                // 更新记录：保留原有的StoreId、EmployeeId、StatisticsMonth等
+                                entity.StoreId = existing.StoreId;
+                                entity.EmployeeId = existing.EmployeeId;
+                                entity.StatisticsMonth = existing.StatisticsMonth;
+                            }
+                            else
+                            {
+                                // 新增记录：尝试根据员工姓名和门店名称查找EmployeeId和StoreId
+                                // 如果找不到，这些字段会保持为空，需要后续通过计算工资时填充
+                                if (!string.IsNullOrWhiteSpace(employeeName))
+                                {
+                                    // 尝试查找用户（通过员工姓名）
+                                    var user = await _db.Queryable<UserEntity>()
+                                        .Where(u => u.RealName == employeeName)
+                                        .FirstAsync();
+
+                                    if (user != null)
+                                    {
+                                        entity.EmployeeId = user.Id;
+
+                                        // 尝试从用户的门店ID获取
+                                        if (!string.IsNullOrEmpty(user.Mdid) && string.IsNullOrWhiteSpace(storeName))
+                                        {
+                                            entity.StoreId = user.Mdid;
+                                        }
+                                    }
+
+                                    // 如果门店名称不为空，尝试查找门店ID
+                                    if (!string.IsNullOrWhiteSpace(storeName) && string.IsNullOrEmpty(entity.StoreId))
+                                    {
+                                        var store = await _db.Queryable<LqMdxxEntity>()
+                                            .Where(s => s.Dm == storeName)
+                                            .FirstAsync();
+
+                                        if (store != null)
+                                        {
+                                            entity.StoreId = store.Id;
+                                        }
+                                    }
+                                }
+
+                                // StatisticsMonth需要从Excel文件名或其他地方获取
+                                // 这里暂时留空，后续可以根据业务需求补充（例如从Excel文件名中提取月份）
+                            }
+
+                            entity.UpdateTime = DateTime.Now;
+
+                            if (existing != null)
+                            {
+                                recordsToUpdate.Add(entity);
+                            }
+                            else
+                            {
+                                recordsToInsert.Add(entity);
+                            }
+
+                            successCount++;
+                        }
+                        catch (Exception ex)
+                        {
+                            errorMessages.Add($"第{i + 1}行数据处理失败: {ex.Message}");
+                            failCount++;
+                        }
+                    }
+                }
+                finally
+                {
+                    // 清理临时文件
+                    if (File.Exists(tempFilePath))
+                    {
+                        File.Delete(tempFilePath);
+                    }
+                }
+
+                // 批量插入新记录
+                if (recordsToInsert.Any())
+                {
+                    await _db.Insertable(recordsToInsert).ExecuteCommandAsync();
+                }
+
+                // 批量更新现有记录
+                if (recordsToUpdate.Any())
+                {
+                    await _db.Updateable(recordsToUpdate).ExecuteCommandAsync();
+                }
+
+                return new
+                {
+                    success = true,
+                    message = $"导入完成：成功 {successCount} 条，失败 {failCount} 条，跳过 {skippedCount} 条（已锁定或已确认）",
+                    successCount = successCount,
+                    failCount = failCount,
+                    skippedCount = skippedCount,
+                    errors = errorMessages
+                };
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"导入健康师工资数据失败: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        /// <summary>
         /// 计算底薪
         /// </summary>
         private decimal CalculateBaseSalary(decimal dailyAvgConsumption, decimal dailyAvgProjectCount, int daysInMonth, decimal workingDays, bool isNewStore)
 using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
 using NCC.Common.Filter;
 using NCC.Common.Helper;
 using NCC.Dependency;
 using NCC.DynamicApiController;
+using NCC.Extend.Entitys.Dto.LqSalary;
 using NCC.Extend.Entitys.Dto.LqStoreManagerSalary;
 using NCC.Extend.Entitys.Enum;
 using NCC.Extend.Entitys.lq_attendance_summary;
@@ -19,10 +22,13 @@ using NCC.Extend.Entitys.lq_store_expense;
 using NCC.Extend.Entitys.lq_store_manager_salary_statistics;
 using NCC.Extend.Entitys.lq_xh_hyhk;
 using NCC.Extend.Entitys.lq_xh_jksyj;
+using NCC.FriendlyException;
 using NCC.System.Entitys.Permission;
 using SqlSugar;
 using System;
 using System.Collections.Generic;
+using System.Data;
+using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using Yitter.IdGenerator;
@@ -37,13 +43,15 @@ namespace NCC.Extend
     public class LqStoreManagerSalaryService : IDynamicApiController, ITransient
     {
         private readonly ISqlSugarClient _db;
+        private readonly ILogger<LqStoreManagerSalaryService> _logger;
  
         /// <summary>
         /// 初始化一个<see cref="LqStoreManagerSalaryService"/>类型的新实例
         /// </summary>
-        public LqStoreManagerSalaryService(ISqlSugarClient db)
+        public LqStoreManagerSalaryService(ISqlSugarClient db, ILogger<LqStoreManagerSalaryService> logger)
         {
             _db = db;
+            _logger = logger;
         }
  
         /// <summary>
@@ -56,17 +64,7 @@ namespace NCC.Extend
         {
             var monthStr = $"{input.Year}{input.Month:D2}";
  
-            // 1. 检查当月是否已生成工资数据
-            var exists = await _db.Queryable<LqStoreManagerSalaryStatisticsEntity>()
-                .AnyAsync(x => x.StatisticsMonth == monthStr);
-
-            // 2. 如果没有数据，则进行计算
-            if (!exists)
-            {
-                await CalculateStoreManagerSalary(input.Year, input.Month);
-            }
-
-            // 3. 查询数据
+            // 查询数据
             var query = _db.Queryable<LqStoreManagerSalaryStatisticsEntity>()
                 .Where(x => x.StatisticsMonth == monthStr);
  
@@ -134,6 +132,73 @@ namespace NCC.Extend
         }
  
         /// <summary>
+        /// 通过月份和员工ID查询工资
+        /// </summary>
+        [HttpGet("query-by-employee")]
+        public async Task<StoreManagerSalaryOutput> GetSalaryByEmployee([FromQuery] SalaryQueryByEmployeeInput input)
+        {
+            if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+                throw NCCException.Oh("年份和月份参数不正确");
+            if (string.IsNullOrWhiteSpace(input.EmployeeId))
+                throw NCCException.Oh("员工ID不能为空");
+            var monthStr = $"{input.Year}{input.Month:D2}";
+            var salary = await _db.Queryable<LqStoreManagerSalaryStatisticsEntity>()
+                .Where(x => x.StatisticsMonth == monthStr && x.EmployeeId == input.EmployeeId)
+                .Select(x => new StoreManagerSalaryOutput
+                {
+                    Id = x.Id,
+                    StoreName = x.StoreName,
+                    EmployeeName = x.EmployeeName,
+                    Position = x.Position,
+                    StoreTotalPerformance = x.StoreTotalPerformance,
+                    StoreBillingPerformance = x.StoreBillingPerformance,
+                    StoreRefundPerformance = x.StoreRefundPerformance,
+                    StoreLifeline = x.StoreLifeline,
+                    PerformanceCompletionRate = x.PerformanceCompletionRate,
+                    PerformanceReached = x.PerformanceReached,
+                    HeadCountReached = x.HeadCountReached,
+                    ConsumeReached = x.ConsumeReached,
+                    AssessmentDeduction = x.AssessmentDeduction,
+                    UnreachedIndicatorCount = x.UnreachedIndicatorCount,
+                    HeadCount = x.HeadCount,
+                    TargetHeadCount = x.TargetHeadCount,
+                    StoreConsume = x.StoreConsume,
+                    TargetConsume = x.TargetConsume,
+                    SalesPerformance = x.SalesPerformance,
+                    ProductMaterial = x.ProductMaterial,
+                    CooperationCost = x.CooperationCost,
+                    StoreExpense = x.StoreExpense,
+                    LaundryCost = x.LaundryCost,
+                    GrossProfit = x.GrossProfit,
+                    CommissionRate = x.CommissionRate,
+                    CommissionAmount = x.CommissionAmount,
+                    BaseSalary = x.BaseSalary,
+                    FlagshipStoreDeduction = x.FlagshipStoreDeduction,
+                    ActualBaseSalary = x.ActualBaseSalary,
+                    WorkingDays = x.WorkingDays,
+                    LeaveDays = x.LeaveDays,
+                    GrossSalary = x.GrossSalary,
+                    ActualSalary = x.ActualSalary,
+                    TotalDeduction = x.TotalDeduction,
+                    TotalSubsidy = x.TotalSubsidy,
+                    Bonus = x.Bonus,
+                    MonthlyPaymentStatus = x.MonthlyPaymentStatus,
+                    PaidAmount = x.PaidAmount,
+                    PendingAmount = x.PendingAmount,
+                    IsLocked = x.IsLocked,
+                    StoreType = x.StoreType,
+                    StoreCategory = x.StoreCategory,
+                    IsNewStore = x.IsNewStore,
+                    NewStoreProtectionStage = x.NewStoreProtectionStage,
+                    UpdateTime = x.UpdateTime
+                })
+                .FirstAsync();
+            if (salary == null)
+                throw NCCException.Oh($"未找到员工{input.EmployeeId}在{input.Year}年{input.Month}月的工资记录");
+            return salary;
+        }
+
+        /// <summary>
         /// 计算店长工资
         /// </summary>
         /// <param name="year">年份</param>
@@ -546,12 +611,61 @@ namespace NCC.Extend
             // 3. 保存数据
             if (storeManagerSalaryList.Any())
             {
-                // 先删除当月旧数据 (防止重复)
-                await _db.Deleteable<LqStoreManagerSalaryStatisticsEntity>()
+                var existingRecords = await _db.Queryable<LqStoreManagerSalaryStatisticsEntity>()
                     .Where(x => x.StatisticsMonth == monthStr)
-                    .ExecuteCommandAsync();
+                    .ToListAsync();
+
+                var existingDict = existingRecords
+                    .Where(x => !string.IsNullOrEmpty(x.EmployeeId))
+                    .GroupBy(x => x.EmployeeId)
+                    .ToDictionary(g => g.Key, g => g.First());
+
+                var recordsToInsert = new List<LqStoreManagerSalaryStatisticsEntity>();
+                var recordsToUpdate = new List<LqStoreManagerSalaryStatisticsEntity>();
+                var skippedCount = 0;
+
+                foreach (var salary in storeManagerSalaryList)
+                {
+                    if (existingDict.ContainsKey(salary.EmployeeId))
+                    {
+                        var existing = existingDict[salary.EmployeeId];
+                        if (existing.IsLocked == 1 || existing.EmployeeConfirmStatus == 1)
+                        {
+                            skippedCount++;
+                            continue;
+                        }
+                        salary.Id = existing.Id;
+                        salary.EmployeeConfirmStatus = existing.EmployeeConfirmStatus;
+                        salary.EmployeeConfirmTime = existing.EmployeeConfirmTime;
+                        salary.EmployeeConfirmRemark = existing.EmployeeConfirmRemark;
+                        salary.IsLocked = existing.IsLocked;
+                        salary.CreateTime = existing.CreateTime;
+                        salary.CreateUser = existing.CreateUser;
+                        recordsToUpdate.Add(salary);
+                    }
+                    else
+                    {
+                        salary.Id = YitIdHelper.NextId().ToString();
+                        salary.EmployeeConfirmStatus = 0;
+                        salary.IsLocked = 0;
+                        salary.CreateTime = DateTime.Now;
+                        salary.CreateUser = "";
+                        recordsToInsert.Add(salary);
+                    }
+                }
  
-                await _db.Insertable(storeManagerSalaryList).ExecuteCommandAsync();
+                if (recordsToInsert.Any())
+                {
+                    await _db.Insertable(recordsToInsert).ExecuteCommandAsync();
+                }
+                if (recordsToUpdate.Any())
+                {
+                    await _db.Updateable(recordsToUpdate).ExecuteCommandAsync();
+                }
+                if (skippedCount > 0)
+                {
+                    _logger.LogWarning($"计算工资时跳过了 {skippedCount} 条已锁定或已确认的记录（月份：{monthStr}）");
+                }
             }
         }
  
@@ -628,6 +742,496 @@ namespace NCC.Extend
             salary.CommissionRate = commissionRate;
             salary.CommissionAmount = grossProfit * commissionRate;
         }
+
+        #region 员工工资确认
+
+        /// <summary>
+        /// 员工确认工资条
+        /// </summary>
+        /// <remarks>
+        /// 员工确认自己的工资条，确认后工资数据不可再修改
+        /// 
+        /// 示例请求：
+        /// <code>
+        /// {
+        ///   "id": "工资记录ID",
+        ///   "employeeId": "员工ID",
+        ///   "remark": "确认备注（可选）"
+        /// }
+        /// </code>
+        /// 
+        /// 参数说明：
+        /// - id: 工资记录ID（必填）
+        /// - employeeId: 员工ID（必填）
+        /// - remark: 确认备注（可选）
+        /// 
+        /// 注意事项：
+        /// - 只能确认自己的工资条
+        /// - 只能确认已锁定的工资条（IsLocked = 1）
+        /// - 已确认的工资条不能重复确认
+        /// </remarks>
+        /// <param name="input">确认参数</param>
+        /// <returns>操作结果</returns>
+        /// <response code="200">确认成功</response>
+        /// <response code="400">参数错误或记录不存在</response>
+        [HttpPost("confirm")]
+        public async Task<string> ConfirmSalary([FromBody] SalaryConfirmInput input)
+        {
+            try
+            {
+                if (string.IsNullOrWhiteSpace(input.Id) || string.IsNullOrWhiteSpace(input.EmployeeId))
+                {
+                    throw NCCException.Oh("工资记录ID和员工ID不能为空");
+                }
+
+                var salary = await _db.Queryable<LqStoreManagerSalaryStatisticsEntity>()
+                    .Where(s => s.Id == input.Id && s.EmployeeId == input.EmployeeId)
+                    .FirstAsync();
+
+                if (salary == null)
+                    throw NCCException.Oh("工资记录不存在或不属于该员工");
+                if (salary.EmployeeConfirmStatus == 1)
+                    throw NCCException.Oh("该工资条已确认，不能重复确认");
+                if (salary.IsLocked != 1)
+                    throw NCCException.Oh("该工资条尚未锁定，请等待管理员锁定后再确认");
+
+                salary.EmployeeConfirmStatus = 1;
+                salary.EmployeeConfirmTime = DateTime.Now;
+                salary.EmployeeConfirmRemark = input.Remark;
+                salary.UpdateTime = DateTime.Now;
+                await _db.Updateable(salary).ExecuteCommandAsync();
+                return "确认成功";
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"确认工资条失败: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        #region 工资锁定/解锁
+
+        /// <summary>
+        /// 批量锁定/解锁工资条
+        /// </summary>
+        [HttpPost("lock")]
+        public async Task<string> LockSalary([FromBody] SalaryLockInput input)
+        {
+            try
+            {
+                if (input == null || input.Ids == null || !input.Ids.Any())
+                    throw NCCException.Oh("工资记录ID列表不能为空");
+                var salaries = await _db.Queryable<LqStoreManagerSalaryStatisticsEntity>()
+                    .Where(s => input.Ids.Contains(s.Id))
+                    .ToListAsync();
+                if (!salaries.Any())
+                    throw NCCException.Oh("未找到指定的工资记录");
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+                foreach (var salary in salaries)
+                {
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+                    if (input.IsLocked) lockedCount++; else unlockedCount++;
+                }
+                await _db.Updateable(salaries).ExecuteCommandAsync();
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+                if (skippedCount > 0)
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+                return message;
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"锁定/解锁工资条失败: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// 批量锁定当月所有工资
+        /// </summary>
+        /// <remarks>
+        /// 批量锁定指定月份的所有店长工资记录
+        /// 
+        /// 示例请求：
+        /// ```json
+        /// {
+        ///   "year": 2025,
+        ///   "month": 12,
+        ///   "isLocked": true
+        /// }
+        /// ```
+        /// 
+        /// 参数说明：
+        /// - year: 年份（必填）
+        /// - month: 月份（1-12，必填）
+        /// - isLocked: 是否锁定（true=锁定，false=解锁，默认true）
+        /// 
+        /// 注意事项：
+        /// - 已确认的记录不能解锁
+        /// - 已锁定的记录再次锁定会跳过
+        /// </remarks>
+        /// <param name="input">批量锁定输入参数</param>
+        /// <returns>锁定结果</returns>
+        /// <response code="200">锁定成功</response>
+        /// <response code="400">参数错误</response>
+        [HttpPost("lock-by-month")]
+        public async Task<dynamic> LockSalaryByMonth([FromBody] SalaryLockByMonthInput input)
+        {
+            try
+            {
+                if (input == null)
+                    throw NCCException.Oh("参数不能为空");
+
+                if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+                    throw NCCException.Oh("年份和月份参数不正确");
+
+                var monthStr = $"{input.Year}{input.Month:D2}";
+
+                // 查询当月所有工资记录
+                var salaries = await _db.Queryable<LqStoreManagerSalaryStatisticsEntity>()
+                    .Where(s => s.StatisticsMonth == monthStr)
+                    .ToListAsync();
+
+                if (!salaries.Any())
+                    throw NCCException.Oh($"未找到{input.Year}年{input.Month}月的工资记录");
+
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+                var alreadyLockedCount = 0;
+
+                foreach (var salary in salaries)
+                {
+                    // 如果已确认，不能解锁
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+
+                    // 如果已经是锁定状态，再次锁定时跳过
+                    if (salary.IsLocked == 1 && input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    // 如果已经是解锁状态，再次解锁时跳过
+                    if (salary.IsLocked == 0 && !input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+
+                    if (input.IsLocked)
+                        lockedCount++;
+                    else
+                        unlockedCount++;
+                }
+
+                // 批量更新
+                if (lockedCount > 0 || unlockedCount > 0)
+                {
+                    var salariesToUpdate = salaries.Where(s => 
+                        (input.IsLocked && s.IsLocked == 0) || 
+                        (!input.IsLocked && s.IsLocked == 1 && s.EmployeeConfirmStatus != 1)
+                    ).ToList();
+                    
+                    if (salariesToUpdate.Any())
+                    {
+                        await _db.Updateable(salariesToUpdate)
+                            .UpdateColumns(s => new { s.IsLocked, s.UpdateTime })
+                            .ExecuteCommandAsync();
+                    }
+                }
+
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+                
+                if (alreadyLockedCount > 0)
+                    message += $"，跳过{alreadyLockedCount}条（已是{action}状态）";
+                
+                if (skippedCount > 0)
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+
+                return new
+                {
+                    success = true,
+                    message = message,
+                    total = salaries.Count,
+                    locked = lockedCount,
+                    unlocked = unlockedCount,
+                    skipped = skippedCount,
+                    alreadyLocked = alreadyLockedCount
+                };
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "批量锁定当月工资失败");
+                var action = input?.IsLocked == true ? "锁定" : "解锁";
+                throw NCCException.Oh($"批量{action}当月工资失败: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        #region 导入工资
+
+        /// <summary>
+        /// 从Excel导入店长工资数据
+        /// </summary>
+        /// <param name="file">Excel文件</param>
+        /// <returns>导入结果</returns>
+        [HttpPost("import")]
+        public async Task<dynamic> ImportSalaryFromExcel(IFormFile file)
+        {
+            try
+            {
+                if (file == null || file.Length == 0)
+                    throw NCCException.Oh("请选择要上传的Excel文件");
+                
+                var allowedExtensions = new[] { ".xlsx", ".xls" };
+                var fileExtension = Path.GetExtension(file.FileName).ToLowerInvariant();
+                if (!allowedExtensions.Contains(fileExtension))
+                    throw NCCException.Oh("只支持.xlsx和.xls格式的Excel文件");
+
+                var recordsToInsert = new List<LqStoreManagerSalaryStatisticsEntity>();
+                var recordsToUpdate = new List<LqStoreManagerSalaryStatisticsEntity>();
+                var errorMessages = new List<string>();
+                var successCount = 0;
+                var failCount = 0;
+                var skippedCount = 0;
+
+                var tempFilePath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + Path.GetExtension(file.FileName));
+                try
+                {
+                    using (var stream = new FileStream(tempFilePath, FileMode.Create))
+                    {
+                        await file.CopyToAsync(stream);
+                    }
+
+                    var dataTable = ExcelImportHelper.ToDataTable(tempFilePath, 0, 0);
+                    if (dataTable.Rows.Count == 0)
+                        throw NCCException.Oh("Excel文件中没有数据行");
+
+                    Func<string, decimal> ParseDecimal = (str) =>
+                    {
+                        if (string.IsNullOrWhiteSpace(str)) return 0;
+                        var cleaned = str.Trim().Replace(",", "").Replace("，", "").Replace("￥", "").Replace("$", "").Replace("元", "").Replace("%", "").Replace(" ", "");
+                        return decimal.TryParse(cleaned, out decimal result) ? result : 0;
+                    };
+
+                    Func<string, int> ParseInt = (str) =>
+                    {
+                        if (string.IsNullOrWhiteSpace(str)) return 0;
+                        var cleaned = str.Trim().Replace(",", "").Replace("，", "").Replace(" ", "");
+                        return int.TryParse(cleaned, out int result) ? result : 0;
+                    };
+
+                    for (int i = 1; i < dataTable.Rows.Count; i++)
+                    {
+                        try
+                        {
+                            var row = dataTable.Rows[i];
+                            Func<int, string> GetColumnValue = (colIndex) => colIndex < row.ItemArray.Length && row[colIndex] != null ? row[colIndex].ToString().Trim() : "";
+
+                            var firstColumnValue = GetColumnValue(0);
+                            bool isOldFormat = !string.IsNullOrWhiteSpace(firstColumnValue) && (firstColumnValue == "门店名称" || (!long.TryParse(firstColumnValue, out _) && firstColumnValue.Length > 20));
+                            
+                            int storeNameIndex = isOldFormat ? 0 : 1;
+                            int employeeNameIndex = isOldFormat ? 1 : 2;
+                            int offset = isOldFormat ? 0 : 1;
+
+                            var id = isOldFormat ? "" : GetColumnValue(0);
+                            var employeeName = GetColumnValue(employeeNameIndex);
+                            var storeName = GetColumnValue(storeNameIndex);
+
+                            if (string.IsNullOrWhiteSpace(id) && string.IsNullOrWhiteSpace(employeeName))
+                                continue;
+
+                            if (string.IsNullOrWhiteSpace(id) && !string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                var matchedRecord = await _db.Queryable<LqStoreManagerSalaryStatisticsEntity>()
+                                    .Where(x => x.EmployeeName == employeeName)
+                                    .WhereIF(!string.IsNullOrWhiteSpace(storeName), x => x.StoreName == storeName)
+                                    .OrderBy(x => x.CreateTime, OrderByType.Desc)
+                                    .FirstAsync();
+                                if (matchedRecord != null) id = matchedRecord.Id;
+                            }
+
+                            if (string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                errorMessages.Add($"第{i + 1}行：员工姓名不能为空");
+                                failCount++;
+                                continue;
+                            }
+
+                            LqStoreManagerSalaryStatisticsEntity existing = null;
+                            if (!string.IsNullOrWhiteSpace(id))
+                            {
+                                existing = await _db.Queryable<LqStoreManagerSalaryStatisticsEntity>()
+                                    .Where(x => x.Id == id).FirstAsync();
+                                
+                                if (existing != null && (existing.IsLocked == 1 || existing.EmployeeConfirmStatus == 1))
+                                {
+                                    skippedCount++;
+                                    failCount++;
+                                    continue;
+                                }
+                            }
+
+                            var entity = existing ?? new LqStoreManagerSalaryStatisticsEntity
+                            {
+                                Id = string.IsNullOrWhiteSpace(id) ? YitIdHelper.NextId().ToString() : id,
+                                EmployeeConfirmStatus = 0,
+                                IsLocked = 0,
+                                CreateTime = DateTime.Now,
+                                CreateUser = ""
+                            };
+
+                            // Excel字段映射（店长工资55列，第一列为ID）
+                            entity.StoreName = storeName;
+                            entity.EmployeeName = employeeName;
+                            entity.Position = GetColumnValue(2 + offset);
+                            entity.StoreBillingPerformance = ParseDecimal(GetColumnValue(3 + offset));
+                            entity.StoreRefundPerformance = ParseDecimal(GetColumnValue(4 + offset));
+                            entity.StoreTotalPerformance = ParseDecimal(GetColumnValue(5 + offset));
+                            entity.StoreLifeline = ParseDecimal(GetColumnValue(6 + offset));
+                            entity.PerformanceCompletionRate = ParseDecimal(GetColumnValue(7 + offset));
+                            entity.PerformanceReached = GetColumnValue(8 + offset);
+                            entity.HeadCount = ParseInt(GetColumnValue(9 + offset));
+                            entity.TargetHeadCount = ParseDecimal(GetColumnValue(10 + offset));
+                            entity.HeadCountReached = GetColumnValue(11 + offset);
+                            entity.StoreConsume = ParseDecimal(GetColumnValue(12 + offset));
+                            entity.TargetConsume = ParseDecimal(GetColumnValue(13 + offset));
+                            entity.ConsumeReached = GetColumnValue(14 + offset);
+                            entity.UnreachedIndicatorCount = ParseInt(GetColumnValue(15 + offset));
+                            entity.AssessmentDeduction = ParseDecimal(GetColumnValue(16 + offset));
+                            entity.GrossProfit = ParseDecimal(GetColumnValue(17 + offset));
+                            entity.CommissionRate = ParseDecimal(GetColumnValue(18 + offset));
+                            entity.CommissionAmount = ParseDecimal(GetColumnValue(19 + offset));
+                            entity.BaseSalary = ParseDecimal(GetColumnValue(20 + offset));
+                            entity.ActualBaseSalary = ParseDecimal(GetColumnValue(21 + offset));
+                            entity.GrossSalary = ParseDecimal(GetColumnValue(22 + offset));
+                            entity.WorkingDays = ParseInt(GetColumnValue(23 + offset));
+                            entity.LeaveDays = ParseInt(GetColumnValue(24 + offset));
+                            // Excel中的车补(25)、少休费(26)、全勤奖(27)字段在实体类中没有对应字段，跳过
+                            entity.MonthlyTrainingSubsidy = ParseDecimal(GetColumnValue(28 + offset));
+                            entity.MonthlyTransportSubsidy = ParseDecimal(GetColumnValue(29 + offset));
+                            entity.LastMonthTrainingSubsidy = ParseDecimal(GetColumnValue(30 + offset));
+                            entity.LastMonthTransportSubsidy = ParseDecimal(GetColumnValue(31 + offset));
+                            entity.TotalSubsidy = ParseDecimal(GetColumnValue(32 + offset));
+                            entity.MissingCard = ParseDecimal(GetColumnValue(33 + offset));
+                            entity.LateArrival = ParseDecimal(GetColumnValue(34 + offset));
+                            entity.LeaveDeduction = ParseDecimal(GetColumnValue(35 + offset));
+                            entity.SocialInsuranceDeduction = ParseDecimal(GetColumnValue(36 + offset));
+                            entity.RewardDeduction = ParseDecimal(GetColumnValue(37 + offset));
+                            entity.AccommodationDeduction = ParseDecimal(GetColumnValue(38 + offset));
+                            entity.StudyPeriodDeduction = ParseDecimal(GetColumnValue(39 + offset));
+                            entity.WorkClothesDeduction = ParseDecimal(GetColumnValue(40 + offset));
+                            entity.TotalDeduction = ParseDecimal(GetColumnValue(41 + offset));
+                            entity.Bonus = ParseDecimal(GetColumnValue(42 + offset));
+                            entity.ReturnPhoneDeposit = ParseDecimal(GetColumnValue(43 + offset));
+                            entity.ReturnAccommodationDeposit = ParseDecimal(GetColumnValue(44 + offset));
+                            entity.LastMonthSupplement = ParseDecimal(GetColumnValue(45 + offset));
+                            entity.ActualSalary = ParseDecimal(GetColumnValue(46 + offset));
+                            entity.MonthlyPaymentStatus = GetColumnValue(47 + offset);
+                            entity.PaidAmount = ParseDecimal(GetColumnValue(48 + offset));
+                            entity.PendingAmount = ParseDecimal(GetColumnValue(49 + offset));
+                            entity.MonthlyTotalPayment = ParseDecimal(GetColumnValue(50 + offset));
+                            // 处理门店分类（Excel中可能是"A类"、"B类"、"C类"）
+                            var storeCategoryStr = GetColumnValue(51 + offset);
+                            if (!string.IsNullOrWhiteSpace(storeCategoryStr))
+                            {
+                                if (storeCategoryStr.Contains("A") || storeCategoryStr == "1") entity.StoreCategory = 1;
+                                else if (storeCategoryStr.Contains("B") || storeCategoryStr == "2") entity.StoreCategory = 2;
+                                else if (storeCategoryStr.Contains("C") || storeCategoryStr == "3") entity.StoreCategory = 3;
+                            }
+                            entity.IsNewStore = GetColumnValue(52 + offset) == "是" ? "是" : "否";
+                            entity.NewStoreProtectionStage = ParseInt(GetColumnValue(53 + offset));
+                            // 处理锁定状态（第55列，索引54）
+                            var isLockedStr = GetColumnValue(54 + offset);
+                            if (isLockedStr == "已锁定" || isLockedStr == "1") entity.IsLocked = 1;
+                            else entity.IsLocked = 0;
+
+                            if (existing != null)
+                            {
+                                entity.StoreId = existing.StoreId;
+                                entity.EmployeeId = existing.EmployeeId;
+                                entity.StatisticsMonth = existing.StatisticsMonth;
+                            }
+                            else
+                            {
+                                if (!string.IsNullOrWhiteSpace(employeeName))
+                                {
+                                    var user = await _db.Queryable<UserEntity>()
+                                        .Where(u => u.RealName == employeeName).FirstAsync();
+                                    if (user != null)
+                                    {
+                                        entity.EmployeeId = user.Id;
+                                        if (!string.IsNullOrEmpty(user.Mdid) && string.IsNullOrWhiteSpace(storeName))
+                                            entity.StoreId = user.Mdid;
+                                    }
+                                    
+                                    if (!string.IsNullOrWhiteSpace(storeName) && string.IsNullOrEmpty(entity.StoreId))
+                                    {
+                                        var store = await _db.Queryable<LqMdxxEntity>()
+                                            .Where(s => s.Dm == storeName).FirstAsync();
+                                        if (store != null) entity.StoreId = store.Id;
+                                    }
+                                }
+                            }
+                            
+                            entity.UpdateTime = DateTime.Now;
+                            if (existing != null) recordsToUpdate.Add(entity);
+                            else recordsToInsert.Add(entity);
+                            successCount++;
+                        }
+                        catch (Exception ex)
+                        {
+                            errorMessages.Add($"第{i + 1}行数据处理失败: {ex.Message}");
+                            failCount++;
+                        }
+                    }
+                }
+                finally
+                {
+                    if (File.Exists(tempFilePath)) File.Delete(tempFilePath);
+                }
+
+                if (recordsToInsert.Any()) await _db.Insertable(recordsToInsert).ExecuteCommandAsync();
+                if (recordsToUpdate.Any()) await _db.Updateable(recordsToUpdate).ExecuteCommandAsync();
+
+                return new
+                {
+                    success = true,
+                    message = $"导入完成：成功 {successCount} 条，失败 {failCount} 条，跳过 {skippedCount} 条（已锁定或已确认）",
+                    successCount,
+                    failCount,
+                    skippedCount,
+                    errors = errorMessages
+                };
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"导入店长工资数据失败: {ex.Message}");
+            }
+        }
+
+        #endregion
     }
 }
  
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
 using NCC.Common.Filter;
 using NCC.Common.Helper;
 using NCC.Dependency;
 using NCC.DynamicApiController;
+using NCC.Extend.Entitys.Dto.LqSalary;
 using NCC.Extend.Entitys.Dto.LqTechGeneralManagerSalary;
 using NCC.Extend.Entitys.lq_attendance_summary;
 using NCC.Extend.Entitys.lq_hytk_hytk;
@@ -16,14 +18,18 @@ using NCC.Extend.Entitys.lq_md_general_manager_lifeline;
 using NCC.Extend.Entitys.lq_mdxx;
 using NCC.Extend.Entitys.lq_tech_general_manager_salary_statistics;
 using NCC.Extend.Entitys.lq_xmzl;
+using NCC.FriendlyException;
 using NCC.System.Entitys.Permission;
 using SqlSugar;
 using System;
 using System.Collections.Generic;
+using System.Data;
+using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using Yitter.IdGenerator;
 using Newtonsoft.Json;
+using Microsoft.AspNetCore.Http;
  
 namespace NCC.Extend
 {
@@ -35,13 +41,15 @@ namespace NCC.Extend
     public class LqTechGeneralManagerSalaryService : IDynamicApiController, ITransient
     {
         private readonly ISqlSugarClient _db;
+        private readonly ILogger<LqTechGeneralManagerSalaryService> _logger;
  
         /// <summary>
         /// 初始化一个<see cref="LqTechGeneralManagerSalaryService"/>类型的新实例
         /// </summary>
-        public LqTechGeneralManagerSalaryService(ISqlSugarClient db)
+        public LqTechGeneralManagerSalaryService(ISqlSugarClient db, ILogger<LqTechGeneralManagerSalaryService> logger)
         {
             _db = db;
+            _logger = logger;
         }
  
         /// <summary>
@@ -54,17 +62,7 @@ namespace NCC.Extend
         {
             var monthStr = $"{input.Year}{input.Month:D2}";
  
-            // 1. 检查当月是否已生成工资数据
-            var exists = await _db.Queryable<LqTechGeneralManagerSalaryStatisticsEntity>()
-                .AnyAsync(x => x.StatisticsMonth == monthStr);
-
-            // 2. 如果没有数据，则进行计算
-            if (!exists)
-            {
-                await CalculateTechGeneralManagerSalary(input.Year, input.Month);
-            }
-
-            // 3. 查询数据
+            // 查询数据
             var query = _db.Queryable<LqTechGeneralManagerSalaryStatisticsEntity>()
                 .Where(x => x.StatisticsMonth == monthStr);
  
@@ -132,6 +130,73 @@ namespace NCC.Extend
         }
  
         /// <summary>
+        /// 通过月份和员工ID查询工资
+        /// </summary>
+        [HttpGet("query-by-employee")]
+        public async Task<TechGeneralManagerSalaryOutput> GetSalaryByEmployee([FromQuery] SalaryQueryByEmployeeInput input)
+        {
+            if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+                throw NCCException.Oh("年份和月份参数不正确");
+            if (string.IsNullOrWhiteSpace(input.EmployeeId))
+                throw NCCException.Oh("员工ID不能为空");
+            var monthStr = $"{input.Year}{input.Month:D2}";
+            var salary = await _db.Queryable<LqTechGeneralManagerSalaryStatisticsEntity>()
+                .Where(x => x.StatisticsMonth == monthStr && x.EmployeeId == input.EmployeeId)
+                .Select(x => new TechGeneralManagerSalaryOutput
+                {
+                    Id = x.Id,
+                    StatisticsMonth = x.StatisticsMonth,
+                    Position = x.Position,
+                    EmployeeName = x.EmployeeName,
+                    EmployeeId = x.EmployeeId,
+                    EmployeeAccount = x.EmployeeAccount,
+                    IsTerminated = x.IsTerminated,
+                    StoreDetail = x.StoreDetail,
+                    TraceabilityAmount = x.TraceabilityAmount,
+                    CellAmount = x.CellAmount,
+                    BaseSalary = x.BaseSalary,
+                    TraceabilityCommissionRate = x.TraceabilityCommissionRate,
+                    TraceabilityCommissionAmount = x.TraceabilityCommissionAmount,
+                    CellCommissionRate = x.CellCommissionRate,
+                    CellCommissionAmount = x.CellCommissionAmount,
+                    TotalCommission = x.TotalCommission,
+                    WorkingDays = x.WorkingDays,
+                    LeaveDays = x.LeaveDays,
+                    CalculatedGrossSalary = x.CalculatedGrossSalary,
+                    FinalGrossSalary = x.FinalGrossSalary,
+                    MonthlyTrainingSubsidy = x.MonthlyTrainingSubsidy,
+                    MonthlyTransportSubsidy = x.MonthlyTransportSubsidy,
+                    LastMonthTrainingSubsidy = x.LastMonthTrainingSubsidy,
+                    LastMonthTransportSubsidy = x.LastMonthTransportSubsidy,
+                    TotalSubsidy = x.TotalSubsidy,
+                    MissingCard = x.MissingCard,
+                    LateArrival = x.LateArrival,
+                    LeaveDeduction = x.LeaveDeduction,
+                    SocialInsuranceDeduction = x.SocialInsuranceDeduction,
+                    RewardDeduction = x.RewardDeduction,
+                    AccommodationDeduction = x.AccommodationDeduction,
+                    StudyPeriodDeduction = x.StudyPeriodDeduction,
+                    WorkClothesDeduction = x.WorkClothesDeduction,
+                    TotalDeduction = x.TotalDeduction,
+                    Bonus = x.Bonus,
+                    ReturnPhoneDeposit = x.ReturnPhoneDeposit,
+                    ReturnAccommodationDeposit = x.ReturnAccommodationDeposit,
+                    ActualSalary = x.ActualSalary,
+                    MonthlyPaymentStatus = x.MonthlyPaymentStatus,
+                    PaidAmount = x.PaidAmount,
+                    PendingAmount = x.PendingAmount,
+                    LastMonthSupplement = x.LastMonthSupplement,
+                    MonthlyTotalPayment = x.MonthlyTotalPayment,
+                    IsLocked = x.IsLocked,
+                    UpdateTime = x.UpdateTime
+                })
+                .FirstAsync();
+            if (salary == null)
+                throw NCCException.Oh($"未找到员工{input.EmployeeId}在{input.Year}年{input.Month}月的工资记录");
+            return salary;
+        }
+
+        /// <summary>
         /// 计算科技部总经理工资
         /// </summary>
         /// <param name="year">年份</param>
@@ -429,12 +494,41 @@ namespace NCC.Extend
             // 3. 保存数据
             if (managerStats.Any())
             {
-                // 先删除当月旧数据 (防止重复)
-                await _db.Deleteable<LqTechGeneralManagerSalaryStatisticsEntity>()
-                    .Where(x => x.StatisticsMonth == monthStr)
-                    .ExecuteCommandAsync();
-
-                await _db.Insertable(managerStats.Values.ToList()).ExecuteCommandAsync();
+                var existingRecords = await _db.Queryable<LqTechGeneralManagerSalaryStatisticsEntity>()
+                    .Where(x => x.StatisticsMonth == monthStr).ToListAsync();
+                var existingDict = existingRecords.Where(x => !string.IsNullOrEmpty(x.EmployeeId))
+                    .GroupBy(x => x.EmployeeId).ToDictionary(g => g.Key, g => g.First());
+                var recordsToInsert = new List<LqTechGeneralManagerSalaryStatisticsEntity>();
+                var recordsToUpdate = new List<LqTechGeneralManagerSalaryStatisticsEntity>();
+                var skippedCount = 0;
+                foreach (var salary in managerStats.Values)
+                {
+                    if (existingDict.ContainsKey(salary.EmployeeId))
+                    {
+                        var existing = existingDict[salary.EmployeeId];
+                        if (existing.IsLocked == 1 || existing.EmployeeConfirmStatus == 1) { skippedCount++; continue; }
+                        salary.Id = existing.Id;
+                        salary.EmployeeConfirmStatus = existing.EmployeeConfirmStatus;
+                        salary.EmployeeConfirmTime = existing.EmployeeConfirmTime;
+                        salary.EmployeeConfirmRemark = existing.EmployeeConfirmRemark;
+                        salary.IsLocked = existing.IsLocked;
+                        salary.CreateTime = existing.CreateTime;
+                        salary.CreateUser = existing.CreateUser;
+                        recordsToUpdate.Add(salary);
+                    }
+                    else
+                    {
+                        salary.Id = YitIdHelper.NextId().ToString();
+                        salary.EmployeeConfirmStatus = 0;
+                        salary.IsLocked = 0;
+                        salary.CreateTime = DateTime.Now;
+                        salary.CreateUser = "";
+                        recordsToInsert.Add(salary);
+                    }
+                }
+                if (recordsToInsert.Any()) await _db.Insertable(recordsToInsert).ExecuteCommandAsync();
+                if (recordsToUpdate.Any()) await _db.Updateable(recordsToUpdate).ExecuteCommandAsync();
+                if (skippedCount > 0) _logger.LogWarning($"计算工资时跳过了 {skippedCount} 条已锁定或已确认的记录（月份：{monthStr}）");
             }
         }
  
@@ -530,8 +624,424 @@ namespace NCC.Extend
             public decimal TraceabilityAmount { get; set; }
             public decimal CellBillingAmount { get; set; }
             public decimal CellRefundAmount { get; set; }
-            public decimal CellAmount { get; set; }
+            public decimal CellAmount { get; set;             }
+        }
+
+        #region 员工工资确认
+
+        /// <summary>
+        /// 员工确认工资条
+        /// </summary>
+        /// <remarks>
+        /// 员工确认自己的工资条，确认后工资数据不可再修改
+        /// 
+        /// 示例请求：
+        /// <code>
+        /// {
+        ///   "id": "工资记录ID",
+        ///   "employeeId": "员工ID",
+        ///   "remark": "确认备注（可选）"
+        /// }
+        /// </code>
+        /// 
+        /// 参数说明：
+        /// - id: 工资记录ID（必填）
+        /// - employeeId: 员工ID（必填）
+        /// - remark: 确认备注（可选）
+        /// 
+        /// 注意事项：
+        /// - 只能确认自己的工资条
+        /// - 只能确认已锁定的工资条（IsLocked = 1）
+        /// - 已确认的工资条不能重复确认
+        /// </remarks>
+        /// <param name="input">确认参数</param>
+        /// <returns>操作结果</returns>
+        /// <response code="200">确认成功</response>
+        /// <response code="400">参数错误或记录不存在</response>
+        [HttpPost("confirm")]
+        public async Task<string> ConfirmSalary([FromBody] SalaryConfirmInput input)
+        {
+            try
+            {
+                if (string.IsNullOrWhiteSpace(input.Id) || string.IsNullOrWhiteSpace(input.EmployeeId))
+                    throw NCCException.Oh("工资记录ID和员工ID不能为空");
+                var salary = await _db.Queryable<LqTechGeneralManagerSalaryStatisticsEntity>()
+                    .Where(s => s.Id == input.Id && s.EmployeeId == input.EmployeeId).FirstAsync();
+                if (salary == null) throw NCCException.Oh("工资记录不存在或不属于该员工");
+                if (salary.EmployeeConfirmStatus == 1) throw NCCException.Oh("该工资条已确认，不能重复确认");
+                if (salary.IsLocked != 1) throw NCCException.Oh("该工资条尚未锁定，请等待管理员锁定后再确认");
+                salary.EmployeeConfirmStatus = 1;
+                salary.EmployeeConfirmTime = DateTime.Now;
+                salary.EmployeeConfirmRemark = input.Remark;
+                salary.UpdateTime = DateTime.Now;
+                await _db.Updateable(salary).ExecuteCommandAsync();
+                return "确认成功";
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"确认工资条失败: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        #region 工资锁定/解锁
+
+        /// <summary>
+        /// 批量锁定/解锁工资条
+        /// </summary>
+        [HttpPost("lock")]
+        public async Task<string> LockSalary([FromBody] SalaryLockInput input)
+        {
+            try
+            {
+                if (input == null || input.Ids == null || !input.Ids.Any())
+                    throw NCCException.Oh("工资记录ID列表不能为空");
+                var salaries = await _db.Queryable<LqTechGeneralManagerSalaryStatisticsEntity>()
+                    .Where(s => input.Ids.Contains(s.Id))
+                    .ToListAsync();
+                if (!salaries.Any())
+                    throw NCCException.Oh("未找到指定的工资记录");
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+                foreach (var salary in salaries)
+                {
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+                    if (input.IsLocked) lockedCount++; else unlockedCount++;
+                }
+                await _db.Updateable(salaries).ExecuteCommandAsync();
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+                if (skippedCount > 0)
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+                return message;
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"锁定/解锁工资条失败: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// 批量锁定当月所有工资
+        /// </summary>
+        /// <param name="input">批量锁定输入参数</param>
+        /// <returns>锁定结果</returns>
+        [HttpPost("lock-by-month")]
+        public async Task<dynamic> LockSalaryByMonth([FromBody] SalaryLockByMonthInput input)
+        {
+            try
+            {
+                if (input == null)
+                    throw NCCException.Oh("参数不能为空");
+
+                if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+                    throw NCCException.Oh("年份和月份参数不正确");
+
+                var monthStr = $"{input.Year}{input.Month:D2}";
+
+                var salaries = await _db.Queryable<LqTechGeneralManagerSalaryStatisticsEntity>()
+                    .Where(s => s.StatisticsMonth == monthStr)
+                    .ToListAsync();
+
+                if (!salaries.Any())
+                    throw NCCException.Oh($"未找到{input.Year}年{input.Month}月的工资记录");
+
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+                var alreadyLockedCount = 0;
+
+                foreach (var salary in salaries)
+                {
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+
+                    if (salary.IsLocked == 1 && input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    if (salary.IsLocked == 0 && !input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+
+                    if (input.IsLocked)
+                        lockedCount++;
+                    else
+                        unlockedCount++;
+                }
+
+                if (lockedCount > 0 || unlockedCount > 0)
+                {
+                    var salariesToUpdate = salaries.Where(s => 
+                        (input.IsLocked && s.IsLocked == 0) || 
+                        (!input.IsLocked && s.IsLocked == 1 && s.EmployeeConfirmStatus != 1)
+                    ).ToList();
+                    
+                    if (salariesToUpdate.Any())
+                    {
+                        await _db.Updateable(salariesToUpdate)
+                            .UpdateColumns(s => new { s.IsLocked, s.UpdateTime })
+                            .ExecuteCommandAsync();
+                    }
+                }
+
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+                
+                if (alreadyLockedCount > 0)
+                    message += $"，跳过{alreadyLockedCount}条（已是{action}状态）";
+                
+                if (skippedCount > 0)
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+
+                return new
+                {
+                    success = true,
+                    message = message,
+                    total = salaries.Count,
+                    locked = lockedCount,
+                    unlocked = unlockedCount,
+                    skipped = skippedCount,
+                    alreadyLocked = alreadyLockedCount
+                };
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "批量锁定当月工资失败");
+                var action = input?.IsLocked == true ? "锁定" : "解锁";
+                throw NCCException.Oh($"批量{action}当月工资失败: {ex.Message}");
+            }
         }
+
+        #endregion
+
+        #region 导入工资
+
+        /// <summary>
+        /// 从Excel导入科技部总经理工资数据
+        /// </summary>
+        /// <param name="file">Excel文件</param>
+        /// <returns>导入结果</returns>
+        [HttpPost("import")]
+        public async Task<dynamic> ImportSalaryFromExcel(IFormFile file)
+        {
+            try
+            {
+                if (file == null || file.Length == 0)
+                    throw NCCException.Oh("请选择要上传的Excel文件");
+                
+                var allowedExtensions = new[] { ".xlsx", ".xls" };
+                var fileExtension = Path.GetExtension(file.FileName).ToLowerInvariant();
+                if (!allowedExtensions.Contains(fileExtension))
+                    throw NCCException.Oh("只支持.xlsx和.xls格式的Excel文件");
+
+                var recordsToInsert = new List<LqTechGeneralManagerSalaryStatisticsEntity>();
+                var recordsToUpdate = new List<LqTechGeneralManagerSalaryStatisticsEntity>();
+                var errorMessages = new List<string>();
+                var successCount = 0;
+                var failCount = 0;
+                var skippedCount = 0;
+
+                var tempFilePath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + Path.GetExtension(file.FileName));
+                try
+                {
+                    using (var stream = new FileStream(tempFilePath, FileMode.Create))
+                    {
+                        await file.CopyToAsync(stream);
+                    }
+
+                    var dataTable = ExcelImportHelper.ToDataTable(tempFilePath, 0, 0);
+                    if (dataTable.Rows.Count == 0)
+                        throw NCCException.Oh("Excel文件中没有数据行");
+
+                    Func<string, decimal> ParseDecimal = (str) =>
+                    {
+                        if (string.IsNullOrWhiteSpace(str)) return 0;
+                        var cleaned = str.Trim().Replace(",", "").Replace("，", "").Replace("￥", "").Replace("$", "").Replace("元", "").Replace("%", "").Replace(" ", "");
+                        return decimal.TryParse(cleaned, out decimal result) ? result : 0;
+                    };
+
+                    Func<string, int> ParseInt = (str) =>
+                    {
+                        if (string.IsNullOrWhiteSpace(str)) return 0;
+                        var cleaned = str.Trim().Replace(",", "").Replace("，", "").Replace(" ", "");
+                        return int.TryParse(cleaned, out int result) ? result : 0;
+                    };
+
+                    for (int i = 1; i < dataTable.Rows.Count; i++)
+                    {
+                        try
+                        {
+                            var row = dataTable.Rows[i];
+                            Func<int, string> GetColumnValue = (colIndex) => colIndex < row.ItemArray.Length && row[colIndex] != null ? row[colIndex].ToString().Trim() : "";
+
+                            var firstColumnValue = GetColumnValue(0);
+                            bool isOldFormat = !string.IsNullOrWhiteSpace(firstColumnValue) && (firstColumnValue == "员工姓名" || (!long.TryParse(firstColumnValue, out _) && firstColumnValue.Length > 20));
+                            
+                            int employeeNameIndex = isOldFormat ? 0 : 1;
+                            int offset = isOldFormat ? 0 : 1;
+
+                            var id = isOldFormat ? "" : GetColumnValue(0);
+                            var employeeName = GetColumnValue(employeeNameIndex);
+
+                            if (string.IsNullOrWhiteSpace(id) && string.IsNullOrWhiteSpace(employeeName))
+                                continue;
+
+                            if (string.IsNullOrWhiteSpace(id) && !string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                var matchedRecord = await _db.Queryable<LqTechGeneralManagerSalaryStatisticsEntity>()
+                                    .Where(x => x.EmployeeName == employeeName)
+                                    .OrderBy(x => x.CreateTime, OrderByType.Desc)
+                                    .FirstAsync();
+                                if (matchedRecord != null) id = matchedRecord.Id;
+                            }
+
+                            if (string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                errorMessages.Add($"第{i + 1}行：员工姓名不能为空");
+                                failCount++;
+                                continue;
+                            }
+
+                            LqTechGeneralManagerSalaryStatisticsEntity existing = null;
+                            if (!string.IsNullOrWhiteSpace(id))
+                            {
+                                existing = await _db.Queryable<LqTechGeneralManagerSalaryStatisticsEntity>()
+                                    .Where(x => x.Id == id).FirstAsync();
+                                
+                                if (existing != null && (existing.IsLocked == 1 || existing.EmployeeConfirmStatus == 1))
+                                {
+                                    skippedCount++;
+                                    failCount++;
+                                    continue;
+                                }
+                            }
+
+                            var entity = existing ?? new LqTechGeneralManagerSalaryStatisticsEntity
+                            {
+                                Id = string.IsNullOrWhiteSpace(id) ? YitIdHelper.NextId().ToString() : id,
+                                EmployeeConfirmStatus = 0,
+                                IsLocked = 0,
+                                CreateTime = DateTime.Now,
+                                CreateUser = ""
+                            };
+
+                            // Excel字段映射（科技部总经理工资41列：员工姓名,员工账号,核算岗位,统计月份,是否离职,溯源金额,Cell金额,底薪,溯源金额提成比例,溯源金额提成金额,Cell金额提成比例,Cell金额提成金额,提成合计...）
+                            entity.EmployeeName = employeeName;
+                            entity.EmployeeAccount = GetColumnValue(1 + offset);
+                            entity.Position = GetColumnValue(2 + offset);
+                            entity.StatisticsMonth = GetColumnValue(3 + offset);
+                            entity.IsTerminated = GetColumnValue(4 + offset) == "离职" || GetColumnValue(4 + offset) == "1" ? 1 : 0;
+                            entity.TraceabilityAmount = ParseDecimal(GetColumnValue(5 + offset));
+                            entity.CellAmount = ParseDecimal(GetColumnValue(6 + offset));
+                            entity.BaseSalary = ParseDecimal(GetColumnValue(7 + offset));
+                            entity.TraceabilityCommissionRate = ParseDecimal(GetColumnValue(8 + offset));
+                            entity.TraceabilityCommissionAmount = ParseDecimal(GetColumnValue(9 + offset));
+                            entity.CellCommissionRate = ParseDecimal(GetColumnValue(10 + offset));
+                            entity.CellCommissionAmount = ParseDecimal(GetColumnValue(11 + offset));
+                            entity.TotalCommission = ParseDecimal(GetColumnValue(12 + offset));
+                            entity.WorkingDays = ParseDecimal(GetColumnValue(13 + offset));
+                            entity.LeaveDays = ParseDecimal(GetColumnValue(14 + offset));
+                            entity.CalculatedGrossSalary = ParseDecimal(GetColumnValue(15 + offset));
+                            entity.FinalGrossSalary = ParseDecimal(GetColumnValue(16 + offset));
+                            entity.MonthlyTrainingSubsidy = ParseDecimal(GetColumnValue(17 + offset));
+                            entity.MonthlyTransportSubsidy = ParseDecimal(GetColumnValue(18 + offset));
+                            entity.LastMonthTrainingSubsidy = ParseDecimal(GetColumnValue(19 + offset));
+                            entity.LastMonthTransportSubsidy = ParseDecimal(GetColumnValue(20 + offset));
+                            entity.TotalSubsidy = ParseDecimal(GetColumnValue(21 + offset));
+                            entity.MissingCard = ParseDecimal(GetColumnValue(22 + offset));
+                            entity.LateArrival = ParseDecimal(GetColumnValue(23 + offset));
+                            entity.LeaveDeduction = ParseDecimal(GetColumnValue(24 + offset));
+                            entity.SocialInsuranceDeduction = ParseDecimal(GetColumnValue(25 + offset));
+                            entity.RewardDeduction = ParseDecimal(GetColumnValue(26 + offset));
+                            entity.AccommodationDeduction = ParseDecimal(GetColumnValue(27 + offset));
+                            entity.StudyPeriodDeduction = ParseDecimal(GetColumnValue(28 + offset));
+                            entity.WorkClothesDeduction = ParseDecimal(GetColumnValue(29 + offset));
+                            entity.TotalDeduction = ParseDecimal(GetColumnValue(30 + offset));
+                            entity.Bonus = ParseDecimal(GetColumnValue(31 + offset));
+                            entity.ReturnPhoneDeposit = ParseDecimal(GetColumnValue(32 + offset));
+                            entity.ReturnAccommodationDeposit = ParseDecimal(GetColumnValue(33 + offset));
+                            entity.LastMonthSupplement = ParseDecimal(GetColumnValue(34 + offset));
+                            entity.ActualSalary = ParseDecimal(GetColumnValue(35 + offset));
+                            entity.MonthlyPaymentStatus = GetColumnValue(36 + offset);
+                            entity.PaidAmount = ParseDecimal(GetColumnValue(37 + offset));
+                            entity.PendingAmount = ParseDecimal(GetColumnValue(38 + offset));
+                            entity.MonthlyTotalPayment = ParseDecimal(GetColumnValue(39 + offset));
+                            var isLockedStr = GetColumnValue(40 + offset);
+                            entity.IsLocked = isLockedStr == "已锁定" || isLockedStr == "1" || isLockedStr == "锁定" ? 1 : 0;
+
+                            if (existing != null)
+                            {
+                                entity.EmployeeId = existing.EmployeeId;
+                                entity.StoreDetail = existing.StoreDetail;
+                            }
+                            else
+                            {
+                                if (!string.IsNullOrWhiteSpace(employeeName))
+                                {
+                                    var user = await _db.Queryable<UserEntity>()
+                                        .Where(u => u.RealName == employeeName).FirstAsync();
+                                    if (user != null) entity.EmployeeId = user.Id;
+                                }
+                            }
+                            
+                            entity.UpdateTime = DateTime.Now;
+                            if (existing != null) recordsToUpdate.Add(entity);
+                            else recordsToInsert.Add(entity);
+                            successCount++;
+                        }
+                        catch (Exception ex)
+                        {
+                            errorMessages.Add($"第{i + 1}行数据处理失败: {ex.Message}");
+                            failCount++;
+                        }
+                    }
+                }
+                finally
+                {
+                    if (File.Exists(tempFilePath)) File.Delete(tempFilePath);
+                }
+
+                if (recordsToInsert.Any()) await _db.Insertable(recordsToInsert).ExecuteCommandAsync();
+                if (recordsToUpdate.Any()) await _db.Updateable(recordsToUpdate).ExecuteCommandAsync();
+
+                return new
+                {
+                    success = true,
+                    message = $"导入完成：成功 {successCount} 条，失败 {failCount} 条，跳过 {skippedCount} 条（已锁定或已确认）",
+                    successCount,
+                    failCount,
+                    skippedCount,
+                    errors = errorMessages
+                };
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"导入科技部总经理工资数据失败: {ex.Message}");
+            }
+        }
+
+        #endregion
     }
 }
  
 using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
 using NCC.Common.Filter;
 using NCC.Common.Helper;
 using NCC.Dependency;
 using NCC.DynamicApiController;
+using NCC.Extend.Entitys.Dto.LqSalary;
 using NCC.Extend.Entitys.Dto.LqTechTeacherSalary;
 using NCC.Extend.Entitys.lq_hytk_kjbsyj;
 using NCC.Extend.Entitys.lq_kd_kjbsyj;
@@ -14,10 +17,13 @@ using NCC.Extend.Entitys.lq_tech_teacher_salary_statistics;
 using NCC.Extend.Entitys.lq_xh_hyhk;
 using NCC.Extend.Entitys.lq_xh_kjbsyj;
 using NCC.Extend.Entitys.lq_person_times_record;
+using NCC.FriendlyException;
 using NCC.System.Entitys.Permission;
 using SqlSugar;
 using System;
 using System.Collections.Generic;
+using System.Data;
+using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using Yitter.IdGenerator;
@@ -32,13 +38,15 @@ namespace NCC.Extend
     public class LqTechTeacherSalaryService : IDynamicApiController, ITransient
     {
         private readonly ISqlSugarClient _db;
+        private readonly ILogger<LqTechTeacherSalaryService> _logger;
  
         /// <summary>
         /// 初始化一个<see cref="LqTechTeacherSalaryService"/>类型的新实例
         /// </summary>
-        public LqTechTeacherSalaryService(ISqlSugarClient db)
+        public LqTechTeacherSalaryService(ISqlSugarClient db, ILogger<LqTechTeacherSalaryService> logger)
         {
             _db = db;
+            _logger = logger;
         }
  
         /// <summary>
@@ -51,17 +59,7 @@ namespace NCC.Extend
         {
             var monthStr = $"{input.Year}{input.Month:D2}";
  
-            // 1. 检查当月是否已生成工资数据
-            var exists = await _db.Queryable<LqTechTeacherSalaryStatisticsEntity>()
-                .AnyAsync(x => x.StatisticsMonth == monthStr);
-
-            // 2. 如果没有数据，则进行计算
-            if (!exists)
-            {
-                await CalculateTechTeacherSalary(input.Year, input.Month);
-            }
-
-            // 3. 查询数据
+            // 查询数据
             var query = _db.Queryable<LqTechTeacherSalaryStatisticsEntity>()
                 .Where(x => x.StatisticsMonth == monthStr);
  
@@ -146,6 +144,90 @@ namespace NCC.Extend
         }
  
         /// <summary>
+        /// 通过月份和员工ID查询工资
+        /// </summary>
+        [HttpGet("query-by-employee")]
+        public async Task<TechTeacherSalaryOutput> GetSalaryByEmployee([FromQuery] SalaryQueryByEmployeeInput input)
+        {
+            if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+                throw NCCException.Oh("年份和月份参数不正确");
+            if (string.IsNullOrWhiteSpace(input.EmployeeId))
+                throw NCCException.Oh("员工ID不能为空");
+            var monthStr = $"{input.Year}{input.Month:D2}";
+            var salary = await _db.Queryable<LqTechTeacherSalaryStatisticsEntity>()
+                .Where(x => x.StatisticsMonth == monthStr && x.EmployeeId == input.EmployeeId)
+                .Select(x => new TechTeacherSalaryOutput
+                {
+                    Id = x.Id,
+                    StatisticsMonth = x.StatisticsMonth,
+                    StoreId = x.StoreId,
+                    StoreName = x.StoreName,
+                    Position = x.Position,
+                    EmployeeName = x.EmployeeName,
+                    EmployeeId = x.EmployeeId,
+                    EmployeeAccount = x.EmployeeAccount,
+                    OrderAchievement = x.OrderAchievement,
+                    ConsumeAchievement = x.ConsumeAchievement,
+                    RefundAchievement = x.RefundAchievement,
+                    TotalPerformance = x.TotalPerformance,
+                    ProjectCount = x.ProjectCount,
+                    BaseSalaryLevel = x.BaseSalaryLevel,
+                    BaseSalary = x.BaseSalary,
+                    PerformanceCommissionRate = x.PerformanceCommissionRate,
+                    PerformanceCommissionAmount = x.PerformanceCommissionAmount,
+                    ConsumeCommissionRate = x.ConsumeCommissionRate,
+                    ConsumeCommissionAmount = x.ConsumeCommissionAmount,
+                    HandworkFee = x.HandworkFee,
+                    WorkingDays = x.WorkingDays,
+                    LeaveDays = x.LeaveDays,
+                    TotalCommission = x.TotalCommission,
+                    TransportationAllowance = x.TransportationAllowance,
+                    LessRest = x.LessRest,
+                    FullAttendance = x.FullAttendance,
+                    CalculatedGrossSalary = x.CalculatedGrossSalary,
+                    GuaranteedSalary = x.GuaranteedSalary,
+                    GuaranteedLeaveDeduction = x.GuaranteedLeaveDeduction,
+                    GuaranteedBaseSalary = x.GuaranteedBaseSalary,
+                    GuaranteedSupplement = x.GuaranteedSupplement,
+                    FinalGrossSalary = x.FinalGrossSalary,
+                    MonthlyTrainingSubsidy = x.MonthlyTrainingSubsidy,
+                    MonthlyTransportSubsidy = x.MonthlyTransportSubsidy,
+                    LastMonthTrainingSubsidy = x.LastMonthTrainingSubsidy,
+                    LastMonthTransportSubsidy = x.LastMonthTransportSubsidy,
+                    TotalSubsidy = x.TotalSubsidy,
+                    MissingCard = x.MissingCard,
+                    LateArrival = x.LateArrival,
+                    LeaveDeduction = x.LeaveDeduction,
+                    SocialInsuranceDeduction = x.SocialInsuranceDeduction,
+                    RewardDeduction = x.RewardDeduction,
+                    AccommodationDeduction = x.AccommodationDeduction,
+                    StudyPeriodDeduction = x.StudyPeriodDeduction,
+                    WorkClothesDeduction = x.WorkClothesDeduction,
+                    TotalDeduction = x.TotalDeduction,
+                    Bonus = x.Bonus,
+                    ReturnPhoneDeposit = x.ReturnPhoneDeposit,
+                    ReturnAccommodationDeposit = x.ReturnAccommodationDeposit,
+                    ActualSalary = x.ActualSalary,
+                    MonthlyPaymentStatus = x.MonthlyPaymentStatus,
+                    PaidAmount = x.PaidAmount,
+                    PendingAmount = x.PendingAmount,
+                    LastMonthSupplement = x.LastMonthSupplement,
+                    MonthlyTotalPayment = x.MonthlyTotalPayment,
+                    IsLocked = x.IsLocked,
+                    IsTerminated = x.IsTerminated,
+                    UpdateTime = x.UpdateTime,
+                    StoreType = x.StoreType,
+                    StoreCategory = x.StoreCategory,
+                    IsNewStore = x.IsNewStore,
+                    NewStoreProtectionStage = x.NewStoreProtectionStage
+                })
+                .FirstAsync();
+            if (salary == null)
+                throw NCCException.Oh($"未找到员工{input.EmployeeId}在{input.Year}年{input.Month}月的工资记录");
+            return salary;
+        }
+
+        /// <summary>
         /// 计算科技老师工资
         /// </summary>
         /// <param name="year">年份</param>
@@ -412,12 +494,71 @@ namespace NCC.Extend
             // 4. 保存数据
             if (techTeacherStats.Any())
             {
-                // 先删除当月旧数据 (防止重复)
-                await _db.Deleteable<LqTechTeacherSalaryStatisticsEntity>()
+                // 查询当月已存在的记录（用于检查是否已锁定或已确认）
+                var existingRecords = await _db.Queryable<LqTechTeacherSalaryStatisticsEntity>()
                     .Where(x => x.StatisticsMonth == monthStr)
-                    .ExecuteCommandAsync();
+                    .ToListAsync();
+
+                var existingDict = existingRecords
+                    .Where(x => !string.IsNullOrEmpty(x.EmployeeId))
+                    .GroupBy(x => x.EmployeeId)
+                    .ToDictionary(g => g.Key, g => g.First());
+
+                // 分离需要插入的新记录和需要更新的记录，以及需要跳过的记录
+                var recordsToInsert = new List<LqTechTeacherSalaryStatisticsEntity>();
+                var recordsToUpdate = new List<LqTechTeacherSalaryStatisticsEntity>();
+                var skippedCount = 0;
+
+                foreach (var salary in techTeacherStats.Values)
+                {
+                    if (existingDict.ContainsKey(salary.EmployeeId))
+                    {
+                        var existing = existingDict[salary.EmployeeId];
+                        // 如果已锁定或已确认，则跳过，不更新
+                        if (existing.IsLocked == 1 || existing.EmployeeConfirmStatus == 1)
+                        {
+                            skippedCount++;
+                            continue; // 跳过，不更新
+                        }
+
+                        // 更新现有记录（保留确认状态相关字段）
+                        salary.Id = existing.Id;
+                        salary.EmployeeConfirmStatus = existing.EmployeeConfirmStatus;
+                        salary.EmployeeConfirmTime = existing.EmployeeConfirmTime;
+                        salary.EmployeeConfirmRemark = existing.EmployeeConfirmRemark;
+                        salary.IsLocked = existing.IsLocked; // 保留锁定状态
+                        salary.CreateTime = existing.CreateTime;
+                        salary.CreateUser = existing.CreateUser;
+                        recordsToUpdate.Add(salary);
+                    }
+                    else
+                    {
+                        // 新记录
+                        salary.Id = YitIdHelper.NextId().ToString();
+                        salary.EmployeeConfirmStatus = 0;
+                        salary.IsLocked = 0;
+                        salary.CreateTime = DateTime.Now;
+                        salary.CreateUser = ""; // 新记录，创建人为空或系统
+                        recordsToInsert.Add(salary);
+                    }
+                }
  
-                await _db.Insertable(techTeacherStats.Values.ToList()).ExecuteCommandAsync();
+                // 批量插入新记录
+                if (recordsToInsert.Any())
+                {
+                    await _db.Insertable(recordsToInsert).ExecuteCommandAsync();
+                }
+
+                // 批量更新现有记录
+                if (recordsToUpdate.Any())
+                {
+                    await _db.Updateable(recordsToUpdate).ExecuteCommandAsync();
+                }
+
+                if (skippedCount > 0)
+                {
+                    _logger.LogWarning($"计算工资时跳过了 {skippedCount} 条已锁定或已确认的记录（月份：{monthStr}）");
+                }
             }
         }
  
@@ -770,14 +911,632 @@ namespace NCC.Extend
                     PersonTimes = personTimesStat?.PersonTimes ?? 0m,
                     LaborCost = consumeStat?.LaborCost ?? 0m, // 手工费只统计耗卡中的手工费
                     DepartmentId = teacher.OrganizeId,
-                    DepartmentName = !string.IsNullOrEmpty(teacher.DepartmentName) 
-                        ? teacher.DepartmentName 
+                    DepartmentName = !string.IsNullOrEmpty(teacher.DepartmentName)
+                        ? teacher.DepartmentName
                         : (techOrganizeDict.ContainsKey(teacher.OrganizeId) ? techOrganizeDict[teacher.OrganizeId] : "")
                 });
             }
  
             return result;
         }
+
+        #region 员工工资确认
+
+        /// <summary>
+        /// 员工确认工资条
+        /// </summary>
+        /// <remarks>
+        /// 员工确认自己的工资条，确认后工资数据不可再修改
+        /// 
+        /// 示例请求：
+        /// <code>
+        /// {
+        ///   "id": "工资记录ID",
+        ///   "employeeId": "员工ID",
+        ///   "remark": "确认备注（可选）"
+        /// }
+        /// </code>
+        /// 
+        /// 参数说明：
+        /// - id: 工资记录ID（必填）
+        /// - employeeId: 员工ID（必填）
+        /// - remark: 确认备注（可选）
+        /// 
+        /// 注意事项：
+        /// - 只能确认自己的工资条
+        /// - 只能确认已锁定的工资条（IsLocked = 1）
+        /// - 已确认的工资条不能重复确认
+        /// </remarks>
+        /// <param name="input">确认参数</param>
+        /// <returns>操作结果</returns>
+        /// <response code="200">确认成功</response>
+        /// <response code="400">参数错误或记录不存在</response>
+        [HttpPost("confirm")]
+        public async Task<string> ConfirmSalary([FromBody] SalaryConfirmInput input)
+        {
+            try
+            {
+                if (string.IsNullOrWhiteSpace(input.Id))
+                {
+                    throw NCCException.Oh("工资记录ID不能为空");
+                }
+
+                if (string.IsNullOrWhiteSpace(input.EmployeeId))
+                {
+                    throw NCCException.Oh("员工ID不能为空");
+                }
+
+                // 查询工资记录
+                var salary = await _db.Queryable<LqTechTeacherSalaryStatisticsEntity>()
+                    .Where(s => s.Id == input.Id && s.EmployeeId == input.EmployeeId)
+                    .FirstAsync();
+
+                if (salary == null)
+                {
+                    throw NCCException.Oh("工资记录不存在或不属于该员工");
+                }
+
+                // 检查是否已确认
+                if (salary.EmployeeConfirmStatus == 1)
+                {
+                    throw NCCException.Oh("该工资条已确认，不能重复确认");
+                }
+
+                // 检查是否已锁定（员工只能确认已锁定的工资条）
+                if (salary.IsLocked != 1)
+                {
+                    throw NCCException.Oh("该工资条尚未锁定，请等待管理员锁定后再确认");
+                }
+
+                // 更新确认状态
+                salary.EmployeeConfirmStatus = 1;
+                salary.EmployeeConfirmTime = DateTime.Now;
+                salary.EmployeeConfirmRemark = input.Remark;
+                // 注意：IsLocked 保持为 1（因为本来就是管理员锁定的）
+                salary.UpdateTime = DateTime.Now;
+
+                await _db.Updateable(salary).ExecuteCommandAsync();
+
+                return "确认成功";
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"确认工资条失败: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        #region 工资锁定/解锁
+
+        /// <summary>
+        /// 批量锁定/解锁工资条
+        /// </summary>
+        [HttpPost("lock")]
+        public async Task<string> LockSalary([FromBody] SalaryLockInput input)
+        {
+            try
+            {
+                if (input == null || input.Ids == null || !input.Ids.Any())
+                    throw NCCException.Oh("工资记录ID列表不能为空");
+                var salaries = await _db.Queryable<LqTechTeacherSalaryStatisticsEntity>()
+                    .Where(s => input.Ids.Contains(s.Id))
+                    .ToListAsync();
+                if (!salaries.Any())
+                    throw NCCException.Oh("未找到指定的工资记录");
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+                foreach (var salary in salaries)
+                {
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+                    if (input.IsLocked) lockedCount++; else unlockedCount++;
+                }
+                await _db.Updateable(salaries).ExecuteCommandAsync();
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+                if (skippedCount > 0)
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+                return message;
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"锁定/解锁工资条失败: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// 批量锁定当月所有工资
+        /// </summary>
+        /// <remarks>
+        /// 批量锁定指定月份的所有科技部老师工资记录
+        /// </remarks>
+        /// <param name="input">批量锁定输入参数</param>
+        /// <returns>锁定结果</returns>
+        [HttpPost("lock-by-month")]
+        public async Task<dynamic> LockSalaryByMonth([FromBody] SalaryLockByMonthInput input)
+        {
+            try
+            {
+                if (input == null)
+                    throw NCCException.Oh("参数不能为空");
+
+                if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
+                    throw NCCException.Oh("年份和月份参数不正确");
+
+                var monthStr = $"{input.Year}{input.Month:D2}";
+
+                var salaries = await _db.Queryable<LqTechTeacherSalaryStatisticsEntity>()
+                    .Where(s => s.StatisticsMonth == monthStr)
+                    .ToListAsync();
+
+                if (!salaries.Any())
+                    throw NCCException.Oh($"未找到{input.Year}年{input.Month}月的工资记录");
+
+                var lockedCount = 0;
+                var unlockedCount = 0;
+                var skippedCount = 0;
+                var alreadyLockedCount = 0;
+
+                foreach (var salary in salaries)
+                {
+                    if (salary.EmployeeConfirmStatus == 1 && !input.IsLocked)
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+
+                    if (salary.IsLocked == 1 && input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    if (salary.IsLocked == 0 && !input.IsLocked)
+                    {
+                        alreadyLockedCount++;
+                        continue;
+                    }
+
+                    salary.IsLocked = input.IsLocked ? 1 : 0;
+                    salary.UpdateTime = DateTime.Now;
+
+                    if (input.IsLocked)
+                        lockedCount++;
+                    else
+                        unlockedCount++;
+                }
+
+                if (lockedCount > 0 || unlockedCount > 0)
+                {
+                    var salariesToUpdate = salaries.Where(s =>
+                        (input.IsLocked && s.IsLocked == 0) ||
+                        (!input.IsLocked && s.IsLocked == 1 && s.EmployeeConfirmStatus != 1)
+                    ).ToList();
+
+                    if (salariesToUpdate.Any())
+                    {
+                        await _db.Updateable(salariesToUpdate)
+                            .UpdateColumns(s => new { s.IsLocked, s.UpdateTime })
+                            .ExecuteCommandAsync();
+                    }
+                }
+
+                var action = input.IsLocked ? "锁定" : "解锁";
+                var count = input.IsLocked ? lockedCount : unlockedCount;
+                var message = $"{action}成功：{count}条";
+
+                if (alreadyLockedCount > 0)
+                    message += $"，跳过{alreadyLockedCount}条（已是{action}状态）";
+
+                if (skippedCount > 0)
+                    message += $"，跳过{skippedCount}条（已确认的记录不能解锁）";
+
+                return new
+                {
+                    success = true,
+                    message = message,
+                    total = salaries.Count,
+                    locked = lockedCount,
+                    unlocked = unlockedCount,
+                    skipped = skippedCount,
+                    alreadyLocked = alreadyLockedCount
+                };
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "批量锁定当月工资失败");
+                var action = input?.IsLocked == true ? "锁定" : "解锁";
+                throw NCCException.Oh($"批量{action}当月工资失败: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        #region 导入工资
+
+        /// <summary>
+        /// 从Excel导入科技部老师工资数据
+        /// </summary>
+        /// <remarks>
+        /// 从Excel文件导入科技部老师工资数据，Excel第一列必须是ID（主键）
+        /// 
+        /// 导入规则：
+        /// 1. Excel第一列是ID（主键），如果为空则自动生成新ID
+        /// 2. 如果ID在数据库中存在，则更新记录（需检查是否已锁定或已确认）
+        /// 3. 如果ID在数据库中不存在，则新增记录
+        /// 4. 已锁定（IsLocked=1）或已确认（EmployeeConfirmStatus=1）的记录不能导入覆盖
+        /// 
+        /// Excel字段顺序（第一列为ID）：
+        /// ID, 门店名称, 员工姓名, 岗位, 开单业绩, ...（共54列）
+        /// </remarks>
+        /// <param name="file">Excel文件</param>
+        /// <returns>导入结果</returns>
+        /// <response code="200">导入成功</response>
+        /// <response code="400">文件格式错误或数据验证失败</response>
+        [HttpPost("import")]
+        public async Task<dynamic> ImportSalaryFromExcel(IFormFile file)
+        {
+            try
+            {
+                if (file == null || file.Length == 0)
+                {
+                    throw NCCException.Oh("请选择要上传的Excel文件");
+                }
+
+                // 检查文件格式
+                var allowedExtensions = new[] { ".xlsx", ".xls" };
+                var fileExtension = Path.GetExtension(file.FileName).ToLowerInvariant();
+                if (!allowedExtensions.Contains(fileExtension))
+                {
+                    throw NCCException.Oh("只支持.xlsx和.xls格式的Excel文件");
+                }
+
+                var recordsToInsert = new List<LqTechTeacherSalaryStatisticsEntity>();
+                var recordsToUpdate = new List<LqTechTeacherSalaryStatisticsEntity>();
+                var errorMessages = new List<string>();
+                var successCount = 0;
+                var failCount = 0;
+                var skippedCount = 0;
+
+                // 保存临时文件
+                var tempFilePath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + Path.GetExtension(file.FileName));
+                try
+                {
+                    using (var stream = new FileStream(tempFilePath, FileMode.Create))
+                    {
+                        await file.CopyToAsync(stream);
+                    }
+
+                    // 使用ExcelImportHelper读取Excel文件
+                    var dataTable = ExcelImportHelper.ToDataTable(tempFilePath, 0, 0);
+
+                    if (dataTable.Rows.Count == 0)
+                    {
+                        throw NCCException.Oh("Excel文件中没有数据行");
+                    }
+
+                    // Excel第一列是ID，第二列开始是业务字段
+                    for (int i = 1; i < dataTable.Rows.Count; i++)
+                    {
+                        try
+                        {
+                            var row = dataTable.Rows[i];
+
+                            // 安全获取列值
+                            Func<int, string> GetColumnValue = (colIndex) =>
+                            {
+                                if (colIndex < row.ItemArray.Length)
+                                {
+                                    return row[colIndex]?.ToString()?.Trim() ?? "";
+                                }
+                                return "";
+                            };
+
+                            // 第一列是ID
+                            var id = GetColumnValue(0);
+
+                            // 判断Excel格式：如果第一列是"门店名称"等中文，说明是旧格式（没有ID列）
+                            var firstColumnValue = GetColumnValue(0);
+                            bool isOldFormat = false;
+                            if (!string.IsNullOrWhiteSpace(firstColumnValue) &&
+                                (firstColumnValue == "门店名称" || firstColumnValue.Contains("门店") || (!string.IsNullOrWhiteSpace(firstColumnValue) && !long.TryParse(firstColumnValue, out _) && firstColumnValue.Length > 20)))
+                            {
+                                isOldFormat = true;
+                                id = "";
+                            }
+
+                            // 根据Excel格式确定字段索引
+                            int storeNameIndex = isOldFormat ? 0 : 1;
+                            int employeeNameIndex = isOldFormat ? 1 : 2;
+
+                            // 跳过空行
+                            var employeeName = GetColumnValue(employeeNameIndex);
+                            var storeName = GetColumnValue(storeNameIndex);
+
+                            if (string.IsNullOrWhiteSpace(id) && string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                continue;
+                            }
+
+                            // 如果ID为空，尝试根据员工姓名和门店名称匹配现有记录的ID
+                            if (string.IsNullOrWhiteSpace(id) && !string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                var matchedRecord = await _db.Queryable<LqTechTeacherSalaryStatisticsEntity>()
+                                    .Where(x => x.EmployeeName == employeeName)
+                                    .WhereIF(!string.IsNullOrWhiteSpace(storeName), x => x.StoreName == storeName)
+                                    .OrderBy(x => x.CreateTime, OrderByType.Desc)
+                                    .FirstAsync();
+
+                                if (matchedRecord != null)
+                                {
+                                    id = matchedRecord.Id;
+                                }
+                            }
+
+                            // 验证必填字段
+                            if (string.IsNullOrWhiteSpace(employeeName))
+                            {
+                                errorMessages.Add($"第{i + 1}行：员工姓名不能为空");
+                                failCount++;
+                                continue;
+                            }
+
+                            // 辅助方法：清理数值字符串
+                            Func<string, decimal> ParseDecimal = (str) =>
+                            {
+                                if (string.IsNullOrWhiteSpace(str))
+                                    return 0;
+                                var cleaned = str.Trim()
+                                    .Replace(",", "")
+                                    .Replace("，", "")
+                                    .Replace("￥", "")
+                                    .Replace("$", "")
+                                    .Replace("元", "")
+                                    .Replace("%", "")
+                                    .Replace(" ", "");
+                                if (decimal.TryParse(cleaned, out decimal result))
+                                    return result;
+                                return 0;
+                            };
+
+                            Func<string, int> ParseInt = (str) =>
+                            {
+                                if (string.IsNullOrWhiteSpace(str))
+                                    return 0;
+                                var cleaned = str.Trim().Replace(",", "").Replace("，", "").Replace(" ", "");
+                                if (int.TryParse(cleaned, out int result))
+                                    return result;
+                                return 0;
+                            };
+
+                            // 如果Excel中有ID，查找现有记录
+                            LqTechTeacherSalaryStatisticsEntity existing = null;
+                            if (!string.IsNullOrWhiteSpace(id))
+                            {
+                                existing = await _db.Queryable<LqTechTeacherSalaryStatisticsEntity>()
+                                    .Where(x => x.Id == id)
+                                    .FirstAsync();
+
+                                if (existing != null)
+                                {
+                                    // 检查是否已锁定或已确认
+                                    if (existing.IsLocked == 1)
+                                    {
+                                        errorMessages.Add($"第{i + 1}行：员工 {existing.EmployeeName} (ID: {id}) 的工资已锁定，不能导入覆盖");
+                                        skippedCount++;
+                                        failCount++;
+                                        continue;
+                                    }
+
+                                    if (existing.EmployeeConfirmStatus == 1)
+                                    {
+                                        errorMessages.Add($"第{i + 1}行：员工 {existing.EmployeeName} (ID: {id}) 的工资已确认，不能导入覆盖");
+                                        skippedCount++;
+                                        failCount++;
+                                        continue;
+                                    }
+                                }
+                            }
+
+                            // 创建或更新实体
+                            LqTechTeacherSalaryStatisticsEntity entity;
+                            if (existing != null)
+                            {
+                                entity = existing;
+                                entity.EmployeeConfirmStatus = 0;
+                                entity.EmployeeConfirmTime = null;
+                                entity.EmployeeConfirmRemark = null;
+                            }
+                            else
+                            {
+                                entity = new LqTechTeacherSalaryStatisticsEntity
+                                {
+                                    Id = string.IsNullOrWhiteSpace(id) ? YitIdHelper.NextId().ToString() : id,
+                                    EmployeeConfirmStatus = 0,
+                                    IsLocked = 0,
+                                    CreateTime = DateTime.Now,
+                                    UpdateTime = DateTime.Now
+                                };
+                            }
+
+                            // 根据Excel格式计算字段索引偏移量
+                            int offset = isOldFormat ? 0 : 1;
+
+                            // 映射Excel字段到实体属性（根据Excel列顺序，第一列是ID，所以业务字段从索引1开始）
+                            // Excel列顺序：ID, 门店名称, 员工姓名, 岗位, 开单业绩, 消耗业绩, 退卡业绩, 总业绩, 项目数, 底薪档位, 底薪, ...
+                            entity.StoreName = storeName;
+                            entity.EmployeeName = employeeName;
+                            entity.Position = GetColumnValue(2 + offset);
+                            entity.OrderAchievement = ParseDecimal(GetColumnValue(3 + offset));
+                            entity.ConsumeAchievement = ParseDecimal(GetColumnValue(4 + offset));
+                            entity.RefundAchievement = ParseDecimal(GetColumnValue(5 + offset));
+                            entity.TotalPerformance = ParseDecimal(GetColumnValue(6 + offset));
+                            entity.ProjectCount = ParseDecimal(GetColumnValue(7 + offset));
+                            entity.BaseSalaryLevel = ParseInt(GetColumnValue(8 + offset));
+                            entity.BaseSalary = ParseDecimal(GetColumnValue(9 + offset));
+                            entity.PerformanceCommissionRate = ParseDecimal(GetColumnValue(10 + offset));
+                            entity.PerformanceCommissionAmount = ParseDecimal(GetColumnValue(11 + offset));
+                            entity.ConsumeCommissionRate = ParseDecimal(GetColumnValue(12 + offset));
+                            entity.ConsumeCommissionAmount = ParseDecimal(GetColumnValue(13 + offset));
+                            entity.HandworkFee = ParseDecimal(GetColumnValue(14 + offset));
+                            entity.TotalCommission = ParseDecimal(GetColumnValue(15 + offset));
+                            entity.WorkingDays = ParseDecimal(GetColumnValue(16 + offset));
+                            entity.LeaveDays = ParseDecimal(GetColumnValue(17 + offset));
+                            entity.TransportationAllowance = ParseDecimal(GetColumnValue(18 + offset));
+                            entity.LessRest = ParseDecimal(GetColumnValue(19 + offset));
+                            entity.FullAttendance = ParseDecimal(GetColumnValue(20 + offset));
+                            entity.MonthlyTrainingSubsidy = ParseDecimal(GetColumnValue(21 + offset));
+                            entity.MonthlyTransportSubsidy = ParseDecimal(GetColumnValue(22 + offset));
+                            entity.LastMonthTrainingSubsidy = ParseDecimal(GetColumnValue(23 + offset));
+                            entity.LastMonthTransportSubsidy = ParseDecimal(GetColumnValue(24 + offset));
+                            entity.TotalSubsidy = ParseDecimal(GetColumnValue(25 + offset));
+                            entity.CalculatedGrossSalary = ParseDecimal(GetColumnValue(26 + offset));
+                            entity.GuaranteedSalary = ParseDecimal(GetColumnValue(27 + offset));
+                            entity.GuaranteedLeaveDeduction = ParseDecimal(GetColumnValue(28 + offset));
+                            entity.GuaranteedBaseSalary = ParseDecimal(GetColumnValue(29 + offset));
+                            entity.GuaranteedSupplement = ParseDecimal(GetColumnValue(30 + offset));
+                            entity.FinalGrossSalary = ParseDecimal(GetColumnValue(31 + offset));
+                            entity.MissingCard = ParseDecimal(GetColumnValue(32 + offset));
+                            entity.LateArrival = ParseDecimal(GetColumnValue(33 + offset));
+                            entity.LeaveDeduction = ParseDecimal(GetColumnValue(34 + offset));
+                            entity.SocialInsuranceDeduction = ParseDecimal(GetColumnValue(35 + offset));
+                            entity.RewardDeduction = ParseDecimal(GetColumnValue(36 + offset));
+                            entity.AccommodationDeduction = ParseDecimal(GetColumnValue(37 + offset));
+                            entity.StudyPeriodDeduction = ParseDecimal(GetColumnValue(38 + offset));
+                            entity.WorkClothesDeduction = ParseDecimal(GetColumnValue(39 + offset));
+                            entity.TotalDeduction = ParseDecimal(GetColumnValue(40 + offset));
+                            entity.Bonus = ParseDecimal(GetColumnValue(41 + offset));
+                            entity.ReturnPhoneDeposit = ParseDecimal(GetColumnValue(42 + offset));
+                            entity.ReturnAccommodationDeposit = ParseDecimal(GetColumnValue(43 + offset));
+                            entity.LastMonthSupplement = ParseDecimal(GetColumnValue(44 + offset));
+                            entity.ActualSalary = ParseDecimal(GetColumnValue(45 + offset));
+                            entity.MonthlyPaymentStatus = GetColumnValue(46 + offset);
+                            entity.PaidAmount = ParseDecimal(GetColumnValue(47 + offset));
+                            entity.PendingAmount = ParseDecimal(GetColumnValue(48 + offset));
+                            entity.MonthlyTotalPayment = ParseDecimal(GetColumnValue(49 + offset));
+
+                            // 处理"是否新店"字段
+                            var isNewStoreStr = GetColumnValue(50 + offset);
+                            entity.IsNewStore = (isNewStoreStr == "是" || isNewStoreStr == "1" || isNewStoreStr.ToLower() == "true") ? "是" : "否";
+
+                            // 处理"新店保护阶段"字段
+                            var newStoreProtectionStageStr = GetColumnValue(51 + offset);
+                            if (int.TryParse(newStoreProtectionStageStr, out int protectionStage))
+                            {
+                                entity.NewStoreProtectionStage = protectionStage;
+                            }
+
+                            // 处理"离职状态"字段（第54列，索引53+offset）
+                            var terminatedStatus = GetColumnValue(53 + offset);
+                            entity.IsTerminated = (terminatedStatus == "离职" || terminatedStatus == "1") ? 1 : 0;
+
+                            // 处理Excel中没有的字段
+                            if (existing != null)
+                            {
+                                entity.StoreId = existing.StoreId;
+                                entity.EmployeeId = existing.EmployeeId;
+                                entity.StatisticsMonth = existing.StatisticsMonth;
+                            }
+                            else
+                            {
+                                // 新增记录：尝试根据员工姓名和门店名称查找EmployeeId和StoreId
+                                if (!string.IsNullOrWhiteSpace(employeeName))
+                                {
+                                    var user = await _db.Queryable<UserEntity>()
+                                        .Where(u => u.RealName == employeeName)
+                                        .FirstAsync();
+
+                                    if (user != null)
+                                    {
+                                        entity.EmployeeId = user.Id;
+                                        entity.EmployeeAccount = user.Account;
+
+                                        if (!string.IsNullOrEmpty(user.Mdid) && string.IsNullOrWhiteSpace(storeName))
+                                        {
+                                            entity.StoreId = user.Mdid;
+                                        }
+                                    }
+
+                                    if (!string.IsNullOrWhiteSpace(storeName) && string.IsNullOrEmpty(entity.StoreId))
+                                    {
+                                        var store = await _db.Queryable<LqMdxxEntity>()
+                                            .Where(s => s.Dm == storeName)
+                                            .FirstAsync();
+
+                                        if (store != null)
+                                        {
+                                            entity.StoreId = store.Id;
+                                        }
+                                    }
+                                }
+                            }
+
+                            entity.UpdateTime = DateTime.Now;
+
+                            if (existing != null)
+                            {
+                                recordsToUpdate.Add(entity);
+                            }
+                            else
+                            {
+                                recordsToInsert.Add(entity);
+                            }
+
+                            successCount++;
+                        }
+                        catch (Exception ex)
+                        {
+                            errorMessages.Add($"第{i + 1}行数据处理失败: {ex.Message}");
+                            failCount++;
+                        }
+                    }
+                }
+                finally
+                {
+                    // 清理临时文件
+                    if (File.Exists(tempFilePath))
+                    {
+                        File.Delete(tempFilePath);
+                    }
+                }
+
+                // 批量插入新记录
+                if (recordsToInsert.Any())
+                {
+                    await _db.Insertable(recordsToInsert).ExecuteCommandAsync();
+                }
+
+                // 批量更新现有记录
+                if (recordsToUpdate.Any())
+                {
+                    await _db.Updateable(recordsToUpdate).ExecuteCommandAsync();
+                }
+
+                return new
+                {
+                    success = true,
+                    message = $"导入完成：成功 {successCount} 条，失败 {failCount} 条，跳过 {skippedCount} 条（已锁定或已确认）",
+                    successCount = successCount,
+                    failCount = failCount,
+                    skippedCount = skippedCount,
+                    errors = errorMessages
+                };
+            }
+            catch (Exception ex)
+            {
+                throw NCCException.Oh($"导入科技部老师工资数据失败: {ex.Message}");
+            }
+        }
+
+        #endregion
     }
 }