package jnpf.onlinedev.util.onlineDevUtil;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import jnpf.base.ActionResult;
import jnpf.base.DataInterFaceApi;
import jnpf.base.DictionaryDataApi;
import jnpf.base.entity.DictionaryDataEntity;
import jnpf.base.entity.ProvinceEntity;
import jnpf.base.model.ColumnDataModel;
import jnpf.base.model.datainterface.DataInterfaceActionVo;
import jnpf.base.service.VisualdevService;
import jnpf.model.visualJson.FieLdsModel;
import jnpf.onlinedev.model.OnlineDevEnum.MultipleControlEnum;
import jnpf.onlinedev.model.OnlineDevEnum.OnlineDataTypeEnum;
import jnpf.onlinedev.model.OnlineDevListModel.OnlineDevListDataVO;
import jnpf.onlinedev.model.OnlineDevListModel.VisualColumnSearchVO;
import jnpf.onlinedev.service.VisualDevInfoService;
import jnpf.onlinedev.service.VisualdevModelDataService;
import jnpf.permission.OrganizeApi;
import jnpf.permission.PositionApi;
import jnpf.permission.UserApi;
import jnpf.util.*;
import jnpf.util.visiual.JnpfKeyConsts;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author JNPF开发平台组
 * @version V3.1.0
 * @copyright 引迈信息技术有限公司（https://www.jnpfsoft.com）
 * @date 2021/7/28
 */
@Slf4j
@Component
public class OnlineDevListUtils {
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private DictionaryDataApi dictionaryDataApi;
    @Autowired
    private DataInterFaceApi dataInterFaceApi;

