用户管理修改回显尝试，薪资管理时间戳修正，工人批量导入（无需模版，且删除后重复数据自动覆盖）

gear-oa/src/main/java/com/gear/oa/controller/GearWorkerController.java

@@ -93,4 +93,6 @@ public class GearWorkerController extends BaseController {
     public R<Void> remove(@NotEmpty(message = "主键不能为空") @PathVariable Long[] workerIds) {
         return toAjax(iGearWorkerService.deleteWithValidByIds(Arrays.asList(workerIds), true));
     }
+
+
 }

gear-oa/src/main/java/com/gear/oa/domain/GearWorker.java

@@ -7,9 +7,6 @@ import com.gear.common.core.domain.BaseEntity;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 
-/**
- * 工人主数据对象 gear_worker
- */
 @Data
 @EqualsAndHashCode(callSuper = true)
 @TableName("gear_worker")
@@ -26,19 +23,16 @@ public class GearWorker extends BaseEntity {
 
     private String phone;
 
-    /**
-     * 默认计费类型（1小时工 2计件工 3天工）
-     */
     private String defaultBillingType;
 
     private String defaultWorkTypeName;
 
-    /**
-     * 状态（0在职 1离职）
-     */
     private String status;
 
-    @TableLogic
+    /**
+     * 逻辑删除标记：0-未删除，2-已删除
+     */
+    @TableLogic(value = "0", delval = "2")
     private String delFlag;
 
     private String remark;

gear-oa/src/main/java/com/gear/oa/mapper/GearWorkerMapper.java

@@ -3,9 +3,40 @@ package com.gear.oa.mapper;
 import com.gear.common.core.mapper.BaseMapperPlus;
 import com.gear.oa.domain.GearWorker;
 import com.gear.oa.domain.vo.GearWorkerVo;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+import org.apache.ibatis.annotations.Update;
 
 /**
  * 工人主数据Mapper接口
  */
 public interface GearWorkerMapper extends BaseMapperPlus<GearWorkerMapper, GearWorker, GearWorkerVo> {
+    /**
+     * 根据工号查询所有记录（包括逻辑删除的），绕过 MyBatis-Plus 自动过滤
+     *
+     * @param workerNo 工号
+     * @return 工人记录（可能为 null）
+     */
+    @Select("SELECT * FROM gear_worker WHERE worker_no = #{workerNo}")
+    GearWorker selectByWorkerNoIncludeDeleted(@Param("workerNo") String workerNo);
+
+    /**
+     * 强制恢复并更新已删除的工人记录
+     * 直接将 del_flag 更新为 0，并更新其他字段
+     *
+     * @param worker 包含新数据的工人对象（必须包含 workerNo 和需要更新的字段）
+     * @return 影响行数
+     */
+    @Update("UPDATE gear_worker SET " +
+        "worker_name = #{workerName}, " +
+        "phone = #{phone}, " +
+        "default_billing_type = #{defaultBillingType}, " +
+        "default_work_type_name = #{defaultWorkTypeName}, " +
+        "status = #{status}, " +
+        "del_flag = '0', " +
+        "remark = #{remark}, " +
+        "update_by = #{updateBy}, " +
+        "update_time = NOW() " +
+        "WHERE worker_no = #{workerNo}")
+    int recoverByWorkerNo(GearWorker worker);
 }

gear-oa/src/main/java/com/gear/oa/service/impl/GearWorkerServiceImpl.java

@@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.gear.common.core.domain.PageQuery;
 import com.gear.common.core.page.TableDataInfo;
+import com.gear.common.exception.ServiceException;
 import com.gear.common.utils.StringUtils;
 import com.gear.oa.domain.GearWorker;
 import com.gear.oa.domain.bo.GearWorkerBo;
@@ -14,14 +15,13 @@ import com.gear.oa.domain.vo.GearWorkerVo;
 import com.gear.oa.mapper.GearWorkerMapper;
 import com.gear.oa.service.IGearWorkerService;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
 import java.util.Collection;
 import java.util.List;
 
-/**
- * 工人主数据Service业务层处理
- */
+@Slf4j
 @RequiredArgsConstructor
 @Service
 public class GearWorkerServiceImpl implements IGearWorkerService {
@@ -48,6 +48,8 @@ public class GearWorkerServiceImpl implements IGearWorkerService {
 
     private LambdaQueryWrapper<GearWorker> buildQueryWrapper(GearWorkerBo bo) {
         LambdaQueryWrapper<GearWorker> lqw = Wrappers.lambdaQuery();
+        // 只查询未删除的数据（del_flag = '0'）
+        lqw.eq(GearWorker::getDelFlag, "0");
         lqw.eq(bo.getWorkerId() != null, GearWorker::getWorkerId, bo.getWorkerId());
         lqw.eq(StringUtils.isNotBlank(bo.getWorkerNo()), GearWorker::getWorkerNo, bo.getWorkerNo());
         lqw.like(StringUtils.isNotBlank(bo.getWorkerName()), GearWorker::getWorkerName, bo.getWorkerName());
@@ -59,17 +61,48 @@ public class GearWorkerServiceImpl implements IGearWorkerService {
 
     @Override
     public Boolean insertByBo(GearWorkerBo bo) {
+        // 使用自定义方法查询所有记录（包括逻辑删除的）
+        GearWorker existing = baseMapper.selectByWorkerNoIncludeDeleted(bo.getWorkerNo());
+
+        if (existing != null) {
+            // 记录存在
+            if ("0".equals(existing.getDelFlag())) {
+                throw new ServiceException("工号 " + bo.getWorkerNo() + " 已存在且未删除，不能重复添加");
+            } else {
+                // 已删除，执行强制恢复更新
+                GearWorker update = BeanUtil.toBean(bo, GearWorker.class);
+                // 必须设置工号，用于 WHERE 条件
+                update.setWorkerNo(bo.getWorkerNo());
+                // 调用自定义恢复方法，直接更新数据库
+                int rows = baseMapper.recoverByWorkerNo(update);
+                if (rows > 0) {
+                    bo.setWorkerId(existing.getWorkerId());
+                    log.info("恢复并更新已删除工人成功，workerNo={}", bo.getWorkerNo());
+                    return true;
+                } else {
+                    throw new ServiceException("恢复工人数据失败，请稍后重试");
+                }
+            }
+        }
+
+        // 完全新增
+        log.info("新增工人，workerNo={}", bo.getWorkerNo());
         GearWorker add = BeanUtil.toBean(bo, GearWorker.class);
         validEntityBeforeSave(add);
-        boolean flag = baseMapper.insert(add) > 0;
-        if (flag) {
-            bo.setWorkerId(add.getWorkerId());
-        }
-        return flag;
+        baseMapper.insert(add);
+        bo.setWorkerId(add.getWorkerId());
+        return true;
     }
 
     @Override
     public Boolean updateByBo(GearWorkerBo bo) {
+        GearWorker existing = baseMapper.selectById(bo.getWorkerId());
+        if (existing == null) {
+            throw new ServiceException("记录不存在");
+        }
+        if (!"0".equals(existing.getDelFlag())) {
+            throw new ServiceException("该记录已被删除，无法更新");
+        }
         GearWorker update = BeanUtil.toBean(bo, GearWorker.class);
         validEntityBeforeSave(update);
         return baseMapper.updateById(update) > 0;
@@ -82,10 +115,14 @@ public class GearWorkerServiceImpl implements IGearWorkerService {
         if (StringUtils.isBlank(entity.getDefaultBillingType())) {
             entity.setDefaultBillingType("1");
         }
+        if (StringUtils.isBlank(entity.getDelFlag())) {
+            entity.setDelFlag("0");
+        }
     }
 
     @Override
     public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
+        // 由于 @TableLogic(value="0", delval="2") 配置，此处会执行 UPDATE gear_worker SET del_flag='2'
         return baseMapper.deleteBatchIds(ids) > 0;
     }
 
@@ -103,24 +140,43 @@ public class GearWorkerServiceImpl implements IGearWorkerService {
                 msg.append("[工号/姓名为空]");
                 continue;
             }
-            GearWorker exist = baseMapper.selectOne(Wrappers.<GearWorker>lambdaQuery()
-                .eq(GearWorker::getWorkerNo, item.getWorkerNo()));
 
-            if (exist == null) {
-                GearWorker add = BeanUtil.toBean(item, GearWorker.class);
-                validEntityBeforeSave(add);
-                baseMapper.insert(add);
-                success++;
-            } else if (Boolean.TRUE.equals(updateSupport)) {
-                GearWorker update = BeanUtil.toBean(item, GearWorker.class);
-                update.setWorkerId(exist.getWorkerId());
-                validEntityBeforeSave(update);
-                baseMapper.updateById(update);
-                success++;
-            } else {
-                fail++;
-                msg.append("[工号重复:").append(item.getWorkerNo()).append("]");
+            // 使用自定义方法查询所有记录（包括逻辑删除的）
+            GearWorker existing = baseMapper.selectByWorkerNoIncludeDeleted(item.getWorkerNo());
+
+            if (existing != null) {
+                if ("0".equals(existing.getDelFlag())) {
+                    // 未删除，根据 updateSupport 决定
+                    if (Boolean.TRUE.equals(updateSupport)) {
+                        GearWorker update = BeanUtil.toBean(item, GearWorker.class);
+                        update.setWorkerId(existing.getWorkerId());
+                        validEntityBeforeSave(update);
+                        baseMapper.updateById(update);
+                        success++;
+                    } else {
+                        fail++;
+                        msg.append("[工号重复:").append(item.getWorkerNo()).append("]");
+                    }
+                } else {
+                    // 已删除，强制恢复
+                    GearWorker recover = BeanUtil.toBean(item, GearWorker.class);
+                    recover.setWorkerNo(item.getWorkerNo());
+                    int rows = baseMapper.recoverByWorkerNo(recover);
+                    if (rows > 0) {
+                        success++;
+                    } else {
+                        fail++;
+                        msg.append("[恢复失败:").append(item.getWorkerNo()).append("]");
+                    }
+                }
+                continue;
             }
+
+            // 完全新增
+            GearWorker add = BeanUtil.toBean(item, GearWorker.class);
+            validEntityBeforeSave(add);
+            baseMapper.insert(add);
+            success++;
         }
         return "导入完成，成功" + success + "条，失败" + fail + "条" + (msg.length() > 0 ? "，" + msg : "");
     }