fix: relocate cwos-portal decompiled output to correct path; remove nested directory

Former-commit-id: dc30d42a8c55ed8b2382a41dc2434233fbed9930

artifacts/decompiled/v1-cfr-compare-20211103/maven-unified-java/cn/cloudwalk/elevator/util/AcsCacheKeyUtil.java

@@ -0,0 +1,19 @@
+package cn.cloudwalk.elevator.util;
+
+public class AcsCacheKeyUtil {
+    public static String getOpenDoorCountKey(String date, String businessId) {
+        return "elevator:passCount:" + date + ":" + businessId;
+    }
+
+    public static String getRecogCountKey(String date, String businessId) {
+        return "acs_recogCount_" + date + "_" + businessId;
+    }
+
+    public static String getBackendRegLogIdKey(String deviceCode, String businessId, String captureId) {
+        return "acs:backendRegLogId:" + deviceCode + "_" + businessId + "_" + captureId;
+    }
+
+    public static String getBackendRegExpireKey(String businessId, String openDoorLogId) {
+        return "acs:backendRegExpire:#" + businessId + "#" + openDoorLogId;
+    }
+}

artifacts/decompiled/v1-cfr-compare-20211103/maven-unified-java/cn/cloudwalk/elevator/util/CollectionUtils.java

@@ -0,0 +1,806 @@
+package cn.cloudwalk.elevator.util;
+
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.lang.reflect.Array;
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Queue;
+import java.util.Set;
+import java.util.Stack;
+import org.springframework.util.Assert;
+import org.springframework.util.MultiValueMap;
+
+public class CollectionUtils {
+    private static final int HASH_MAP_DEFAULT_INITIAL_CAPACITY = 16;
+    private static final float HASH_MAP_DEFAULT_LOAD_FACTOR = 0.75F;
+
+    public static <E> E getFirst(Collection<E> c) {
+        if (c == null) {
+            return null;
+        }
+        if (c instanceof List) {
+            List<E> list = (List<E>)c;
+            return list.isEmpty() ? null : list.get(0);
+        }
+        if (c instanceof Set)
+            return c.isEmpty() ? null : c.iterator().next();
+        if (c instanceof Queue) {
+            return c.isEmpty() ? null : ((Queue<E>)c).peek();
+        }
+        return c.isEmpty() ? null : c.iterator().next();
+    }
+
+    public static List<String> removeList(List<String> listA, List<String> listB) {
+        HashSet<String> hs1 = new HashSet<>(listA);
+        HashSet<String> hs2 = new HashSet<>(listB);
+        hs1.removeAll(hs2);
+        List<String> listC = new ArrayList<>();
+        listC.addAll(hs1);
+        return listC;
+    }
+
+    public static <E> List<List<E>> split(List<E> list, E element) {
+        if (list == null) {
+            return new ArrayList<>(0);
+        }
+        List<List<E>> result = new ArrayList<>();
+        int start = 0, end = 0;
+        for (E e : list) {
+            if ((element == null) ? (e == null) : element.equals(e)) {
+                result.add(new ArrayList<>(list.subList(start, end)));
+                start = end + 1;
+            }
+            end++;
+        }
+        if (start == list.size()) {
+            result.add(new ArrayList<>(0));
+        } else if (start < list.size()) {
+            result.add(new ArrayList<>(list.subList(start, list.size())));
+        }
+        return result;
+    }
+
+    public static <E> List<List<E>> split(List<E> list, int... index) {
+        if (list == null) {
+            return new ArrayList<>(0);
+        }
+        if (index == null || index.length == 0) {
+            ArrayList<List<E>> arrayList = new ArrayList<>();
+            arrayList.add(new ArrayList<>(list));
+            return arrayList;
+        }
+        if (index.length > list.size()) {
+            throw new IllegalArgumentException("{index}数量不能大于{list}长度。");
+        }
+        List<List<E>> result = new ArrayList<>();
+        int temp = 0;
+        for (int i : index) {
+            if (i < temp) {
+                throw new IllegalArgumentException("{index}的每个值必须比前一个大。");
+            }
+            if (i > list.size()) {
+                throw new IllegalArgumentException("{index}值不能大于{list}长度。");
+            }
+            result.add(new ArrayList<>(list.subList(temp, i)));
+            temp = i;
+        }
+        if (temp == list.size()) {
+            result.add(new ArrayList<>(0));
+        } else if (temp < list.size()) {
+            result.add(new ArrayList<>(list.subList(temp, list.size())));
+        }
+        return result;
+    }
+
+    public static <T> List<T> wrap(final T[] array) {
+        if (array == null) {
+            return null;
+        }
+        return new AbstractList<T>() {
+            public T get(int index) {
+                return (T)array[index];
+            }
+
+            public int size() {
+                return array.length;
+            }
+
+            public T set(int index, T element) {
+                T old = (T)array[index];
+                array[index] = element;
+                return old;
+            }
+
+            public void clear() {
+                throw new UnsupportedOperationException();
+            }
+
+            public int indexOf(Object o) {
+                if (o == null) {
+                    for (int i = 0; i < array.length; i++) {
+                        if (null == array[i]) {
+                            return i;
+                        }
+                    }
+                } else {
+                    for (int i = 0; i < array.length; i++) {
+                        if (o.equals(array[i])) {
+                            return i;
+                        }
+                    }
+                }
+                return -1;
+            }
+
+            public int lastIndexOf(Object o) {
+                if (o == null) {
+                    for (int i = array.length - 1; i > -1; i--) {
+                        if (null == array[i]) {
+                            return i;
+                        }
+                    }
+                } else {
+                    for (int i = array.length - 1; i > -1; i--) {
+                        if (o.equals(array[i])) {
+                            return i;
+                        }
+                    }
+                }
+                return -1;
+            }
+
+            public boolean removeAll(Collection<?> c) {
+                throw new UnsupportedOperationException();
+            }
+
+            public boolean retainAll(Collection<?> c) {
+                throw new UnsupportedOperationException();
+            }
+        };
+    }
+
+    public static <T> List<T> values(Map<?, T> map) {
+        if (map == null) {
+            return null;
+        }
+        List<T> list = new ArrayList<>(map.size());
+        for (T t : map.values()) {
+            list.add(t);
+        }
+        return list;
+    }
+
+    public static <T> List<T> keys(Map<T, ?> map) {
+        if (map == null) {
+            return null;
+        }
+        List<T> list = new ArrayList<>(map.size());
+        for (T t : map.keySet()) {
+            list.add(t);
+        }
+        return list;
+    }
+
+    public static <E> int countOccurrence(E element, Iterable<E> elements) {
+        if (elements == null) {
+            return 0;
+        }
+        int i = 0;
+        if (element == null) {
+            for (E e : elements) {
+                if (null == e) {
+                    i++;
+                }
+            }
+        } else {
+            for (E e : elements) {
+                if (element.equals(e)) {
+                    i++;
+                }
+            }
+        }
+        return i;
+    }
+
+    public static <E> E[] toArray(Collection<E> collection, Class<E> typeClass) {
+        E[] t = (E[])Array.newInstance(typeClass, collection.size());
+        int i = 0;
+        for (Iterator<E> iterator = collection.iterator(); iterator.hasNext(); i++) {
+            t[i] = iterator.next();
+        }
+        return t;
+    }
+
+    public static <E> Iterator<E> iterator(final Enumeration<E> enumeration) {
+        return new Iterator<E>() {
+            public boolean hasNext() {
+                return enumeration.hasMoreElements();
+            }
+
+            public E next() {
+                if (!hasNext()) {
+                    throw new NoSuchElementException();
+                }
+                return enumeration.nextElement();
+            }
+
+            public void remove() {
+                throw new UnsupportedOperationException("该迭代器没有指向的集合，所以移除元素为不支持的操作。");
+            }
+        };
+    }
+
+    public static <E> Enumeration<E> enumeration(final Iterator<E> iterator) {
+        return new Enumeration<E>() {
+            public boolean hasMoreElements() {
+                return iterator.hasNext();
+            }
+
+            public E nextElement() {
+                return iterator.next();
+            }
+        };
+    }
+
+    public static <T> void add(Collection<T> collection, Object value) {
+        if (value == null) {
+            collection.add(null);
+        } else if (value.getClass().isArray()) {
+            if (value instanceof Object[]) {
+                for (Object o : (Object[])value) {
+                    collection.add((T)o);
+                }
+            } else {
+                int length = Array.getLength(value);
+                for (int i = 0; i < length; i++) {
+                    collection.add((T)Array.get(value, i));
+                }
+            }
+        } else if (value instanceof Collection || value instanceof Stack) {
+            for (Object object : (Iterable<?>)value) {
+                collection.add((T)object);
+            }
+        } else if (value instanceof Iterator) {
+            for (Iterator<T> iterator = (Iterator<T>)value; iterator.hasNext();) {
+                collection.add(iterator.next());
+            }
+        } else {
+            collection.add((T)value);
+        }
+    }
+
+    public static <T> void push(Stack<T> stack, Object value) {
+        if (value == null) {
+            stack.push((T)null);
+        } else if (value.getClass().isArray()) {
+            if (value instanceof Object[]) {
+                for (Object o : (Object[])value) {
+                    stack.push((T)o);
+                }
+            } else {
+                int length = Array.getLength(value);
+                for (int i = 0; i < length; i++) {
+                    stack.push((T)Array.get(value, i));
+                }
+            }
+        } else if (value instanceof Collection || value instanceof Stack) {
+            for (Object object : (Iterable<?>)value) {
+                stack.push((T)object);
+            }
+        } else {
+            stack.push((T)value);
+        }
+    }
+
+    public static <K, V> MultiValueMap<K, V> synchronizedMultiValueMap(MultiValueMap<K, V> multiValueMap) {
+        if (multiValueMap == null) {
+            throw new IllegalArgumentException("The input argument is null!");
+        }
+        return new SynchronizedMultiValueMap<>(multiValueMap);
+    }
+
+    public static <K, V> MultiValueMap<K, V>
+        unmodifiableMultiValueMap(MultiValueMap<? extends K, ? extends V> multiValueMap) {
+        if (multiValueMap == null) {
+            throw new IllegalArgumentException("The input argument is null!");
+        }
+        return new UnmodifiableMultiValueMap<>(multiValueMap);
+    }
+
+    public static boolean isEmpty(Collection<?> collection) {
+        return (collection == null || collection.isEmpty());
+    }
+
+    public static boolean isEmpty(Stack<?> stack) {
+        return (stack == null || stack.isEmpty());
+    }
+
+    public static boolean isEmpty(Map<?, ?> map) {
+        return (map == null || map.isEmpty());
+    }
+
+    public static boolean isNotEmpty(Collection<?> collection) {
+        return (collection != null && !collection.isEmpty());
+    }
+
+    public static boolean isNotEmpty(Stack<?> stack) {
+        return (stack != null && !stack.isEmpty());
+    }
+
+    public static boolean isNotEmpty(Map<?, ?> map) {
+        return (map != null && !map.isEmpty());
+    }
+
+    private static boolean isComparable(List<?> list, List<?> compareList, int index) {
+        if (isEmpty(list) || isEmpty(compareList)) {
+            return false;
+        }
+        Assert.isTrue((index >= 0 && index < list.size()), "{index} 的值必须从0 至 list.size() - 1 之间。");
+        if (list.size() < compareList.size()) {
+            return false;
+        }
+        return true;
+    }
+
+    public static String[] toStringArray(Collection<?> collection) {
+        if (collection == null) {
+            return null;
+        }
+        String[] stringArray = new String[collection.size()];
+        int i = 0;
+        for (Object o : collection) {
+            stringArray[i] = StringUtils.toString(o);
+            i++;
+        }
+        return stringArray;
+    }
+
+    public static <K, V> void putAllIfAbsent(Map<K, V> map, Map<? extends K, ? extends V> paramMap) {
+        if (map == null || paramMap == null) {
+            return;
+        }
+        for (Map.Entry<? extends K, ? extends V> entry : paramMap.entrySet()) {
+            if (!map.containsKey(entry.getKey())) {
+                map.put(entry.getKey(), entry.getValue());
+            }
+        }
+    }
+
+    public static int calculateHashMapMinInitialCapacity(int size) {
+        return calculateHashMapMinInitialCapacity(size, 0.75F, 16);
+    }
+
+    public static int calculateHashMapMinInitialCapacity(int size, float loadFactor, int initlalCapcity) {
+        return Math.max((int)(size / loadFactor) + 1, initlalCapcity);
+    }
+
+    public static List<Integer> strArrayToList(String var) {
+        List<Integer> list = new ArrayList<>();
+        for (String v : var.split(",")) {
+            list.add(Integer.valueOf(Integer.parseInt(v)));
+        }
+        return list;
+    }
+
+    static class SynchronizedMultiValueMap<K, V> implements MultiValueMap<K, V> {
+        final MultiValueMap<K, V> multiValueMap;
+        final Object mutex;
+        private transient Set<K> keySet = null;
+        private transient Set<Map.Entry<K, List<V>>> entrySet;
+        private transient Collection<List<V>> values;
+        private transient Set<Map.Entry<K, V>> singleValueEntrySet;
+        private transient Collection<V> singleValues;
+
+        SynchronizedMultiValueMap(MultiValueMap<K, V> multiValueMap) {
+            if (multiValueMap == null) {
+                throw new IllegalArgumentException("The input argument is null!");
+            }
+            this.multiValueMap = multiValueMap;
+            this.mutex = this;
+        }
+
+        SynchronizedMultiValueMap(MultiValueMap<K, V> multiValueMap, Object mutex) {
+            if (multiValueMap == null) {
+                throw new IllegalArgumentException("The input argument is null!");
+            }
+            this.multiValueMap = multiValueMap;
+            this.mutex = mutex;
+        }
+
+        public void add(K key, V value) {
+            synchronized (this.mutex) {
+                this.multiValueMap.add(key, value);
+            }
+        }
+
+        public void addAll(K k, List<? extends V> list) {}
+
+        public void addAll(MultiValueMap<K, V> multiValueMap) {}
+
+        public void clear() {
+            synchronized (this.mutex) {
+                this.multiValueMap.clear();
+            }
+        }
+
+        public boolean containsKey(Object key) {
+            synchronized (this.mutex) {
+                return this.multiValueMap.containsKey(key);
+            }
+        }
+
+        public boolean containsValue(Object value) {
+            synchronized (this.mutex) {
+                return this.multiValueMap.containsValue(value);
+            }
+        }
+
+        public Set<Map.Entry<K, List<V>>> entrySet() {
+            synchronized (this.mutex) {
+                if (this.entrySet == null) {
+                    this.entrySet = new CollectionUtils.SynchronizedSet<>(this.multiValueMap.entrySet(), this.mutex);
+                }
+                return this.entrySet;
+            }
+        }
+
+        public boolean equals(Object o) {
+            synchronized (this.mutex) {
+                return this.multiValueMap.equals(o);
+            }
+        }
+
+        public List<V> get(Object key) {
+            synchronized (this.mutex) {
+                return (List<V>)this.multiValueMap.get(key);
+            }
+        }
+
+        public V getFirst(K key) {
+            synchronized (this.mutex) {
+                return (V)this.multiValueMap.getFirst(key);
+            }
+        }
+
+        public int hashCode() {
+            synchronized (this.mutex) {
+                return this.multiValueMap.hashCode();
+            }
+        }
+
+        public boolean isEmpty() {
+            synchronized (this.mutex) {
+                return this.multiValueMap.isEmpty();
+            }
+        }
+
+        public Set<K> keySet() {
+            synchronized (this.mutex) {
+                if (this.keySet == null) {
+                    this.keySet = new CollectionUtils.SynchronizedSet<>(this.multiValueMap.keySet(), this.mutex);
+                }
+                return this.keySet;
+            }
+        }
+
+        public List<V> put(K key, List<V> value) {
+            synchronized (this.mutex) {
+                return (List<V>)this.multiValueMap.put(key, value);
+            }
+        }
+
+        public void putAll(Map<? extends K, ? extends List<V>> t) {
+            synchronized (this.mutex) {
+                this.multiValueMap.putAll(t);
+            }
+        }
+
+        public List<V> remove(Object key) {
+            synchronized (this.mutex) {
+                return (List<V>)this.multiValueMap.remove(key);
+            }
+        }
+
+        public void set(K key, V value) {
+            synchronized (this.mutex) {
+                this.multiValueMap.set(key, value);
+            }
+        }
+
+        public void setAll(Map<K, V> values) {
+            synchronized (this.mutex) {
+                this.multiValueMap.setAll(values);
+            }
+        }
+
+        public int size() {
+            synchronized (this.mutex) {
+                return this.multiValueMap.size();
+            }
+        }
+
+        public Map<K, V> toSingleValueMap() {
+            synchronized (this.mutex) {
+                return this.multiValueMap.toSingleValueMap();
+            }
+        }
+
+        public Collection<List<V>> values() {
+            synchronized (this.mutex) {
+                if (this.values == null) {
+                    this.values = new CollectionUtils.SynchronizedCollection<>(this.multiValueMap.values(), this.mutex);
+                }
+                return this.values;
+            }
+        }
+
+        public String toString() {
+            synchronized (this.mutex) {
+                return this.multiValueMap.toString();
+            }
+        }
+
+        private void writeObject(ObjectOutputStream s) throws IOException {
+            synchronized (this.mutex) {
+                s.defaultWriteObject();
+            }
+        }
+    }
+
+    static class SynchronizedCollection<E> implements Collection<E>, Serializable {
+        private static final long serialVersionUID = -7540724106974451779L;
+        final Collection<E> collection;
+        final Object mutex;
+
+        SynchronizedCollection(Collection<E> collection) {
+            if (collection == null) {
+                throw new IllegalArgumentException("The input argument is null!");
+            }
+            this.collection = collection;
+            this.mutex = this;
+        }
+
+        SynchronizedCollection(Collection<E> collection, Object mutex) {
+            if (collection == null) {
+                throw new IllegalArgumentException("The input argument is null!");
+            }
+            this.collection = collection;
+            this.mutex = mutex;
+        }
+
+        public int size() {
+            synchronized (this.mutex) {
+                return this.collection.size();
+            }
+        }
+
+        public boolean isEmpty() {
+            synchronized (this.mutex) {
+                return this.collection.isEmpty();
+            }
+        }
+
+        public boolean contains(Object o) {
+            synchronized (this.mutex) {
+                return this.collection.contains(o);
+            }
+        }
+
+        public Object[] toArray() {
+            synchronized (this.mutex) {
+                return this.collection.toArray();
+            }
+        }
+
+        public <T> T[] toArray(T[] a) {
+            synchronized (this.mutex) {
+                return this.collection.toArray(a);
+            }
+        }
+
+        public Iterator<E> iterator() {
+            return this.collection.iterator();
+        }
+
+        public boolean add(E o) {
+            synchronized (this.mutex) {
+                return this.collection.add(o);
+            }
+        }
+
+        public boolean remove(Object o) {
+            synchronized (this.mutex) {
+                return this.collection.remove(o);
+            }
+        }
+
+        public boolean containsAll(Collection<?> coll) {
+            synchronized (this.mutex) {
+                return this.collection.containsAll(coll);
+            }
+        }
+
+        public boolean addAll(Collection<? extends E> coll) {
+            synchronized (this.mutex) {
+                return this.collection.addAll(coll);
+            }
+        }
+
+        public boolean removeAll(Collection<?> coll) {
+            synchronized (this.mutex) {
+                return this.collection.removeAll(coll);
+            }
+        }
+
+        public boolean retainAll(Collection<?> coll) {
+            synchronized (this.mutex) {
+                return this.collection.retainAll(coll);
+            }
+        }
+
+        public void clear() {
+            synchronized (this.mutex) {
+                this.collection.clear();
+            }
+        }
+
+        public String toString() {
+            synchronized (this.mutex) {
+                return this.collection.toString();
+            }
+        }
+
+        private void writeObject(ObjectOutputStream s) throws IOException {
+            synchronized (this.mutex) {
+                s.defaultWriteObject();
+            }
+        }
+    }
+
+    static class SynchronizedSet<E> extends SynchronizedCollection<E> implements Set<E> {
+        private static final long serialVersionUID = 6982504952424781802L;
+
+        SynchronizedSet(Set<E> set) {
+            super(set);
+        }
+
+        SynchronizedSet(Set<E> set, Object mutex) {
+            super(set, mutex);
+        }
+
+        public boolean equals(Object o) {
+            synchronized (this.mutex) {
+                return this.collection.equals(o);
+            }
+        }
+
+        public int hashCode() {
+            synchronized (this.mutex) {
+                return this.collection.hashCode();
+            }
+        }
+    }
+
+    static class UnmodifiableMultiValueMap<K, V> implements MultiValueMap<K, V>, Serializable {
+        private static final long serialVersionUID = 7629840602579792180L;
+        final MultiValueMap<K, V> multiValueMap;
+        Set<Map.Entry<K, List<V>>> entrySet;
+        Collection<List<V>> values;
+        Set<K> keySet;
+        Map<K, V> singleValueMap;
+
+        UnmodifiableMultiValueMap(MultiValueMap<? extends K, ? extends V> multiValueMap) {
+            this.multiValueMap = (MultiValueMap)multiValueMap;
+        }
+
+        public void add(K key, V value) {
+            throw new UnsupportedOperationException();
+        }
+
+        public void addAll(K k, List<? extends V> list) {}
+
+        public void addAll(MultiValueMap<K, V> multiValueMap) {}
+
+        public void clear() {
+            throw new UnsupportedOperationException();
+        }
+
+        public boolean containsKey(Object key) {
+            return this.multiValueMap.containsKey(key);
+        }
+
+        public boolean containsValue(Object value) {
+            return this.multiValueMap.containsValue(value);
+        }
+
+        public Set<Map.Entry<K, List<V>>> entrySet() {
+            if (this.entrySet == null) {
+                this.entrySet = Collections.unmodifiableSet(this.multiValueMap.entrySet());
+            }
+            return this.entrySet;
+        }
+
+        public boolean equals(Object o) {
+            return this.multiValueMap.equals(o);
+        }
+
+        public List<V> get(Object key) {
+            return (List<V>)this.multiValueMap.get(key);
+        }
+
+        public V getFirst(K key) {
+            return (V)this.multiValueMap.getFirst(key);
+        }
+
+        public int hashCode() {
+            return this.multiValueMap.hashCode();
+        }
+
+        public boolean isEmpty() {
+            return this.multiValueMap.isEmpty();
+        }
+
+        public Set<K> keySet() {
+            if (this.keySet == null) {
+                this.keySet = Collections.unmodifiableSet(this.multiValueMap.keySet());
+            }
+            return this.keySet;
+        }
+
+        public List<V> put(K key, List<V> value) {
+            throw new UnsupportedOperationException();
+        }
+
+        public void putAll(Map<? extends K, ? extends List<V>> t) {
+            throw new UnsupportedOperationException();
+        }
+
+        public List<V> remove(Object key) {
+            throw new UnsupportedOperationException();
+        }
+
+        public void set(K key, V value) {
+            throw new UnsupportedOperationException();
+        }
+
+        public void setAll(Map<K, V> values) {
+            throw new UnsupportedOperationException();
+        }
+
+        public Set<Map.Entry<K, V>> singleValueEntrySet() {
+            return toSingleValueMap().entrySet();
+        }
+
+        public Collection<V> singleValues() {
+            return toSingleValueMap().values();
+        }
+
+        public int size() {
+            return this.multiValueMap.size();
+        }
+
+        public Map<K, V> toSingleValueMap() {
+            if (this.singleValueMap == null) {
+                this.singleValueMap = Collections.unmodifiableMap(this.multiValueMap.toSingleValueMap());
+            }
+            return this.singleValueMap;
+        }
+
+        public Collection<List<V>> values() {
+            if (this.values == null) {
+                this.values = Collections.unmodifiableCollection(this.multiValueMap.values());
+            }
+            return this.values;
+        }
+    }
+}