    /**
     * 查询条件
     *
     * @param list
     * @param searchList
     * @return
     */
    public static List<Map<String, Object>> getNoSwapList(List<Map<String, Object>> list, List<VisualColumnSearchVO> searchList) {
        List<Map<String, Object>> resultList = new ArrayList<>();
        if (searchList == null) {
            return list;
        }
        for (Map<String, Object> dataVo : list) {
            int i = 0;
            for (VisualColumnSearchVO vo : searchList) {
                Object dataModel = dataVo.get(vo.getVModel());
                if (dataModel == null || ObjectUtil.isEmpty(dataModel)) {
                    continue;
                }
                //多选框默认添加多选属性
                if (vo.getConfig().getJnpfKey().equals(JnpfKeyConsts.CHECKBOX) || JnpfKeyConsts.CASCADER.equals(vo.getConfig().getJnpfKey())) {
                    vo.setMultiple(true);
                }
                if (vo.getSearchType().equals("1")) {
                    //多选框筛选
                    if (vo.getMultiple() != null && vo.getMultiple() == true) {
                        List<String> asList;
                        if (String.valueOf(dataModel).contains("[")) {
                            asList = JsonUtil.getJsonToList(String.valueOf(dataModel), String.class);
                        } else {
                            String[] multipleList = String.valueOf(dataModel).split(",");
                            asList = Arrays.asList(multipleList);
                        }
                        boolean b = asList.stream().anyMatch(t -> vo.getValue().toString().contains(t));
                        if (b) {
                            i++;
                        }
                    } else {
                        if (String.valueOf(vo.getValue()).equals(String.valueOf(dataModel))) {
                            i++;
                        }
                    }
                }
                if (vo.getSearchType().equals("2")) {
                    if (String.valueOf(dataModel).contains(String.valueOf(vo.getValue()))) {
                        i++;
                    }
                }
                if (vo.getSearchType().equals("3")) {
                    String key = vo.getConfig().getJnpfKey();
                    switch (key) {
                        case JnpfKeyConsts.MODIFYTIME:
                        case JnpfKeyConsts.CREATETIME:
                            JSONArray timeStampArray = (JSONArray) vo.getValue();
                            Long o1 = (Long) timeStampArray.get(0);
                            Long o2 = (Long) timeStampArray.get(1);

                            //时间戳转string格式
                            String startTime = DateUtil.daFormat(o1);
                            String endTime = DateUtil.daFormat(o2);
                            //处理时间查询条件范围
                            endTime = endTime.substring(0, 10);
                            String firstTimeDate = OnlineDatabaseUtils.getTimeFormat(startTime);
                            String lastTimeDate = OnlineDatabaseUtils.getLastTimeFormat(endTime);

                            String value = String.valueOf(dataModel);
                            if (value.contains(".")) {
                                value = value.substring(0, value.lastIndexOf("."));
                            }
                            //只判断到日期
                            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                            try {
                                boolean b = DateUtil.isEffectiveDate(sdf.parse(value), sdf.parse(firstTimeDate), sdf.parse(lastTimeDate));
                                if (b) {
                                    i++;
                                }
                            } catch (ParseException e) {
                                e.printStackTrace();
                            }
                            break;
                        case JnpfKeyConsts.NUM_INPUT:
                        case JnpfKeyConsts.CALCULATE:
                            Float firstValue = null;
                            Float secondValue = null;
                            JSONArray objects = (JSONArray) vo.getValue();
                            for (int k = 0; k < objects.size(); k++) {
                                Object n = objects.get(k);
                                if (ObjectUtil.isNotEmpty(n)) {
                                    if (k == 0) {
                                        firstValue = Float.parseFloat(String.valueOf(n));
                                    } else {
                                        secondValue = Float.parseFloat(String.valueOf(n));
                                    }
                                }
                            }
                            //数据
                            Float numValue = Float.parseFloat(String.valueOf(dataModel));

                            //条件1,2组合的情况
                            if (firstValue != null && secondValue == null) {
                                if (numValue >= firstValue) {
                                    i++;
                                }
                            }
                            if (firstValue != null && secondValue != null) {
                                if (numValue >= firstValue && numValue <= secondValue) {
                                    i++;
                                }
                            }
                            if (firstValue == null && secondValue != null) {
                                if (numValue <= secondValue) {
                                    i++;
                                }
                            }
                            break;
                        case JnpfKeyConsts.DATE:
                        case JnpfKeyConsts.DATE_CALCULATE:
                            String starTimeDates;
                            String endTimeDates;
                            if (dataModel == null) {
                                break;
                            }
                            //时间戳
                            if (!String.valueOf(vo.getValue()).contains(":") && !String.valueOf(vo.getValue()).contains("-")) {
                                JSONArray DateTimeStampArray = (JSONArray) vo.getValue();
                                Long d1 = (Long) DateTimeStampArray.get(0);
                                Long d2 = (Long) DateTimeStampArray.get(1);
                                long d1FirstTime = Long.parseLong(String.valueOf(d1));
                                long d2LastTime = Long.parseLong(String.valueOf(d2));

                                //时间戳转string格式
                                starTimeDates = DateUtil.daFormat(d1FirstTime);
                                endTimeDates = DateUtil.daFormat(d2LastTime);

                            } else {
                                //时间字符串
                                String[] keyArray = String.valueOf(vo.getValue()).split(",");
                                starTimeDates = keyArray[0];
                                endTimeDates = keyArray[1];
                            }
                            if (vo.getFormat() == null) {
                                starTimeDates = starTimeDates.substring(0, 10);
                                endTimeDates = endTimeDates.substring(0, 10);
                            }
                            starTimeDates = OnlineDatabaseUtils.getTimeFormat(starTimeDates);
                            endTimeDates = OnlineDatabaseUtils.getLastTimeFormat(endTimeDates);

                            String dateValue = dataModel.toString();
                            if (!dateValue.contains(":") && !dateValue.contains("-")) {
                                //时间戳
                                Long timeResult = (Long) dataModel;
                                dateValue = DateUtil.daFormat(timeResult);
                            }
                            if (dateValue.contains(".")) {
                                dateValue = dateValue.substring(0, dateValue.lastIndexOf("."));
                            }
                            dateValue = OnlineDatabaseUtils.getTimeFormat(dateValue);
                            //只判断到日期
                            SimpleDateFormat sdfDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                            try {
                                Boolean b = DateUtil.isEffectiveDate(sdfDate.parse(dateValue), sdfDate.parse(starTimeDates), sdfDate.parse(endTimeDates));
                                if (b) {
                                    i++;
                                }
                            } catch (ParseException e) {
                                e.printStackTrace();
                            }
                            break;
                        case JnpfKeyConsts.TIME:
                            JSONArray timeArray = (JSONArray) vo.getValue();
                            String start = String.valueOf(timeArray.get(0));
                            String end = String.valueOf(timeArray.get(1));
                            start = OnlineDatabaseUtils.getTimeFormat(start);
                            end = OnlineDatabaseUtils.getLastTimeFormat(end);
                            String timeValue = OnlineDatabaseUtils.getTimeFormat(String.valueOf(dataModel));
                            SimpleDateFormat timeSim = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                            try {
                                boolean b = DateUtil.isEffectiveDate(timeSim.parse(timeValue), timeSim.parse(start), timeSim.parse(end));
                                if (b) {
                                    i++;
                                }
                            } catch (ParseException e) {
                                e.printStackTrace();
                            }
                            break;
                        default:
                            break;
                    }
                }
                if (i == searchList.size()) {
                    resultList.add(dataVo);
                }
            }
        }
        return resultList;
    }

