From d2570148ec3884de3af721bd99c4b7acbbdee075 Mon Sep 17 00:00:00 2001
From: 田源 <lastanimals@163.com>
Date: 星期二, 09 五月 2023 17:07:26 +0800
Subject: [PATCH] 前端代码提交
---
Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/web/util/VciBaseUtil.java | 1228 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 1,228 insertions(+), 0 deletions(-)
diff --git a/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/web/util/VciBaseUtil.java b/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/web/util/VciBaseUtil.java
new file mode 100644
index 0000000..a3d65cc
--- /dev/null
+++ b/Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/web/util/VciBaseUtil.java
@@ -0,0 +1,1228 @@
+package com.vci.ubcs.starter.web.util;
+
+//
+// Source code recreated from a .class file by IntelliJ IDEA
+// (powered by FernFlower decompiler)
+//
+
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson.serializer.SerializerFeature;
+import com.baomidou.mybatisplus.core.toolkit.StringUtils;
+import com.vci.ubcs.starter.exception.VciBaseException;
+import com.vci.ubcs.starter.web.enumpck.BooleanEnum;
+import com.vci.ubcs.starter.web.pagemodel.SessionInfo;
+import com.vci.ubcs.starter.web.toolmodel.DateConverter;
+import com.vci.ubcs.starter.web.wrapper.VciQueryWrapperForDO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.ResourceUtils;
+
+import java.beans.IntrospectionException;
+import java.beans.PropertyDescriptor;
+import java.io.File;
+import java.io.IOException;
+import java.lang.Character.UnicodeBlock;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.net.InetAddress;
+import java.net.NetworkInterface;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+public class VciBaseUtil {
+
+ private static Logger log = LoggerFactory.getLogger(VciBaseUtil.class);
+ public static final String NOTIN = "not in";
+ private static String localIp = null;
+
+ public VciBaseUtil() {
+ }
+
+ public static String getPk() {
+ return UUID.randomUUID().toString();
+ }
+
+ public static int getIntForBoolean(boolean b) {
+ return b ? 1 : 0;
+ }
+
+ public static int getIntFromHibernateResult(Object obj) {
+ if (obj == null) {
+ return 0;
+ } else if (obj instanceof BigDecimal) {
+ return ((BigDecimal)obj).intValue();
+ } else if (obj instanceof BigInteger) {
+ return ((BigInteger)obj).intValue();
+ } else if (obj instanceof Double) {
+ return ((Double)obj).intValue();
+ } else if (obj instanceof Long) {
+ return ((Long)obj).intValue();
+ } else if (obj instanceof Short) {
+ return ((Short)obj).intValue();
+ } else if (obj instanceof Float) {
+ return ((Float)obj).intValue();
+ } else if (obj instanceof String) {
+ try {
+ return Integer.valueOf(obj.toString());
+ } catch (Exception var2) {
+ return 0;
+ }
+ } else {
+ return 0;
+ }
+ }
+
+ public static long getLong(String s) {
+ long l = 0L;
+ if (s == null) {
+ return 0L;
+ } else {
+ try {
+ l = Long.parseLong(s);
+ return l;
+ } catch (Exception var4) {
+ return 0L;
+ }
+ }
+ }
+
+ public static float getFloat(String s) {
+ float f = 0.0F;
+ if (s == null) {
+ return 0.0F;
+ } else {
+ try {
+ f = Float.parseFloat(s);
+ return f;
+ } catch (Exception var3) {
+ return 0.0F;
+ }
+ }
+ }
+
+ public static int getInt(String string) {
+ //int i = false;
+ if (string != null && !"".equals(string.trim())) {
+ if (string.contains(".")) {
+ string = string.substring(0, string.indexOf("."));
+ }
+
+ try {
+ int i = Integer.parseInt(string);
+ return i;
+ } catch (Exception var3) {
+ return 0;
+ }
+ } else {
+ return 0;
+ }
+ }
+
+ public static double getDouble(String s) {
+ double d = 0.0D;
+ if (isNull(s)) {
+ return 0.0D;
+ } else {
+ try {
+ d = Double.parseDouble(s);
+ return d;
+ } catch (Exception var4) {
+ return 0.0D;
+ }
+ }
+ }
+
+
+ public static boolean getBoolean(String s) {
+ return BooleanEnum.TRUE.getValue().equals(s);
+ }
+
+ public static String removeComma(String s) {
+ if (s != null && s.trim().length() != 0) {
+ if (s.startsWith(",")) {
+ s = s.substring(1, s.length());
+ }
+
+ if (s.endsWith(",")) {
+ s = s.substring(0, s.length() - 1);
+ }
+
+ return s;
+ } else {
+ return s;
+ }
+ }
+
+ public static String toInSql(String s) {
+ s = removeComma(s);
+ if (s != null && s.trim().length() != 0) {
+ String[] temp = s.split(",");
+ return toInSql(temp);
+ } else {
+ return "";
+ }
+ }
+
+ public static String toInSql(String[] s) {
+ if (s != null && s.length > 0) {
+ StringBuilder sb = new StringBuilder();
+ if (s != null && s.length > 0) {
+ for(int i = 0; i < s.length; ++i) {
+ if (s[i] != null && s[i].trim().length() > 0 && !s[i].startsWith("'")) {
+ sb.append("'").append(s[i]).append("',");
+ }
+ }
+ }
+
+ return removeComma(sb.toString());
+ } else {
+ return "";
+ }
+ }
+
+ public static String toInSql(String field, String s) {
+ return !StringUtils.isBlank(field) && !StringUtils.isBlank(s) ? toInSql(field, removeComma(s).split(","), "") : "";
+ }
+
+ public static String toInSql(String field, String[] s) {
+ return toInSql(field, s, "in");
+ }
+
+ public static String toInSql(String field, String[] s, String operation) {
+ if (!StringUtils.isBlank(field) && s != null && s.length != 0) {
+ StringBuilder sb = new StringBuilder();
+ if (s != null && s.length > 0) {
+ String andOr = "or";
+ if (operation.trim().toLowerCase().equals("not in")) {
+ andOr = "and";
+ }
+
+ for(int i = 0; i < s.length; ++i) {
+ if (s[i] != null && s[i].trim().length() > 0 && !s[i].startsWith("'")) {
+ if (i == 0) {
+ sb.append(field).append(" ").append(operation).append(" (");
+ }
+
+ if (i % 500 == 0 && i != 0) {
+ sb.append(" ").append(andOr).append(" ").append(field).append(" ").append(operation).append(" (");
+ }
+
+ sb.append("'").append(s[i]).append("'");
+ if (i % 500 != 499 && i != s.length - 1) {
+ sb.append(",");
+ }
+
+ if (i % 500 == 499 || i == s.length - 1) {
+ sb.append(") ");
+ }
+ }
+ }
+ }
+
+ return sb.toString();
+ } else {
+ return "";
+ }
+ }
+
+ /** @deprecated */
+ @Deprecated
+ public static String arrayToString(String[] array) {
+ if (array != null && array.length > 0) {
+ StringBuilder sb = new StringBuilder();
+
+ for(int i = 0; i < array.length; ++i) {
+ String record = array[i];
+ if (StringUtils.isNotBlank(record)) {
+ sb.append(record).append(",");
+ }
+ }
+
+ return removeComma(sb.toString());
+ } else {
+ return "";
+ }
+ }
+
+ public static String collectionToString(Collection collection) {
+ if (CollectionUtils.isEmpty(collection)) {
+ return "";
+ } else {
+ StringBuilder sb = new StringBuilder();
+ Iterator it = collection.iterator();
+
+ while(true) {
+ Object record;
+ do {
+ do {
+ if (!it.hasNext()) {
+ return removeComma(sb.toString());
+ }
+
+ record = it.next();
+ } while(record == null);
+ } while(record instanceof String && !StringUtils.isNotBlank((String)record));
+
+ sb.append(record.toString()).append(",");
+ }
+ }
+ }
+
+ public static String toUpForFirst(String s) {
+ if (s != null && s.trim().length() != 0) {
+ String temp = s.substring(0, 1);
+ temp = temp.toUpperCase();
+ return temp + s.substring(1, s.length());
+ } else {
+ return "";
+ }
+ }
+
+ public static String toLowForFirst(String s) {
+ if (s != null && s.trim().length() != 0) {
+ String temp = s.substring(0, 1);
+ temp = temp.toLowerCase();
+ return temp + s.substring(1, s.length());
+ } else {
+ return "";
+ }
+ }
+
+ public static int countOfString(String s, char findC) {
+ Map<String, Integer> charMap = new HashMap();
+ char[] cs = s.toCharArray();
+ char[] var4 = cs;
+ int var5 = cs.length;
+
+ for(int var6 = 0; var6 < var5; ++var6) {
+ char c = var4[var6];
+ charMap.put(String.valueOf(c), !charMap.containsKey(String.valueOf(c)) ? 1 : (Integer)charMap.get(String.valueOf(c)) + 1);
+ }
+
+ return (Integer)charMap.get(String.valueOf(findC));
+ }
+
+ public static List<String> str2List(String s) {
+ if (isNull(s)) {
+ return null;
+ } else {
+ List<String> l = new ArrayList();
+ Collections.addAll(l, removeComma(s).split(","));
+ return l;
+ }
+ }
+
+ public static String list2String(List<String> ls) {
+ return ls != null && ls.size() != 0 ? (String)ls.stream().collect(Collectors.joining(",")) : "";
+ }
+
+ public static boolean isNull(String o) {
+ return StringUtils.isEmpty(o);
+ }
+
+ public static boolean isNotNull(String o) {
+ return !isNull(o);
+ }
+
+ public static boolean isNullOrNullString(String o) {
+ return StringUtils.isBlank(o);
+ }
+
+ public static boolean inArray(String[] arr, String s) {
+ if (arr != null && s != null) {
+ String[] var2 = arr;
+ int var3 = arr.length;
+
+ for(int var4 = 0; var4 < var3; ++var4) {
+ String a = var2[var4];
+ if (s.trim().equalsIgnoreCase(a)) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+ public static boolean inArray(Object[] arr, Object o) {
+ if (arr != null && o != null) {
+ Object[] var2 = arr;
+ int var3 = arr.length;
+
+ for(int var4 = 0; var4 < var3; ++var4) {
+ Object a = var2[var4];
+ if (a.equals(o)) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+ public static double round(double value, int scale, int roundingMode) {
+ BigDecimal bd = new BigDecimal(value);
+ bd = bd.setScale(scale, roundingMode);
+ double d = bd.doubleValue();
+ bd = null;
+ return d;
+ }
+
+ public static double round(double value, int scale) {
+ return round(value, scale, 4);
+ }
+
+ public static boolean isEmail(String string) {
+ if (StringUtils.isBlank(string)) {
+ return false;
+ } else {
+ String regEx1 = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
+ Pattern p = Pattern.compile(regEx1);
+ Matcher m = p.matcher(string);
+ return m.matches();
+ }
+ }
+
+ public static boolean isNumber(String s) {
+ return StringUtils.isNotBlank(s) && s.matches("\\d+\\.?\\d*");
+ }
+
+ public static Field getFieldForObject(String fieldName, List<Field> fieldsList) {
+ if (StringUtils.isBlank(fieldName)) {
+ return null;
+ } else {
+ if (fieldsList != null && fieldsList.size() > 0) {
+ Iterator var2 = fieldsList.iterator();
+
+ while(var2.hasNext()) {
+ Field field = (Field)var2.next();
+ if (field.getName().toLowerCase().equals(fieldName.toLowerCase())) {
+ return field;
+ }
+ }
+ }
+
+ return null;
+ }
+ }
+
+ public static Method getSetmethod(Class c, String fieldName) {
+ if (c != null && StringUtils.isNotBlank(fieldName)) {
+ try {
+ PropertyDescriptor pd = new PropertyDescriptor(fieldName, c);
+ return pd.getWriteMethod();
+ } catch (SecurityException var3) {
+ if (log.isErrorEnabled()) {
+ log.error("鑾峰彇getter鍑洪敊", var3);
+ }
+ } catch (IntrospectionException var4) {
+ if (log.isErrorEnabled()) {
+ log.error("鑾峰彇getter鍑洪敊", var4);
+ }
+ }
+ }
+
+ return null;
+ }
+
+ public static Method getGetmethod(Class c, String fieldName) {
+ if (c != null && StringUtils.isNotBlank(fieldName)) {
+ try {
+ PropertyDescriptor pd = new PropertyDescriptor(fieldName, c);
+ return pd.getReadMethod();
+ } catch (SecurityException var3) {
+ if (log.isErrorEnabled()) {
+ log.error("鑾峰彇getter鍑洪敊", var3);
+ }
+ } catch (IntrospectionException var4) {
+ if (log.isErrorEnabled()) {
+ log.error("鑾峰彇getter鍑洪敊", var4);
+ }
+ }
+ }
+
+ return null;
+ }
+
+ public static String getColumnAnnotaionNameValue(Annotation[] fieldAnnotaions) {
+ return getAnnotationValue("com.vci.starter.web.annotation.Column,javax.persistence.Column", "name", fieldAnnotaions);
+ }
+
+ public static String getAnnotationValue(String annotationName, String methodName, Annotation[] fieldAnnotaions) {
+ String[] annotaionNameArray = annotationName.split(",");
+ Annotation[] var4 = fieldAnnotaions;
+ int var5 = fieldAnnotaions.length;
+
+ for(int var6 = 0; var6 < var5; ++var6) {
+ Annotation annotation = var4[var6];
+ String anname = annotation.annotationType().getName();
+ if (inArray(annotaionNameArray, anname)) {
+ String name = null;
+
+ try {
+ name = (String)annotation.getClass().getMethod(methodName).invoke(annotation);
+ } catch (IllegalAccessException var11) {
+ var11.printStackTrace();
+ } catch (InvocationTargetException var12) {
+ var12.printStackTrace();
+ } catch (NoSuchMethodException var13) {
+ var13.printStackTrace();
+ }
+
+ return name;
+ }
+ }
+
+ return null;
+ }
+
+ public static Object getValueFromField(String fieldName, Object sourceObject) {
+ if (StringUtils.isNotBlank(fieldName)) {
+ try {
+ Method getMethod = getGetmethod(sourceObject.getClass(), fieldName);
+ if (getMethod != null) {
+ return getMethod.invoke(sourceObject);
+ }
+
+ Field field = getFieldForObject(fieldName, sourceObject);
+ if (field != null) {
+ field.setAccessible(true);
+ return field.get(sourceObject);
+ }
+ } catch (SecurityException var4) {
+ if (log.isErrorEnabled()) {
+ log.error("浠庡睘鎬т笂鑾峰彇鍊�", var4);
+ }
+ } catch (IllegalAccessException var5) {
+ if (log.isErrorEnabled()) {
+ log.error("浠庡睘鎬т笂鑾峰彇鍊�", var5);
+ }
+ } catch (IllegalArgumentException var6) {
+ if (log.isErrorEnabled()) {
+ log.error("浠庡睘鎬т笂鑾峰彇鍊�", var6);
+ }
+ } catch (InvocationTargetException var7) {
+ if (log.isErrorEnabled()) {
+ log.error("浠庡睘鎬т笂鑾峰彇鍊�", var7);
+ }
+ }
+ }
+
+ return null;
+ }
+
+ public static void setValueForMethod(Field field, Object obj, Object value) {
+ try {
+ if (field != null) {
+ field.setAccessible(true);
+ Method setMethod = getSetmethod(field.getDeclaringClass(), field.getName());
+ setMethod.invoke(obj, value);
+ }
+ } catch (Exception var4) {
+ log.error("鍙嶅皠璋冪敤鏂规硶鍑虹幇浜嗛敊璇�,", var4);
+ }
+
+ }
+
+ public static void alertNotNull(Object... s) throws VciBaseException {
+ if (s != null && s.length > 0) {
+ for(int i = 0; i < s.length; ++i) {
+ Object obj = s[i];
+ String param = "";
+
+ try {
+ ++i;
+ param = s[i].toString();
+ } catch (Exception var5) {
+ }
+
+ if (obj == null) {
+ throw new VciBaseException("鍙傛暟[{0}]涓嶈兘涓虹┖", new String[]{param});
+ }
+
+ if (obj instanceof Collection) {
+ if (CollectionUtils.isEmpty((Collection)obj)) {
+ throw new VciBaseException("鍙傛暟[{0}]涓嶈兘涓虹┖", new String[]{param});
+ }
+ } else if (StringUtils.isBlank(obj.toString())) {
+ throw new VciBaseException("鍙傛暟[{0}]涓嶈兘涓虹┖", new String[]{param});
+ }
+ }
+ }
+
+ }
+
+ /** @deprecated */
+ @Deprecated
+ public static void alertCollectionNotNull(String param, Collection collections) throws VciBaseException {
+ if (CollectionUtils.isEmpty(collections)) {
+ throw new VciBaseException("鍙傛暟{0}涓嶈兘涓虹┖", new String[]{param});
+ }
+ }
+
+ public static <T> Set<Set<T>> switchSetForOracleIn(Set<T> set) {
+ Set<Set<T>> listHasList = new HashSet();
+ if (set == null) {
+ return listHasList;
+ } else {
+ int muti = 1;
+ if (set.size() > 500) {
+ int balance = set.size() % 500;
+ muti = (set.size() - balance) / 500 + (balance == 0 ? 0 : 1);
+ }
+
+ List list = new ArrayList();
+ Iterator it = set.iterator();
+
+ while(it.hasNext()) {
+ list.add(it.next());
+ }
+
+ for(int i = 0; i < muti; ++i) {
+ int start = i * 500;
+ int end = start + 500;
+ if (i == muti - 1 || end > set.size()) {
+ end = set.size();
+ }
+
+ List subList = list.subList(start, end);
+ Set subSet = new HashSet();
+ Iterator var10 = subList.iterator();
+
+ while(var10.hasNext()) {
+ Object obj = var10.next();
+ subSet.add(obj);
+ }
+
+ listHasList.add(subSet);
+ }
+
+ return listHasList;
+ }
+ }
+
+ public static <T> Vector<Vector<T>> switchVectorForOracleIn(Vector<T> vector) {
+ Vector<Vector<T>> listHasList = new Vector();
+ if (vector == null) {
+ return listHasList;
+ } else {
+ int muti = 1;
+ if (vector.size() > 500) {
+ int balance = vector.size() % 500;
+ muti = (vector.size() - balance) / 500 + (balance == 0 ? 0 : 1);
+ }
+
+ List list = new ArrayList();
+ Iterator it = vector.iterator();
+
+ while(it.hasNext()) {
+ list.add(it.next());
+ }
+
+ for(int i = 0; i < muti; ++i) {
+ int start = i * 500;
+ int end = start + 500;
+ if (i == muti - 1 || end > vector.size()) {
+ end = vector.size();
+ }
+
+ List subList = list.subList(start, end);
+ Vector subSet = new Vector();
+ Iterator var10 = subList.iterator();
+
+ while(var10.hasNext()) {
+ Object obj = var10.next();
+ subSet.add(obj);
+ }
+
+ listHasList.add(subSet);
+ }
+
+ return listHasList;
+ }
+ }
+
+ public static <T> T jsonString2JavaBean(String jsonString, Class<T> beanClass) {
+ return JSONObject.parseObject(jsonString, beanClass);
+ }
+
+ public static void ifNullSetDefautl(String str, String defaultValue) {
+ if (isNull(str)) {
+ ;
+ }
+
+ }
+
+ public static <T> T getFristObjectFromJson(String jsonString, Class<T> beanClass) {
+ return !isNull(jsonString) ? JSONObject.parseArray(jsonString, beanClass).get(0) : null;
+ }
+
+ public static String getJSONStringWithDateFormat(Object obj) {
+ return JSONObject.toJSONStringWithDateFormat(obj, "yyyy-MM-dd HH:mm:ss.SSS", new SerializerFeature[]{SerializerFeature.WriteDateUseDateFormat});
+ }
+
+ public static Map<String, Object> objectToMap(Object o) {
+ Map<String, Object> map = new HashMap();
+ if (o != null) {
+ String jsonString = JSONObject.toJSONStringWithDateFormat(o, "yyyy-MM-dd HH:mm:ss.SSS", new SerializerFeature[]{SerializerFeature.WriteDateUseDateFormat});
+ if (StringUtils.isNotBlank(jsonString)) {
+ JSONObject jsonObject = JSONObject.parseObject(jsonString);
+ if (jsonObject != null) {
+ Iterator var4 = jsonObject.keySet().iterator();
+
+ while(var4.hasNext()) {
+ String key = (String)var4.next();
+ map.put(key, jsonObject.get(key));
+ }
+ }
+ }
+ }
+
+ return map;
+ }
+
+ public static Map<String, String> objectToMapString(Object o) {
+ Map<String, String> map = new HashMap();
+ if (o != null) {
+ String jsonString = JSONObject.toJSONStringWithDateFormat(o, "yyyy-MM-dd HH:mm:ss.SSS", new SerializerFeature[]{SerializerFeature.WriteDateUseDateFormat});
+ if (StringUtils.isNotBlank(jsonString)) {
+ JSONObject jsonObject = JSONObject.parseObject(jsonString);
+ if (jsonObject != null) {
+ Iterator var4 = jsonObject.keySet().iterator();
+
+ while(var4.hasNext()) {
+ String key = (String)var4.next();
+ map.put(key, jsonObject.getString(key));
+ }
+ }
+ }
+ }
+
+ return map;
+ }
+
+ public static boolean isNotNullForField(Object obj, Field f) {
+ return !"serialVersionUID".equalsIgnoreCase(f.getName()) && !"DEFAULT_INITIAL_CAPACITY".equalsIgnoreCase(f.getName()) && null != obj && !isNullOrNullString(obj.toString());
+ }
+
+ public static String array2String(String[] array) {
+ if (null != array && array.length != 0) {
+ String ss = "";
+ String[] var2 = array;
+ int var3 = array.length;
+
+ for(int var4 = 0; var4 < var3; ++var4) {
+ String s = var2[var4];
+ ss = ss + s + ",";
+ }
+
+ return removeComma(ss);
+ } else {
+ return "";
+ }
+ }
+
+ public static void copyValueForMap(Map source, Map target, String[] copyField) {
+ Map<String, String> copyFieldMap = new HashMap();
+ String[] var4 = copyField;
+ int var5 = copyField.length;
+
+ for(int var6 = 0; var6 < var5; ++var6) {
+ String field = var4[var6];
+ copyFieldMap.put(field, field);
+ }
+
+ copyValueForMap(source, target, (Map)copyFieldMap);
+ }
+
+ public static void copyValueForMap(Map source, Map target, Map<String, String> copyField) {
+ try {
+ Iterator it = copyField.keySet().iterator();
+
+ while(it.hasNext()) {
+ String field = (String)it.next();
+ target.put(field, source.get(copyField.get(field)));
+ }
+ } catch (Exception var5) {
+ }
+
+ }
+
+ public static Double getDoubleFromMap(String field, Map<String, Object> record) {
+ if (!isNullOrNullString(field) && record != null && record.containsKey(field)) {
+ Object v = record.get(field);
+ if (v instanceof BigDecimal) {
+ return ((BigDecimal)v).doubleValue();
+ } else {
+ return v instanceof Double ? (Double)v : getDouble((String)v);
+ }
+ } else {
+ return null;
+ }
+ }
+
+ public static String getDataByKey(String key, Map<String, Object> data) {
+ String value = "";
+ if (data.containsKey(key)) {
+ value = (String)data.get(key);
+ }
+
+ if (value == null) {
+ value = "";
+ }
+
+ return value;
+ }
+
+ public static Map getNotNullMap(Map map) {
+ if (map == null) {
+ return new HashMap();
+ } else {
+ Iterator it = map.keySet().iterator();
+ HashMap unNullMap = new HashMap();
+
+ while(true) {
+ while(true) {
+ String newKey;
+ Object value;
+ do {
+ if (!it.hasNext()) {
+ return unNullMap;
+ }
+
+ Object key = it.next();
+ newKey = key.toString().toLowerCase();
+ value = map.get(key);
+ } while(value == null);
+
+ if (value instanceof String && isNotNull(value.toString())) {
+ unNullMap.put(newKey, value);
+ } else if (!(value instanceof String)) {
+ unNullMap.put(newKey, value);
+ }
+ }
+ }
+ }
+ }
+
+ public static List<Field> getAllFieldForObj(Class c) {
+ List<Field> allField = new ArrayList();
+ Set<String> fieldNameSet = new HashSet();
+
+ for(Class classz = c; classz != Object.class; classz = classz.getSuperclass()) {
+ Field[] thisClassField = classz.getDeclaredFields();
+ Field[] var5 = thisClassField;
+ int var6 = thisClassField.length;
+
+ for(int var7 = 0; var7 < var6; ++var7) {
+ Field field = var5[var7];
+ if (!field.getName().equals("serialVersionUID")) {
+ String fieldLowerName = field.getName().toLowerCase();
+ if (!fieldNameSet.contains(fieldLowerName)) {
+ fieldNameSet.add(fieldLowerName);
+ allField.add(field);
+ }
+ }
+ }
+ }
+
+ return allField;
+ }
+
+ public static String getTableName(String btmname) {
+ return (VciQueryWrapperForDO.USER_TABLE_COMPATIBILITY ? "pl_code_" : "vcibt_") + btmname.trim().toLowerCase();
+ }
+
+ public static Field getTsField(Class c) {
+ List<Field> allField = getAllFieldForObj(c);
+ if (allField != null && allField.size() > 0) {
+ Iterator var2 = allField.iterator();
+
+ while(var2.hasNext()) {
+ Field field = (Field)var2.next();
+ if (field.getName().equals("ts")) {
+ return field;
+ }
+ }
+ }
+
+ return null;
+ }
+
+ public static Field getFieldForObject(String fieldName, Object obj) {
+ return obj == null ? null : getFieldForObject(fieldName, obj.getClass());
+ }
+
+ public static Field getFieldForObject(String fieldName, Class c) {
+ List<Field> allField = getAllFieldForObj(c);
+ if (allField != null && allField.size() > 0) {
+ Iterator var3 = allField.iterator();
+
+ while(var3.hasNext()) {
+ Field field = (Field)var3.next();
+ if (field.getName().toLowerCase().equalsIgnoreCase(fieldName.toLowerCase())) {
+ return field;
+ }
+ }
+ }
+
+ return null;
+ }
+
+ public static Method getSetmethod(Class c, Field field) {
+ return getSetmethod(c, field.getName());
+ }
+
+ public static Method getGetmethod(Class c, Field field) {
+ return getGetmethod(c, field.getName());
+ }
+
+ public static Method getMethodByName(Class<?> classObj, String methodName) {
+ alertNotNull(classObj, "鑾峰彇鏂规硶鐨勫璞℃墍灞炵殑绫�", methodName, "鏂规硶鐨勫悕瀛�");
+ Method[] methods = classObj.getMethods();
+ List<Method> sameMethods = (List)Arrays.stream(methods).filter((method) -> {
+ return method.getName().equalsIgnoreCase(methodName);
+ }).collect(Collectors.toList());
+ return !CollectionUtils.isEmpty(sameMethods) ? (Method)sameMethods.get(0) : null;
+ }
+
+ public static Map<String, String> whereSql2Map(String whereSql) {
+ Map<String, String> map = new HashMap();
+ if (isNotNull(whereSql)) {
+ String[] selects = whereSql.split("and");
+ if (selects != null && selects.length > 0) {
+ String[] var3 = selects;
+ int var4 = selects.length;
+
+ for(int var5 = 0; var5 < var4; ++var5) {
+ String s = var3[var5];
+ s = s.trim();
+ map.put(s.substring(0, s.indexOf(" ")).trim(), s.substring(s.indexOf(" ") + 1).trim());
+ }
+ }
+ }
+
+ return map;
+ }
+
+ public static synchronized String getRoundFilename(String prefix) {
+ if (prefix == null) {
+ prefix = "";
+ }
+
+ return prefix + System.currentTimeMillis();
+ }
+
+ public static String getLocalIp() {
+ if (localIp == null) {
+ try {
+ InetAddress inetAddress = getLocalHostLANAddress();
+ if (inetAddress == null) {
+ localIp = "127.0.0.1";
+ } else {
+ localIp = inetAddress.getHostAddress();
+ }
+ } catch (Exception var1) {
+ localIp = "127.0.0.1";
+ }
+ }
+
+ return localIp;
+ }
+
+ private static InetAddress getLocalHostLANAddress() throws Exception {
+ try {
+ InetAddress candidateAddress = null;
+ Enumeration ifaces = NetworkInterface.getNetworkInterfaces();
+
+ while(ifaces.hasMoreElements()) {
+ NetworkInterface iface = (NetworkInterface)ifaces.nextElement();
+ Enumeration inetAddrs = iface.getInetAddresses();
+
+ while(inetAddrs.hasMoreElements()) {
+ InetAddress inetAddr = (InetAddress)inetAddrs.nextElement();
+ if (!inetAddr.isLoopbackAddress()) {
+ if (inetAddr.isSiteLocalAddress()) {
+ return inetAddr;
+ }
+
+ if (candidateAddress == null) {
+ candidateAddress = inetAddr;
+ }
+ }
+ }
+ }
+
+ if (candidateAddress != null) {
+ return candidateAddress;
+ } else {
+ InetAddress jdkSuppliedAddress = InetAddress.getLocalHost();
+ return jdkSuppliedAddress;
+ }
+ } catch (Exception var5) {
+ var5.printStackTrace();
+ return null;
+ }
+ }
+
+ public static String getProjectPath() {
+ String path = "";
+
+ try {
+ String jarFilePath = ResourceUtils.getURL("classpath:").getPath();
+ if (jarFilePath.contains("!")) {
+ path = (new File(jarFilePath)).getParentFile().getParentFile().getParent();
+ } else {
+ path = (new File(jarFilePath)).getParent();
+ }
+ } catch (IOException var2) {
+ throw new VciBaseException("鑾峰彇褰撳墠鏈嶅姟鎵�鍦ㄧ殑鏂囦欢澶瑰嚭鐜颁簡閿欒");
+ }
+
+ if (path.startsWith("file:\\")) {
+ path = path.substring(6);
+ }
+
+ return path;
+ }
+
+ public static Map<String, String> getParamsByUrl(String url) {
+ if (StringUtils.isBlank(url)) {
+ return new HashMap();
+ } else {
+ String[] array = url.split("&");
+ Map<String, String> params = new HashMap();
+ String[] var3 = array;
+ int var4 = array.length;
+
+ for(int var5 = 0; var5 < var4; ++var5) {
+ String temp = var3[var5];
+ if (temp.contains("=")) {
+ String[] keyValues = temp.split("=");
+ params.put(keyValues[0], keyValues[1]);
+ } else {
+ params.put(temp, "");
+ }
+ }
+
+ return params;
+ }
+ }
+
+ public static boolean isChinese(char c) {
+ UnicodeBlock ub = UnicodeBlock.of(c);
+ return ub == UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS || ub == UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS || ub == UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A || ub == UnicodeBlock.GENERAL_PUNCTUATION || ub == UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION || ub == UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS;
+ }
+
+ public static boolean containsKeyUnCaseForMap(Map map, String key) {
+ if (!CollectionUtils.isEmpty(map)) {
+ boolean[] finded = new boolean[]{false};
+ map.forEach((k, value) -> {
+ if (k instanceof String && k.toString().toLowerCase(Locale.ROOT).equalsIgnoreCase(key)) {
+ finded[0] = true;
+ }
+ });
+ return finded[0];
+ } else {
+ return false;
+ }
+ }
+
+ public static boolean isChinese(String str) {
+ char[] ch = str.toCharArray();
+ char[] var2 = ch;
+ int var3 = ch.length;
+
+ for(int var4 = 0; var4 < var3; ++var4) {
+ char c = var2[var4];
+ if (isChinese(c)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public static String toDBC(String input) {
+ if (StringUtils.isBlank(input)) {
+ return input;
+ } else {
+ char[] c = input.toCharArray();
+
+ for(int i = 0; i < c.length; ++i) {
+ if (c[i] == 12288) {
+ c[i] = ' ';
+ } else if (c[i] > '\uff00' && c[i] < '锝�') {
+ c[i] -= '锘�';
+ }
+ }
+
+ return new String(c);
+ }
+ }
+
+ public static String toSBC(String input) {
+ if (StringUtils.isBlank(input)) {
+ return input;
+ } else {
+ char[] c = input.toCharArray();
+
+ for(int i = 0; i < c.length; ++i) {
+ if (c[i] == 12288) {
+ c[i] = ' ';
+ } else if (c[i] > '\uff00' && c[i] < '锝�') {
+ c[i] += '锘�';
+ }
+ }
+
+ return new String(c);
+ }
+ }
+
+ public static String getStringValueFromObject(Object obj) {
+ if (obj == null) {
+ return "";
+ } else if (!(obj instanceof Integer) && !(obj instanceof Float) && !(obj instanceof Long) && !(obj instanceof Double)) {
+ return obj instanceof Date ? VciDateUtil.date2Str((Date)obj, "yyyy-MM-dd HH:mm:ss.SSS") : obj.toString();
+ } else {
+ if (obj instanceof Double) {
+ Double aDouble = (Double)obj;
+ if (aDouble != null && aDouble % 1.0D == 0.0D) {
+ return String.valueOf(aDouble.intValue());
+ }
+ }
+
+ return String.valueOf(obj);
+ }
+ }
+
+ public static SessionInfo getCurrentUserSessionInfoNotException() {
+ return (SessionInfo) WebThreadLocalUtil.getCurrentUserSessionInfoInThread().get();
+ }
+
+
+ public static <T> Collection<Collection<T>> switchCollectionForOracleIn(Collection<T> list) {
+ return switchCollectionForOracleIn(list, 500);
+ }
+
+ public static <T> Collection<Collection<T>> switchCollectionForOracleIn(Collection<T> collection, int preSize) {
+ Collection<Collection<T>> listHasList = new ArrayList();
+ if (collection == null) {
+ return listHasList;
+ } else {
+ List<T> newList = new ArrayList();
+ Iterator var4 = collection.iterator();
+
+ while(var4.hasNext()) {
+ Object obj = var4.next();
+ newList.add((T) obj);
+ }
+
+ int muti = 1;
+ int i;
+ if (newList.size() > preSize) {
+ i = newList.size() % preSize;
+ muti = (newList.size() - i) / preSize + (i == 0 ? 0 : 1);
+ }
+
+ for(i = 0; i < muti; ++i) {
+ int start = i * preSize;
+ int end = start + preSize;
+ if (i == muti - 1 || end > newList.size()) {
+ end = newList.size();
+ }
+
+ List subList = newList.subList(start, end);
+ listHasList.add(subList);
+ }
+
+ return listHasList;
+ }
+ }
+ public static short getShort(String s) {
+// short i = false;
+ if (s == null) {
+ return 0;
+ } else {
+ try {
+ short i = Short.parseShort(s);
+ return i;
+ } catch (Exception var3) {
+ return 0;
+ }
+ }
+ }
+
+ public static void setValueForField(Field field, Object obj, String value) {
+ try {
+ if (field != null && StringUtils.isNotBlank(value)) {
+ field.setAccessible(true);
+ Method setMethod = getSetmethod(field.getDeclaringClass(), field.getName());
+ Class type = field.getType();
+ Object valueObj = null;
+ if (!type.equals(Integer.TYPE) && !type.equals(Integer.class)) {
+ if (!type.equals(Float.TYPE) && !type.equals(Float.class)) {
+ if (!type.equals(Long.TYPE) && !type.equals(Long.class)) {
+ if (!type.equals(Double.class) && !type.equals(Double.TYPE)) {
+ if (type.equals(Date.class)) {
+ DateConverter dateConverter = new DateConverter();
+ dateConverter.setAsText(value);
+ valueObj = dateConverter.getValue();
+ } else if (type.equals(String.class)) {
+ valueObj = value;
+ } else {
+ valueObj = value;
+ if (log.isErrorEnabled()) {
+ log.error("涓嶆敮鎸佺殑绫诲瀷" + type.toString());
+ }
+ }
+ } else {
+ valueObj = getDouble(value);
+ }
+ } else {
+ valueObj = getLong(value);
+ }
+ } else {
+ valueObj = getFloat(value);
+ }
+ } else {
+ valueObj = getInt(value);
+ }
+
+ if (setMethod != null) {
+ setMethod.invoke(obj, valueObj);
+ } else {
+ field.set(obj, valueObj);
+ }
+ }
+ } catch (Throwable var7) {
+ if (log.isErrorEnabled()) {
+ log.error("璁剧疆灞炴�х殑鍊煎嚭閿欎簡閿欒", var7);
+ }
+ }
+
+ }
+
+ public static void setValueForField(String fieldName, Object obj, String value) {
+ try {
+ Field field = getFieldForObject(fieldName, obj);
+ if (field != null) {
+ setValueForField(field, obj, value);
+ }
+ } catch (Exception var4) {
+ if (log.isErrorEnabled()) {
+ log.error("璁剧疆灞炴�х殑鍊煎嚭閿欎簡閿欒", var4);
+ }
+ }
+
+ }
+
+}
+
--
Gitblit v1.9.3