artifacts/decompiled/v1-cfr-compare-20211103/maven-unified-java/cn/cloudwalk/elevator/util/CommunityConstants.java

@@ -0,0 +1,114 @@
+package cn.cloudwalk.elevator.util;
+
+public class CommunityConstants {
+    public static interface Common {
+        public static final String NOTE_TYPE_ORG = "1";
+        public static final String NOTE_TYPE_TAG = "2";
+        public static final String NOTE_TYPE_PERSON = "3";
+        public static final String NOTE_TYPE_EDG = "4";
+        public static final String ACCESS_NAME_SUFFIX = "门禁";
+        public static final Integer ACCESS_AUTO = Integer.valueOf(0);
+        public static final Integer ONE_HUNDRED = Integer.valueOf(100);
+        public static final Integer BATCH_SIZE = Integer.valueOf(500);
+        public static final Integer MAX_SHOW_CAPTURE = Integer.valueOf(7);
+        public static final String TEMP_PATH = "java.io.tmpdir";
+        public static final String FONT_PATH = "font/simsun.ttc";
+        public static final String TEMPLATE_NAME = "appraiseReportTemplate";
+        public static final String FONT_SUFFIX = ".ttc";
+        public static final String DASH = "-";
+        public static final String HTTP_PREFIX = "http://";
+        public static final String BR = "<br/>";
+        public static final String FORMAT = "yyyy/MM/dd/HH";
+        public static final String CLIENT_IP = "ClientIP";
+    }
+
+    public static interface Snap {
+        public static final String IMG_DOWNLOAD_PARSE_ERROR = "img_download_parse_error";
+        public static final String DATA_IMAGE_BASE64_HEAD = "data:image/";
+    }
+
+    public static interface Symbol {
+        public static final String COMMA = ",";
+        public static final String HYPHEN = "-";
+        public static final String COLON = ":";
+    }
+
+    public static interface Alarm {
+        public static final Integer IN = Integer.valueOf(1);
+        public static final Integer OUT = Integer.valueOf(0);
+        public static final String STRANGER = "STRANGER";
+        public static final String BLACK_LIST = "BLACK_LIST";
+    }
+
+    public static interface Redis {
+        public static final String EVENT_CODE_INC_KEY = "EVENT_CODE:INC_KEY";
+        public static final Integer EVENT_CODE_INC_MAX_VALUE = Integer.valueOf(9999);
+        public static final String TF_BRAIN_ACCESS_TOKEN = "tfbrain_access_token";
+        public static final String USER_TOKEN_KEY = "USER_TOKEN:%s";
+        public static final String OUT_IN_IMAGE_STORE = "upOutInStore";
+        public static final String AGREEMENT = "redis://";
+        public static final String LOCK = "redisLock";
+        public static final String OLD_AUTO_CREATE_SETTING = "OLD:AUTO_CREATE";
+        public static final String CHILD_AUTO_CREATE_SETTING = "CHILD:AUTO_CREATE:%s";
+        public static final String IMPORT_FAILURE_MSG = "IMPORT:FAILURE:%s";
+        public static final String VILLAGE_RECORD_LIST = "village:list";
+        public static final String COMMUNITY_LIST = "community:list";
+        public static final Long VALUE_CHANGE_EXPIRE_TIME = Long.valueOf(1L);
+        public static final String PROVINCE_TREE = "tree:province:level:%s";
+    }
+
+    public static interface Data {
+        public static final String MALE = "男";
+        public static final String FEMALE = "女";
+        public static final String ID = "id";
+        public static final String CREATE_TIME = "createTime";
+        public static final String LAST_UPDATE_TIME = "lastUpdateTime";
+        public static final String REGISTER_PERSON_ID = "register_person_id";
+        public static final String GRID_ID = "grid_id";
+        public static final Integer TOP_VALUE = Integer.valueOf(1);
+        public static final Integer NO_TOP_VALUE = Integer.valueOf(0);
+        public static final Integer PUBLISH_STATUS_1 = Integer.valueOf(1);
+        public static final Integer PUBLISH_STATUS_2 = Integer.valueOf(2);
+        public static final Integer PUBLISH_STATUS_3 = Integer.valueOf(3);
+        public static final String AGE = "age";
+        public static final String SEX = "sex";
+        public static final String COMMUNITY_ID = "community_id";
+        public static final String VILLAGE_ID = "village_id";
+    }
+
+    public static interface Dcs {
+        public static final String DCS_URL_ID_FORMAT = "%s:%s@%s:2015?dcsID=";
+        public static final String DCS_URL_FORMAT = "%s:%s@%s:2015";
+    }
+
+    public static interface Dcr {
+        public static final String HTTPS_PREFIX = "https://";
+        public static final String MID_PART_DOWNLOAD_URL = "/object/download?pool=";
+        public static final String MID_PART_UPLOAD_URL = "/object/upload/do?token=";
+        public static final String MID_DOWNLOAD_FILE_URL = "/simple-file/download?pool=";
+        public static final String MID_UPLOAD_FILE_URL = "/simple-file/upload/full?pool=";
+        public static final String PARA_PATH = "&path=";
+        public static final String PARA_SIZE = "&offset=0&size=";
+        public static final String PARA_ID = "&id=";
+        public static final String ID = "ID";
+        public static final String AUTH_TYPE = "Basic ";
+        public static final String AUTH = "authorization";
+        public static final String POOL = "pool";
+        public static final String TOKEN = "Token";
+        public static final String ADDRESS = "Address";
+        public static final String AUTH_SUFFIX = "/object/upload";
+        public static final Integer MAX_DOWNLOAD_SIZE = Integer.valueOf(16000000);
+        public static final String OFFSET = "&offset=";
+        public static final String SIZE = "&size=";
+    }
+
+    public static interface Icc {
+        public static final String ICC_RTSP_URL = "rtsp://%s:9090/dss/monitor/param?cameraid=%s%%24%s&substream=1";
+        public static final String ICC_PLAYBACK_RTSP_URL =
+            "rtsp://%s:9090/dss/playback/param?cameraid=%s%%24%s&substream=1&type=3";
+        public static final String ICC_OUTSIDE_HLS_URL = "/live/cameraid/%s%%24%s/substream/1.m3u8";
+        public static final String ICC_PLAYBACK_OUTSIDE_HLS_URL = "/vod/center/cameraid/%s%%24%s/substream/1";
+        public static final int DEVICE_TYPE_NVR = 6;
+        public static final int DEVICE_TYPE_IPC = 2;
+    }
+}