    /**
     * 取出列表所用到的 用户 组织 岗位的id
     *
     * @param list           数据
     * @param swapDataVoList 控件
     */
    public static void pageIdList(List<OnlineDevListDataVO> list, List<FieLdsModel> swapDataVoList, Map<String, Object> localCache) {
        Set<String> userList = (Set<String>) localCache.get("__user_list");
        Set<String> orgList = (Set<String>) localCache.get("__org_list");
        Set<String> posList = (Set<String>) localCache.get("__pos_list");
        Set<String> AllOrgList = (Set<String>) localCache.get("__allOrg_list");
        Set<String> roleList = (Set<String>) localCache.get("__role_list");
        for (FieLdsModel swapDataVo : swapDataVoList) {
            String jnpfKey = swapDataVo.getConfig().getJnpfKey();
            String vModel = swapDataVo.getVModel();
            for (OnlineDevListDataVO listVo : list) {
                Map<String, Object> dataMap = listVo.getData();
                if (StringUtil.isEmpty(String.valueOf(dataMap.get(vModel))) || dataMap.get(vModel) == null) {
                    continue;
                }
                if (String.valueOf(dataMap.get(vModel)).equals("[]") || String.valueOf(dataMap.get(vModel)).equals("null")) {
                    continue;
                } else {
                    switch (jnpfKey) {
                        //公司组件
                        case JnpfKeyConsts.COMSELECT:
                            //部门组件
                        case JnpfKeyConsts.DEPSELECT:
                            //所属部门
                        case JnpfKeyConsts.CURRDEPT:
                            //所属公司
                        case JnpfKeyConsts.CURRORGANIZE:
                            if ("all".equals(swapDataVo.getShowLevel())) {
                                getIdInMethod(AllOrgList, dataMap.get(vModel));
                            } else {
                                getIdInMethod(orgList, dataMap.get(vModel));
                            }
                            break;
                        //角色
                        case JnpfKeyConsts.ROLESELECT:
                            getIdInMethod(roleList, dataMap.get(vModel));
                            break;
                        //岗位组件
                        case JnpfKeyConsts.POSSELECT:
                            //所属岗位
                        case JnpfKeyConsts.CURRPOSITION:
                            getIdInMethod(posList, dataMap.get(vModel));
                            break;

                        //用户组件
                        case JnpfKeyConsts.USERSELECT:
                            //创建用户
                        case JnpfKeyConsts.CREATEUSER:
                            //修改用户
                        case JnpfKeyConsts.MODIFYUSER:
                            getIdInMethod(userList, dataMap.get(vModel));
                            break;
                        default:
                            break;
                    }
                }
            }
        }
    }

    /**
     * 存取对应id集合
     *
     * @param idList
     * @param modelData
     * @return
     */
    public static Collection<String> getIdInMethod(Collection<String> idList, Object modelData) {
        if (OnlinePublicUtils.getMultiple(String.valueOf(modelData), MultipleControlEnum.MULTIPLE_JSON_TWO.getMultipleChar())) {
            String[][] data = JsonUtil.getJsonToBean(String.valueOf(modelData), String[][].class);
            for (String[] AddressData : data) {
                for (String s : AddressData) {
                    idList.add(s);
                }
            }
        } else if (OnlinePublicUtils.getMultiple(String.valueOf(modelData), MultipleControlEnum.MULTIPLE_JSON_ONE.getMultipleChar())) {
            idList.addAll(JsonUtil.getJsonToList(String.valueOf(modelData), String.class));
        } else {
            String[] modelDatas = String.valueOf(modelData).split(",");
            for (int i = 0; i < modelDatas.length; i++) {
                idList.add(modelDatas[i]);
            }
        }
        return idList;
    }

