feat:添加测试更新guid

cjl

2023-09-20 4e250e6a954ab426cc54dcf11caec806eb8df688

feat:添加测试更新guid

 screen-api/pom.xml

@@ -67,6 +67,11 @@
            <artifactId>jfreechart</artifactId>
            <version>1.5.0</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.3.0</version>
        </dependency>
    </dependencies>

    <build>

 screen-api/src/main/java/com/moral/api/controller/DictController.java

New file
@@ -0,0 +1,39 @@
package com.moral.api.controller;

import com.moral.api.entity.CityConfigAqi;
import com.moral.api.pojo.enums.ChangeEnum;
import com.moral.api.pojo.enums.InvestigationEnum;
import com.moral.api.pojo.enums.StateEnum;
import com.moral.api.pojo.enums.YesOrNo;
import com.moral.api.pojo.vo.DictionaryVo;
import com.moral.constant.ResultMessage;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @ClassName DictController
 * @Description TODO
 * @Author @lizijie
 * @Date 2023-09-20 11:39
 * @Version 1.0
 */
@RestController
@RequestMapping("/dict")
@Api(tags = {"字典"})
public class DictController {
    @GetMapping("list")

    public ResultMessage<DictionaryVo> list() {
        DictionaryVo dictionaryVo = new DictionaryVo()
                .setStateEnums(StateEnum.values())
                .setChangeEnum(ChangeEnum.values())
                .setInvestigationEnum(InvestigationEnum.values())
                .setYesOrNo(YesOrNo.values())
                ;
        return ResultMessage.ok(dictionaryVo);
    }

}

 screen-api/src/main/java/com/moral/api/pojo/enums/AllocationApproveEnum.java

New file
@@ -0,0 +1,71 @@
package com.moral.api.pojo.enums;

import com.baomidou.mybatisplus.annotation.EnumValue;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.moral.api.exception.BusinessException;
import lombok.Getter;

import java.util.HashMap;
import java.util.Map;

/**
 * @ClassName InvestigationEnum
 * @Description TODO
 * @Author @cjl
 * @Date 2023-09-20 14:47
 * @Version 1.0
 */
@Getter
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum AllocationApproveEnum implements IntegerValueEnum{
    /**
     *新建
     */
    NEW_BUILT(10, "新建"),
    /**
     *整改中
     */
    UNDER_RECTIFICATION(20, "整改中"),
    /**
     *审批中
     */
    IN_APPROVAL(30, "审批中"),
    /**
     *通过
     */
    PASS(40, "通过"),
    /**
     *拒绝
     */
    REFUSE(50, "拒绝"),

    ;

    @EnumValue
    public  final Integer value;
    public  final String name;

    AllocationApproveEnum(Integer value, String name) {
        this.value = value;
        this.name = name;
    }

    private static Map<Integer, AllocationApproveEnum> valueMap = new HashMap<>();
    static {
        for (AllocationApproveEnum v : AllocationApproveEnum.values()) {
            valueMap.put(v.value, v);
        }
    }
    @JsonCreator
    public static AllocationApproveEnum getByValue(Integer value) {
        if (value == null) {
            return null;
        }
        AllocationApproveEnum result = valueMap.get(value);
        if (result == null) {
            throw new BusinessException("枚举转换异常" + value);
        }
        return result;
    }
}

 screen-api/src/main/java/com/moral/api/pojo/enums/ChangeEnum.java

New file
@@ -0,0 +1,59 @@
package com.moral.api.pojo.enums;

import com.baomidou.mybatisplus.annotation.EnumValue;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.moral.api.exception.BusinessException;
import lombok.Getter;

import java.util.HashMap;
import java.util.Map;

/**
 * @ClassName StateEnum
 * @Description TODO
 * @Author @lizijie
 * @Date 2023-09-20 11:11
 * @Version 1.0
 */