artifacts/decompiled/v1-cfr-compare-20211103/maven-unified-java/cn/cloudwalk/elevator/util/DateUtils.java

@@ -0,0 +1,436 @@
+package cn.cloudwalk.elevator.util;
+
+import java.security.Timestamp;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.time.DayOfWeek;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.ZoneOffset;
+import java.time.temporal.ChronoField;
+import java.time.temporal.TemporalAdjusters;
+import java.time.temporal.WeekFields;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class DateUtils {
+    private static final Logger logger = LoggerFactory.getLogger(DateUtils.class);
+    public static final long ONE_DAY_LONG = 86400000L;
+    public static final String YYYYMMDD = "yyyyMMdd";
+    public static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm";
+    public static final String YYYY_MM_DD = "yyyy-MM-dd";
+    public static final String YYYY_MM_DD_HMS = "yyyy-MM-dd HH:mm:ss";
+    public static final String HHMMSS = "HH:mm:ss";
+    public static final String YYYYMM = "yyyyMM";
+    public static final String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
+
+    public static long getCurrentTime() {
+        return System.currentTimeMillis();
+    }
+
+    public static String timestamp2String(Timestamp time, String pattern) {
+        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
+        return sdf.format(time.getTimestamp());
+    }
+
+    public static String formatDate(Date date, String pattern) {
+        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
+        return sdf.format(date);
+    }
+
+    public static int defaultFormat(Date date) {
+        return Integer.valueOf(formatDate(date, "yyyyMMdd")).intValue();
+    }
+
+    public static Date defaultFormat(String str) {
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
+        try {
+            return sdf.parse(str);
+        } catch (ParseException e) {
+            logger.error("日期格式转换失败", e);
+            return null;
+        }
+    }
+
+    public static Date customFormat(String str, String pattern) {
+        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
+        try {
+            return sdf.parse(str);
+        } catch (ParseException e) {
+            logger.error("日期格式转换失败", e);
+            return null;
+        }
+    }
+
+    public static int defaultFormat(long millis) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTimeInMillis(millis);
+        return defaultFormat(cal.getTime());
+    }
+
+    public static String parseTimestamp(Timestamp time) {
+        return parseDate(time.getTimestamp());
+    }
+
+    public static String parseDate(Date date) {
+        try {
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
+            return sdf.format(date);
+        } catch (Exception e) {
+            logger.error("日期格式转换失败", e);
+            return null;
+        }
+    }
+
+    public static String parseDate(Date date, String partern) {
+        try {
+            SimpleDateFormat sdf = new SimpleDateFormat(partern);
+            return sdf.format(date);
+        } catch (Exception e) {
+            logger.error("日期格式转换失败", e);
+            return null;
+        }
+    }
+
+    public static int getYear() {
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(new Date());
+        return cal.get(1);
+    }
+
+    public static long getMonthFirstDate(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        calendar.set(5, 1);
+        calendar.set(11, 0);
+        calendar.set(12, 0);
+        calendar.set(13, 0);
+        calendar.set(14, 0);
+        return calendar.getTime().getTime();
+    }
+
+    public static long getMonthLastDate(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        calendar.set(5, calendar.getActualMaximum(5));
+        calendar.set(11, 23);
+        calendar.set(12, 59);
+        calendar.set(13, 59);
+        calendar.set(14, 999);
+        return calendar.getTime().getTime();
+    }
+
+    public static Long dateToStamp(String s) {
+        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd");
+        try {
+            Date date = simpleDateFormat.parse(s);
+            long ts = date.getTime();
+            return Long.valueOf(ts);
+        } catch (Exception e) {
+            logger.error("日期转为时间戳失败", e);
+            return Long.valueOf(0L);
+        }
+    }
+
+    public static String stampToDate(String s) {
+        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        long lt = (new Long(s)).longValue();
+        Date date = new Date(lt);
+        String res = simpleDateFormat.format(date);
+        return res;
+    }
+
+    public static String getTwoDaysDesc(Integer startTime, Integer endTime) {
+        String twoDayDesc;
+        List<Integer> days = new ArrayList<>();
+        if (null == startTime || null == endTime) {
+            return "日";
+        }
+        DateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
+        try {
+            Date start = dateFormat.parse(String.valueOf(startTime));
+            Date end = dateFormat.parse(String.valueOf(endTime));
+            Calendar tempStart = Calendar.getInstance();
+            tempStart.setTime(start);
+            Calendar tempEnd = Calendar.getInstance();
+            tempEnd.setTime(end);
+            tempEnd.add(5, 1);
+            while (tempStart.before(tempEnd)) {
+                days.add(Integer.valueOf(Integer.parseInt(dateFormat.format(tempStart.getTime()))));
+                tempStart.add(6, 1);
+            }
+        } catch (ParseException e) {
+            logger.error("时间转换失败", e);
+        }
+        int dayOfWeek = 7;
+        if (days.size() > dayOfWeek) {
+            twoDayDesc = "月";
+        } else if (days.size() > 1) {
+            twoDayDesc = "周";
+        } else {
+            twoDayDesc = "日";
+        }
+        return twoDayDesc;
+    }
+
+    public static Long todayStart() {
+        Calendar calendar = Calendar.getInstance();
+        calendar.set(11, 0);
+        calendar.set(12, 0);
+        calendar.set(13, 0);
+        calendar.set(14, 0);
+        return Long.valueOf(calendar.getTimeInMillis());
+    }
+
+    public static Long dateToStampTomorrow(String s) {
+        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd");
+        try {
+            Date date = simpleDateFormat.parse(s);
+            Calendar cal = Calendar.getInstance();
+            cal.setTime(date);
+            cal.add(5, 1);
+            long ts = cal.getTimeInMillis();
+            return Long.valueOf(ts);
+        } catch (Exception e) {
+            logger.error("日期转换失败", e);
+            return Long.valueOf(0L);
+        }
+    }
+
+    public static Date getDateSubDay(int day) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(new Date());
+        cal.add(5, day);
+        return cal.getTime();
+    }
+
+    public static Date getDateSubDay(Date date, int day) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(date);
+        cal.add(5, day);
+        return cal.getTime();
+    }
+
+    public static Long todayStart(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        calendar.set(11, 0);
+        calendar.set(12, 0);
+        calendar.set(13, 0);
+        calendar.set(14, 0);
+        return Long.valueOf(calendar.getTimeInMillis());
+    }
+
+    public static Long todayEnd(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        calendar.set(11, 23);
+        calendar.set(12, 59);
+        calendar.set(13, 59);
+        calendar.set(14, 999);
+        return Long.valueOf(calendar.getTimeInMillis());
+    }
+
+    public static Long todayEnd() {
+        Calendar calendar = Calendar.getInstance();
+        calendar.set(11, 23);
+        calendar.set(12, 59);
+        calendar.set(13, 59);
+        calendar.set(14, 999);
+        return Long.valueOf(calendar.getTimeInMillis());
+    }
+
+    public static String formatTimeDuration(long duration, int format) {
+        boolean fu = false;
+        long fduration = duration;
+        if (duration < 0L) {
+            fu = true;
+            fduration = Math.abs(duration);
+        }
+        StringBuilder builder = new StringBuilder();
+        long sec = fduration / 1000L % 60L;
+        long min = fduration / 1000L / 60L % 60L;
+        long hour = fduration / 1000L / 60L / 60L % 24L;
+        long day = fduration / 1000L / 60L / 60L / 24L;
+        if (day > 0L && format > 0) {
+            format--;
+            builder.append(day).append("天");
+        }
+        format--;
+        if (hour > 0L && format > 0) {
+            builder.append(hour).append("小时");
+        }
+        format--;
+        if (min > 0L && format > 0) {
+            builder.append(min).append("分钟");
+        }
+        format--;
+        if (sec > 0L && format > 0) {
+            builder.append(sec).append("秒");
+        }
+        if (fu) {
+            builder.insert(0, "-");
+        }
+        return builder.toString();
+    }
+
+    public static String formatTimeDurationHour(long duration, int format) {
+        if (duration == 0L) {
+            return "-";
+        }
+        long fduration = Math.abs(duration);
+        StringBuilder builder = new StringBuilder();
+        long sec = fduration / 1000L % 60L;
+        long min = fduration / 1000L / 60L % 60L;
+        long hour = fduration / 1000L / 60L / 60L;
+        if (hour > 0L && format > 0) {
+            builder.append(hour).append("小时");
+        }
+        format--;
+        if (min > 0L && format > 0) {
+            builder.append(min).append("分钟");
+        }
+        format--;
+        if (sec > 0L && format > 0) {
+            builder.append(sec).append("秒");
+        }
+        return builder.toString();
+    }
+
+    public static Date getMonth(Date date, int count) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        int month = calendar.get(2);
+        calendar.set(2, month - count);
+        return calendar.getTime();
+    }
+
+    public static int getYear(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        return calendar.get(1);
+    }
+
+    public static int getMonth(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        return calendar.get(2) + 1;
+    }
+
+    public static Long dateToStampFormat(String s, String format) {
+        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
+        try {
+            Date date = simpleDateFormat.parse(s);
+            return Long.valueOf(date.getTime());
+        } catch (Exception e) {
+            logger.error("日期转换失败", e);
+            return Long.valueOf(0L);
+        }
+    }
+
+    public static boolean timeIsInRound(String now, String start, String end, String format) {
+        Date nowTime, beginTime, endTime;
+        SimpleDateFormat df = new SimpleDateFormat(format);
+        try {
+            nowTime = df.parse(now);
+            beginTime = df.parse(start);
+            endTime = df.parse(end);
+        } catch (Exception e) {
+            logger.error("时间格式转换异常,原因=[{}]", e.getMessage(), e);
+            return false;
+        }
+        if (nowTime.getTime() >= beginTime.getTime() && nowTime.getTime() <= endTime.getTime()) {
+            return true;
+        }
+        return false;
+    }
+
+    public static int getDayOfWeek(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        return calendar.get(7);
+    }
+
+    public static LocalDateTime millToDate(Long mill) {
+        return LocalDateTime.ofInstant(Instant.ofEpochMilli(mill.longValue()), ZoneOffset.ofHours(8));
+    }
+
+    public static List<StartTimeAndEndTime> getCycle(Integer timeType, int cycleNum) {
+        LocalDateTime nowStartTime, nowEndTime;
+        int i;
+        LocalDateTime nowMonday, nowSunday;
+        int j;
+        LocalDateTime nowFirstDay, nowLastDay;
+        int k;
+        if (timeType == null) {
+            return Collections.emptyList();
+        }
+        List<StartTimeAndEndTime> timeList = new ArrayList<>(cycleNum);
+        switch (timeType.intValue()) {
+            case 0:
+                nowStartTime = LocalDateTime.of(LocalDate.now(), LocalTime.MIN);
+                nowEndTime = LocalDateTime.of(LocalDate.now(), LocalTime.MAX);
+                timeList.add(
+                    new StartTimeAndEndTime(Long.valueOf(nowStartTime.toInstant(ZoneOffset.of("+8")).toEpochMilli()),
+                        Long.valueOf(nowEndTime.toInstant(ZoneOffset.of("+8")).toEpochMilli()),
+                        nowStartTime.getDayOfMonth() + "号"));
+                for (i = 1; i < cycleNum; i++) {
+                    LocalDateTime firstDay = nowStartTime.minusDays(i);
+                    LocalDateTime lastDay = nowEndTime.minusDays(i);
+                    timeList.add(
+                        new StartTimeAndEndTime(Long.valueOf(firstDay.toInstant(ZoneOffset.of("+8")).toEpochMilli()),
+                            Long.valueOf(lastDay.toInstant(ZoneOffset.of("+8")).toEpochMilli()),
+                            firstDay.getDayOfMonth() + "号"));
+                }
+                break;
+            case 1:
+                nowMonday = LocalDateTime.of(LocalDate.now(), LocalTime.MIN).with(DayOfWeek.MONDAY);
+                nowSunday = LocalDateTime.of(LocalDate.now(), LocalTime.MAX).with(DayOfWeek.SUNDAY);
+                timeList
+                    .add(new StartTimeAndEndTime(Long.valueOf(nowMonday.toInstant(ZoneOffset.of("+8")).toEpochMilli()),
+                        Long.valueOf(nowSunday.toInstant(ZoneOffset.of("+8")).toEpochMilli()),
+                        nowMonday.get(WeekFields.ISO.weekOfWeekBasedYear()) + "周"));
+                for (j = 1; j < cycleNum; j++) {
+                    LocalDateTime lastMonday = nowMonday.minusWeeks(j);
+                    LocalDateTime lastSunday = nowSunday.minusWeeks(j);
+                    timeList.add(
+                        new StartTimeAndEndTime(Long.valueOf(lastMonday.toInstant(ZoneOffset.of("+8")).toEpochMilli()),
+                            Long.valueOf(lastSunday.toInstant(ZoneOffset.of("+8")).toEpochMilli()),
+                            lastMonday.get(WeekFields.ISO.weekOfWeekBasedYear()) + "周"));
+                }
+                break;
+            case 2:
+                nowFirstDay =
+                    LocalDateTime.of(LocalDate.now(), LocalTime.MIN).with(TemporalAdjusters.firstDayOfMonth());
+                nowLastDay = LocalDateTime.of(LocalDate.now(), LocalTime.MAX).with(TemporalAdjusters.lastDayOfMonth());
+                timeList.add(
+                    new StartTimeAndEndTime(Long.valueOf(nowFirstDay.toInstant(ZoneOffset.of("+8")).toEpochMilli()),
+                        Long.valueOf(nowLastDay.toInstant(ZoneOffset.of("+8")).toEpochMilli()),
+                        nowFirstDay.get(ChronoField.MONTH_OF_YEAR) + "月"));
+                for (k = 1; k < cycleNum; k++) {
+                    LocalDateTime firstDay = LocalDateTime.now().minusMonths(k)
+                        .with(TemporalAdjusters.firstDayOfMonth()).with(LocalTime.MIN);
+                    LocalDateTime lastDay =
+                        LocalDateTime.now().minusMonths(k).with(TemporalAdjusters.lastDayOfMonth()).with(LocalTime.MAX);
+                    timeList.add(
+                        new StartTimeAndEndTime(Long.valueOf(firstDay.toInstant(ZoneOffset.of("+8")).toEpochMilli()),
+                            Long.valueOf(lastDay.toInstant(ZoneOffset.of("+8")).toEpochMilli()),
+                            firstDay.get(ChronoField.MONTH_OF_YEAR) + "月"));
+                }
+                break;
+        }
+        return timeList;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(">>>>>>>>>>>>>>" + dateToStampFormat("202002", "yyyyMM"));
+    }
+}