    /**
     * 分组页面
     *
     * @param realList
     * @param columnDataModel
     * @return
     */
    public static List<Map<String, Object>> groupData(List<Map<String, Object>> realList, ColumnDataModel columnDataModel) {
        List<Map<String, Object>> columnList = JsonUtil.getJsonToListMap(columnDataModel.getColumnList());
        String firstField;
        String groupField = columnDataModel.getGroupField();
        List<Map<String, Object>> collect = columnList.stream().filter(t -> "left".equals(t.get("fixed"))
                && !String.valueOf(t.get("prop")).equals(columnDataModel.getGroupField())).collect(Collectors.toList());
        Map<String, Object> map = null;
        if(CollectionUtil.isNotEmpty(collect)){
            map = collect.stream().filter(t -> !String.valueOf(t.get("prop")).equals(columnDataModel.getGroupField())).findFirst().orElse(null);
        }else{
            map = columnList.stream().filter(t -> !String.valueOf(t.get("prop")).equals(columnDataModel.getGroupField())).findFirst().orElse(null);
        }
        if (map == null) {
            map = columnList.stream().filter(t -> String.valueOf(t.get("prop")).equals(columnDataModel.getGroupField())).findFirst().orElse(null);
        }
        firstField = String.valueOf(map.get("prop"));

        Map<String, List<Map<String, Object>>> twoMap = new LinkedHashMap<>(16);

        for (Map<String, Object> realMap : realList) {
            String value = String.valueOf(realMap.get(groupField));
            if(realMap.get(groupField) instanceof Double){
                value = realMap.get(groupField).toString().replaceAll(".0+?$","").replaceAll("[.]$","");
            }
            boolean isKey = twoMap.get(value) != null;
            if (isKey) {
                List<Map<String, Object>> maps = twoMap.get(value);
                maps.add(realMap);
                twoMap.put(value, maps);
            } else {
                List<Map<String, Object>> childrenList = new ArrayList<>();
                childrenList.add(realMap);
                twoMap.put(value, childrenList);
            }
        }

        List<Map<String, Object>> resultList = new ArrayList<>();
        for (String key : twoMap.keySet()) {
            Map<String, Object> thirdMap = new HashMap<>(16);
            thirdMap.put(firstField, !key.equals("null") ? key : "");
            thirdMap.put("top", true);
            thirdMap.put("id", RandomUtil.uuId());
            thirdMap.put("children", twoMap.get(key));
            resultList.add(thirdMap);
        }
        return resultList;
    }

    /**
     * 递归查询
     *
     * @param label
     * @param value
     * @param Children
     * @param data
     * @param options
     */
    public static void getOptions(String label, String value, String Children, JSONArray data, List<Map<String, Object>> options) {
        for (int i = 0; i < data.size(); i++) {
            JSONObject ob = data.getJSONObject(i);
            Map<String, Object> tree = new HashMap<>(16);
            tree.put(value, String.valueOf(ob.get(value)));
            tree.put(label, String.valueOf(ob.get(label)));
            options.add(tree);
            if (ob.get(Children) != null) {
                JSONArray childrenArray = ob.getJSONArray(Children);
                getOptions(label, value, Children, childrenArray, options);
            }
        }
    }

    /**
     * 树形列表页面
     *
     * @param realList
     * @param columnDataModel
     * @return
     */
    public static List<Map<String, Object>> treeListData(List<Map<String, Object>> realList, ColumnDataModel columnDataModel) {
        String parentField = columnDataModel.getParentField() + "_id";
        String childField = columnDataModel.getSubField();
        for (int i = 0; i < realList.size(); i++) {
            Map<String, Object> item = realList.get(i);
            if ((item.get(parentField) != null && !StringUtil.isNotEmpty(item.get(parentField).toString())) || (item.get(parentField) != null && !"[]".equals(item.get(parentField).toString()))) {
                if (addChild(item, realList, parentField, childField) && realList.size() > 0) {
                    realList.remove(item);
                    i--;
                }
            }
        }
        return realList;
    }

