自动化立体仓库 - WMS系统
zwl
19 小时以前 a1b99c6eb0e36c36f7696eff9bc23ecf57206661
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
package com.zy.asrs.task.support;
 
import com.alibaba.fastjson.JSON;
import com.core.common.Cools;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
 
@Slf4j
@Service
public class AutoFrontLocMoveConfigResolver {
 
    public static final String CONFIG_CODE = "AutoFrontLocMove";
 
    private static final int DEFAULT_INTERVAL_SECONDS = 60;
    private static final long DEFAULT_USER_ID = 9527L;
 
    @Autowired
    private ConfigService configService;
 
    /**
     * 从 sys_config 读取 JSON 配置。
     * 配置缺失、停用或解析失败时,回退成“关闭状态”的默认配置。
     */
    public AutoFrontLocMoveSettings resolve() {
        AutoFrontLocMoveSettings settings = defaults();
        Config config = configService.selectConfigByCode(CONFIG_CODE);
        if (!isConfigEnabled(config)) {
            return settings;
        }
        try {
            AutoFrontLocMoveSettings parsed = JSON.parseObject(config.getValue(), AutoFrontLocMoveSettings.class);
            if (parsed == null) {
                return settings;
            }
            normalize(parsed);
            return parsed;
        } catch (Exception e) {
            log.error("前排补货移库配置解析失败,code={}, value={}", CONFIG_CODE, config.getValue(), e);
            return settings;
        }
    }
 
    AutoFrontLocMoveSettings defaults() {
        AutoFrontLocMoveSettings settings = new AutoFrontLocMoveSettings();
        settings.setEnabled(false);
        settings.setIntervalSeconds(DEFAULT_INTERVAL_SECONDS);
        settings.setUserId(DEFAULT_USER_ID);
        settings.setRules(new ArrayList<>());
        return settings;
    }
 
    void normalize(AutoFrontLocMoveSettings settings) {
        if (settings.getIntervalSeconds() == null || settings.getIntervalSeconds() <= 0) {
            settings.setIntervalSeconds(DEFAULT_INTERVAL_SECONDS);
        }
        if (settings.getUserId() == null || settings.getUserId() <= 0L) {
            settings.setUserId(DEFAULT_USER_ID);
        }
        List<AutoFrontLocMoveSettings.Rule> normalizedRules = new ArrayList<>();
        if (!Cools.isEmpty(settings.getRules())) {
            for (AutoFrontLocMoveSettings.Rule rule : settings.getRules()) {
                if (rule == null || rule.getCrnNo() == null) {
                    continue;
                }
                List<Integer> frontRows = parseRows(rule.getFrontRows());
                if (frontRows.isEmpty()) {
                    continue;
                }
                // 解析结果预先挂在 rule 上,调度执行时直接使用,避免每次扫描重复拆字符串。
                rule.setFrontRowList(frontRows);
                rule.setSourceRowList(parseRows(rule.getSourceRows()));
                normalizedRules.add(rule);
            }
        }
        settings.setRules(normalizedRules);
        if (normalizedRules.isEmpty()) {
            settings.setEnabled(false);
        }
    }
 
    List<Integer> parseRows(String rawRows) {
        LinkedHashSet<Integer> rows = new LinkedHashSet<>();
        if (Cools.isEmpty(rawRows)) {
            return new ArrayList<>();
        }
        String[] parts = rawRows.split(",");
        for (String part : parts) {
            String token = part == null ? null : part.trim();
            if (Cools.isEmpty(token)) {
                continue;
            }
            if (token.contains("-")) {
                String[] range = token.split("-");
                if (range.length != 2) {
                    continue;
                }
                Integer start = safeParseInt(range[0]);
                Integer end = safeParseInt(range[1]);
                if (start == null || end == null || start <= 0 || end <= 0) {
                    continue;
                }
                // 支持正序/倒序区间,例如 1-3 或 20-18。
                int step = start <= end ? 1 : -1;
                for (int row = start; ; row += step) {
                    rows.add(row);
                    if (row == end) {
                        break;
                    }
                }
                continue;
            }
            Integer row = safeParseInt(token);
            if (row != null && row > 0) {
                rows.add(row);
            }
        }
        return new ArrayList<>(rows);
    }
 
    private boolean isConfigEnabled(Config config) {
        return config != null
                && config.getStatus() != null
                && config.getStatus() == 1
                && !Cools.isEmpty(config.getValue());
    }
 
    private Integer safeParseInt(String raw) {
        try {
            return Integer.parseInt(raw.trim());
        } catch (Exception ignore) {
            return null;
        }
    }
}