artifacts/decompiled/v1-cfr-compare-20211103/maven-unified-java/cn/cloudwalk/elevator/util/JsonUtils.java

@@ -0,0 +1,74 @@
+package cn.cloudwalk.elevator.util;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.Module;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class JsonUtils {
+    private static final Logger log = LoggerFactory.getLogger(JsonUtils.class);
+    private static final Logger logger = LoggerFactory.getLogger(DateUtils.class);
+
+    public static String toJson(Object obj) {
+        ObjectMapper mapper = objectMapper();
+        try {
+            return mapper.writeValueAsString(obj);
+        } catch (JsonProcessingException e) {
+            logger.warn("json parase  exception :{}", e.getMessage());
+            return null;
+        }
+    }
+
+    public static <T> T toObj(String json, Class<T> clazz) {
+        ObjectMapper mapper = objectMapper();
+        T value = null;
+        try {
+            value = (T)mapper.readValue(json, clazz);
+        } catch (IOException e) {
+            logger.warn("json parase  exception :{}", e.getMessage());
+        }
+        return value;
+    }
+
+    public static <T> T toObj(String json, TypeReference<T> tTypeReference) {
+        ObjectMapper mapper = objectMapper();
+        T value = null;
+        try {
+            value = (T)mapper.readValue(json, tTypeReference);
+        } catch (IOException e) {
+            logger.warn("json parase  exception :{}", e.getMessage());
+        }
+        return value;
+    }
+
+    public static <T> List<T> toObjList(String json, Class<T> clazz) {
+        ObjectMapper mapper = objectMapper();
+        List<T> value = null;
+        try {
+            JavaType jt = mapper.getTypeFactory().constructParametricType(ArrayList.class, new Class[] {clazz});
+            value = (List<T>)mapper.readValue(json, jt);
+        } catch (IOException e) {
+            logger.warn("json parase  exception :{}", e.getMessage());
+        }
+        return value;
+    }
+
+    public static ObjectMapper objectMapper() {
+        ObjectMapper mapper = new ObjectMapper();
+        mapper.registerModule((Module)new JavaTimeModule());
+        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
+        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+        return mapper;
+    }
+}