@Getter
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum ChangeEnum implements IntegerValueEnum {

    /**
     *立行整改
     */
    IMMEDIATELY(1, "立行整改"),
    /**
     *限期整改
     */
    DEADLINE(2, "限期整改"),
   ;

    @EnumValue
    public  final Integer value;
    public  final String name;

    ChangeEnum(Integer value, String name) {
        this.value = value;
        this.name = name;
    }

    private static Map<Integer, ChangeEnum> valueMap = new HashMap<>();
    static {
        for (ChangeEnum v : ChangeEnum.values()) {
            valueMap.put(v.value, v);
        }
    }
    @JsonCreator
    public static ChangeEnum getByValue(Integer value) {
        if (value == null) {
            return null;
        }
        ChangeEnum result = valueMap.get(value);
        if (result == null) {
            throw new BusinessException("枚举转换异常" + value);
        }
        return result;
    }
}

 screen-api/src/main/java/com/moral/api/pojo/enums/IntegerValueEnum.java

New file
@@ -0,0 +1,18 @@
package com.moral.api.pojo.enums;

/**
 * @ClassName IntegerValueEnum
 * @Description TODO
 * @Author @lizijie
 * @Date 2023-09-20 11:35
 * @Version 1.0
 */
public interface IntegerValueEnum {

    /**
     * 获得value
     *
     * @return
     */
    Integer getValue();
}

 screen-api/src/main/java/com/moral/api/pojo/enums/InvestigationEnum.java

New file
@@ -0,0 +1,60 @@
package com.moral.api.pojo.enums;

import com.baomidou.mybatisplus.annotation.EnumValue;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.moral.api.exception.BusinessException;
import lombok.Getter;

import java.util.HashMap;
import java.util.Map;

/**
 * @ClassName InvestigationEnum
 * @Description TODO
 * @Author @cjl
 * @Date 2023-09-20 14:47
 * @Version 1.0
 */
@Getter
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum InvestigationEnum implements IntegerValueEnum{
    /**
     *立行整改
     */
    SCENE(1, "现场"),
    /**
     *限期整改
     */
    TRAVELING_VEHICLE(2, "走航"),

    UAV(3, "无人机"),
    ;

    @EnumValue
    public  final Integer value;
    public  final String name;

    InvestigationEnum(Integer value, String name) {
        this.value = value;
        this.name = name;
    }

    private static Map<Integer, InvestigationEnum> valueMap = new HashMap<>();
    static {
        for (InvestigationEnum v : InvestigationEnum.values()) {
            valueMap.put(v.value, v);
        }
    }
    @JsonCreator
    public static InvestigationEnum getByValue(Integer value) {
        if (value == null) {
            return null;
        }
        InvestigationEnum result = valueMap.get(value);
        if (result == null) {
            throw new BusinessException("枚举转换异常" + value);
        }
        return result;
    }
}

 screen-api/src/main/java/com/moral/api/pojo/enums/StateEnum.java

New file
@@ -0,0 +1,57 @@
package com.moral.api.pojo.enums;

import com.baomidou.mybatisplus.annotation.EnumValue;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.moral.api.exception.BusinessException;
import lombok.Getter;

import java.util.HashMap;
import java.util.Map;

/**
 * @ClassName StateEnum
 * @Description TODO
 * @Author @lizijie
 * @Date 2023-09-20 11:11
 * @Version 1.0
 */
@Getter
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum StateEnum implements IntegerValueEnum {
    /**
     *未生效
     */
    NOT_EFFECTIVE(10, "未生效"),
    /**
     *已生效
     */
    TAKE_EFFECT(20, "已生效");

    @EnumValue
    public  final Integer value;
    public  final String name;

    StateEnum(Integer value, String name) {
        this.value = value;
        this.name = name;
    }

    private static Map<Integer, StateEnum> valueMap = new HashMap<>();
    static {
        for (StateEnum v : StateEnum.values()) {
            valueMap.put(v.value, v);
        }
    }
    @JsonCreator
    public static StateEnum getByValue(Integer value) {
        if (value == null) {
            return null;
        }
        StateEnum result = valueMap.get(value);
        if (result == null) {
            throw new BusinessException("枚举转换异常" + value);
        }
        return result;
    }
}

 screen-api/src/main/java/com/moral/api/pojo/enums/StringValueEnum.java

New file
@@ -0,0 +1,18 @@
package com.moral.api.pojo.enums;

/**
 * @ClassName StringValueEnum
 * @Description TODO
 * @Author @lizijie
 * @Date 2023-09-20 11:36
 * @Version 1.0
 */
