Initial commit: bositao cloud (jnpf-java-cloud-v6x)

刘光辉

8 小时以前 06f314545ac3514d7ce28939920866ae8188d31c

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
package jnpf.base.util;
 
import jnpf.constant.GenerateConstant;
import jnpf.util.JsonUtil;
import jnpf.util.StringUtil;
import jnpf.util.visiual.JnpfKeyConsts;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.StringJoiner;
 
/** Validates field names against reserved keywords in the original form configuration. */
public final class VisualFieldKeywordValidator {
 
    private VisualFieldKeywordValidator() {
    }
 
    public static String invalidFields(String fieldsJson) {
        StringJoiner invalid = new StringJoiner(",");
        collect(JsonUtil.getJsonToListMap(fieldsJson), invalid);
        return invalid.toString();
    }
 
    private static void collect(List<Map<String, Object>> fields, StringJoiner invalid) {
        if (fields == null) {
            return;
        }
        for (Map<String, Object> field : fields) {
            Map<String, Object> config = asMap(field.get("__config__"));
            if (config == null) {
                continue;
            }
            Object children = config.get("children");
            if (JnpfKeyConsts.CHILD_TABLE.equals(config.get("jnpfKey"))) {
                for (Map<String, Object> child : asMapList(children)) {
                    checkField(child, invalid);
                }
            } else if (children != null) {
                collect(asMapList(children), invalid);
            } else {
                checkField(field, invalid);
            }
        }
    }
 
    private static void checkField(Map<String, Object> field, StringJoiner invalid) {
        String fieldName = (String) field.get("__vModel__");
        if (StringUtil.isEmpty(fieldName) || !GenerateConstant.containKeyword(fieldName)) {
            return;
        }
        Map<String, Object> config = asMap(field.get("__config__"));
        if ("f_flow_state".equals(fieldName) && config != null
                && JnpfKeyConsts.SELECT.equals(config.get("jnpfKey"))
                && Boolean.TRUE.equals(config.get("isDisplayOnly"))) {
            return;
        }
        invalid.add(String.valueOf(config == null ? null : config.get("label")) + "-" + fieldName);
    }
 
    @SuppressWarnings("unchecked")
    private static Map<String, Object> asMap(Object value) {
        return value instanceof Map ? (Map<String, Object>) value : null;
    }
 
    private static List<Map<String, Object>> asMapList(Object value) {
        List<Map<String, Object>> result = new ArrayList<>();
        if (value instanceof List) {
            for (Object child : (List<?>) value) {
                Map<String, Object> field = asMap(child);
                if (field != null) {
                    result.add(field);
                }
            }
        }
        return result;
    }
}