artifacts/decompiled/v1-cfr-compare-20211103/maven-unified-java/cn/cloudwalk/elevator/util/RestTemplateUtil.java

@@ -0,0 +1,163 @@
+package cn.cloudwalk.elevator.util;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.net.URI;
+import java.util.List;
+import javax.annotation.PostConstruct;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.http.client.ClientHttpRequestFactory;
+import org.springframework.http.client.SimpleClientHttpRequestFactory;
+import org.springframework.http.converter.HttpMessageConverter;
+import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
+import org.springframework.stereotype.Component;
+import org.springframework.util.MultiValueMap;
+import org.springframework.web.client.RestTemplate;
+
+@Component
+public class RestTemplateUtil {
+    private static final Logger logger = LoggerFactory.getLogger(DateUtils.class);
+    private static RestTemplate restTemplate;
+
+    private static class SingletonRestTemplate {
+        static SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
+        static {
+            requestFactory.setConnectTimeout(10000);
+            requestFactory.setReadTimeout(10000);
+        }
+        static final RestTemplate INSTANCE = new RestTemplate((ClientHttpRequestFactory)requestFactory);
+    }
+
+    @PostConstruct
+    public void getInstance() {
+        RestTemplate restTemplate = SingletonRestTemplate.INSTANCE;
+        List<HttpMessageConverter<?>> converterList = restTemplate.getMessageConverters();
+        HttpMessageConverter<?> converterTarget = null;
+        for (HttpMessageConverter<?> item : converterList) {
+            if (MappingJackson2HttpMessageConverter.class == item.getClass()) {
+                converterTarget = item;
+                break;
+            }
+        }
+        if (null != converterTarget) {
+            converterList.remove(converterTarget);
+        }
+        ObjectMapper objectMapper = new ObjectMapper();
+        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+        converterList.add(new MappingJackson2HttpMessageConverter(objectMapper));
+        RestTemplateUtil.restTemplate = restTemplate;
+    }
+
+    public static String get(String url) {
+        HttpHeaders headers = new HttpHeaders();
+        headers.add("Accept", "application/json");
+        headers.add("Content-Encoding", "UTF-8");
+        headers.add("Content-Type", "application/json; charset=UTF-8");
+        HttpEntity<String> requestEntity = new HttpEntity(null, (MultiValueMap)headers);
+        ResponseEntity<String> response =
+            restTemplate.exchange(url, HttpMethod.GET, requestEntity, String.class, new Object[0]);
+        return (String)response.getBody();
+    }
+
+    public static String get(URI url, HttpHeaders headers) {
+        HttpEntity<String> requestEntity = new HttpEntity(null, (MultiValueMap)headers);
+        ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.GET, requestEntity, String.class);
+        return (String)response.getBody();
+    }
+
+    public static <T> T get(URI url, HttpHeaders headers, Class<T> responseType) {
+        HttpEntity<Object> requestEntity = new HttpEntity(null, (MultiValueMap)headers);
+        T resultEntity = null;
+        try {
+            ResponseEntity<T> result = restTemplate.exchange(url, HttpMethod.GET, requestEntity, responseType);
+            resultEntity = getResultEntity(result, url);
+        } catch (Exception e) {
+            logger.warn(">>>>>>>>>>>>>>>>>【{}】接口调用失败，错误信息", url, e);
+        }
+        return resultEntity;
+    }
+
+    public static <T> T post(URI url, Object data, HttpHeaders headers, Class<T> responseType) {
+        HttpEntity<Object> requestEntity = new HttpEntity(data, (MultiValueMap)headers);
+        T resultEntity = null;
+        try {
+            logger.info(">>>>>>>>>>>>>>>>>开始请求接口:{}，payload:{},", url.toString(), data);
+            ResponseEntity<T> result = restTemplate.postForEntity(url, requestEntity, responseType);
+            resultEntity = getResultEntity(result, url);
+        } catch (Exception e) {
+            logger.warn(">>>>>>>>>>>>>>>>>接口调用失败，错误信息：{}", e.getMessage());
+        }
+        return resultEntity;
+    }
+
+    public static <T> T postTf(URI url, Object data, HttpHeaders headers, Class<T> responseType) throws Exception {
+        HttpEntity<Object> requestEntity = new HttpEntity(data, (MultiValueMap)headers);
+        T resultEntity = null;
+        try {
+            logger.info(">>>>>>>>>>>>>>>>>开始请求接口:{},payload:{},", url.toString(), data);
+            ResponseEntity<T> result = restTemplate.postForEntity(url, requestEntity, responseType);
+            resultEntity = getTfResultEntity(result, url);
+        } catch (Exception e) {
+            logger.warn(">>>>>>>>>>>>>>>>>接口调用失败，错误信息：{}", e.getMessage());
+            throw e;
+        }
+        return resultEntity;
+    }
+
+    public static <T> T post(URI url, Object data, HttpHeaders headers, TypeReference<T> tTypeReference) {
+        HttpEntity<Object> requestEntity = new HttpEntity(data, (MultiValueMap)headers);
+        T resultEntity = null;
+        try {
+            ResponseEntity<String> result = restTemplate.postForEntity(url, requestEntity, String.class);
+            if (HttpStatus.OK == result.getStatusCode()) {
+                if (logger.isDebugEnabled()) {
+                    logger.debug("接口返回值：{}", JsonUtils.toJson(result.getBody()));
+                }
+                return JsonUtils.toObj((String)result.getBody(), tTypeReference);
+            }
+            logger.info(">>>>>>>>>>>>>>>>>接口调用失败，状态码：{},错误原因：{}", result.getStatusCode(),
+                JsonUtils.toJson(result.getBody()));
+        } catch (Exception e) {
+            logger.warn(">>>>>>>>>>>>>>>>>接口调用失败，错误信息：{}", e.getMessage());
+        }
+        return resultEntity;
+    }
+
+    private static <T> T getTfResultEntity(ResponseEntity<T> result, URI url) throws Exception {
+        HttpStatus statusCode = result.getStatusCode();
+        if (HttpStatus.OK == statusCode) {
+            logger.info(">>>>>>>>>>>>>>>>>接口:{} 调用成功", url);
+            if (logger.isDebugEnabled()) {
+                logger.debug("接口返回值：{}", JsonUtils.toJson(result.getBody()));
+            }
+            return (T)result.getBody();
+        }
+        logger.info(">>>>>>>>>>>>>>>>>接口调用失败，状态码：{},错误原因：{}", statusCode, JsonUtils.toJson(result.getBody()));
+        if (HttpStatus.UNAUTHORIZED == statusCode) {
+            throw new Exception(statusCode.toString());
+        }
+        return null;
+    }
+
+    private static <T> T getResultEntity(ResponseEntity<T> result, URI url) {
+        if (HttpStatus.OK == result.getStatusCode()) {
+            logger.info(">>>>>>>>>>>>>>>>>接口:{} 调用成功", url);
+            if (logger.isDebugEnabled()) {
+                logger.debug("接口返回值：{}", JsonUtils.toJson(result.getBody()));
+            }
+            return (T)result.getBody();
+        }
+        logger.info(">>>>>>>>>>>>>>>>>接口调用失败，状态码：{},错误原因：{}", result.getStatusCode(),
+            JsonUtils.toJson(result.getBody()));
+        return null;
+    }
+}