public interface StringValueEnum {

    /**
     * 获得value
     *
     * @return
     */
    String getValue();
}

 screen-api/src/main/java/com/moral/api/pojo/enums/YesOrNo.java

New file
@@ -0,0 +1,57 @@
package com.moral.api.pojo.enums;

import com.baomidou.mybatisplus.annotation.EnumValue;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.moral.api.exception.BusinessException;
import lombok.Getter;

import java.util.HashMap;
import java.util.Map;

/**
 * @ClassName StateEnum
 * @Description TODO
 * @Author @lizijie
 * @Date 2023-09-20 11:11
 * @Version 1.0
 */
@Getter
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum YesOrNo implements IntegerValueEnum {
    /**
     *未生效
     */
    YES(1, "是"),
    /**
     *已生效
     */
    No(0, "否");

    @EnumValue
    public  final Integer value;
    public  final String name;

    YesOrNo(Integer value, String name) {
        this.value = value;
        this.name = name;
    }

    private static Map<Integer, YesOrNo> valueMap = new HashMap<>();
    static {
        for (YesOrNo v : YesOrNo.values()) {
            valueMap.put(v.value, v);
        }
    }
    @JsonCreator
    public static YesOrNo getByValue(Integer value) {
        if (value == null) {
            return null;
        }
        YesOrNo result = valueMap.get(value);
        if (result == null) {
            throw new BusinessException("枚举转换异常" + value);
        }
        return result;
    }
}

 screen-api/src/main/java/com/moral/api/pojo/vo/DictionaryVo.java

New file
@@ -0,0 +1,66 @@
package com.moral.api.pojo.vo;

import com.moral.api.pojo.enums.ChangeEnum;
import com.moral.api.pojo.enums.InvestigationEnum;
import com.moral.api.pojo.enums.StateEnum;
import com.moral.api.pojo.enums.YesOrNo;
import com.moral.api.utils.BeanConverts;
import io.swagger.annotations.ApiModel;
import lombok.Data;
import lombok.experimental.Accessors;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @ClassName DictionaryVo
 * @Description TODO
 * @Author @lizijie
 * @Date 2023-09-20 13:30
 * @Version 1.0
 */
@Data
@Accessors(chain = true)
@ApiModel(value = "字典选项 - VO", description = "字典选项 - VO")
public class DictionaryVo {

    private List<Map<String, Object>> StateEnums;

    private List<Map<String, Object>> InvestigationEnum;

    private List<Map<String, Object>> ChangeEnum;
    private List<Map<String, Object>> YesOrNo;




    public static List<Map<String, Object>> enumArray2Map(Enum[] enums) {
        List<Map<String, Object>> mapList = Arrays.asList(enums).stream().map(BeanConverts::objToMapNonJson).collect(Collectors.toList());
        mapList.stream().map(map -> map.remove("declaringClass")).collect(Collectors.toList());
        return mapList;
    }

    public DictionaryVo setStateEnums(StateEnum[] enumResult) {
        this.StateEnums = enumArray2Map(enumResult);
        return this;
    }

    public DictionaryVo setInvestigationEnum(com.moral.api.pojo.enums.InvestigationEnum[] stateEnum) {
        this.InvestigationEnum = enumArray2Map(stateEnum);
        return this;
    }

    public DictionaryVo setChangeEnum(com.moral.api.pojo.enums.ChangeEnum[] enumResult) {
        this.ChangeEnum = enumArray2Map(enumResult);
        return this;
    }

    public DictionaryVo setYesOrNo(com.moral.api.pojo.enums.YesOrNo[] enumResult) {
        this.YesOrNo = enumArray2Map(enumResult);
        return this;
    }


}

 screen-api/src/main/java/com/moral/api/utils/BeanConverts.java

New file
@@ -0,0 +1,340 @@
package com.moral.api.utils;

import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
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 com.fasterxml.jackson.databind.SerializationFeature;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.cglib.beans.BeanMap;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;


import java.util.*;

/**
 * @ClassName BeanConverts
 * @Description TODO
 * @Author @lizijie
 * @Date 2023-09-20 13:41
 * @Version 1.0
 */