    /**
     * 级联递归
     *
     * @param value
     * @param label
     * @param children
     * @param data
     * @param result
     */
    private static void treeToList(String value, String label, String children, JSONArray data, List<Map<String, Object>> result) {
        for (int i = 0; i < data.size(); i++) {
            JSONObject ob = data.getJSONObject(i);
            Map<String, Object> tree = new HashMap<>(16);
            tree.put(value, String.valueOf(ob.get(value)));
            tree.put(label, String.valueOf(ob.get(label)));
            result.add(tree);
            if (ob.get(children) != null) {
                JSONArray childArray = ob.getJSONArray(children);
                treeToList(value, label, children, childArray, result);
            }
        }
    }

    //递归
    private static boolean addChild(Map<String, Object> node, List<Map<String, Object>> list, String parentField, String childField) {

        for (int i = 0; i < list.size(); i++) {
            Map<String, Object> ele = list.get(i);
            if (ele.get(childField).equals(node.get(parentField))) {
                if (ele.get("children") == null) {
                    ele.put("children", new ArrayList<>());
                }
                List<Map<String, Object>> children = (List<Map<String, Object>>) ele.get("children");
                children.add(node);
                ele.put("children", children);
                return true;
            }
            if (ele.get("children") != null) {
                List<Map<String, Object>> children = (List<Map<String, Object>>) ele.get("children");
                if (addChild(node, children, parentField, childField)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 保存需要转换的数据到redis(系统控件)
     *
     * @param swapDataVoList
     */
    public void sysNeedSwapData(List<FieLdsModel> swapDataVoList, String visualDevId, Map<String, Object> localCache) {

        //公共数据
        String dsName = Optional.ofNullable(TenantHolder.getDatasourceId()).orElse("");

        String redisKey;
        try {
            for (FieLdsModel swapDataVo : swapDataVoList) {
                String jnpfKey = swapDataVo.getConfig().getJnpfKey();
                String dataType = swapDataVo.getConfig().getDataType();
                switch (jnpfKey) {
                    //省市区联动
                    case JnpfKeyConsts.ADDRESS:
                        redisKey = "";
                        if (!redisUtil.exists("")) {
                            List<ProvinceEntity> provinceEntityList = new ArrayList<>();
                            Map<String, String> provinceMap = new HashMap<>(16);
                            provinceEntityList.stream().forEach(p -> provinceMap.put(p.getId(), p.getFullName()));
                            redisUtil.insert(redisKey, provinceMap, RedisUtil.CAHCEWEEK);
                        }
                        if (!localCache.containsKey(redisKey)) {
                            localCache.put(redisKey, redisUtil.getMap(redisKey));
                        }
                        break;
                    default:
                        break;
                }
                if (dataType != null) {
                    //数据接口的数据存放
                    String label= swapDataVo.getProps().getLabel();
                    String value= swapDataVo.getProps().getValue();
                    String children  = swapDataVo.getProps().getChildren();
                    List<Map<String, Object>> options = new ArrayList<>();
                    Map<String, String> dataInterfaceMap = new HashMap<>(16);

                    //静态数据
                    if (dataType.equals(OnlineDataTypeEnum.STATIC.getType())) {
                        redisKey = String.format("%s-%s-%s", visualDevId, swapDataVo.getVModel(), OnlineDataTypeEnum.STATIC.getType());
                        if (!redisUtil.exists(redisKey)) {
                            if (swapDataVo.getOptions() != null) {
                                options = JsonUtil.getJsonToListMap(swapDataVo.getOptions());
                                String Children = swapDataVo.getProps().getChildren();
                                JSONArray data = JsonUtil.getListToJsonArray(options);
                                getOptions(label, value, Children, data, options);
                            } else {
                                options = JsonUtil.getJsonToListMap(swapDataVo.getOptions());
                            }
                            options.stream().forEach(o -> {
                                dataInterfaceMap.put(String.valueOf(o.get(value)), String.valueOf(o.get(label)));
                            });
                            String staticData = JsonUtil.getObjectToString(dataInterfaceMap);
                            redisUtil.insert(redisKey, staticData, 60 * 5);
                            if (!localCache.containsKey(redisKey)) {
                                localCache.put(redisKey, dataInterfaceMap);
                            }
                        } else {
                            if (!localCache.containsKey(redisKey)) {
                                String staticDataString = redisUtil.getString(redisKey).toString();
                                localCache.put(redisKey, JsonUtil.stringToMap(staticDataString));
                            }
                        }
                    }
                    //远端数据
                    if (dataType.equals(OnlineDataTypeEnum.DYNAMIC.getType())) {
                        redisKey = String.format("%s-%s-%s", dsName, OnlineDataTypeEnum.DYNAMIC.getType(), swapDataVo.getConfig().getPropsUrl());
                        String redisKey2 = String.format("%s-%s-%s-%s-%s-%s", dsName, OnlineDataTypeEnum.DYNAMIC.getType(), swapDataVo.getConfig().getPropsUrl(), label, value, children);
                        if (!redisUtil.exists(redisKey2)) {
                            ActionResult data = null;
                            if (!redisUtil.exists(redisKey)) {
                                data = dataInterFaceApi.infoToId(swapDataVo.getConfig().getPropsUrl());
                                //缓存接口全部数据
                                redisUtil.insert(redisKey, JSONObject.toJSONString(data), 60 * 5);
                            } else {
                                data = JSONObject.parseObject(String.valueOf(redisUtil.getString(redisKey)), ActionResult.class);
                            }
                            if (!localCache.containsKey(redisKey)) {
                                localCache.put(redisKey, data);
                            }
                            if (data != null && data.getData() != null) {
                                List<Map<String, Object>> dataList = new ArrayList<>();
                                if (data.getData() instanceof DataInterfaceActionVo) {
                                    DataInterfaceActionVo actionVo = (DataInterfaceActionVo) data.getData();
                                    if (actionVo.getData() instanceof List) {
                                        dataList = (List<Map<String, Object>>) actionVo.getData();
                                    }
                                } else if (data.getData() instanceof List) {
                                    dataList = (List<Map<String, Object>>) data.getData();
                                }
                                JSONArray dataAll = JsonUtil.getListToJsonArray(dataList);
                                treeToList(label, value, children, dataAll, options);
                                options.stream().forEach(o -> {
                                    dataInterfaceMap.put(String.valueOf(o.get(value)), String.valueOf(o.get(label)));
                                });

                                //缓存接口根据特定字段转换后的全部数据
                                String dynamicData = JsonUtil.getObjectToString(dataInterfaceMap);
                                redisUtil.insert(redisKey2, dynamicData, 60 * 5);
                                localCache.put(redisKey2, dataInterfaceMap);
                            }
                        } else {
                            if (!localCache.containsKey(redisKey)) {
                                localCache.put(redisKey, JSONObject.parseObject(String.valueOf(redisUtil.getString(redisKey)), ActionResult.class));
                            }
                            if (!localCache.containsKey(redisKey2)) {
                                //转成map格式
                                String dynamicString = redisUtil.getString(redisKey2).toString();
                                localCache.put(redisKey2, JsonUtil.stringToMap(dynamicString));
                            }
                        }
                    }
                    //数据字典
                    if (dataType.equals(OnlineDataTypeEnum.DICTIONARY.getType())) {
                        redisKey = String.format("%s-%s-%s", dsName, OnlineDataTypeEnum.DICTIONARY.getType(), swapDataVo.getConfig().getDictionaryType());
                        if (!redisUtil.exists(redisKey)) {
                            List<DictionaryDataEntity> list = dictionaryDataApi.getDicList(swapDataVo.getConfig().getDictionaryType());
                            options = list.stream().map(dic -> {
                                Map<String, Object> dictionaryMap = new HashMap<>(16);
                                dictionaryMap.put("id", dic.getId());
                                dictionaryMap.put("enCode", dic.getEnCode());
                                dictionaryMap.put("fullName", dic.getFullName());
                                return dictionaryMap;
                            }).collect(Collectors.toList());

                            String dictionaryData = JsonUtil.getObjectToString(options);
                            redisUtil.insert(redisKey, dictionaryData, 60 * 5);
                            localCache.put(redisKey, options);
                        } else {
                            if (!localCache.containsKey(redisKey)) {
                                String dictionaryStringData = redisUtil.getString(redisKey).toString();
                                localCache.put(redisKey, JsonUtil.getJsonToListMap(dictionaryStringData));
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            log.error("在线开发转换数据异常:" + e.getMessage());
            e.printStackTrace();
        }


    }


}