artifacts/decompiled/v1-cfr-compare-20211103/maven-unified-java/cn/cloudwalk/elevator/util/StartTimeAndEndTime.java

@@ -0,0 +1,37 @@
+package cn.cloudwalk.elevator.util;
+
+public class StartTimeAndEndTime {
+    public StartTimeAndEndTime(Long startTime, Long endTime, String currentTime) {
+        this.startTime = startTime;
+        this.endTime = endTime;
+        this.currentTime = currentTime;
+    }
+
+    private Long startTime;
+    private Long endTime;
+    private String currentTime;
+
+    public Long getStartTime() {
+        return this.startTime;
+    }
+
+    public void setStartTime(Long startTime) {
+        this.startTime = startTime;
+    }
+
+    public Long getEndTime() {
+        return this.endTime;
+    }
+
+    public void setEndTime(Long endTime) {
+        this.endTime = endTime;
+    }
+
+    public String getCurrentTime() {
+        return this.currentTime;
+    }
+
+    public void setCurrentTime(String currentTime) {
+        this.currentTime = currentTime;
+    }
+}

artifacts/decompiled/v1-cfr-compare-20211103/maven-unified-java/cn/cloudwalk/elevator/util/ToolUtil.java

@@ -0,0 +1,19 @@
+package cn.cloudwalk.elevator.util;
+
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+public class ToolUtil {
+    public static String generateUUID() {
+        String uuid = UUID.randomUUID().toString();
+        return uuid.replaceAll("-", "");
+    }
+
+    public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
+        Set<Object> seen = ConcurrentHashMap.newKeySet();
+        return t -> seen.add(keyExtractor.apply(t));
+    }
+}