@Slf4j
@SuppressWarnings("unchecked")
public class BeanConverts {
    private static  ObjectMapper objectMapper = new ObjectMapper();
    static{

        //序列化的时候序列对象的所有属性
        objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);

        //反序列化的时候如果多了其他属性,不抛出异常
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

        //如果是空对象的时候,不抛异常
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);

        //属性为null的转换
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    }

    private BeanConverts() {
    }

    /**
     * BeanUtils.copyProperties 增强
     * 拷贝时，source 值为空则不拷贝
     *
     * @param source           源数据
     * @param target           目标数据
     * @param ignoreProperties 忽略属性
     */
    public static void copyPropertiesIgnoreNull(Object source, Object target, String... ignoreProperties) {
        Set<String> ignoreSet = new HashSet<>();
        if (ignoreProperties != null) {
            ignoreSet.addAll(Arrays.asList(ignoreProperties));
        }
        ignoreSet.addAll(getObjectNullFieldName(source));
        BeanUtils.copyProperties(source, target, ignoreSet.toArray(new String[0]));
    }

    /**
     * 获取对象字段值为null 的字段名称集合
     *
     * @param object 源数据
     * @return 字段名称集合
     */
    public static List<String> getObjectNullFieldName(Object object) {
        BeanMap beanMap = BeanMap.create(object);
        List<String> fieldNameList = new ArrayList<>();
        for (Object key : beanMap.keySet()) {
            if (beanMap.get(key) == null) {
                fieldNameList.add(key.toString());
            }
        }
        return fieldNameList;
    }

    /**
     * 将对象转换为map
     * 不转换空值字段
     *
     * @param obj 对象
     * @return 键值对
     */
    public static Map<String, Object> objToMapIgnoreNull(Object obj) {
        return objToMap(obj, true);
    }

    /**
     * 将对象转换为map
     *
     * @param obj 对象
     * @return 键值对
     */
    public static Map<String, Object> objToMap(Object obj) {
        return objToMap(obj, false);
    }

    /**
     * 将对象转换为map
     *
     * @param obj        对象
     * @param ignoreNull 忽略空值字段
     * @return 键值对
     */
    private static Map<String, Object> objToMap(Object obj, boolean ignoreNull) {
        return JSONUtil.parseObj(obj, ignoreNull);
    }

    /**
     * entity 转换
     *
     * @param obj   源对象
     * @param clazz 目标类型
     * @param <T>   泛型
     * @return 目标对象
     */
    public static <T> T cloneShallow(Object obj, Class<T> clazz) {
        if (obj == null) {
            return null;
        }
        T t = BeanUtils.instantiateClass(clazz);
        BeanUtils.copyProperties(obj, t);
        return t;
    }

    /**
     * entity 集合转换
     *
     * @param collection 源对象集合
     * @param clazz      目标类型
     * @param <T>        泛型
     * @return 目标对象集合
     */
    public static <T> List<T> cloneShallow(Collection<?> collection, Class<T> clazz) {
        return collection.stream().map(item -> convert(item, clazz)).collect(Collectors.toList());
    }

    /**
     * entity 转换
     *
     * @param obj   源对象
     * @param clazz 目标类型
     * @param <T>   泛型
     * @return 目标对象
     */
    public static <T> T convert(Object obj, Class<T> clazz) {

        return objectMapper.convertValue(obj, clazz);
    }

    public static <T> T convert(Object obj, TypeReference<T> type) {
        return objectMapper.convertValue(obj, type);
    }

    /**
     * entity 转换
     *
     * @param optional 源对象
     * @param clazz    目标类型
     * @param <T>      泛型
     * @return 目标对象
     */
    public static <T> T convert(Optional<?> optional, Class<T> clazz) {
        return optional.map(obj -> convert(obj, clazz)).orElseGet(null);
    }

    /**
     * entity 集合转换
     *
     * @param collection 源对象集合
     * @param clazz      目标类型
     * @param <T>        泛型
     * @return 目标对象集合
     */
    public static <T> List<T> convert(Collection<?> collection, Class<T> clazz) {
        return JSONArray.parseArray(JSONArray.toJSONString(collection), clazz);
    }

    /**
     * entity 集合转换
     *
     * @param iterable 实体集合
     * @param clazz    目标类型
     * @param <T>      泛型
     * @return 目标对象集合
     */
    public static <T> List<T> convert(Iterable<?> iterable, Class<T> clazz) {
        return convert(StreamSupport.stream(iterable.spliterator(), false), clazz);
    }

    /**
     * entity 集合转换
     *
     * @param stream 实体集合流
     * @param clazz  目标类型
     * @param <T>    泛型
     * @return 目标对象集合
     */
    public static <T> List<T> convert(Stream<?> stream, Class<T> clazz) {
        return stream.map(entity -> convert(entity, clazz)).collect(Collectors.toList());
    }


    /**
     * map 转对象
     *
     * @param clazz      目标类型
     * @param collection 键值对集合
     * @param <T>        泛型
     * @return 目标对象集合
     */
    public static <T> List<T> mapToObj(Class<T> clazz, Collection<Map<String, Object>> collection) {
        return collection.stream().map(map -> BeanConverts.mapToObj(clazz, map)).collect(Collectors.toList());
    }

    /**
     * map 转对象
     *
     * @param clazz 目标类型
     * @param map   键值对
     * @param <T>   泛型
     * @return 目标对象
     */
    public static <T> T mapToObj(Class<T> clazz, Map<String, Object> map) {
        T d = BeanUtils.instantiateClass(clazz);
        BeanInfo beanInfo;
        try {
            beanInfo = Introspector.getBeanInfo(d.getClass());
        } catch (IntrospectionException e) {
            log.warn(e.getMessage(), e);
            return null;
        }
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        for (PropertyDescriptor property : propertyDescriptors) {
            Method setter = property.getWriteMethod();
            if (setter == null) {
                continue;
            }
            Object value = map.get(property.getName());
            if (value == null) {
                continue;
            } else if (value instanceof Timestamp) {
                if (property.getPropertyType().equals(LocalDate.class)) {
                    value = ((Timestamp) value).toLocalDateTime().toLocalDate();
                } else {
                    value = ((Timestamp) value).toLocalDateTime();
                }
            } else if (property.getPropertyType().equals(BigDecimal.class)) {
                value = BigDecimal.valueOf((double) value);
            }
            try {
                setter.invoke(d, value);
            } catch (Exception e) {
                log.warn(e.getMessage(), e);
            }
        }
        return d;
    }

    /**
     * 对象集合中取出两个字段，组成map
     *
     * @param collection    对象集合
     * @param keyProperty   key属性值
     * @param valueProperty value属性值
     * @param <E>           泛型
     * @return 属性值map
     */
    public static <E> Map<String, E> propertyToMap(Collection collection, String keyProperty, String valueProperty) {
        Map<String, E> map = new LinkedHashMap<>();
        if (collection.isEmpty()) {
            return map;
        }
        Object obj = collection.iterator().next();
        BeanInfo beanInfo;
        try {
            beanInfo = Introspector.getBeanInfo(obj.getClass());
        } catch (IntrospectionException e) {
            log.warn(e.getMessage(), e);
            return map;
        }
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        Method keyGetter = null;
        Method valueGetter = null;
        for (PropertyDescriptor property : propertyDescriptors) {
            if (keyProperty.equals(property.getName()) && property.getReadMethod() != null) {
                keyGetter = property.getReadMethod();
            } else if (valueProperty.equals(property.getName()) && property.getReadMethod() != null) {
                valueGetter = property.getReadMethod();
            }
        }
        if (keyGetter == null || valueGetter == null) {
            return map;
        }
        for (Object item : collection) {
            try {
                map.put(keyGetter.invoke(item).toString(), (E) valueGetter.invoke(item));
            } catch (IllegalAccessException | InvocationTargetException e) {
                log.warn(e.getMessage(), e);
            }
        }
        return map;
    }

    /**
     * 将对象转换为map
     *
     * @param obj        对象
     * @return 键值对
     */
    public static Map<String, Object> objToMapNonJson(Object obj) {
        Map<String, Object> map = new HashMap<>(8);
        if (obj != null) {
            BeanMap beanMap = BeanMap.create(obj);
            for (Object key : beanMap.keySet()) {
                Object value = beanMap.get(key);
                map.put(key.toString(), value);
            }
        }
        return map;
    }
}

 screen-api/src/main/java/com/moral/api/utils/JsonUtils.java

