1 /**
2 * @ProjectName: BSP 海康威视大数据服务平台
3 * @Copyright: 2015 HangZhou Hikvision System Technology Co., Ltd. All Right Reserved.
4 * @address: http://www.hikvision.com
5 * @date: 2016/5/19 9:43
6 * @Description: 本内容仅限于杭州海康威视数字技术股份有限公司内部使用，禁止转发.
7 */
8 package com.hikvision.bsp.facecloud.utils;
9
10 import com.alibaba.fastjson.JSON;
11 import com.alibaba.fastjson.JSONObject;
12 import com.alibaba.fastjson.util.TypeUtils;
13 import com.hikvision.bsp.common.exception.BaseException;
14 import com.hikvision.bsp.common.util.DateFormatUtils;
15 import com.hikvision.bsp.common.util.StringUtil;
16 import com.hikvision.bsp.facecloud.comparator.FaceComparator;
17 import com.hikvision.bsp.facecloud.config.FaceCloudConfig;
18 import com.hikvision.bsp.facecloud.queue.HumanInfoRecordQueue;
19 import com.hikvision.facecloud.constant.FaceCloudConstant;
20 import com.hikvision.bsp.facecloud.domain.*;
21 import com.hikvision.bsp.facecloud.message.TimeSpaceResultLibCache;
22 import com.hikvision.bsp.facecloud.ws.webservice.domain.*;
23 import com.hikvision.facecloud.constant.ErrorCodeEnum;
24 import com.hikvision.filter.SimilarityConditionFilter;
25 import org.apache.commons.beanutils.PropertyUtils;
26 import org.apache.commons.lang3.StringUtils;
27 import org.apache.hadoop.hbase.util.Base64;
28 import org.apache.spark.unsafe.types.UTF8String;
29
30 import java.text.SimpleDateFormat;
31 import java.util.*;
32 import java.util.regex.Matcher;
33 import java.util.regex.Pattern;
34
35 /**
36 * <p>
37 * 参数校验工具类
38 * </p>
39 *
40 * @author zhuchao 2016/5/19 9:43
41 * @version V1.0
42 * @modificationHistory=========================逻辑或功能性重大变更记录
43 * @modify by user: $author$ $date$
44 * @modify by reason: {方法名}:{原因}
45 */
46 public class ParamCheckUtil {
47 /**
48 * 校验是否为空
49 *
50 * @param param
51 * @param paramName
52 */
53 public static void checkNotNull(Object param, String paramName) {
54 if (param == null) {
55 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "Param[" + paramName + "]should not be null");
56 }
57 }
58
59 /**
60 * 校验字符串不能为空
61 *
62 * @param param
63 * @param paramName
64 */
65 public static void checkNotBlank(String param, String paramName) {
66 if (StringUtils.isBlank(param)) {
67 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "Param[" + paramName + "]should not be null");
68 }
69 }
70
71 public static void checkNotBlank(String param1, String paramName1, String param2, String paramName2) {
72 if (StringUtils.isBlank(param1) && StringUtils.isBlank(param2)) {
73 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "Param[" + paramName1 + "],Param[" + paramName2 + "] least one has value.");
74 }
75 }
76
77 public static void checkCloudAnalysisStatus() {
78 throw new BaseException(ErrorCodeEnum.CODE_CLOUD_ANALYSIS_NOT_UNUSABLE, "Cloud Analysis Server unusable, Or Cloud Analysis url is not configuration.");
79 }
80
81 public static void checkParmIsZero(String param, String paramName) {
82 if (Integer.valueOf(param.trim()) == 0) {
83 throw new BaseException(ErrorCodeEnum.CODE_CLOUD_STATUS_IN_NOT_ZERO, "Param[" + paramName + "]should not be submit. Because of can't submit right task.");
84 }
85 }
86
87 public static void checkIsInteger(String str) {
88 if (StringUtil.isNoneEmpty(str)) {
89 Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
90 if (!pattern.matcher(str).matches()) {
91 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "Param[" + str + "]must be Integer type");
92 }
93 }
94 }
95
96 /**
97 * 校验字符串为空使用默认值
98 *
99 * @param param
100 */
101 public static String checkBlankWithDefaultValue(String param, String defaultValue) {
102 if (StringUtils.isBlank(param)) {
103 param = defaultValue;
104 }
105 return param;
106 }
107
108 /**
109 * 校验字符串不能为特定值
110 *
111 * @param param
112 * @param value
113 */
114 public static <T> void checkBanValue(T param, T value, String paramName) {
115 if (param != null) {
116 if (param instanceof String && param.equals(value)) {
117 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "param[" + paramName + "]can not be" + value);
118 } else if (param instanceof Integer && param.equals(value)) {
119 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "param[" + paramName + "]can not be" + value);
120 } else if (param instanceof Double && param.equals(value)) {
121 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "param[" + paramName + "]can not be" + value);
122 } else if (param instanceof Boolean && param.equals(value)) {
123 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "param[" + paramName + "]can not be" + value);
124 } else {
125 if (param.equals(value)) {
126 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "param[" + paramName + "]can not be" + value);
127 }
128 }
129 }
130 }
131
132 /**
133 * 校验字符串长度
134 *
135 * @param param
136 * @param paramName
137 * @param length
138 */
139 public static void checkLength(String param, String paramName, int length) {
140 checkNotBlank(param, paramName);
141 if (param.length() > length) {
142 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID,
143 "param[" + paramName + "]length cannot be greater than" + length + "bytes");
144 }
145 }
146
147 /**
148 * 校验数据在可选值中
149 *
150 * @param param
151 * @param paramName
152 * @param rang
153 */
154 public static void checkRandValue(int param, String paramName, int... rang) {
155 for (int i = 0; i < rang.length; i++) {
156 if (param == rang[i]) {
157 return;
158 }
159 }
160 throw new BaseException(FaceCloudConstant.MESSAGE.RET_FAIL,
161 "Param[" + paramName + "],value should be " + Arrays.toString(rang));
162 }
163
164 /**
165 * 校验日期格式,如正确转化为Date类型返回
166 *
167 * @param dateStr
168 * @param paramName
169 * @param pattern
170 * @return
171 */
172 public static Date checkDate(String dateStr, String paramName, String pattern) {
173 try {
174 if (dateStr.length() != pattern.length()) {
175 throw new BaseException(FaceCloudConstant.MESSAGE.RET_FAIL,
176 "Param[" + paramName + "]incorrect format, correct format is:" + pattern);
177 }
178
179 Date date = DateFormatUtils.toDate(dateStr, pattern);
180 if (date == null) {
181 throw new BaseException(FaceCloudConstant.MESSAGE.RET_FAIL,
182 "Param[" + paramName + "]incorrect format,correct format is:" + pattern);
183 }
184 //输入日期不能过小
185 Date limitDate = DateFormatUtils.toDate("1700-01-01 00:00:00", pattern);
186
187 if (!DateUtil.checkDateTime(dateStr, pattern)) {
188 throw new BaseException(FaceCloudConstant.MESSAGE.RET_FAIL,
189 "Param[" + paramName + "]invalid, please enter a valid date");
190 }
191
192 if (limitDate.after(date)) {
193 throw new BaseException(FaceCloudConstant.MESSAGE.RET_FAIL,
194 "please enter 1700-01-01 later date");
195 }
196 return date;
197 } catch (BaseException e) {
198 throw new BaseException(e.getErrorCode(), e.getMessage());
199 } catch (Throwable e) {
200 throw new BaseException(FaceCloudConstant.MESSAGE.RET_FAIL, "Param[" + paramName + "]incorrect format, correct format is: " + pattern);
201 }
202 }
203
204 /**
205 * 校验时间(HH:MM:SS)是否合法
206 *
207 * @param timeStr
208 * @return
209 */
210 public static void checkTimeFormat(String timeStr) {
211 SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:MM:SS");
212 if (!checkTimeValue(timeStr)) {
213 throw new BaseException(FaceCloudConstant.MESSAGE.RET_FAIL, "please enter right time");
214 }
215 try {
216 simpleDateFormat.parse(timeStr);
217 } catch (Exception e) {
218 throw new BaseException(FaceCloudConstant.MESSAGE.RET_FAIL, "Param[" + timeStr + "]incorrect format, correct format is: HH:MM:SS");
219 }
220 }
221
222 private static boolean checkTimeValue(String timeStr) {
223 String timeValue[] = timeStr.split(":");
224 if (timeValue.length != 3) {
225 return false;
226 }
227 if (Integer.parseInt(timeValue[0]) < 0 || Integer.parseInt(timeValue[0]) > 23) {
228 return false;
229 }
230 if (Integer.parseInt(timeValue[1]) < 0 || Integer.parseInt(timeValue[1]) > 59) {
231 return false;
232 }
233 if (Integer.parseInt(timeValue[2]) < 0 || Integer.parseInt(timeValue[2]) > 59) {
234 return false;
235 }
236 return true;
237 }
238
239 /**
240 * 人脸查重、碰撞参数检查
241 *
242 * @param beginBirthDate
243 * @param endBirthDate
244 * @param threshold
245 * @param pageNum
246 * @param pageSize
247 */
248 public static void checkFaceSimilarCheckParam(String beginBirthDate, String endBirthDate, float threshold,
249 int pageNum, int pageSize) {
250 // 日期格式检查
251 if (StringUtils.isNoneEmpty())
252
253 if (StringUtils.isNotEmpty(beginBirthDate)) {
254 ParamCheckUtil.checkDate(beginBirthDate, "beginBirthDate", DateFormatUtils.DATE_TIME_FORMATTER_YMD);
255 }
256 if (StringUtils.isNotEmpty(endBirthDate)) {
257 ParamCheckUtil.checkDate(endBirthDate, "endBirthDate", DateFormatUtils.DATE_TIME_FORMATTER_YMD);
258 }
259 if (StringUtils.isNotEmpty(beginBirthDate) && StringUtils.isNotEmpty(endBirthDate)
260 && beginBirthDate.compareTo(endBirthDate) > 0) {
261 throw new BaseException(FaceCloudConstant.MESSAGE.RET_FAIL, "endBirthDate must be earlier than beginBirthDate");
262 }
263
264 ParamCheckUtil.checkRange(threshold, "threshold", 0.0, false, 1.0, true);
265 ParamCheckUtil.checkPage(pageNum, pageSize, null, null);
266 }
267
268 /**
269 * 验证开始结束时间是否正确（结束时间晚于开始时间）
270 *
271 * @param beginTime
272 * @param beginTimeParamName
273 * @param endTime
274 * @param endTimeParamName
275 */
276 public static void checkTimeRight(Date beginTime, String beginTimeParamName, Date endTime,
277 String endTimeParamName) {
278 if (!beginTime.before(endTime)) {
279 throw new BaseException(FaceCloudConstant.MESSAGE.RET_FAIL,
280 "Parameter " + beginTimeParamName + "='" + beginTime + "must earlier than " + endTimeParamName + "='" + endTime
281 + "', please input true time range");
282 }
283 }
284
285 /**
286 * 验证开始结束时间格式是否正确
287 * （结束时间晚于开始时间）
288 *
289 * @param beginParam
290 * @param beginName
291 * @param beginPattern
292 * @param endParam
293 * @param endName
294 * @param endPattern
295 */
296 public static void checkDateRight(String beginParam, String beginName, String beginPattern, String endParam,
297 String endName, String endPattern) {
298 Date beginDate = null;
299 if (StringUtil.isNotBlank(beginParam)) {
300 beginDate = checkDate(beginParam, beginName, beginPattern);
301 }
302
303 if (StringUtil.isNotBlank(endParam)) {
304 Date endDate = checkDate(endParam, endName, endPattern);
305 if (null != beginDate && !beginDate.before(endDate)) {
306 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED,
307 "param" + beginName + "='" + beginParam + "must be earlier than" + endName + "='" + endParam + "',please enter the correct time range");
308 }
309 }
310 }
311
312 /**
313 * 验证开始结束时间格式是否正确
314 * （结束时间晚于开始时间包括相等）
315 *
316 * @param beginParam
317 * @param beginName
318 * @param beginPattern
319 * @param endParam
320 * @param endName
321 * @param endPattern
322 */
323 public static void checkDateRightWithEquals(String beginParam, String beginName, String beginPattern, String endParam,
324 String endName, String endPattern) {
325 Date beginDate = null;
326 if (StringUtil.isNotBlank(beginParam)) {
327 beginDate = checkDate(beginParam, beginName, beginPattern);
328 }
329
330 if (StringUtil.isNotBlank(endParam)) {
331 Date endDate = checkDate(endParam, endName, endPattern);
332 if (null != beginDate && beginDate.after(endDate)) {
333 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED,
334 "param" + beginName + "='" + beginParam + "must be earlier than" + endName + "='" + endParam + "',please enter the correct time range");
335 }
336 }
337 }
338
339 public static void checkTimeRight(long beginTime, String beginTimeParamName, long endTime,
340 String endTimeParamName) {
341 if (beginTime > endTime) {
342 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED,
343 "param" + beginTimeParamName + "='" + beginTime + " must earlier than " + endTimeParamName + "='" + endTime
344 + "',please enter right timezone");
345 }
346 }
347
348 public static void checkEndTimeRight(long time, String timeParamName) {
349 Date endDate = DateFormatUtils.toDate(time, DateFormatUtils.DATE_TIME_FORMATTER_YMD);
350 //一天时间差
351 Date now = DateFormatUtils.toDate(System.currentTimeMillis() + 24 * 60 * 60 * 1000, DateFormatUtils.DATE_TIME_FORMATTER_YMD);
352 if (endDate.after(now)) {
353 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED,
354 "param[" + timeParamName + "]could not after than now 1 day");
355 }
356 }
357
358 public static void checkJSONFormat(String param, String paramName) {
359 try {
360 JSON.parseObject(param, Map.class);
361 } catch (Exception e) {
362 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID,
363 "Param:" + paramName
364 + " should be json format");
365 }
366 }
367
368 /**
369 * 校验相似度
370 *
371 * @param minSimilarity
372 * @param maxSimilarity
373 */
374 public static void checkSimilarity(double minSimilarity, double maxSimilarity) {
375 if (minSimilarity < 0.0 || minSimilarity > 1.0) {
376 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Parameter [minSimilarity] must in [0,1]");
377 }
378 if (maxSimilarity < 0.0 || maxSimilarity > 1.0) {
379 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Parameter [maxSimilarity] must in [0,1]");
380 }
381 if (maxSimilarity < minSimilarity) {
382 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Parameter [maxSimilarity] must >= [minSimilarity] ");
383 }
384 //TODO 暂用这种方法判断 以后用具有扩展性的条件
385 if ((minSimilarity < 0.001 && minSimilarity > 0) || (maxSimilarity < 0.001 && maxSimilarity > 0)) {
386 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Parameter[maxSimilarity] and [minSimilarity] can not less than 0.001");
387 }
388 }
389
390 /**
391 * 校验Int型参数范围
392 *
393 * @param param
394 * @param paramName
395 * @param minValue
396 * @param minEqualInd
397 * @param maxValue
398 * @param maxEqualInd
399 */
400 public static void checkRange(int param, String paramName, Integer minValue, boolean minEqualInd, Integer maxValue,
401 boolean maxEqualInd) {
402 if (minValue != null) {
403 if (minEqualInd && param < minValue) {
404 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "Param[" + paramName + "]should equal or greater than " + minValue);
405 } else if (!minEqualInd && param <= minValue) {
406 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "Param[" + paramName + "]should greater " + minValue);
407 }
408 }
409 if (maxValue != null) {
410 if (maxEqualInd && param > maxValue) {
411 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "Param[" + paramName + "]should less than or equal " + maxValue);
412 } else if (!maxEqualInd && param >= maxValue) {
413 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "Param[" + paramName + "]should less " + maxValue);
414 }
415 }
416 }
417
418 /**
419 * 校验Double型参数范围
420 *
421 * @param param
422 * @param paramName
423 * @param minValue
424 * @param minEqualInd
425 * @param maxValue
426 * @param maxEqualInd
427 */
428 public static void checkRange(double param, String paramName, Double minValue, boolean minEqualInd, Double maxValue,
429 boolean maxEqualInd) {
430
431 if (minValue != null) {
432 if (minEqualInd && param < minValue) {
433 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Parameter [" + paramName + "] must >=" + minValue);
434 } else if (!minEqualInd && param <= minValue) {
435 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Parameter [" + paramName + "] must >" + minValue);
436 }
437 }
438 if (maxValue != null) {
439 if (maxEqualInd && param > maxValue) {
440 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Parameter [" + paramName + "] must <=" + maxValue);
441 } else if (!maxEqualInd && param >= maxValue) {
442 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Parameter [" + paramName + "] must <" + maxValue);
443 }
444 }
445 }
446
447 /**
448 * 校验模型
449 *
450 * @param modelStr
451 * @return
452 */
453 public static byte[] checkModel(String modelStr) {
454 checkNotBlank(modelStr, "face model");
455
456 byte[] modelData = Base64.decode(modelStr);
457 checkNotNull(modelData, "face model decoding");
458
459 if (!FaceComparator.apply().checkModel(modelData)) {
460 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "face model is not legal");
461 }
462 return modelData;
463 }
464
465 /**
466 * 校验模型
467 *
468 * @param modelData
469 * @return
470 */
471 public static byte[] checkModel(byte[] modelData) {
472 checkNotNull(modelData, "face model");
473 if (!FaceComparator.apply().checkModel(modelData)) {
474 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "face model is not legal");
475 }
476 return modelData;
477 }
478
479 /**
480 * 校验分页参数
481 *
482 * @param pageNum
483 * @param pageSize
484 * @param maxPageNum
485 * @param maxPageSize
486 */
487 public static void checkPage(int pageNum, int pageSize, Integer maxPageNum, Integer maxPageSize) {
488 checkRange(pageNum, "pageNum", 1, true, maxPageNum, true);
489 checkRange(pageSize, "pageSize", 1, true, maxPageSize, true);
490 }
491
492 /**
493 * 校验报警信息参数
494 *
495 * @param param
496 */
497 public static AlarmInfoParam checkAlarmInfoParam(AlarmInfoParam param) {
498 checkNotNull(param, "AlarmInfoParam");
499
500 checkRandValue(param.getSortByType(), "sort type", 0, 1);
501
502 checkSimilarity(param.getSimilarityMin(), param.getSimilarityMax());
503
504 if (param.getResultSize() == 0 ){
505 int resultSize = FaceCloudConfig.getOrElse(FaceCloudConstant.FEATUREMATCH.HUMAN_FACE_MODEL_TOPN,
506 FaceCloudConstant.FEATUREMATCH.DEFAULT_MODEL_TOPN);
507 param.setResultSize(resultSize);
508 }
509
510 checkResultSize(param.getResultSize(), "resultSize");
511 checkNotBlank(param.getBeginDate(), "begin time");
512 checkNotBlank(param.getEndDate(), "end time");
513 checkDateRight(param.getBeginDate(), "begin time", FaceCloudConstant.DATE_FORMATTER_YMDHMS, param.getEndDate(),
514 "end time", FaceCloudConstant.DATE_FORMATTER_YMDHMS);
515
516 checkPage(param.getPageNum(), param.getPageSize(), null, null);
517
518 return param;
519 }
520
521 /**
522 * 校验抓拍查询信息参数
523 *
524 * @param param
525 * @return
526 */
527 public static QuerySnapRecordParm checkQuerySnapRecordParm(QuerySnapRecordParm param) {
528 checkNotNull(param, "QuerySnapRecordParm");
529
530 checkRandValue(param.getSex(), "sex", -1, 0, 1, 2);
531 checkRandValue(param.getGlass(), "glasses", -1, 0, 1, 2);
532 checkRandValue(param.getResultStatus(), "resultStatus", -1, 0, 1);
533 checkRandValue(param.getSmile(), "smile", -1, 0, 1, 2);
534
535 checkRandValue(param.getCertificate(), "certificate", -1, 100, 1, 2, 3);
536 checkRandValue(param.getEthnic(), "ethnic", -1, 0, 1, 2);
537
538 checkPage(param.getPageNum(), param.getPageSize(), null, null);
539 return param;
540 }
541
542 /**
543 * 校验抓拍查询信息参数
544 *
545 * @param param
546 * @return
547 */
548 public static QuerySnapRecordWithIQAParam checkQuerySnapRecordwithIQAParm(QuerySnapRecordWithIQAParam param) {
549 checkNotNull(param, "QuerySnapRecordParm");
550
551 checkRandValue(param.getSex(), "sex", -1, 0, 1, 2);
552 checkRandValue(param.getGlass(), "glasses", -1, 0, 1, 2);
553 checkRandValue(param.getResultStatus(), "resultStatus", -1, 0, 1);
554 checkRandValue(param.getSmile(), "smile", -1, 0, 1, 2);
555
556 checkRandValue(param.getCertificate(), "certificate", -1, 100, 1, 2, 3);
557 checkRandValue(param.getEthnic(), "ethnic", -1, 0, 1, 2);
558
559 checkPage(param.getPageNum(), param.getPageSize(), null, null);
560 return param;
561 }
562
563 /**
564 * 校验人证库查询信息参数
565 *
566 * @param param
567 * @return
568 */
569 public static PersonClusterRecordParm checkPersonClusterRecordParm(PersonClusterRecordParm param) {
570 checkNotNull(param, "PersonClusterRecordParm");
571 checkRandValue(param.getHumanMale(), "humanMale", -1, 0, 1, 2);
572 checkPage(param.getPageNum(), param.getPageSize(), null, null);
573
574
575 if (StringUtil.isNotBlank(param.getBeginBirthDate())) {
576 checkDate(param.getBeginBirthDate(), "begin birth date", FaceCloudConstant.DATE_FORMATTER_YMD);
577 }
578
579 if (StringUtil.isNotBlank(param.getEndBirthDate())) {
580 checkDate(param.getEndBirthDate(), "end birth date", FaceCloudConstant.DATE_FORMATTER_YMD);
581 }
582
583 checkDateRight(param.getBeginBirthDate(), "begin birth date", FaceCloudConstant.DATE_FORMATTER_YMD,
584 param.getEndBirthDate(), "end birth date", FaceCloudConstant.DATE_FORMATTER_YMD);
585 return param;
586 }
587
588 /**
589 * 校验人证库任务参数
590 *
591 * @param param
592 * @return
593 */
594 public static PersonClusterJobParam checkPersonClusterFaceJobParam(PersonClusterFaceParam param) {
595 checkNotNull(param, "person cluster task param");
596
597 PersonClusterJobParam personClusterJobParam = new PersonClusterJobParam();
598 try {
599 PropertyUtils.copyProperties(personClusterJobParam, param);
600 } catch (Exception e) {
601 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "error converting parameters", e);
602 }
603
604 Date beginDate = null;
605 if (StringUtil.isNotBlank(personClusterJobParam.getBeginBirthDate())) {
606 beginDate = checkDate(personClusterJobParam.getBeginBirthDate(), "begin birth date",
607 FaceCloudConstant.DATE_FORMATTER_YMD);
608 }
609 if (StringUtil.isNotBlank(personClusterJobParam.getEndBirthDate())) {
610 Date endDate = checkDate(personClusterJobParam.getEndBirthDate(), "end birth date",
611 FaceCloudConstant.DATE_FORMATTER_YMD);
612 if (null != beginDate && beginDate.after(endDate)) {
613 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED,
614 "param" + "begin birth date" + "='" + personClusterJobParam.getBeginBirthDate() + "is later than" + "end birth date" + "='"
615 + personClusterJobParam.getEndBirthDate() + "',please enter right date range");
616 }
617 }
618
619 Date now = new Date();
620 if (StringUtil.isNotBlank(personClusterJobParam.getBeginBirthDate())) {
621 beginDate = checkDate(personClusterJobParam.getBeginBirthDate(), "birth date", FaceCloudConstant.DATE_FORMATTER_YMD);
622 if (beginDate.after(now)) {
623 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "the birth date is not greater than the current date");
624 }
625 }
626
627
628 if (personClusterJobParam.getResultSize() == 0 ){
629 int resultSize = FaceCloudConfig.getOrElse(FaceCloudConstant.FEATUREMATCH.HUMAN_FACE_MODEL_TOPN,
630 FaceCloudConstant.FEATUREMATCH.DEFAULT_MODEL_TOPN);
631 personClusterJobParam.setResultSize(resultSize);
632 }
633
634 byte[] model = checkModel(param.getFaceModel());
635 checkBanValue(model.length, 1, "face model amount");
636 personClusterJobParam.setModelData(model);
637
638 checkSimilarity(personClusterJobParam.getSimilarityMin(), personClusterJobParam.getSimilarityMax());
639 checkRandValue(personClusterJobParam.getHumanMale(), "human male", -1, 0, 1, 2);
640 checkResultSize(personClusterJobParam.getResultSize(), "resultSize");
641
642 return personClusterJobParam;
643 }
644
645 /**
646 * 校验人脸质量评分阈值
647 * @param faceIQA
648 */
649 public static void checkFaceQualityParam(String faceIQA){
650 JSONObject faceIQAJSON = JSON.parseObject(faceIQA);
651 checkQualityIntegerParam("detectQuality",Integer.MIN_VALUE,Integer.MAX_VALUE,faceIQAJSON.get("detectQuality"));
652 checkQualityIntegerParam("grayScale",Integer.MIN_VALUE,Integer.MAX_VALUE,faceIQAJSON.get("grayScale"));
653 checkQualityFloatParam("clearity",-Float.MAX_VALUE,Float.MAX_VALUE,faceIQAJSON.get("clearity"));
654 checkQualityFloatParam("uncovered",-Float.MAX_VALUE,Float.MAX_VALUE,faceIQAJSON.get("uncovered"));
655 checkQualityFloatParam("colorful",-Float.MAX_VALUE,Float.MAX_VALUE,faceIQAJSON.get("colorful"));
656 checkQualityFloatParam("posePitch",-Float.MAX_VALUE,Float.MAX_VALUE,faceIQAJSON.get("posePitch"));
657 checkQualityFloatParam("pointsQuality",-Float.MAX_VALUE,Float.MAX_VALUE,faceIQAJSON.get("pointsQuality"));
658 checkQualityFloatParam("poseYaw",-Float.MAX_VALUE,Float.MAX_VALUE,faceIQAJSON.get("poseYaw"));
659 checkQualityFloatParam("totalQuality",-Float.MAX_VALUE,Float.MAX_VALUE,faceIQAJSON.get("totalQuality"));
660 checkQualityFloatParam("frontal",-Float.MAX_VALUE,Float.MAX_VALUE,faceIQAJSON.get("frontal"));
661 checkQualityFloatParam("eyeDistance",-Float.MAX_VALUE,Float.MAX_VALUE,faceIQAJSON.get("eyeDistance"));
662 checkQualityFloatParam("poseConf",-Float.MAX_VALUE,Float.MAX_VALUE,faceIQAJSON.get("poseConf"));
663 checkQualityFloatParam("grayMeanMin",-Float.MAX_VALUE,Float.MAX_VALUE,faceIQAJSON.get("grayMeanMin"));
664 checkQualityFloatParam("grayMeanMax",-Float.MAX_VALUE,Float.MAX_VALUE,faceIQAJSON.get("grayMeanMax"));
665 checkQualityFloatParam("grayVarMin",-Float.MAX_VALUE,Float.MAX_VALUE,faceIQAJSON.get("grayVarMin"));
666 checkQualityFloatParam("grayVarMax",-Float.MAX_VALUE,Float.MAX_VALUE,faceIQAJSON.get("grayVarMax"));
667 checkQualityFloatParam("poseRoll",-Float.MAX_VALUE,Float.MAX_VALUE,faceIQAJSON.get("poseRoll"));
668 }
669
670 public static void checkQualityIntegerParam(String paramName,int min,int max,Object value){
671 int paramValue;
672 try{
673 paramValue = Integer.parseInt(value.toString());
674 }catch (NullPointerException e){
675 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "Param["+ paramName +"] is null");
676 }catch (Exception e){
677 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "Param["+ paramName +"] is illegal");
678 }
679 if (paramValue<min&¶mValue>max){
680 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "Param["+ paramName +"] is illegal");
681 }
682 }
683
684 public static void checkQualityFloatParam(String paramName,float min,float max,Object value){
685 float paramValue;
686 try{
687 paramValue = Float.parseFloat(value.toString());
688 }catch (NullPointerException e){
689 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "Param["+ paramName +"] is null");
690 }catch (Exception e){
691 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "Param["+ paramName +"] is illegal");
692 }
693 if (paramValue<min&¶mValue>max){
694 throw new BaseException(ErrorCodeEnum.CODE_ARGS_INVALID, "Param["+ paramName +"] is illegal");
695 }
696 }
697
698
699 /**
700 * 校验静态库任务参数
701 *
702 * @param param
703 * @return
704 */
705 public static HumanFaceJobParam checkHumanFaceJobParam(HumanFaceParam param) {
706 checkNotNull(param, "HumanFaceJobParam");
707
708 HumanFaceJobParam humanFaceJobParam = new HumanFaceJobParam();
709 try {
710 PropertyUtils.copyProperties(humanFaceJobParam, param);
711 } catch (Exception e) {
712 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "error converting parameters", e);
713 }
714
715 checkNotBlank(param.getFacelibIds(), "face library");
716 try {
717 if (!"-1".equals(param.getFacelibIds())) {
718 String[] facelibs = param.getFacelibIds().split(FaceCloudConstant.TASK.LIST_PARAM_SEPARATOR);
719 List<String> facelibList = new ArrayList<String>();
720 for (String facelib : facelibs) {
721 facelibList.add(facelib);
722 }
723 humanFaceJobParam.setFacelibList(facelibList);
724 }
725 } catch (Exception e) {
726 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "face library parameters is not a correct format");
727 }
728
729 Date beginDate = null;
730
731 if (StringUtil.isNotBlank(humanFaceJobParam.getBeginBirthDate())) {
732 beginDate = checkDate(humanFaceJobParam.getBeginBirthDate(), "beginBirthDate",
733 FaceCloudConstant.DATE_FORMATTER_YMD);
734 }
735 if (StringUtil.isNotBlank(humanFaceJobParam.getEndBirthDate())) {
736 Date endDate = checkDate(humanFaceJobParam.getEndBirthDate(), "endBirthDate",
737 FaceCloudConstant.DATE_FORMATTER_YMD);
738 if (null != beginDate && beginDate.after(endDate)) {
739 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED,
740 " parameter" + "beginBirthDate" + "='" + humanFaceJobParam.getBeginBirthDate() + "after" + "endBirthDate" + "='"
741 + humanFaceJobParam.getEndBirthDate() + "',please input the right time scope");
742 }
743 }
744
745 Date now = new Date();
746 if (StringUtil.isNotBlank(humanFaceJobParam.getBeginBirthDate())) {
747 beginDate = checkDate(humanFaceJobParam.getBeginBirthDate(), "beginBirthDate", FaceCloudConstant.DATE_FORMATTER_YMD);
748 if (beginDate.after(now)) {
749 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "beginBirthDate cannot be bigger than the current date");
750 }
751 }
752
753 if (humanFaceJobParam.getResultSize() == 0 ){
754 int resultSize = FaceCloudConfig.getOrElse(FaceCloudConstant.FEATUREMATCH.HUMAN_FACE_MODEL_TOPN,
755 FaceCloudConstant.FEATUREMATCH.DEFAULT_MODEL_TOPN);
756 humanFaceJobParam.setResultSize(resultSize);
757 }
758
759
760 byte[] model = checkModel(param.getFaceModel());
761 humanFaceJobParam.setModelData(model);
762
763 checkSimilarity(humanFaceJobParam.getSimilarityMin(), humanFaceJobParam.getSimilarityMax());
764
765 checkRandValue(humanFaceJobParam.getHumanMale(), "humanMale", -1, 0, 1, 2);
766 checkRandValue(humanFaceJobParam.getHumanCredtype(), "credType", -1, 0, 1, 2);
767 checkRandValue(humanFaceJobParam.getGradeValue(), "gradeValue", -1, 0, 1);
768 checkResultSize(humanFaceJobParam.getResultSize(), "resultSize");
769 checkRandValue(humanFaceJobParam.getCertificate(), "certificate", -1, 0, 1, 2, 3);
770
771
772 boolean staticIncreaOpen = FaceCloudConfig.isAvailable(FaceCloudConstant.FEATUREMATCH.FEATURE_TYPE_INCREMENT_STATIC);
773 //如果开启静态库增量服务，则将删除队列加入前置过滤条件
774 if(staticIncreaOpen){
775 humanFaceJobParam.setDeleteQueue(HumanInfoRecordQueue.getInstance().getQueue());
776 }else{
777 humanFaceJobParam.setDeleteQueue(null);
778 }
779
780 return humanFaceJobParam;
781 }
782
783 public static BlackInfoFaceJobParam checkBlackInfoFaceJobParam(BlackInfoFaceJobParam param) {
784 checkNotNull(param, "blacklist task id parameter");
785
786 checkNotBlank(param.getBlacklistIds(), "blacklistIds");
787 try {
788 if (!"-1".equals(param.getBlacklistIds())) {
789 String[] blacklistIds = param.getBlacklistIds().split(FaceCloudConstant.TASK.LIST_PARAM_SEPARATOR);
790 List<String> blacklistIdList = Arrays.asList(blacklistIds);
791 param.setBlacklistIdList(blacklistIdList);
792 }
793 } catch (Exception e) {
794 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Human info parameter syntax error");
795 }
796
797 Date beginDate = null;
798 if (StringUtil.isNotBlank(param.getBeginBirthDate())) {
799 beginDate = checkDate(param.getBeginBirthDate(), "begin birthdate", FaceCloudConstant.DATE_FORMATTER_YMD);
800 Date now = new Date();
801 if (beginDate.after(now)) {
802 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "beginBirthDate cannot be bigger than the current date");
803 }
804 }
805
806 if (StringUtil.isNotBlank(param.getEndBirthDate())) {
807 Date endDate = checkDate(param.getEndBirthDate(), "end birthdate", FaceCloudConstant.DATE_FORMATTER_YMD);
808 if (null != beginDate && beginDate.after(endDate)) {
809 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED,
810 "parameter" + "begin birthdate" + "='" + param.getBeginBirthDate() + "later than parameter " + "end birthdate " + "='" + param
811 .getEndBirthDate() + "',please input true time scope");
812 }
813 }
814
815
816 if (param.getResultSize() == 0 ){
817 int resultSize = FaceCloudConfig.getOrElse(FaceCloudConstant.FEATUREMATCH.HUMAN_FACE_MODEL_TOPN,
818 FaceCloudConstant.FEATUREMATCH.DEFAULT_MODEL_TOPN);
819 param.setResultSize(resultSize);
820 }
821
822 byte[] model = checkModel(param.getModelDataStr());
823 param.setModelData(model);
824
825 checkSimilarity(param.getSimilarityMin(), param.getSimilarityMax());
826
827 checkRandValue(param.getHumanMale(), "sex", -1, 0, 1, 2);
828 checkRandValue(param.getHumanCredtype(), "cred type", -1, 0, 1, 2);
829
830 checkRange(param.getResultSize(), "resultSize", 1, true, null, true);
831
832 return param;
833 }
834
835 /**
836 * 校验抓拍库任务参数
837 *
838 * @param param
839 * @return
840 */
841 public static SnapHumanFaceJobParam checkSnapHumanFaceParam(SnapHumanFaceParam param) {
842 checkNotNull(param, "snap task parameter");
843
844 SnapHumanFaceJobParam snapHumanFaceJobParam = new SnapHumanFaceJobParam();
845 try {
846 PropertyUtils.copyProperties(snapHumanFaceJobParam, param);
847 } catch (Exception e) {
848 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "parameter convert error", e);
849 }
850
851 checkNotBlank(snapHumanFaceJobParam.getDeviceId(), "device id");
852
853 try {
854 String[] deviceIds = snapHumanFaceJobParam.getDeviceId().split(FaceCloudConstant.TASK.LIST_PARAM_SEPARATOR);
855 List<String> deviceList = Arrays.asList(deviceIds);
856 snapHumanFaceJobParam.setDeviceList(deviceList);
857 } catch (Exception e) {
858 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "device id syntax error");
859 }
860
861 if (snapHumanFaceJobParam.getResultSize() == 0 ){
862 int resultSize = FaceCloudConfig.getOrElse(FaceCloudConstant.FEATUREMATCH.HUMAN_FACE_MODEL_TOPN,
863 FaceCloudConstant.FEATUREMATCH.DEFAULT_MODEL_TOPN);
864 snapHumanFaceJobParam.setResultSize(resultSize);
865 }
866
867 byte[] model = checkModel(snapHumanFaceJobParam.getFaceModel());
868 snapHumanFaceJobParam.setModelData(model);
869
870 checkDate(snapHumanFaceJobParam.getBeginDate(), "begin time", FaceCloudConstant.DATE_FORMATTER_YMDHMS);
871 checkDate(snapHumanFaceJobParam.getEndDate(), "end time", FaceCloudConstant.DATE_FORMATTER_YMDHMS);
872
873 checkSimilarity(snapHumanFaceJobParam.getSimilarityMin(), snapHumanFaceJobParam.getSimilarityMax());
874
875 checkRange(snapHumanFaceJobParam.getResultSize(), "resultSize", 1, true, null, true);
876 return snapHumanFaceJobParam;
877 }
878
879 /**
880 * 校验静态库人脸入库参数
881 *
882 * @param addFaceRecordParam
883 * @return
884 */
885 public static AddFaceRecordParam checkAddFaceRecordParam(AddFaceRecordParam addFaceRecordParam) {
886 checkNotNull(addFaceRecordParam, "face record");
887
888 checkNotNull(addFaceRecordParam.getFacelib_id(), "facelib id");
889
890 //静态库id不能为-1
891 checkBanValue(addFaceRecordParam.getFacelib_id(), -1, "facelib id");
892
893 String birthDateStr = addFaceRecordParam.getBirth_date();
894 Date now = new Date();
895 Date birth = null;
896 if (StringUtil.isNotBlank(birthDateStr)) {
897 birth = checkDate(birthDateStr, "birth date", FaceCloudConstant.DATE_FORMATTER_YMD);
898 if (birth.after(now)) {
899 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Birth date can not later than now");
900 }
901 }
902
903 String createDateStr = addFaceRecordParam.getCreate_date();
904 Date createDate = now;
905 if (StringUtils.isNotEmpty(createDateStr)) {
906 createDate = checkDate(createDateStr, "create date", FaceCloudConstant.DATE_FORMATTER_YMD);
907 if (null != birth && birth.after(createDate)) {
908 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Birth date can not later than create date");
909 }
910 } else {
911 addFaceRecordParam.setCreate_date(DateFormatUtils.format(now, FaceCloudConstant.DATE_FORMATTER_YMD));
912 }
913
914 if (null != birth) {
915 addFaceRecordParam.setHuman_age(calAge(birth, createDate));
916 }
917
918 checkNotBlank(addFaceRecordParam.getFace_picurl(), "face picture URL");
919
920 checkRandValue(addFaceRecordParam.getHuman_male(), "sex", 0, 1, 2);
921 checkRandValue(addFaceRecordParam.getHuman_credtype(), "cred type", 0, 1, 2);
922
923 checkRandValue(addFaceRecordParam.getCertificate(), "certificate", -1, 0, 1, 2, 3);
924
925 // checkNotBlank(addFaceRecordParam.getBkg_picurl(), "大图URL");
926
927 return addFaceRecordParam;
928 }
929
930 /**
931 * 校验静态库人脸更新参数
932 *
933 * @param updateFaceRecordParam
934 * @return
935 */
936 public static UpdateFaceRecordParam checkUpdateFaceRecordParam(UpdateFaceRecordParam updateFaceRecordParam) {
937 checkNotNull(updateFaceRecordParam, "face record");
938 checkNotNull(updateFaceRecordParam.getFacelib_id(), "facelib id");
939 // checkNotNull(updateFaceRecordParam.getRowKey(), "记录唯一标识");
940 checkNotBlank(updateFaceRecordParam.getRowKey(),"rowKey");
941 //静态库id不能为-1
942 checkNotBlank(updateFaceRecordParam.getFacelib_id().toString(), "facelib id");
943 checkBanValue(updateFaceRecordParam.getFacelib_id(), -1, "facelib id");
944 if (null != updateFaceRecordParam.getHuman_male()) {
945 checkRandValue(updateFaceRecordParam.getHuman_male(), "sex", 0, 1, 2);
946 }
947 if (null != updateFaceRecordParam.getHuman_credtype()) {
948 checkRandValue(updateFaceRecordParam.getHuman_credtype(), "cred type", 0, 1, 2);
949 }
950 String birthDateStr = updateFaceRecordParam.getBirth_date();
951 Date now = new Date();
952 Date birth = null;
953 if (StringUtil.isNotBlank(birthDateStr)) {
954 birth = checkDate(birthDateStr, "birth date", FaceCloudConstant.DATE_FORMATTER_YMD);
955 if (birth.after(now)) {
956 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Birth date can not later than now");
957 }
958 }
959
960
961 String createDateStr = updateFaceRecordParam.getCreate_date();
962 Date createDate = now;
963 if (StringUtils.isNotEmpty(createDateStr)) {
964 createDate = checkDate(createDateStr, "create date", FaceCloudConstant.DATE_FORMATTER_YMD);
965 if (null != birth && birth.after(createDate)) {
966 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Birth date can not later than create date");
967 }
968 if (createDate.after(now)) {
969 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Create date can not later than now");
970 }
971 } else {
972 updateFaceRecordParam.setCreate_date(DateFormatUtils.format(now, FaceCloudConstant.DATE_FORMATTER_YMD));
973 }
974
975 if (null != birth) {
976 updateFaceRecordParam.setHuman_age(calAge(birth, createDate));
977 }
978
979 if (null != updateFaceRecordParam.getCertificate()) {
980 checkRandValue(updateFaceRecordParam.getCertificate(), "certificate" , 0, 1, 2, 3);
981 }
982
983 return updateFaceRecordParam;
984 }
985
986 /**
987 * 校验静态库人脸查询参数
988 *
989 * @param getFaceRecordsParam
990 * @return
991 */
992 public static void checkGetFaceRecords(GetFaceRecordsParam getFaceRecordsParam) {
993 checkNotNull(getFaceRecordsParam, "query parameter");
994
995 String facelibIds = getFaceRecordsParam.getFacelibIds();
996 checkNotBlank(facelibIds, "facelib id");
997 if (!"-1".equals(facelibIds)) {
998 List<String> facelibIdList = new ArrayList<String>();
999 for (String facelibId : ConditionSqlUtil.paramParseList(facelibIds, ",")) {
1000 facelibIdList.add(facelibId);
1001 /*try {
1002 facelibIdList.add(Integer.parseInt(facelibId));
1003 } catch (Exception e) {
1004 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "facelib id convert error");
1005 }*/
1006 }
1007 getFaceRecordsParam.setFacelibIdList(facelibIdList);
1008 }
1009
1010 String rowKeys = getFaceRecordsParam.getRowKeys();
1011 if (!ConditionSqlUtil.preConditionFilter(rowKeys, "-1")) {
1012 List<String> rowKeyList = ConditionSqlUtil.paramParseList(rowKeys, ",");
1013 getFaceRecordsParam.setRowKeyList(rowKeyList);
1014 }
1015
1016 checkPage(getFaceRecordsParam.getPageNum(), getFaceRecordsParam.getPageSize(), null, null);
1017
1018 // 姓名模糊查询，_ 符号转义
1019 if (StringUtil.isNotBlank(getFaceRecordsParam.getHumanName())) {
1020 getFaceRecordsParam.setHumanName(ConditionSqlUtil.underLineCharTran(getFaceRecordsParam.getHumanName()));
1021 }
1022
1023 // 证件号码模糊查询，_ 符号转义
1024 if (StringUtil.isNotBlank(getFaceRecordsParam.getHumanCrednum())) {
1025 getFaceRecordsParam.setHumanCrednum(ConditionSqlUtil.underLineCharTran(getFaceRecordsParam.getHumanCrednum()));
1026 }
1027
1028 if (StringUtil.isNotBlank(getFaceRecordsParam.getBeginBirthDate())) {
1029 checkDate(getFaceRecordsParam.getBeginBirthDate(), "begin birth date", FaceCloudConstant.DATE_FORMATTER_YMD);
1030 }
1031
1032 if (StringUtil.isNotBlank(getFaceRecordsParam.getEndBirthDate())) {
1033 checkDate(getFaceRecordsParam.getEndBirthDate(), "end birth date", FaceCloudConstant.DATE_FORMATTER_YMD);
1034 }
1035
1036 checkDateRightWithEquals(getFaceRecordsParam.getBeginBirthDate(), "begin birth date", FaceCloudConstant.DATE_FORMATTER_YMD,
1037 getFaceRecordsParam.getEndBirthDate(), "end birth date", FaceCloudConstant.DATE_FORMATTER_YMD);
1038
1039 String externalIds = getFaceRecordsParam.getExternalIds();
1040 if (!ConditionSqlUtil.preConditionFilter(externalIds, "-1")) {
1041 List<String> externalIdList = ConditionSqlUtil.paramParseList(externalIds, ",");
1042 getFaceRecordsParam.setExternalIdList(externalIdList);
1043 }
1044
1045 checkRandValue(getFaceRecordsParam.getHumanMale(), "humanMale", -1, 0, 1, 2);
1046 checkRandValue(getFaceRecordsParam.getHumanCredtype(), "cred type", -1, 0, 1, 2);
1047 checkRandValue(getFaceRecordsParam.getResultStatus(), "resultStatus", -1, 0, 1);
1048
1049 checkRandValue(getFaceRecordsParam.getCertificate(), "certificate" , -1, 0, 1, 2, 3);
1050
1051 if (!ConditionSqlUtil.preConditionFilter(getFaceRecordsParam.getBeginStorageDate(), -1L)
1052 && !ConditionSqlUtil.preConditionFilter(getFaceRecordsParam.getEndStorageDate(), -1L)) {
1053 checkTimeRight(getFaceRecordsParam.getBeginStorageDate(), "beginStorageDate",
1054 getFaceRecordsParam.getEndStorageDate(), "endStorageDate");
1055 }
1056
1057 checkRandValue(getFaceRecordsParam.getOrder(), "order" , 0, 1);
1058 }
1059
1060 /**
1061 * 校验静态库碰撞任务参数
1062 *
1063 * @param faceOverlapJobParm
1064 */
1065 public static void checkFaceOverlapJobParam(FaceOverlapJobParm faceOverlapJobParm) {
1066 checkTimeFormat(faceOverlapJobParm.getHitBeginTime());
1067 checkTimeFormat(faceOverlapJobParm.getHitEndTime());
1068
1069 checkNotNull(faceOverlapJobParm, "faceOverlapJobParam");
1070 //限制性别为指定值中的一个
1071 // checkRandValue((Integer)faceOverlapJobParm.getCondition1().get(HumanInfo.HUMAN_MALE), "性别", -1, 0);
1072 // checkRandValue((Integer)faceOverlapJobParm.getCondition2().get(HumanInfo.HUMAN_MALE), "性别", -1, 0);
1073 checkRandValue(faceOverlapJobParm.getHitMale(), "sex", -1, 0);
1074 checkRandValue(faceOverlapJobParm.getGradeValue(), "gradeValue", -1, 0);
1075
1076 checkRange(faceOverlapJobParm.getThreshold(), "threshold", 0.0, true, 1.0, true);
1077 checkRange(faceOverlapJobParm.getHitPriority(), "hitPriority", 0, true, 100, true);
1078 int humanNum = faceOverlapJobParm.getHumanNum();
1079 if (humanNum <= 0) {
1080 throw new BaseException(ErrorCodeEnum.CODE_INTERNAL_ERROR, "HumanNum must larger than 0");
1081 }
1082
1083 if (faceOverlapJobParm.getHitAgeInterval() < -1) {
1084 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "hitAgeInterval can't be less than -1");
1085 }
1086 //静态库碰撞时间校验
1087 String beginDate = faceOverlapJobParm.getHitBeginTime();
1088 String endDate = faceOverlapJobParm.getHitEndTime();
1089 checkTimeFormat(beginDate);
1090 checkTimeFormat(endDate);
1091 checkTimeRight(DateUtil.getDayTime(beginDate), "hit begin time", DateUtil.getDayTime(endDate), "hitEndTime");
1092
1093 }
1094
1095 /**
1096 * 计算年龄
1097 *
1098 * @param birthDate
1099 * @param now
1100 * @return
1101 * @author chenxiaoyou 2015年12月23日 13:40
1102 */
1103 private static int calAge(Date birthDate, Date now) {
1104 Calendar birthCal = Calendar.getInstance();
1105 birthCal.setTime(birthDate);
1106
1107 Calendar nowCal = Calendar.getInstance();
1108 nowCal.setTime(now);
1109
1110 int age = nowCal.get(Calendar.YEAR) - birthCal.get(Calendar.YEAR);
1111 if (nowCal.get(Calendar.DAY_OF_YEAR) < birthCal.get(Calendar.DAY_OF_YEAR)) {
1112 age -= 1;
1113 }
1114 return age;
1115 }
1116
1117 /**
1118 * 人脸记录入库参数校验
1119 *
1120 * @param addMultiFaceParam
1121 * @return
1122 */
1123 public static void checkAddMultiFaceParam(AddMultiFaceParam addMultiFaceParam) {
1124 checkNotNull(addMultiFaceParam, "multiFaceParam");
1125
1126 if (StringUtil.isBlank(addMultiFaceParam.getHumanId()) || StringUtil.isBlank(addMultiFaceParam.getRowKeys())) {
1127 checkNotBlank(addMultiFaceParam.getFace_picurl(), "facePicurl");
1128 checkNotBlank(addMultiFaceParam.getBkg_picurl(), "bkgPicurl");
1129 checkNotBlank(addMultiFaceParam.getModelData(), "modelData");
1130 checkModel(addMultiFaceParam.getModelData());
1131 }
1132 }
1133
1134 /**
1135 * 多模型转换校验
1136 * 个数校验
1137 *
1138 * @param modelDatas
1139 * @return
1140 */
1141 public static List<byte[]> checkMultiModels(String modelDatas) {
1142 checkNotBlank(modelDatas, "modelDatas");
1143
1144 List<byte[]> models = new ArrayList<byte[]>();
1145 String[] modelStrs = modelDatas.split(",");
1146 if (null != modelStrs) {
1147 for (String modelStr : modelStrs) {
1148 models.add(checkModel(modelStr));
1149 }
1150 }
1151 if (models.size() > FaceCloudConstant.FEATUREMATCH.MAX_MODEL_COUNT) {
1152 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED,
1153 "model parameters is not greater than" + FaceCloudConstant.FEATUREMATCH.MAX_MODEL_COUNT);
1154 }
1155 return models;
1156 }
1157
1158 /**
1159 * 检索结果记录数参数检验
1160 *
1161 * @param resultSize
1162 * @param paramName
1163 */
1164 public static void checkResultSize(int resultSize, String paramName) {
1165 int resultSizeLimit = FaceCloudConfig.getOrElse(FaceCloudConstant.FEATUREMATCH.MAX_FACE_MODEL_TOPN, FaceCloudConstant.FEATUREMATCH.MAX_DEFULT_FACE_MODEL_TOPN);
1166
1167 checkRange(resultSize, paramName, 1, true, resultSizeLimit, true);
1168 }
1169
1170 /**
1171 * 多图检索参数校验
1172 *
1173 * @param param
1174 * @return
1175 */
1176 public static MultiSnapHumanFaceJobParam checkMultiSnapParam(MultiSnapHumanFaceParam param) {
1177 checkNotNull(param, "抓拍检索参数");
1178
1179 MultiSnapHumanFaceJobParam multiSnapHumanFaceJobParam = new MultiSnapHumanFaceJobParam();
1180
1181 checkRandValue(param.getMale(), "human male", -1, 0, 1, 2);
1182 checkRandValue(param.getGlass(), "glass", -1, 0, 1, 2);
1183 checkRandValue(param.getSmile(), "smile", -1, 0, 1, 2);
1184 checkRandValue(param.getGradeValue(), "gradeValue", -1, 0, 1);
1185 try {
1186 PropertyUtils.copyProperties(multiSnapHumanFaceJobParam, param);
1187 } catch (Exception e) {
1188 throw new BaseException(FaceCloudConstant.MESSAGE.RET_FAIL, "Parameter conversion failure", e);
1189 }
1190
1191 String modelDatas = multiSnapHumanFaceJobParam.getModelDatas();
1192 List<byte[]> models = checkMultiModels(modelDatas);
1193
1194 multiSnapHumanFaceJobParam.setModelDataList(models);
1195
1196 String deviceIds = multiSnapHumanFaceJobParam.getDeviceIds();
1197 checkNotBlank(deviceIds, "device ids");
1198 if (!"-1".equals(deviceIds)) {
1199 Set<UTF8String> deviceIdSet = new HashSet<>();
1200 for(String deviceId: deviceIds.split(",")){
1201 deviceIdSet.add(UTF8String.fromString(deviceId));
1202 }
1203 multiSnapHumanFaceJobParam.setDeviceIdSet(deviceIdSet);
1204
1205 String regionIndexCodes = multiSnapHumanFaceJobParam.getRegionIndexCodes();
1206 if (StringUtils.isNotBlank(regionIndexCodes)) {
1207 Set<UTF8String> regionIndexCodeSet = new HashSet<>();
1208 for (String regionIndexCode : regionIndexCodes.split(",")) {
1209 regionIndexCodeSet.add(UTF8String.fromString(regionIndexCode));
1210 }
1211 multiSnapHumanFaceJobParam.setRegionIndexCodeSet(regionIndexCodeSet);
1212 }
1213 }
1214
1215 String beginDateStr = multiSnapHumanFaceJobParam.getBeginDate();
1216 checkNotBlank(beginDateStr, "begin date");
1217 Date beginDate = checkDate(beginDateStr, "begin date", FaceCloudConstant.DATE_FORMATTER_YMDHMS);
1218 multiSnapHumanFaceJobParam.setBeginDateTime(beginDate.getTime());
1219
1220 String endDateStr = multiSnapHumanFaceJobParam.getEndDate();
1221 checkNotBlank(endDateStr, "end date");
1222 Date endDate = checkDate(endDateStr, "end date", FaceCloudConstant.DATE_FORMATTER_YMDHMS);
1223 multiSnapHumanFaceJobParam.setEndDateTime(endDate.getTime());
1224 if (null != beginDate && beginDate.after(endDate)) {
1225 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED,
1226 "parameter" + "begin date" + "='" + beginDateStr + "later than parameter" + "end date" + "='" + endDateStr + "',please input true time scope");
1227 }
1228
1229 if (multiSnapHumanFaceJobParam.getResultSize() == 0 ){
1230 int resultSize = FaceCloudConfig.getOrElse(FaceCloudConstant.FEATUREMATCH.HUMAN_FACE_MODEL_TOPN,
1231 FaceCloudConstant.FEATUREMATCH.DEFAULT_MODEL_TOPN);
1232 multiSnapHumanFaceJobParam.setResultSize(resultSize);
1233 }
1234
1235
1236
1237 checkSimilarity(multiSnapHumanFaceJobParam.getSimilarityMin(), multiSnapHumanFaceJobParam.getSimilarityMax());
1238
1239 checkResultSize(multiSnapHumanFaceJobParam.getResultSize(), "result size");
1240
1241
1242
1243 return multiSnapHumanFaceJobParam;
1244 }
1245
1246 /**
1247 * 时空检索首次参数校验
1248 *
1249 * @param param
1250 * @return
1251 */
1252 public static TimeSpaceSnapHumanFaceJobParam checkFirstTimeSpaceParam(TimeSpaceSnapHumanFaceJobParam param) {
1253 checkNotNull(param, "timeSpaceSnapHumanFaceJobParam");
1254
1255 byte[] model = checkModel(param.getModelDataStr());
1256 param.setModelData(model);
1257
1258 //用户输入的地点检测参数
1259 if (!StringUtils.isBlank(param.getDeviceId())) {
1260 try {
1261 String deviceIds = param.getDeviceId();
1262 List<String> deviceList = Arrays.asList(deviceIds.split(FaceCloudConstant.TASK.LIST_PARAM_SEPARATOR));
1263 param.setDeviceList(deviceList);
1264 } catch (Exception e) {
1265 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "parameter deviceIds is wrong", e);
1266 }
1267 }
1268
1269 //对用户输入的作案地点进行分割处理
1270 if (!StringUtils.isBlank(param.getCrimedeviceId())) {
1271 try {
1272 String crimeDeviceIds = param.getCrimedeviceId();
1273 List<String> crimeDeviceList = Arrays
1274 .asList(crimeDeviceIds.split(FaceCloudConstant.TASK.LIST_PARAM_SEPARATOR));
1275 param.setCrimeDeviceList(crimeDeviceList);
1276 } catch (Exception e) {
1277 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "parameter crimeDeviceIds is wrong", e);
1278 }
1279 }
1280
1281 String beginDateStr = param.getBeginDate();
1282 if (StringUtils.isNotBlank(beginDateStr)) {
1283 Date beginDate = checkDate(beginDateStr, "begin date", FaceCloudConstant.DATE_FORMATTER_YMDHMS);
1284 param.setBeginDateTime(beginDate.getTime());
1285 }
1286 String endDateStr = param.getEndDate();
1287 if (StringUtils.isNotBlank(endDateStr)) {
1288 Date endDate = checkDate(endDateStr, "end date", FaceCloudConstant.DATE_FORMATTER_YMDHMS);
1289 param.setEndDateTime(endDate.getTime());
1290 }
1291
1292 String crimeBeginDateStr = param.getCrimeBeginDate();
1293 if (StringUtils.isNotBlank(crimeBeginDateStr)) {
1294 Date beginDate = checkDate(crimeBeginDateStr, "crime begin date", FaceCloudConstant.DATE_FORMATTER_YMDHMS);
1295 param.setCrimeBeginDateTime(beginDate.getTime());
1296 }
1297 String crimeEndDateStr = param.getCrimeEndDate();
1298 if (StringUtils.isNotBlank(crimeEndDateStr)) {
1299 Date endDate = checkDate(crimeEndDateStr, "crime end date", FaceCloudConstant.DATE_FORMATTER_YMDHMS);
1300 param.setCrimeEndDateTime(endDate.getTime());
1301 }
1302
1303 checkSimilarity(param.getSimilarityMin(), param.getSimilarityMax());
1304 if (param.getSimilarityMax() == 0) {
1305 param.setSimilarityMax(1.0);
1306 }
1307
1308 checkResultSize(param.getResultSize(), "result size");
1309 return param;
1310 }
1311
1312 /**
1313 * 时空检索再次提交参数校验
1314 *
1315 * @param param
1316 * @return
1317 */
1318 public static TimeSpaceSnapHumanFaceJobParam checkNextTimeSpaceParam(TimeSpaceSnapHumanFaceJobParam param) {
1319 checkNotNull(param, "timeSpaceSnapHumanFaceJobParam");
1320
1321 checkNotBlank(param.getTaskId(), "task id");
1322
1323 try {
1324 List<String> rowKeyList = new ArrayList<String>();
1325 for (String j : TimeSpaceResultLibCache.snapRealLibCache.asMap().get(param.getTaskId()).keySet()) {
1326 rowKeyList.add(j);
1327 }
1328 param.setRowKeyList(rowKeyList);
1329 } catch (Exception e) {
1330 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "parameter rowKeys is wrong", e);
1331 }
1332
1333 //用户输入的地点检测参数
1334 checkNotBlank(param.getDeviceId(), "device id");
1335 try {
1336 String deviceIds = param.getDeviceId();
1337 List<String> deviceList = Arrays.asList(deviceIds.split(FaceCloudConstant.TASK.LIST_PARAM_SEPARATOR));
1338 param.setDeviceList(deviceList);
1339 } catch (Exception e) {
1340 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "parameter deviceIds is wrong", e);
1341 }
1342
1343 //对用户输入的作案地点进行分割处理
1344 if (!StringUtils.isBlank(param.getCrimedeviceId())) {
1345 try {
1346 String crimeDeviceIds = param.getCrimedeviceId();
1347 List<String> crimeDeviceList = Arrays
1348 .asList(crimeDeviceIds.split(FaceCloudConstant.TASK.LIST_PARAM_SEPARATOR));
1349 param.setCrimeDeviceList(crimeDeviceList);
1350 } catch (Exception e) {
1351 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "parameter crimeDeviceIds is wrong", e);
1352 }
1353 }
1354
1355 String beginDateStr = param.getBeginDate();
1356 if (StringUtils.isNotBlank(beginDateStr)) {
1357 Date beginDate = checkDate(beginDateStr, "begin date", FaceCloudConstant.DATE_FORMATTER_YMDHMS);
1358 param.setBeginDateTime(beginDate.getTime());
1359 }
1360 String endDateStr = param.getEndDate();
1361 if (StringUtils.isNotBlank(endDateStr)) {
1362 Date endDate = checkDate(endDateStr, "end date", FaceCloudConstant.DATE_FORMATTER_YMDHMS);
1363 param.setEndDateTime(endDate.getTime());
1364 }
1365
1366 String crimeBeginDateStr = param.getCrimeBeginDate();
1367 if (StringUtils.isNotBlank(crimeBeginDateStr)) {
1368 Date beginDate = checkDate(crimeBeginDateStr, "crime begin date", FaceCloudConstant.DATE_FORMATTER_YMDHMS);
1369 param.setCrimeBeginDateTime(beginDate.getTime());
1370 }
1371 String crimeEndDateStr = param.getCrimeEndDate();
1372 if (StringUtils.isNotBlank(crimeEndDateStr)) {
1373 Date endDate = checkDate(crimeEndDateStr, "crime end date", FaceCloudConstant.DATE_FORMATTER_YMDHMS);
1374 param.setCrimeEndDateTime(endDate.getTime());
1375 }
1376
1377 checkSimilarity(param.getSimilarityMin(), param.getSimilarityMax());
1378 if (param.getSimilarityMax() == 0) {
1379 param.setSimilarityMax(1.0);
1380 }
1381
1382 checkResultSize(param.getResultSize(), "result size");
1383
1384 return param;
1385 }
1386
1387 /**
1388 * 人员库操作参数校验
1389 *
1390 * @param operateHumanRecordParam
1391 * @return
1392 */
1393 public static OperateHumanRecordParam checkOperateHumanRecordParam(
1394 OperateHumanRecordParam operateHumanRecordParam) {
1395
1396 if (null != operateHumanRecordParam.getHuman_male()) {
1397 checkRandValue(operateHumanRecordParam.getHuman_male(), "human male", 0, 1, 2);
1398 } else {
1399 if (StringUtil.isBlank(operateHumanRecordParam.getHuman_id())) {
1400 operateHumanRecordParam.setHuman_male(0);
1401 }
1402 }
1403 if (null != operateHumanRecordParam.getHuman_credtype()) {
1404 checkRandValue(operateHumanRecordParam.getHuman_credtype(), "cred type", 0, 1, 2);
1405 } else {
1406 if (StringUtil.isBlank(operateHumanRecordParam.getHuman_id())) {
1407 operateHumanRecordParam.setHuman_credtype(0);
1408 }
1409 }
1410
1411 // 参数校验
1412 String birthDateStr = operateHumanRecordParam.getBirth_date();
1413 Date birth = null;
1414 Date now = null;
1415 if (StringUtils.isNotEmpty(birthDateStr)) {
1416 birth = checkDate(birthDateStr, "birth date", FaceCloudConstant.DATE_FORMATTER_YMD);
1417 now = new Date();
1418 if (birth.after(now)) {
1419 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Birth date can not later than current date");
1420 }
1421 }
1422
1423 String createDateStr = operateHumanRecordParam.getCreate_date();
1424 if (StringUtils.isNotEmpty(createDateStr)) {
1425 Date createDate = checkDate(createDateStr, "createDateStr", FaceCloudConstant.DATE_FORMATTER_YMD);
1426 if (null != birth && birth.after(createDate)) {
1427 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Birth date can not later than create date");
1428 }
1429 } else {
1430 now = new Date();
1431 operateHumanRecordParam.setCreate_date(DateFormatUtils.format(now, FaceCloudConstant.DATE_FORMATTER_YMD));
1432 }
1433
1434 if (null != birth && null != now) {
1435 operateHumanRecordParam.setHuman_age(DateUtil.calAge(birth, now));
1436 }
1437
1438 return operateHumanRecordParam;
1439 }
1440
1441 /**
1442 * 人员库查询参数校验
1443 *
1444 * @param queryHumanRecordParam
1445 * @return
1446 */
1447 public static void checkQueryHumanRecord(QueryHumanRecordParam queryHumanRecordParam) {
1448
1449 checkNotNull(queryHumanRecordParam, "queryHumanRecordParam");
1450 checkPage(queryHumanRecordParam.getPageNum(), queryHumanRecordParam.getPageSize(), null, null);
1451
1452 checkRandValue(queryHumanRecordParam.getHuman_male(), "humanMale", -1, 0, 1, 2);
1453 checkRandValue(queryHumanRecordParam.getHuman_credtype(), "cred type", -1, 0, 1, 2);
1454
1455 String beginBirthDate = queryHumanRecordParam.getBeginBirthDate();
1456 String endBirthDate = queryHumanRecordParam.getEndBirthDate();
1457 checkDateRight(beginBirthDate, "beginBirthDate", FaceCloudConstant.DATE_FORMATTER_YMD, endBirthDate, "endBirthDate",
1458 FaceCloudConstant.DATE_FORMATTER_YMD);
1459 }
1460
1461 public static List<Map<String, Object>> checkParseJson(String addHumanData, String paramName) {
1462 try {
1463 List<Map<String, Object>> addFaceList = JSON.parseObject(addHumanData, List.class);
1464 return addFaceList;
1465 } catch (Throwable e) {
1466 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Param[" + paramName + "]is not a correct format");
1467 }
1468 }
1469
1470 public static List<Map<String, Object>> checkBlackListFace(String addHumanData, String paramName) {
1471 try {
1472 List<Map<String, Object>> addFaceList = JSON.parseObject(addHumanData, List.class);
1473 return addFaceList;
1474 } catch (Throwable e) {
1475 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Param[" + paramName + "]is not a correct format");
1476 }
1477 }
1478
1479 /**
1480 * 黑名单版本号生成
1481 *
1482 * @param version
1483 * @return
1484 */
1485 public static String createVersion(long version) {
1486 String versionStr = "0";
1487 try {
1488 versionStr = TypeUtils.castToString(version);
1489 } catch (Exception e) {
1490 e.printStackTrace();
1491 }
1492 return versionStr;
1493 }
1494
1495 /**
1496 * 黑名单版本号转换校验
1497 *
1498 * @param versionStr
1499 * @param paramName
1500 * @return
1501 */
1502 public static long parseVersion(String versionStr, String paramName) {
1503 long version = 0;
1504 try {
1505 TypeUtils.castToLong(versionStr);
1506 version = Long.parseLong(versionStr);
1507 } catch (Exception e) {
1508 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Param[" + paramName + "]is not a correct format");
1509 }
1510 return version;
1511 }
1512
1513 /**
1514 * IP 正则校验
1515 *
1516 * @param addr
1517 * @param paramName
1518 */
1519 public static void checkIPPattern(String addr, String paramName) {
1520 if (addr.length() < 7 || addr.length() > 15 || "".equals(addr)) {
1521 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Param[" + paramName + "]is not a correct format length");
1522 }
1523 /**
1524 * 判断IP格式和范围
1525 */
1526 String rexp = "([1-9]|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])(\\.(\\d|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])){3}";
1527 Pattern pat = Pattern.compile(rexp);
1528 Matcher mat = pat.matcher(addr);
1529 boolean ipAddress = mat.find();
1530 if (!ipAddress) {
1531 throw new BaseException(ErrorCodeEnum.CODE_AUTHENTICATION_FAILED, "Param[" + paramName + "]is not a correct format");
1532 }
1533 }
1534
1535 /**
1536 * 判断是否需要加载热点数据
1537 *
1538 * @return true 加载热点数据; false 不加载热点数据
1539 */
1540 public static boolean hasHotDataSnapLoading() {
1541 int range = FaceCloudConfig.getOrElse(FaceCloudConstant.FEATUREMATCH.SNAP_HOTDATA_RANGE, 3);
1542 if (range < 0) {
1543 return false;
1544 }
1545 return true;
1546 }
1547
1548 /**
1549 * 后置过滤条件
1550 *
1551 * @param similarityMin
1552 * @param minEqualInd
1553 * @param similarityMax
1554 * @param maxEqualInd
1555 * @return
1556 */
1557 public static SimilarityConditionFilter getPostFilters(double similarityMin, boolean minEqualInd,
1558 double similarityMax, boolean maxEqualInd) {
1559 Double minValue = null;
1560 if (similarityMin != 0.0) {
1561 minValue = similarityMin;
1562 }
1563 Double maxValue = null;
1564 if (similarityMax != 1.0) {
1565 maxValue = similarityMax;
1566 }
1567 SimilarityConditionFilter similarityConditionFilter = new SimilarityConditionFilter(minValue, minEqualInd,
1568 maxValue, maxEqualInd);
1569
1570 return similarityConditionFilter;
1571 }
1572
1573
1574 public static UpdateFaceRecordParam checkAndReturnUpdateFaceRecordParam(JSONObject humanInfoMap) {
1575
1576 String humanName = humanInfoMap.getString("humanName");
1577 Integer humanMale = humanInfoMap.getInteger("humanMale");
1578 String birthDate = humanInfoMap.getString("birthDate");
1579 String createDate = humanInfoMap.getString("createDate");
1580 String humanProvince = humanInfoMap.getString("humanProvince");
1581 String humanCity = humanInfoMap.getString("humanCity");
1582 Integer humanCredtype = humanInfoMap.getInteger("humanCredtype");
1583 String humanCrednum = humanInfoMap.getString("humanCrednum");
1584 //String humanId = humanInfoMap.getString("humanId");
1585 Integer certificate = humanInfoMap.getInteger("certificate");
1586 String caseCode = humanInfoMap.getString("caseCode");
1587 String managePolice = humanInfoMap.getString("managePolice");
1588 String policePhone = humanInfoMap.getString("policePhone");
1589 String nativeCountyCode = humanInfoMap.getString("nativeCountyCode");
1590 String residenceCountyCode = humanInfoMap.getString("residenceCountyCode");
1591 Integer resNum1 = humanInfoMap.getInteger("resNum1");
1592 Integer resNum2 = humanInfoMap.getInteger("resNum2");
1593 String resStr3 = humanInfoMap.getString("resStr3");
1594 String resStr4 = humanInfoMap.getString("resStr4");
1595 String resStr5 = humanInfoMap.getString("resStr5");
1596 String resStr6 = humanInfoMap.getString("resStr6");
1597 String resStr7 = humanInfoMap.getString("resStr7");
1598 String resStr8 = humanInfoMap.getString("resStr8");
1599 String resStr9 = humanInfoMap.getString("resStr9");
1600 String resStr10 = humanInfoMap.getString("resStr10");
1601 String passthroughField = humanInfoMap.getString("passthroughField");
1602 String humanAddress = humanInfoMap.getString("humanAddress");
1603
1604 String facePicurl = humanInfoMap.getString("facePicurl");
1605 String bkgPicurl = humanInfoMap.getString("bkgPicurl");
1606 //String externalId = humanInfoMap.getString("externalId");
1607 String humanNation = humanInfoMap.getString("humanNation");
1608
1609 String rowKey = humanInfoMap.getString("rowKey");
1610 String facelibId = humanInfoMap.getString("facelibId");
1611
1612 UpdateFaceRecordParam updateFaceRecordParam = new UpdateFaceRecordParam(rowKey, facelibId, humanName, humanMale,
1613 birthDate, createDate, humanNation, humanProvince, humanCity, humanCredtype, humanCrednum, caseCode, managePolice,
1614 policePhone, nativeCountyCode, residenceCountyCode, facePicurl, bkgPicurl, humanAddress, resNum1, resNum2, resStr3,
1615 resStr4, resStr5, resStr6, resStr7, resStr8, resStr9, resStr10, passthroughField, certificate);
1616
1617 return checkUpdateFaceRecordParam(updateFaceRecordParam);
1618 }
1619
1620 }
