fix: 优化导入过鱼设施逻辑

backend/src/main/java/com/yfd/platform/data/domain/FishDraftData.java

@@ -31,12 +31,6 @@ public class FishDraftData implements Serializable {
      */
     private String stcd;
 
-    /**
-     * 所属基地编码
-     */
-    @TableField(exist = false)
-    private String baseId;
-
     /**
      * 填报时间
      */
@@ -47,6 +41,7 @@ public class FishDraftData implements Serializable {
      */
     private String ftp;
 
+
     /**
      * 鱼类全长
      */
@@ -135,24 +130,6 @@ public class FishDraftData implements Serializable {
     private BigDecimal wt;
 
 
-    /**
-     * 电站名称
-     */
-    @TableField(exist = false)
-    private String engName;
-
-    /**
-     * 基地名称
-     */
-    @TableField(exist = false)
-    private String baseName;
-
-    /**
-     * 设施名称
-     */
-    @TableField(exist = false)
-    private String fPname;
-
 
     /**
      * 审批完成时间
@@ -197,4 +174,42 @@ public class FishDraftData implements Serializable {
      */
     @TableField(fill = FieldFill.INSERT_UPDATE)
     private String updatedBy;
+
+    /**
+     * 所属基地编码
+     */
+    @TableField(exist = false)
+    private String baseId;
+
+
+    /**
+     * 电站名称
+     */
+    @TableField(exist = false)
+    private String engName;
+
+    /**
+     * 基地名称
+     */
+    @TableField(exist = false)
+    private String baseName;
+
+    /**
+     * 流域编码
+     */
+    @TableField(exist = false)
+    private String rvcd;
+
+    /**
+     * 设施名称
+     */
+    @TableField(exist = false)
+    private String fpname;
+
+    /**
+     * 鱼类名称
+     */
+    @TableField(exist = false)
+    private String ftpName;
+
 }

backend/src/main/java/com/yfd/platform/data/service/impl/FishImportServiceImpl.java

@@ -5,10 +5,12 @@ import com.yfd.platform.data.domain.FishImportRequest;
 import com.yfd.platform.data.domain.FishImportResult;
 import com.yfd.platform.data.service.IFishImportService;
 import com.yfd.platform.data.utils.ZipFileUtil;
-import com.yfd.platform.env.domain.SdEngInfoBH;
+import com.yfd.platform.env.domain.*;
-import com.yfd.platform.env.domain.SdHydrobase;
+import com.yfd.platform.env.mapper.*;
-import com.yfd.platform.env.mapper.SdEngInfoBHMapper;
+import com.yfd.platform.system.domain.SysDictionary;
-import com.yfd.platform.env.mapper.SdHydrobaseMapper;
+import com.yfd.platform.system.domain.SysDictionaryItems;
+import com.yfd.platform.system.service.ISysDictionaryItemsService;
+import com.yfd.platform.system.service.ISysDictionaryService;
 import jakarta.annotation.Resource;
 import org.apache.poi.ss.usermodel.*;
 import org.apache.poi.xssf.usermodel.XSSFWorkbook;
@@ -16,7 +18,6 @@ import org.springframework.stereotype.Service;
 import org.springframework.util.StringUtils;
 import org.springframework.web.multipart.MultipartFile;
 
-import java.io.ByteArrayInputStream;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
@@ -34,30 +35,73 @@ public class FishImportServiceImpl implements IFishImportService {
     @Resource
     private SdHydrobaseMapper hydrobaseMapper;
 
-    private static final Map<String, String> EXCEL_COLUMN_MAPPING = new LinkedHashMap<>();
+    @Resource
+    private SdRvcdDicMapper rvcdDicMapper;
 
-    private static final Map<String, String> STATION_NAME_CACHE = new HashMap<>();
+    @Resource
-    private static final Map<String, String> STATION_CODE_CACHE = new HashMap<>();
+    private SdFpssBHMapper fpssBHMapper;
-    private static final Map<String, String> BASE_NAME_CACHE = new HashMap<>();
+
-    private static final Map<String, String> BASE_CODE_CACHE = new HashMap<>();
+    @Resource
+    private SdFishDictoryBMapper fishDictoryBMapper;
+
+    @Resource
+    private ISysDictionaryService sysDictionaryService;
+
+    @Resource
+    private ISysDictionaryItemsService sysDictionaryItemsService;
+
+    private static final Map<String, String> EXCEL_COLUMN_MAPPING = new LinkedHashMap<>();
+    private static final Map<Integer, String> EXCEL_COLUMN_INDEX_MAPPING = new LinkedHashMap<>();
+
+    private static final Map<String, String> STATION_NAME_CACHE = new LinkedHashMap<>();
+    private static final Map<String, String> BASE_NAME_CACHE = new LinkedHashMap<>();
+    private static final Map<String, String> RIVER_NAME_CACHE = new LinkedHashMap<>();
+
+    private static final Map<String, String> FISH_DICT_CACHE = new LinkedHashMap<>();
+    private static final Map<String, String> FPSS_BH_CACHE = new LinkedHashMap<>();
+    private static final Map<String, String> DIRECTION_DICT_CACHE = new LinkedHashMap<>();
+    private static final Map<String, String> ISFS_DICT_CACHE = new LinkedHashMap<>();
+
+    private static final String DICT_CODE_FISH = "FISH_TYPE";
+    private static final String DICT_CODE_DIRECTION = "FISH_DIRECTION";
+    private static final String DICT_CODE_ISFS = "YES_NO";
 
     static {
         EXCEL_COLUMN_MAPPING.put("电站名称", "stcd");
         EXCEL_COLUMN_MAPPING.put("基地名称", "baseId");
+        EXCEL_COLUMN_MAPPING.put("流域名称", "rvcd");
         EXCEL_COLUMN_MAPPING.put("数据时间", "tm");
+        EXCEL_COLUMN_MAPPING.put("过鱼时间", "tm");
         EXCEL_COLUMN_MAPPING.put("鱼类", "ftp");
+        EXCEL_COLUMN_MAPPING.put("鱼种类", "ftp");
         EXCEL_COLUMN_MAPPING.put("鱼类全长", "fsz");
         EXCEL_COLUMN_MAPPING.put("过鱼数量", "fcnt");
+        EXCEL_COLUMN_MAPPING.put("过鱼数量（尾）", "fcnt");
         EXCEL_COLUMN_MAPPING.put("平均体重", "fwet");
         EXCEL_COLUMN_MAPPING.put("开始日期", "strdt");
         EXCEL_COLUMN_MAPPING.put("结束日期", "enddt");
         EXCEL_COLUMN_MAPPING.put("游向", "direction");
+        EXCEL_COLUMN_MAPPING.put("水温", "wt");
         EXCEL_COLUMN_MAPPING.put("年份", "yr");
         EXCEL_COLUMN_MAPPING.put("月份", "mouth");
         EXCEL_COLUMN_MAPPING.put("过鱼视频文件路径", "vdpth");
         EXCEL_COLUMN_MAPPING.put("图片文件路径", "picpth");
         EXCEL_COLUMN_MAPPING.put("是否鱼苗", "isfs");
         EXCEL_COLUMN_MAPPING.put("数据来源", "sourceType");
+        EXCEL_COLUMN_MAPPING.put("过鱼设施名称", "fpname");
+
+
+        EXCEL_COLUMN_INDEX_MAPPING.put(0, "baseName");
+        EXCEL_COLUMN_INDEX_MAPPING.put(1, "stationName");
+        EXCEL_COLUMN_INDEX_MAPPING.put(2, "fpname");
+        EXCEL_COLUMN_INDEX_MAPPING.put(3, "tm");
+        EXCEL_COLUMN_INDEX_MAPPING.put(4, "ftp");
+        EXCEL_COLUMN_INDEX_MAPPING.put(5, "isfs");
+        EXCEL_COLUMN_INDEX_MAPPING.put(6, "direction");
+        EXCEL_COLUMN_INDEX_MAPPING.put(7, "fcnt");
+        EXCEL_COLUMN_INDEX_MAPPING.put(8, "fsz");
+        EXCEL_COLUMN_INDEX_MAPPING.put(9, "fwet");
+        EXCEL_COLUMN_INDEX_MAPPING.put(10, "wt");
     }
 
     @Override
@@ -96,25 +140,8 @@ public class FishImportServiceImpl implements IFishImportService {
             return result;
         }
 
-        Map<Integer, String> columnIndexMap = new HashMap<>();
         List<String> unrecognizedHeaders = new ArrayList<>();
-
+        Map<Integer, String> columnIndexMap = new HashMap<>(EXCEL_COLUMN_INDEX_MAPPING);
-        for (int i = 0; i < headerRow.getLastCellNum(); i++) {
-            Cell cell = headerRow.getCell(i);
-            if (cell != null) {
-                String headerName = getCellStringValue(cell).trim();
-                String mappedField = EXCEL_COLUMN_MAPPING.get(headerName);
-                if (mappedField != null) {
-                    columnIndexMap.put(i, mappedField);
-                } else {
-                    unrecognizedHeaders.add(headerName);
-                }
-            }
-        }
-
-        if (!unrecognizedHeaders.isEmpty()) {
-            result.setUnrecognizedFields(unrecognizedHeaders);
-        }
 
         int totalRows = sheet.getLastRowNum();
         result.setTotalCount(totalRows);
@@ -126,7 +153,7 @@ public class FishImportServiceImpl implements IFishImportService {
             }
 
             FishImportResult.FishImportRow importRow = parseRow(row, columnIndexMap, i);
-            if (importRow.getData() != null && importRow.getUnrecognizedFields().isEmpty()) {
+            if (importRow.getData() != null && importRow.getWarnings().isEmpty()) {
                 result.getSuccessRows().add(importRow);
                 result.setSuccessCount(result.getSuccessCount() + 1);
             } else {
@@ -146,45 +173,93 @@ public class FishImportServiceImpl implements IFishImportService {
         FishImportResult.FishImportRow importRow = new FishImportResult.FishImportRow(rowIndex);
         FishDraftData data = new FishDraftData();
         data.setId(UUID.randomUUID().toString());
-        List<String> unrecognizedFields = new ArrayList<>();
+        List<String> missingRequiredFields = new ArrayList<>();
 
         for (Map.Entry<Integer, String> entry : columnIndexMap.entrySet()) {
             Integer columnIndex = entry.getKey();
             String fieldName = entry.getValue();
             Cell cell = row.getCell(columnIndex);
             String cellValue = getCellStringValue(cell);
-
-            if (!StringUtils.hasText(cellValue)) {
-                continue;
-            }
-
             try {
                 switch (fieldName) {
-                    case "stcd":
+                    case "stationName":
-                        String stcd = resolveStationCode(cellValue.trim());
+                        if (!StringUtils.hasText(cellValue)) {
-                        if (stcd == null) {
+                            missingRequiredFields.add("电站名称");
-                            importRow.getWarnings().add("无法识别的电站: " + cellValue);
+                        } else {
+                            String stcd = resolveStationCode(cellValue.trim());
+                            if (stcd == null) {
+                                importRow.getWarnings().add(fieldName);
+                                data.setEngName(cellValue.trim());
+                            } else {
+                                data.setEngName(cellValue.trim());
+                            }
                         }
-                        data.setStcd(stcd);
                         break;
-                    case "baseId":
+                    case "baseName":
-                        String baseId = resolveBaseCode(cellValue.trim());
+                        if (!StringUtils.hasText(cellValue)) {
-                        if (baseId == null) {
+                            missingRequiredFields.add("水电基地");
-                            importRow.getWarnings().add("无法识别的基地: " + cellValue);
+                        } else {
+                            String baseId = resolveBaseCode(cellValue.trim());
+                            if (baseId == null) {
+                                importRow.getWarnings().add(fieldName);
+                                data.setBaseId(cellValue.trim());
+                                data.setBaseName(cellValue.trim());
+                            } else {
+                                data.setBaseId(baseId);
+                                data.setBaseName(cellValue.trim());
+                            }
+                        }
+                        break;
+                    case "rvcd":
+                        if (StringUtils.hasText(cellValue)) {
+                            String rvcd = resolveRiverCode(cellValue.trim());
+                            if (rvcd == null) {
+                                importRow.getWarnings().add(fieldName);
+                            } else {
+                                data.setRvcd(rvcd);
+                            }
                         }
-                        data.setBaseId(baseId);
                         break;
                     case "tm":
-                        data.setTm(parseDate(cellValue));
+                        if (!StringUtils.hasText(cellValue)) {
+                            missingRequiredFields.add("过鱼时间");
+                        } else {
+                            Date tm = parseDate(cellValue);
+                            if (tm == null) {
+                                importRow.getWarnings().add("过鱼时间格式错误: " + cellValue);
+                            }
+                            data.setTm(tm);
+                        }
                         break;
                     case "ftp":
-                        data.setFtp(cellValue.trim());
+                        if (!StringUtils.hasText(cellValue)) {
+                            missingRequiredFields.add("鱼种类");
+                        } else {
+                            String stcd = resolveFishDictCode(cellValue.trim());
+                            if (stcd == null) {
+                                importRow.getWarnings().add(fieldName);
+                                data.setFtp(cellValue.trim());
+                                data.setFtpName(cellValue.trim());
+                            } else {
+                                data.setFtp(stcd);
+                                data.setFtpName(cellValue.trim());
+                            }
+                        }
                         break;
                     case "fsz":
                         data.setFsz(cellValue.trim());
                         break;
                     case "fcnt":
-                        data.setFcnt(parseInteger(cellValue));
+                        if (!StringUtils.hasText(cellValue)) {
+                            missingRequiredFields.add("过鱼数量");
+                        } else {
+                            Integer fcnt = parseInteger(cellValue);
+                            if (fcnt == null) {
+                                importRow.getWarnings().add(fieldName);
+                                data.setFcnt(parseInteger(cellValue));
+                            }
+                            data.setFcnt(fcnt);
+                        }
                         break;
                     case "fwet":
                         data.setFwet(cellValue.trim());
@@ -196,7 +271,12 @@ public class FishImportServiceImpl implements IFishImportService {
                         data.setEnddt(parseDate(cellValue));
                         break;
                     case "direction":
-                        data.setDirection(parseDirection(cellValue.trim()));
+                        if (!StringUtils.hasText(cellValue)) {
+                            missingRequiredFields.add("游向");
+                        } else {
+                            String direction = resolveDirection(cellValue.trim(), importRow);
+                            data.setDirection(direction);
+                        }
                         break;
                     case "yr":
                         data.setYr(parseInteger(cellValue));
@@ -211,21 +291,38 @@ public class FishImportServiceImpl implements IFishImportService {
                         data.setPicpth(cellValue.trim());
                         break;
                     case "isfs":
-                        data.setIsfs(parseIsfs(cellValue));
+                        if (StringUtils.hasText(cellValue)) {
+                            String isfs = resolveIsfs(cellValue.trim(), importRow);
+                            data.setIsfs("是".equals(isfs) ? 1 : 0);
+                        }
                         break;
                     case "sourceType":
                         data.setSourceType(parseSourceType(cellValue.trim()));
                         break;
+                    case "fpname":
+                        if (!StringUtils.hasText(cellValue)) {
+                            missingRequiredFields.add("过鱼设施名称");
+                        } else {
+                            String stcd = resolveFpssCode(cellValue.trim());
+                            if (stcd == null) {
+                                importRow.getWarnings().add(fieldName);
+                                data.setStcd(cellValue.trim());
+                                data.setFpname(cellValue.trim());
+                            } else {
+                                data.setFpname(stcd);
+                                data.setStcd(stcd);
+                            }
+                        }
+                        break;
                     default:
                         break;
                 }
             } catch (Exception e) {
-                importRow.getWarnings().add("字段[" + fieldName + "]解析异常: " + e.getMessage());
+                e.printStackTrace();
+//                importRow.getWarnings().add("字段[" + fieldName + "]解析异常: " + e.getMessage());
             }
         }
-
         importRow.setData(data);
-        importRow.setUnrecognizedFields(unrecognizedFields);
         return importRow;
     }
 
@@ -237,7 +334,7 @@ public class FishImportServiceImpl implements IFishImportService {
                     STATION_NAME_CACHE.put(station.getEnnm().trim().toLowerCase(), station.getStcd());
                 }
                 if (StringUtils.hasText(station.getStcd())) {
-                    STATION_CODE_CACHE.put(station.getStcd().trim().toLowerCase(), station.getStcd());
+                    STATION_NAME_CACHE.put(station.getStcd().trim().toLowerCase(), station.getStcd());
                 }
             }
         }
@@ -249,12 +346,50 @@ public class FishImportServiceImpl implements IFishImportService {
                     BASE_NAME_CACHE.put(base.getBasename().trim().toLowerCase(), base.getBaseid());
                 }
                 if (StringUtils.hasText(base.getBaseid())) {
-                    BASE_CODE_CACHE.put(base.getBaseid().trim().toLowerCase(), base.getBaseid());
+                    BASE_NAME_CACHE.put(base.getBaseid().trim().toLowerCase(), base.getBaseid());
+                }
+            }
+        }
+
+        if (RIVER_NAME_CACHE.isEmpty()) {
+            List<SdRvcdDic> riverList = rvcdDicMapper.selectList(null);
+            for (SdRvcdDic river : riverList) {
+                if (StringUtils.hasText(river.getRvnm())) {
+                    RIVER_NAME_CACHE.put(river.getRvnm().trim().toLowerCase(), river.getRvcd());
+                }
+                if (StringUtils.hasText(river.getRvcd())) {
+                    RIVER_NAME_CACHE.put(river.getRvcd().trim().toLowerCase(), river.getRvcd());
+                }
+            }
+        }
+
+        if (FISH_DICT_CACHE.isEmpty()) {
+            List<SdFishDictoryB> sdFishDictoryBS = fishDictoryBMapper.selectList(null);
+            for (SdFishDictoryB fishDictoryB : sdFishDictoryBS) {
+                if (StringUtils.hasText(fishDictoryB.getName())) {
+                    FISH_DICT_CACHE.put(fishDictoryB.getName().trim().toLowerCase(), fishDictoryB.getCode());
+                }
+                if (StringUtils.hasText(fishDictoryB.getCode())) {
+                    FISH_DICT_CACHE.put(fishDictoryB.getCode().trim().toLowerCase(), fishDictoryB.getCode());
+                }
+            }
+        }
+
+        if (FPSS_BH_CACHE.isEmpty()) {
+            List<SdFpssBH> sdFpssBHS = fpssBHMapper.selectList(null);
+            for (SdFpssBH sdFpssBH : sdFpssBHS) {
+                if (StringUtils.hasText(sdFpssBH.getStnm())) {
+                    FPSS_BH_CACHE.put(sdFpssBH.getStnm().trim().toLowerCase(), sdFpssBH.getStcd());
+                }
+                if (StringUtils.hasText(sdFpssBH.getStcd())) {
+                    FPSS_BH_CACHE.put(sdFpssBH.getStcd().trim().toLowerCase(), sdFpssBH.getStcd());
                 }
             }
         }
     }
 
+
+
     private String resolveStationCode(String stationName) {
         if (stationName == null) {
             return null;
@@ -271,6 +406,38 @@ public class FishImportServiceImpl implements IFishImportService {
         return null;
     }
 
+    private String resolveFpssCode(String name) {
+        if (name == null) {
+            return null;
+        }
+        String lowerName = name.toLowerCase().trim();
+        if (FPSS_BH_CACHE.containsKey(lowerName)) {
+            return FPSS_BH_CACHE.get(lowerName);
+        }
+        for (Map.Entry<String, String> entry : FPSS_BH_CACHE.entrySet()) {
+            if (entry.getKey().contains(lowerName) || lowerName.contains(entry.getKey())) {
+                return entry.getValue();
+            }
+        }
+        return null;
+    }
+
+    private String resolveFishDictCode(String name) {
+        if (name == null) {
+            return null;
+        }
+        String lowerName = name.toLowerCase().trim();
+        if (FISH_DICT_CACHE.containsKey(lowerName)) {
+            return FISH_DICT_CACHE.get(lowerName);
+        }
+        for (Map.Entry<String, String> entry : FISH_DICT_CACHE.entrySet()) {
+            if (entry.getKey().contains(lowerName) || lowerName.contains(entry.getKey())) {
+                return entry.getValue();
+            }
+        }
+        return null;
+    }
+
     private String resolveBaseCode(String baseName) {
         if (baseName == null) {
             return null;
@@ -287,6 +454,165 @@ public class FishImportServiceImpl implements IFishImportService {
         return null;
     }
 
+    private String resolveRiverCode(String riverName) {
+        if (riverName == null) {
+            return null;
+        }
+        String lowerName = riverName.toLowerCase().trim();
+        if (RIVER_NAME_CACHE.containsKey(lowerName)) {
+            return RIVER_NAME_CACHE.get(lowerName);
+        }
+        for (Map.Entry<String, String> entry : RIVER_NAME_CACHE.entrySet()) {
+            if (entry.getKey().contains(lowerName) || lowerName.contains(entry.getKey())) {
+                return entry.getValue();
+            }
+        }
+        return null;
+    }
+
+    private String validateFishType(String fishName, FishImportResult.FishImportRow importRow) {
+        if (fishName == null) {
+            return null;
+        }
+        String lowerName = fishName.toLowerCase().trim();
+
+        if (!FISH_DICT_CACHE.isEmpty()) {
+            if (FISH_DICT_CACHE.containsKey(lowerName)) {
+                return FISH_DICT_CACHE.get(lowerName);
+            }
+            for (Map.Entry<String, String> entry : FISH_DICT_CACHE.entrySet()) {
+                if (entry.getKey().contains(lowerName) || lowerName.contains(entry.getKey())) {
+                    return entry.getValue();
+                }
+            }
+        }
+
+        importRow.getWarnings().add("鱼种类【" + fishName + "】未在字典中找到匹配，请手动确认");
+        return fishName;
+    }
+
+    private String validateFishFacility(String facilityName, FishImportResult.FishImportRow importRow) {
+        if (facilityName == null) {
+            return null;
+        }
+        String lowerName = facilityName.toLowerCase().trim();
+
+        importRow.getWarnings().add("过鱼设施【" + facilityName + "】暂无可用字典验证，请手动确认");
+        return facilityName;
+    }
+
+    private String resolveDirection(String direction, FishImportResult.FishImportRow importRow) {
+        if (direction == null) {
+            return null;
+        }
+        String lowerName = direction.toLowerCase().trim();
+
+        if (!DIRECTION_DICT_CACHE.isEmpty()) {
+            if (DIRECTION_DICT_CACHE.containsKey(lowerName)) {
+                return DIRECTION_DICT_CACHE.get(lowerName);
+            }
+            for (Map.Entry<String, String> entry : DIRECTION_DICT_CACHE.entrySet()) {
+                if (entry.getKey().contains(lowerName) || lowerName.contains(entry.getKey())) {
+                    return entry.getValue();
+                }
+            }
+        }
+
+        if (lowerName.contains("上行") && lowerName.contains("折返")) {
+            return "上行折返";
+        } else if (lowerName.contains("下行") && lowerName.contains("折返")) {
+            return "下行折返";
+        } else if (lowerName.contains("上行")) {
+            return "上行";
+        } else if (lowerName.contains("下行")) {
+            return "下行";
+        }
+
+        importRow.getWarnings().add("无法识别的游向: " + direction + "，请手动选择");
+        return direction;
+    }
+
+    private String resolveIsfs(String value, FishImportResult.FishImportRow importRow) {
+        if (value == null) {
+            return null;
+        }
+        String lowerName = value.toLowerCase().trim();
+
+        if (!ISFS_DICT_CACHE.isEmpty()) {
+            if (ISFS_DICT_CACHE.containsKey(lowerName)) {
+                return ISFS_DICT_CACHE.get(lowerName);
+            }
+            for (Map.Entry<String, String> entry : ISFS_DICT_CACHE.entrySet()) {
+                if (entry.getKey().contains(lowerName) || lowerName.contains(entry.getKey())) {
+                    return entry.getValue();
+                }
+            }
+        }
+
+        if (lowerName.equals("1") || lowerName.equals("是") || lowerName.equals("yes") || lowerName.equals("true")) {
+            return "是";
+        } else if (lowerName.equals("0") || lowerName.equals("否") || lowerName.equals("no") || lowerName.equals("false")) {
+            return "否";
+        }
+
+        importRow.getWarnings().add("无法识别的【是否鱼苗】值: " + value + "，将默认设置为【否】");
+        return "否";
+    }
+
+//    private void loadDirectionDict() {
+//        if (DIRECTION_DICT_CACHE.isEmpty()) {
+//            try {
+//                SysDictionary dict = sysDictionaryService.getByDictCode(DICT_CODE_DIRECTION);
+//                if (dict != null) {
+//                    List<SysDictionaryItems> items = sysDictionaryItemsService.listByDictId(dict.getId());
+//                    for (SysDictionaryItems item : items) {
+//                        if (StringUtils.hasText(item.getItemName())) {
+//                            DIRECTION_DICT_CACHE.put(item.getItemName().trim().toLowerCase(), item.getItemName());
+//                        }
+//                    }
+//                }
+//            } catch (Exception e) {
+//            }
+//        }
+//    }
+//
+//    private void loadIsfsDict() {
+//        if (ISFS_DICT_CACHE.isEmpty()) {
+//            try {
+//                SysDictionary dict = sysDictionaryService.getByDictCode(DICT_CODE_ISFS);
+//                if (dict != null) {
+//                    List<SysDictionaryItems> items = sysDictionaryItemsService.listByDictId(dict.getId());
+//                    for (SysDictionaryItems item : items) {
+//                        if (StringUtils.hasText(item.getItemName())) {
+//                            ISFS_DICT_CACHE.put(item.getItemName().trim().toLowerCase(), item.getItemName());
+//                        }
+//                    }
+//                }
+//            } catch (Exception e) {
+//            }
+//        }
+//    }
+
+//    private void loadFishDict() {
+//        if (FISH_DICT_CACHE.isEmpty()) {
+//            try {
+//                SysDictionary dict = sysDictionaryService.getByDictCode(DICT_CODE_FISH);
+//                if (dict != null) {
+//                    List<SysDictionaryItems> items = sysDictionaryItemsService.listByDictId(dict.getId());
+//                    for (SysDictionaryItems item : items) {
+//                        if (StringUtils.hasText(item.getItemName())) {
+//                            FISH_DICT_CACHE.put(item.getItemName().trim().toLowerCase(), item.getItemCode());
+//                        }
+//                        if (StringUtils.hasText(item.getItemCode())) {
+//                            FISH_DICT_CACHE.put(item.getItemCode().trim().toLowerCase(), item.getItemCode());
+//                        }
+//                    }
+//                }
+//            } catch (Exception e) {
+//            }
+//        }
+//    }
+
     private String getCellStringValue(Cell cell) {
         if (cell == null) {
             return "";
@@ -359,37 +685,6 @@ public class FishImportServiceImpl implements IFishImportService {
         }
     }
 
-    private String parseDirection(String direction) {
-        if (!StringUtils.hasText(direction)) {
-            return null;
-        }
-        String d = direction.toLowerCase();
-        if (d.contains("上行") || d.contains("up")) {
-            return "上行";
-        } else if (d.contains("下行") || d.contains("down")) {
-            return "下行";
-        } else if (d.contains("折返")) {
-            if (d.contains("上行")) {
-                return "上行折返";
-            } else if (d.contains("下行")) {
-                return "下行折返";
-            }
-            return "折返";
-        }
-        return direction;
-    }
-
-    private Integer parseIsfs(String value) {
-        if (!StringUtils.hasText(value)) {
-            return 0;
-        }
-        String v = value.toLowerCase().trim();
-        if (v.equals("1") || v.equals("是") || v.equals("yes") || v.equals("鱼苗")) {
-            return 1;
-        }
-        return 0;
-    }
-
     private String parseSourceType(String value) {
         if (!StringUtils.hasText(value)) {
             return "IMPORT";
@@ -397,7 +692,7 @@ public class FishImportServiceImpl implements IFishImportService {
         String v = value.toLowerCase();
         if (v.contains("手工") || v.contains("manual") || v.contains("录入")) {
             return "MANUAL";
-        } else if (v.contains("自动") || v.contains("auto")) {
+        } else if (v.contains("自动") || v.contains("auto") || v.contains("采集")) {
             return "AUTO";
         } else if (v.contains("导入") || v.contains("import")) {
             return "IMPORT";

backend/src/main/java/com/yfd/platform/env/domain/SdFishDictoryB.java

@@ -7,6 +7,11 @@ import lombok.EqualsAndHashCode;
 import java.io.Serializable;
 import java.util.Date;
 
+/**
+ * <p>
+ * 鱼类字典信息表
+ * </p>
+ */
 @Data
 @EqualsAndHashCode(callSuper = false)
 @TableName("SD_FISHDICTORY_B")
@@ -14,104 +19,254 @@ public class SdFishDictoryB implements Serializable {
 
     private static final long serialVersionUID = 1L;
 
+    /**
+     * 主键
+     */
     @TableId(type = IdType.INPUT)
     private String id;
 
+    /**
+     * 编码
+     */
     private String code;
 
+    /**
+     * 名称
+     */
     private String name;
 
+    /**
+     * 英文名称
+     */
     private String nameEn;
 
+    /**
+     * 俗名
+     */
     private String alias;
 
+    /**
+     * LOGO
+     */
     private String logo;
 
+    /**
+     * 介绍
+     */
     private String introduce;
 
+    /**
+     * 介绍弹窗图片
+     */
     private String inffile;
 
+    /**
+     * 目
+     */
     private String orders;
 
+    /**
+     * 科
+     */
     private String family;
 
+    /**
+     * 属
+     */
     private String genus;
 
+    /**
+     * 种
+     */
     private String species;
 
+    /**
+     * 分类：1=淡水 2=海水
+     */
     private Integer type;
 
+    /**
+     * 成鱼大小：单位：cm
+     */
     private String fsz;
 
+    /**
+     * 是否珍稀鱼类：0=否 1=是
+     */
     private Integer rare;
 
+    /**
+     * 物种来源：1=本土物种 2=外来物种
+     */
     private Integer specOrigin;
 
+    /**
+     * 保护类型：1=濒危 2=极危 3=近危 4=易危 5=重点保护 6=无危 7=国家二级 8=市二级保护
+     */
     private Integer ptype;
 
+    /**
+     * 所属流域
+     */
     private String rvcd;
 
+    /**
+     * 洄游习性
+     */
     private String habitMigrat;
 
+    /**
+     * 摄食习性
+     */
     private String feedingHabit;
 
+    /**
+     * 产卵特性
+     */
     private String spawnCharact;
 
+    /**
+     * 主要食物
+     */
     private String food;
 
+    /**
+     * 觅食时段
+     */
     private String timeFeed;
 
+    /**
+     * 产地及产期
+     */
     private String orignDate;
 
+    /**
+     * 适宜温度：单位：℃
+     */
     private String pretemp;
 
+    /**
+     * 适宜流速：单位：m/s
+     */
     private String flowRate;
 
+    /**
+     * 适宜水深：单位（m）
+     */
     private String depth;
 
+    /**
+     * 适宜底质
+     */
     private String botmMater;
 
+    /**
+     * 水质要求：1=Ⅰ类 2=Ⅱ类 3=Ⅲ类 4=Ⅳ类 5=Ⅴ类 6=劣质V
+     */
     private String wqtq;
 
+    /**
+     * 主要生活环境 1=流水生境 2=静缓流生境 3=洞穴生境
+     */
     private Integer habitat;
 
+    /**
+     * 种群现状 1=优势种 2=常见种 3=少见种 4=记录种
+     */
     private Integer situation;
 
+    /**
+     * 资源类型 1=保护鱼类 2=特有鱼类 3=重要经济鱼类 4=濒危状况
+     */
     private Integer resourceType;
 
+    /**
+     * 形态描述
+     */
     private String shapedesc;
 
+    /**
+     * 保护级别
+     */
     private String protectlvl;
 
+    /**
+     * 栖息习性
+     */
     private String habitation;
 
+    /**
+     * 附件
+     */
     private String fid;
 
+    /**
+     * 描述
+     */
     private String description;
 
+    /**
+     * 是否启用：0=禁用 1=启用
+     */
     private Integer enable;
 
+    /**
+     * 系统内置项：0=否 1=是
+     */
     private Integer internal;
 
+    /**
+     * 排序
+     */
     private Integer orderIndex;
 
+    /**
+     * 创建人：关联SYS_USER.ID
+     */
     private String recordUser;
 
+    /**
+     * 创建时间
+     */
     private Date recordTime;
 
+    /**
+     * 更新人：关联SYS_USER.ID
+     */
     private String modifyUser;
 
+    /**
+     * 更新时间
+     */
     private Date modifyTime;
 
+    /**
+     * 是否已删除：0=未删除 1=已删除
+     */
     private Integer isDeleted;
 
+    /**
+     * 删除人：关联SYS_USER.ID
+     */
     private String deleteUser;
 
+    /**
+     * 删除时间
+     */
     private Date deleteTime;
 
+    /**
+     * 产卵月份：多个月份以逗号分隔
+     */
     private String spawnMonth;
 
+    /**
+     * 数据来源
+     */
     private String vlsr;
 
+    /**
+     * 数据来源时间
+     */
     private Date vlsrTm;
 }

backend/src/main/java/com/yfd/platform/env/domain/SdFpssBH.java

@@ -1,6 +1,7 @@
 package com.yfd.platform.env.domain;
 
 import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
@@ -9,150 +10,373 @@ import java.io.Serializable;
 import java.math.BigDecimal;
 import java.util.Date;
 
+/**
+ * <p>
+ * 过鱼设施工程信息表
+ * </p>
+ */
 @Data
 @TableName("SD_FPSS_B_H")
 public class SdFpssBH implements Serializable {
 
     private static final long serialVersionUID = 1L;
 
+    /**
+     * 过鱼设施编码
+     */
     @TableId(type = IdType.INPUT)
     private String stcd;
 
-    private String sttp;
+    /**
+     * 设施名称
+     */
+    private String stnm;
 
+    /**
+     * 数据时间
+     */
     private Date tm;
 
+    /**
+     * 过鱼设施类型，字典编码：sd_fpss_b_h.sttp
+     * FP_1=鱼道 FP_2=仿自然通道 FP_3=集运鱼系统 FP_4=升鱼机 FP_5=其它过鱼方式 FP_6=网捕过坝
+     */
+    private String sttp;
+
+    /**
+     * 所属建设阶段 字典编码：common.blprd
+     * 1001000=规划 1002000=预可研 1003000=环评 1004000=可研 1005000=在建 1006000=招标设计
+     * 1007000=施工详图 1009000=建设 1010000=蓄水阶段环保验收 1011000=竣工 1012000=竣工环保验收 1013000=环境影响后评价
+     */
     private Integer blprd;
 
+    /**
+     * 经度，单位：(°)
+     */
     private BigDecimal lgtd;
 
+    /**
+     * 纬度，单位：(°)
+     */
     private BigDecimal lttd;
 
+    /**
+     * 高程，单位：m
+     */
     private BigDecimal elev;
 
+    /**
+     * 站址/位置
+     */
     private String stlc;
 
+    /**
+     * 是否启用 字典编码：common.enabled 0=禁用 1=启用
+     */
     private Integer usfl;
 
+    /**
+     * 数据是否接入 字典编码：common.yn 0=否 1=是
+     */
     private Integer dtin;
 
+    /**
+     * 数据接入时间
+     */
     private Date dtinTm;
 
+    /**
+     * 排序，按照业务规则"升序"
+     */
     private Integer orderIndex;
 
+    /**
+     * 所属电站编码，关联SD_ENGINFO_B_H.STCD
+     */
     private String rstcd;
 
+    /**
+     * 规划设计日期
+     */
     private Date stdsdt;
 
+    /**
+     * 计划开工日期
+     */
     private Date pststdt;
 
+    /**
+     * 计划完工日期
+     */
     private Date pesstdt;
 
+    /**
+     * 开工日期
+     */
     private Date swdt;
 
+    /**
+     * 建成日期
+     */
     private Date jcdt;
 
+    /**
+     * 退役/拆除日期
+     */
     private Date wddt;
 
+    /**
+     * 建设状态分类：0=未建/规划(3,4,5,6,为空) 1=在建(2,7,8) 2=已建(1,10,11)
+     */
     private Integer bldsttCode;
 
+    /**
+     * 简介
+     */
     private String introduce;
 
+    /**
+     * LOGO
+     */
     private String logo;
 
+    /**
+     * 介绍弹窗图片
+     */
     private String inffile;
 
+    /**
+     * 投资，单位：亿元
+     */
     private BigDecimal inv;
 
+    /**
+     * 鱼道型式
+     */
     private String ydxs;
 
+    /**
+     * 鱼道总长度，单位：m
+     */
     private BigDecimal ydzcd;
 
+    /**
+     * 鱼道进口运行设计水位，单位：m
+     */
     private BigDecimal ydjkz;
 
+    /**
+     * 鱼道进口数量，单位：个
+     */
     private Integer ydjkcnt;
 
+    /**
+     * 鱼道或仿自然通道-进口高程，单位：m
+     */
     private BigDecimal jkhg;
 
+    /**
+     * 鱼道进口诱鱼型式
+     */
     private String ydyyxs;
 
+    /**
+     * 鱼道出口运行设计水位，单位：m
+     */
     private BigDecimal ydckz;
 
+    /**
+     * 鱼道出口数量，单位：个
+     */
     private Integer ydckcnt;
 
+    /**
+     * 鱼道或仿自然通道-出口高程，单位：m
+     */
     private BigDecimal ckhg;
 
+    /**
+     * 鱼道池室设计流速，单位：m/s
+     */
     private BigDecimal ydcsv;
 
+    /**
+     * 鱼道每级池室长，单位：m
+     */
     private Integer ydcscd;
 
+    /**
+     * 鱼道每级池室宽，单位：m
+     */
     private Integer ydcskd;
 
+    /**
+     * 鱼道池室坡度
+     */
     private String ydcspd;
 
+    /**
+     * 鱼道池室数量，单位：个
+     */
     private Integer ydcscnt;
 
+    /**
+     * 鱼道休息池个数
+     */
     private Integer ydxxccnt;
 
+    /**
+     * 鱼道或仿自然通道-流速，单位：m/s
+     */
     private BigDecimal v;
 
+    /**
+     * 仿自然通道断面形状
+     */
     private String fzrdmxz;
 
-    private String fzrtdz;
+    /**
+     * 仿自然通道长度*宽度
+     */
+    private String fzrtdsz;
 
+    /**
+     * 仿自然通道运行水深，单位：m
+     */
     private BigDecimal fzryxwdp;
 
+    /**
+     * 仿自然通道坡降
+     */
     private BigDecimal fzrpj;
 
-    private String symtlcs;
+    /**
+     * 集运鱼系统或升鱼机-上游码头位置
+     */
+    private String symtlc;
 
+    /**
+     * 集运鱼系统或升鱼机-上游码头型式
+     */
     private String symtxs;
 
-    private String xymtlcs;
+    /**
+     * 集运鱼系统或升鱼机-下游码头位置
+     */
+    private String xymtlc;
 
+    /**
+     * 集运鱼系统或升鱼机-下游码头型式
+     */
     private String xymtxs;
 
+    /**
+     * 集运鱼系统或升鱼机-集诱鱼方式
+     */
     private String jyfs;
 
+    /**
+     * 集运鱼系统或升鱼机-运鱼设施方式
+     */
     private String yyfs;
 
+    /**
+     * 升鱼机集鱼槽数量，单位：个
+     */
     private Integer syjcnt;
 
+    /**
+     * 升鱼机集鱼槽进口高程，单位：m
+     */
     private BigDecimal syjhg;
 
+    /**
+     * 升鱼机集鱼槽流量，单位：m3/s
+     */
     private BigDecimal syjq;
 
+    /**
+     * 升鱼机断面尺寸（长*宽*高），单位：m
+     */
     private String syjsz;
 
+    /**
+     * 升鱼机集鱼槽水深，单位：m
+     */
     private BigDecimal syjwdp;
 
+    /**
+     * 设计过鱼规模，单位：尾
+     */
     private Long sjgycnt;
 
-    private String ZygyDx;
+    /**
+     * 主要过鱼对象{[code:鱼编码1,name:鱼名称1，数量],[code:鱼编码2,name:鱼名称2]...}
+     */
+    private String zygydx;
 
-    private String ZygyDxms;
+    /**
+     * 主要过鱼对象描述
+     */
+    private String zygydxms;
 
-    private String JggyDx;
+    /**
+     * 兼顾过鱼对象{[code:鱼编码1,name:鱼名称1，数量],[code:鱼编码2,name:鱼名称2]...}
+     */
+    private String jggydx;
 
-    private String JggyDxms;
+    /**
+     * 兼顾过鱼对象描述
+     */
+    private String jggydxms;
 
+    /**
+     * 过鱼时间
+     */
     private String gytm;
 
+    /**
+     * 运行时间
+     */
     private String yxtm;
 
+    /**
+     * 主要过鱼月份（多个月份用,隔开）
+     */
     private String fpssmn;
 
+    /**
+     * 数据监测频次，单位：min
+     */
     private Integer dtfrqcy;
 
+    /**
+     * 基本特性参数（文字描述）
+     */
     private String jbtxcs;
 
+    /**
+     * 设施是否实现鱼类上行 0=否 1=是
+     */
     private Integer isUp;
 
+    /**
+     * 设施是否实现鱼类下行 0=否 1=是
+     */
     private Integer isDown;
 
+    /**
+     * 备注
+     */
     private String remark;
 
+    /**
+     * 数据来源
+     */
     private String vlsr;
 
+    /**
+     * 数据来源时间
+     */
     private Date vlsrTm;
 }