New file
@@ -0,0 +1,151 @@
package com.moral.api.utils;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.core.type.TypeReference;
import java.io.IOException;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
 * @ClassName JsonUtils
 * @Description TODO
 * @Author @lizijie
 * @Date 2023-09-20 13:43
 * @Version 1.0
 */
public class JsonUtils {
    private static ObjectMapper objectMapper = new ObjectMapper();

    /**
     * 对象转json字符串
     *
     * @param object
     * @return
     */
    public static String objectToJson(Object object) {
        return objectToJson(object, null);
    }

    /**
     * 对象转json字符串
     *
     * @param object     需要转换json的对象
     * @param defaultStr 如果抛异常的默认字符串
     * @return
     */
    public static String objectToJson(Object object, String defaultStr) {
        try {
            return objectMapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return defaultStr;
    }

    /**
     * json字符串转对象实体
     *
     * @param jsonStr json字符串
     * @param object  转换异常的默认对象
     * @param <T>     泛型
     * @return
     */
    public static <T> T jsonToObject(String jsonStr, T object) {
        try {
            return objectMapper.readValue(jsonStr, new TypeReference<T>() {
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
        return object;

    }

    /**
     * json字符串转对象实体
     *
     * @param jsonStr json字符串
     * @param t       实体类的类型
     * @param <T>     泛型
     * @return
     */
    public static <T> T jsonToObject(String jsonStr, Class<T> t) {
        try {
            return objectMapper.readValue(jsonStr, t);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;

    }

    /**
     * json字符串转对象实体
     *
     * @param jsonStr       json字符串
     * @param typeReference
     * @param <T>
     * @return
     */
    public static <T> T jsonToObject(String jsonStr, TypeReference<T> typeReference) {
        try {
            return objectMapper.readValue(jsonStr, typeReference);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;

    }

    /**
     * json字符串转Map
     *
     * @param jsonStr
     * @param t
     * @param v
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K, V> Map<K, V> jsonToMap(String jsonStr, Class<K> t, Class<V> v) {
        try {
            return objectMapper.readValue(jsonStr, new TypeReference<Map<K, V>>() {
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;

    }
    public static <K, V> Map<K, V> objectToMap(Object object, Class<K> t, Class<V> v) {
        try {
            return objectMapper.readValue(objectToJson(object), new TypeReference<Map<K, V>>() {
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;

    }

    /**
     * json字符串转集合
     *
     * @param jsonStr     json字符串
     * @param objectClass 类信息
     * @param <T>
     * @return
     */
    public static <T> List<T> jsonToList(String jsonStr, Class<T> objectClass) {
        try {
            return objectMapper.readValue(jsonStr, new TypeReference<List<T>>() {
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
    public static <T> List<T> convert(Collection<?> collection, Class<T> clazz) {
        return jsonToList(objectToJson(collection), clazz);
    }
}

 screen-manage/src/main/java/com/moral/api/controller/GovMonitorPoionController.java

@@ -12,10 +12,7 @@
import com.moral.constant.ResultMessage;
import com.moral.util.WebUtils;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

@@ -97,6 +94,16 @@
        return ResultMessage.ok();
    }

    @GetMapping("updateGuid")
    @ApiOperation(value = "更新站点编号", notes = "更新站点编号")
    public ResultMessage updateGuid(@RequestParam @ApiParam(value = "id",name = "主键id") Integer id,
                                    @RequestParam @ApiParam(value = "guid",name = "站点编号") String guid) {

        govMonitorPointService.updateList(id,guid);
        return ResultMessage.ok();
    }


    @RequestMapping(value = "delete", method = RequestMethod.POST)
    @ResponseBody
    public ResultMessage delete(@RequestBody Map map) {

 screen-manage/src/main/java/com/moral/api/service/GovMonitorPointService.java

@@ -46,6 +46,8 @@
    @Transactional
    void update(GovMonitorPoint govMonitorPoint);

    void updateList(Integer id,String guid);

    /**
      *@Description: 删除政府站点
      *@Param: [id]

 screen-manage/src/main/java/com/moral/api/service/impl/DeviceServiceImpl.java

@@ -630,6 +630,7 @@
        List<Device> list = lambdaQuery().eq(Device::getIsDelete,0).list();
        for(Device d : list){
           Map<String, Object> deviceInfo = selectDeviceInfoById(d.getId());
           redisTemplate.opsForHash().delete(RedisConstants.DEVICE, d.getMac());
           setDeviceInfoToRedis(d.getMac(), deviceInfo);
        }
    }

 screen-manage/src/main/java/com/moral/api/service/impl/GovMonitorPointServiceImpl.java

@@ -4,11 +4,13 @@
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.moral.api.entity.Device;
import com.moral.api.entity.GovMonitorPoint;
import com.moral.api.entity.Organization;
import com.moral.api.entity.SysArea;
import com.moral.api.exception.BusinessException;
import com.moral.api.mapper.DeviceMapper;
import com.moral.api.mapper.GovMonitorPointMapper;
import com.moral.api.mapper.SysAreaMapper;
@@ -20,6 +22,7 @@
import com.moral.constant.Constants;
import com.moral.constant.RedisConstants;
import com.moral.constant.ResponseCodeEnum;
import com.moral.constant.ResultMessage;
import com.moral.util.RegionCodeUtils;

import org.springframework.beans.factory.annotation.Autowired;
@@ -58,6 +61,9 @@

    @Resource
    private OrganizationService organizationService;

    @Resource
    private DeviceService deviceService;

    @Autowired(required = false)
    private DeviceMapper deviceMapper;
@@ -213,6 +219,47 @@
    }

    @Override
    @Transactional
    public void updateList(Integer id, String guid) {
        QueryWrapper<GovMonitorPoint> wrapper_govMonitorPoint = new QueryWrapper<>();
        wrapper_govMonitorPoint.eq("is_delete", Constants.NOT_DELETE);
        wrapper_govMonitorPoint.eq("id", id);
        List<GovMonitorPoint> govMonitorPoints = govMonitorPointMapper.selectList(wrapper_govMonitorPoint);
        if (govMonitorPoints.size() == 0) {
            throw new BusinessException("站点不存在！");
        }
        GovMonitorPoint govMonitorPoint = govMonitorPoints.get(0);
        String oldGuid = govMonitorPoint.getGuid();
        if(!oldGuid.equals(guid)){
            govMonitorPoint.setGuid(guid);
            govMonitorPointMapper.updateById(govMonitorPoint);
            //删除redis
            delGovMonitorPointInfoFromRedis(id.toString());
            //更新redis
            setGovMonitorPointInfoToRedis(id.toString(), selectGovMonitorPointInfoById(id));
            //操作日志记录
            HttpServletRequest request = ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
            StringBuilder content = new StringBuilder();
            content.append("修改了政府站点：").append("id:").append(govMonitorPoint.getId() + ";");
            if (!ObjectUtils.isEmpty(govMonitorPoint.getGuid())) {
                content.append("guid:").append(oldGuid).append("->").append(guid).append(";");
            }
            LogUtils.saveOperationForManage(request, content.toString(), Constants.UPDATE_OPERATE_TYPE);
            LambdaQueryChainWrapper<Device> wrapper = deviceService.lambdaQuery();
            wrapper.eq(Device::getIsDelete,0);
            wrapper.eq(Device::getGuid,oldGuid);
            List<Device> list = wrapper.list();
            list.forEach(it->it.setGuid(guid));
            deviceService.updateBatchById(list);
            for(Device d : list){
                Map<String, Object> deviceInfo = deviceService.selectDeviceInfoById(d.getId());
                redisTemplate.opsForHash().delete(RedisConstants.DEVICE, d.getMac());
                redisTemplate.opsForHash().put(RedisConstants.DEVICE, d.getMac(), deviceInfo);
            }
        }
    }

    @Override
    public void delete(Integer id) {
        UpdateWrapper<GovMonitorPoint> wrapper_delete = new UpdateWrapper<>();
        wrapper_delete.eq("id", id).set("is_delete", Constants.DELETE);