|
5 | 5 | import org.javawebstack.graph.GraphArray; |
6 | 6 | import org.javawebstack.graph.GraphElement; |
7 | 7 | import org.javawebstack.graph.GraphMapper; |
| 8 | +import org.javawebstack.graph.GraphNull; |
8 | 9 | import org.javawebstack.validator.rule.*; |
9 | 10 |
|
10 | 11 | import java.lang.reflect.Constructor; |
@@ -128,54 +129,88 @@ public Validator rule(String key, ValidationRule... rules){ |
128 | 129 |
|
129 | 130 | public ValidationResult validate(GraphElement rootElement){ |
130 | 131 | Map<String[], List<String>> errors = new HashMap<>(); |
131 | | - for(String[] sourceKey : rules.keySet()){ |
132 | | - Map<String[], GraphElement> map = matchKeys(sourceKey, rootElement); |
133 | | - List<ValidationRule> validators = rules.get(sourceKey); |
134 | | - map.forEach((key, value) -> { |
135 | | - List<String> fieldErrors = new ArrayList<>(); |
136 | | - for(ValidationRule rule : validators){ |
137 | | - String error = rule.validate(this, value); |
138 | | - if(error != null) |
139 | | - fieldErrors.add(error); |
140 | | - } |
141 | | - if(fieldErrors.size() > 0) |
142 | | - errors.put(key, fieldErrors); |
143 | | - }); |
| 132 | + for(String[] key : rules.keySet()){ |
| 133 | + errors.putAll(check(rules, new String[0], new String[0], key, rootElement)); |
144 | 134 | } |
145 | 135 | return new ValidationResult(errors); |
146 | 136 | } |
147 | 137 |
|
148 | | - private Map<String[], GraphElement> matchKeys(String[] keys, GraphElement element){ |
149 | | - Map<String[], GraphElement> result = new HashMap<>(); |
150 | | - if(keys.length == 0){ |
151 | | - result.put(keys, element); |
152 | | - return result; |
| 138 | + private Map<String[], List<String>> check(Map<String[], List<ValidationRule>> rules, String[] keyPrefix, String[] resolvedKeyPrefix, String[] key, GraphElement element){ |
| 139 | + if(key.length == 0){ |
| 140 | + Map<String[], List<String>> errors = new HashMap<>(); |
| 141 | + for(ValidationRule rule : getMapValue(rules, keyPrefix)){ |
| 142 | + String error = rule.validate(this, element); |
| 143 | + if(error != null){ |
| 144 | + if(!errors.containsKey(resolvedKeyPrefix)) |
| 145 | + errors.put(resolvedKeyPrefix, new ArrayList<>()); |
| 146 | + errors.get(resolvedKeyPrefix).add(error); |
| 147 | + } |
| 148 | + } |
| 149 | + return errors; |
| 150 | + } |
| 151 | + if(element == null) |
| 152 | + element = GraphNull.INSTANCE; |
| 153 | + String[] innerKey = new String[key.length-1]; |
| 154 | + System.arraycopy(key, 1, innerKey, 0, innerKey.length); |
| 155 | + String[] innerKeyPrefix = new String[keyPrefix.length+1]; |
| 156 | + System.arraycopy(keyPrefix, 0, innerKeyPrefix, 0, keyPrefix.length); |
| 157 | + innerKeyPrefix[innerKeyPrefix.length-1] = key[0]; |
| 158 | + if(key[0].equals("*")){ |
| 159 | + Map<String[], List<String>> errors = new HashMap<>(); |
| 160 | + if(element.isArray()){ |
| 161 | + for(int i=0; i<element.array().size(); i++){ |
| 162 | + String[] innerResolvedKeyPrefix = new String[keyPrefix.length+1]; |
| 163 | + System.arraycopy(resolvedKeyPrefix, 0, innerResolvedKeyPrefix, 0, resolvedKeyPrefix.length); |
| 164 | + innerResolvedKeyPrefix[innerResolvedKeyPrefix.length-1] = String.valueOf(i); |
| 165 | + errors.putAll(check(rules, innerKeyPrefix, innerResolvedKeyPrefix, innerKey, element.array().get(i))); |
| 166 | + } |
| 167 | + } |
| 168 | + if(element.isObject()){ |
| 169 | + for(String k : element.object().keys()){ |
| 170 | + String[] innerResolvedKeyPrefix = new String[keyPrefix.length+1]; |
| 171 | + System.arraycopy(resolvedKeyPrefix, 0, innerResolvedKeyPrefix, 0, resolvedKeyPrefix.length); |
| 172 | + innerResolvedKeyPrefix[innerResolvedKeyPrefix.length-1] = k; |
| 173 | + errors.putAll(check(rules, innerKeyPrefix, innerResolvedKeyPrefix, innerKey, element.object().get(k))); |
| 174 | + } |
| 175 | + } |
| 176 | + return errors; |
| 177 | + } |
| 178 | + GraphElement value = GraphNull.INSTANCE; |
| 179 | + if(element.isArray()){ |
| 180 | + try { |
| 181 | + value = element.array().get(Integer.parseInt(key[0])); |
| 182 | + }catch (Exception ignored){} |
153 | 183 | } |
154 | | - if(element.isArray()) |
155 | | - element = element.object(); |
156 | 184 | if(element.isObject()){ |
157 | | - String currentKey = keys[0]; |
158 | | - String[] newKeys = new String[keys.length-1]; |
159 | | - System.arraycopy(keys, 1, newKeys, 0, newKeys.length); |
160 | | - if(currentKey != null){ |
161 | | - matchKeys(newKeys, element.object().get(currentKey)).forEach((nk, actualValue) -> { |
162 | | - String[] actualKey = new String[nk.length + 1]; |
163 | | - actualKey[0] = currentKey; |
164 | | - System.arraycopy(nk, 0, actualKey, 1, nk.length); |
165 | | - result.put(actualKey, actualValue); |
166 | | - }); |
167 | | - }else{ |
168 | | - element.object().forEach((k, value) -> { |
169 | | - matchKeys(newKeys, value).forEach((nk, actualValue) -> { |
170 | | - String[] actualKey = new String[nk.length + 1]; |
171 | | - actualKey[0] = k; |
172 | | - System.arraycopy(nk, 0, actualKey, 1, nk.length); |
173 | | - result.put(actualKey, actualValue); |
174 | | - }); |
175 | | - }); |
| 185 | + value = element.object().get(key[0]); |
| 186 | + } |
| 187 | + String[] innerResolvedKeyPrefix = new String[keyPrefix.length+1]; |
| 188 | + System.arraycopy(resolvedKeyPrefix, 0, innerResolvedKeyPrefix, 0, resolvedKeyPrefix.length); |
| 189 | + innerResolvedKeyPrefix[innerResolvedKeyPrefix.length-1] = key[0]; |
| 190 | + return check(rules, innerKeyPrefix, innerResolvedKeyPrefix, innerKey, value); |
| 191 | + } |
| 192 | + |
| 193 | + private static boolean stringArrayEqual(String[] a, String[] b){ |
| 194 | + if(a.length != b.length) |
| 195 | + return false; |
| 196 | + for(int i=0; i<a.length; i++){ |
| 197 | + if(a[0] == null && b[0] == null) |
| 198 | + continue; |
| 199 | + if(a[0] == null || b[0] == null) |
| 200 | + return false; |
| 201 | + if(!a[0].equals(b[0])) |
| 202 | + return false; |
| 203 | + } |
| 204 | + return true; |
| 205 | + } |
| 206 | + |
| 207 | + private static <V> V getMapValue(Map<String[], V> map, String[] key){ |
| 208 | + for(String[] k : map.keySet()){ |
| 209 | + if(stringArrayEqual(k, key)){ |
| 210 | + return map.get(k); |
176 | 211 | } |
177 | 212 | } |
178 | | - return result; |
| 213 | + return null; |
179 | 214 | } |
180 | 215 |
|
181 | 216 | private static Map<String[], List<ValidationRule>> getClassRules(Class<?> type){ |
|
0 commit comments