kanban-parent/kanban-console/src/main/java/com/uas/kanban/service/impl/PanelInstanceServiceImpl.java

package com.uas.kanban.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.uas.kanban.annotation.NotEmpty;
import com.uas.kanban.base.BaseService;
import com.uas.kanban.dao.KanbanDao;
import com.uas.kanban.dao.PanelDao;
import com.uas.kanban.dao.PanelInstanceDao;
import com.uas.kanban.exception.OperationException;
import com.uas.kanban.model.*;
import com.uas.kanban.service.PanelInstanceService;
import com.uas.kanban.service.ParameterService;
import com.uas.kanban.support.DataSourceManager;
import com.uas.kanban.support.KanbanParser;
import com.uas.kanban.support.SystemSession;
import com.uas.kanban.util.CollectionUtils;
import com.uas.kanban.util.ObjectUtils;
import com.uas.kanban.util.StringUtils;
import me.chyxion.jdbc.NewbieJdbcSupport;
import org.dom4j.DocumentException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.xml.transform.TransformerException;
import java.io.IOException;
import java.io.NotSerializableException;
import java.sql.SQLException;
import java.util.*;

/**
 * 面板实例
 *
 * @author sunyj
 * @since 2017/10/18 16:33
 */
@Service
public class PanelInstanceServiceImpl extends BaseService<PanelInstance> implements PanelInstanceService {

    @Autowired
    private PanelInstanceDao panelInstanceDao;

    @Autowired
    private PanelDao panelDao;

    @Autowired
    private KanbanDao kanbanDao;

    @Autowired
    private ParameterService parameterService;

    @Autowired
    private DataSourceManager dataSourceManager;

    @Autowired
    private KanbanParser kanbanParser;

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Override
    public int update(@NotEmpty("json") String json) throws IllegalArgumentException, OperationException {
        PanelInstance panelInstance = panelInstanceDao.parse(json);
        checkParameters(panelInstance);
        return panelInstanceDao.update(panelInstance);
    }

    /**
     * 检查参数是否正确填写（没有遗漏参数、每个参数都有值并且类型匹配）
     *
     * @param panelInstance 面板实例
     */
    private void checkParameters(@NotEmpty("panelInstance") PanelInstance panelInstance) {
        List<Parameter> parameters = panelInstance.fromParameters();
        try {
            if (!CollectionUtils.isEmpty(parameters)) {
                for (Parameter parameter : parameters) {
                    parameter.mayInitValue();
                }
            }
            List<Parameter> references = generateParameters(panelInstance.getPanelCode());
            // 重置 SQL 类型的参数（其值是解析出来的，不进行保存）
            resetSQLParameter(parameters, references);
            panelInstance.toParameters(parameters);
            compare(parameters, references);
        } catch (ClassNotFoundException | IOException | InstantiationException | IllegalAccessException e) {
            throw new IllegalStateException("深克隆对象时失败", e);
        }
    }

    /**
     * 根据面板，为面板实例生成参数
     *
     * @param panelCode 面板 code
     * @return 生成的参数
     */
    private List<Parameter> generateParameters(@NotEmpty("panelCode") String panelCode) {
        List<Parameter> parameters = parameterService.getByPanelCode(panelCode);
        if (CollectionUtils.isEmpty(parameters)) {
            return null;
        }
        for (Parameter parameter : parameters) {
            parameter.mayInitValue();
        }
        return parameters;
    }

    /**
     * 获取 sql 执行结果
     *
     * @param jdbc jdbc
     * @param sql  sql 查询语句
     * @return 执行结果
     */
    private List<Object> getValue(@NotEmpty("jdbc") NewbieJdbcSupport jdbc, @NotEmpty("sql") String sql) {
        List<Map<String, Object>> listMap = jdbc.listMap(sql);
        Map<String, List<Object>> map = kanbanParser.convert(listMap);
        Set<String> keySet = map.keySet();
        if (CollectionUtils.isEmpty(map)) {
            return new ArrayList<>();
        }
        if (keySet.size() > 1) {
            logger.error("参数解析结果不止一列：" + map);
        }
        return map.get(keySet.iterator().next());
    }

    /**
     * 重置 SQL 类型的参数
     *
     * @param parameters 需要重置的对象
     * @param references 参照对象
     */
    private void resetSQLParameter(List<Parameter> parameters, List<Parameter> references) {
        int parametersSize = parameters == null ? 0 : parameters.size() - 1;
        for (int i = parametersSize; i >= 0; i--) {
            Parameter parameter = parameters.get(i);
            // 只重置 SQL 类型
            if (parameter.getType() != Type.SQL) {
                continue;
            }
            // 获取 code 相同的参数，用于重置
            for (int j = references == null ? 0 : references.size() - 1; j >= 0; j--) {
                Parameter reference = references.get(j);
                if (Objects.equals(parameter.getCode(), reference.getCode())) {
                    parameter.setOptionalValues(reference.getOptionalValues());
                }
            }
        }
    }

    /**
     * 比较参数数量、名称等是否一致
     *
     * @param parameters 比较的对象
     * @param references 参照对象
     */
    private void compare(List<Parameter> parameters, List<Parameter> references)
            throws NotSerializableException, InstantiationException, IllegalAccessException, ClassNotFoundException,
            IOException {
        // 因为对象会被修改，所以先进行深克隆，参照对象不需要克隆
        List<Parameter> parametersClone = (List<Parameter>) ObjectUtils.clone(parameters);
        int parametersSize = parametersClone == null ? 0 : parametersClone.size() - 1;
        for (int i = parametersSize; i >= 0; i--) {
            Parameter parameter = parametersClone.get(i);
            // 先检查值
            parameter.checkValue();
            // 再去除 code 相同的参数，以找出不一样的参数
            for (int j = references == null ? 0 : references.size() - 1; j >= 0; j--) {
                Parameter reference = references.get(j);
                if (Objects.equals(parameter.getCode(), reference.getCode())) {
                    // 排除值的干扰
                    reference.setValue(parameter.getValue());
                    // 与参照对象不一致，说明填写的参数不规范
                    if (!parameter.equals(reference)) {
                        throw new IllegalArgumentException("参数属性不一致：" + parameter + "，应为：" + reference);
                    }
                    // 移除比较对象中通过检查的参数，最终剩下的全是不合法的参数
                    parametersClone.remove(parameter);
                    references.remove(reference);
                }
            }
        }
        if (!CollectionUtils.isEmpty(parametersClone)) {
            throw new IllegalArgumentException("不需要填写参数：" + parametersClone);
        }
        if (!CollectionUtils.isEmpty(references)) {
            throw new IllegalArgumentException("未填写参数：" + references);
        }
    }

    @Override
    public int updatePart(@NotEmpty("json") String json) throws IllegalArgumentException, OperationException {
        return update(json);
    }

    @Override
    public Map<String, Object> parseData(@NotEmpty("code") String code, String kanbanCode) {
        PanelInstance panelInstance = panelInstanceDao.checkExist(code);
        Panel panel = panelDao.checkExist(panelInstance.getPanelCode());
        List<PanelInstance.RelatedKanban> relatedKanbans = panelInstance.getRelatedKanbans();
        if (CollectionUtils.isEmpty(relatedKanbans)) {
            throw new IllegalStateException("面板下没有看板");
        }
        // 只保留已启用的看板
        List<String> enabledKanbanCodes = new ArrayList<>();
        for (PanelInstance.RelatedKanban relatedKanban : relatedKanbans) {
            if (relatedKanban.getEnabled() != null && relatedKanban.getEnabled()) {
                enabledKanbanCodes.add(relatedKanban.getCode());
            }
        }
        // 如果指定了看板，则解析该看板，否则解析该面板下的第一个看板
        if (!StringUtils.isEmpty(kanbanCode)) {
            if (!enabledKanbanCodes.contains(kanbanCode)) {
                throw new IllegalArgumentException("看板不存在或未启用：" + kanbanCode);
            }
        } else {
            kanbanCode = enabledKanbanCodes.get(0);
        }
        Kanban kanban = kanbanDao.checkExist(kanbanCode);
        String content = kanban.getContent();
        String title = kanban.getTitle();
        if (StringUtils.isEmpty(content)) {
            throw new IllegalStateException("看板内容为空：" + kanbanCode);
        }
        List<Parameter> parameters = panelInstance.fromParameters();
        // 解析看板
        String kanbanContent;
        try {
            NewbieJdbcSupport jdbc = dataSourceManager.getJdbc(panel.getDataSourceCode());
            kanbanContent = kanbanParser.parseXml(content, title, parameters, jdbc);
        } catch (DocumentException e) {
            throw new IllegalStateException("xml 解析出错", e);
        } catch (TransformerException e) {
            throw new IllegalStateException("xml 映射出错", e);
        } catch (IOException e) {
            throw new IllegalStateException("xml 转换出错", e);
        } catch (SQLException e) {
            throw new IllegalStateException("SQL 查询错误", e);
        }
        Map<String, Object> result = new HashMap<>();
        Map<String, Object> instance = new HashMap<>();
        instance.put("parameters", parameters);
        instance.put("enabledKanbanCodes", enabledKanbanCodes);
        instance.put("display", panel.getDisplay());
        instance.put("switchFrequency", panelInstance.getSwitchFrequency());
        instance.put("refreshFrequency", panelInstance.getRefreshFrequency());
        result.put("instance", instance);
        List<JSONObject> data = new ArrayList<>();
        data.add(JSONObject.parseObject(kanbanContent));
        result.put("data", data);
        // TODO 多个看板返回的json
        return result;
    }

    @Override
    public PanelInstance getByPanelCode(@NotEmpty("panelCode") String panelCode) throws OperationException {
        Panel panel = panelDao.checkExist(panelCode);
        PanelInstance panelInstance = panelInstanceDao.findByPanelCode(panelCode);
        if (panelInstance == null || panel.getVersion() > panelInstance.getPanelVersion()) {
            // 如果面板有更新，先删除旧的实例
            if (panelInstance != null) {
                deleteOne(panelInstance.getCode());
            }
            panelInstance = generateInstance(panelCode);
        }
        try {
            NewbieJdbcSupport jdbc = dataSourceManager.getJdbc(panel.getDataSourceCode());
            List<Parameter> parameters = panelInstance.fromParameters();
            parseSQLParameters(parameters, jdbc);
            panelInstance.toParameters(parameters);
        } catch (SQLException e) {
            throw new IllegalStateException("参数解析错误", e);
        }
        return panelInstance;
    }

    /**
     * 解析 SQL 类型的参数
     *
     * @param parameters 参数
     * @param jdbc       jdbc
     */
    private void parseSQLParameters(List<Parameter> parameters, NewbieJdbcSupport jdbc) {
        if (CollectionUtils.isEmpty(parameters)) {
            return;
        }
        for (Parameter parameter : parameters) {
            parameter.mayInitValue();
            // 如果是 SQL 类型，需要解析参数
            if (parameter.getType() == Type.SQL) {
                // 需要解析 optionalValues 里可选择的值
                List<Object> optionalValues = parameter.getOptionalValues();
                if (!CollectionUtils.isEmpty(optionalValues)) {
                    if (optionalValues.size() > 1) {
                        throw new IllegalArgumentException("SQL 类型的参数多于一个");
                    }
                    Object optionValue = optionalValues.get(0);
                    optionalValues = getValue(jdbc, String.valueOf(optionValue));
                    parameter.setOptionalValues(optionalValues);
                    if (parameter.getValue() == null) {
                        parameter.setValue(CollectionUtils.isEmpty(optionalValues) ? null : optionalValues.get(0));
                    }
                }
            }
        }
    }

    /**
     * 根据用户和面板，删除相应的实例
     *
     * @param panelCode 面板 code
     * @return 面板实例
     */
    private PanelInstance generateInstance(@NotEmpty("panelCode") String panelCode) {
        Panel panel = panelDao.checkExist(panelCode);
        PanelInstance panelInstance = new PanelInstance();
        panelInstance.setUserCode(SystemSession.getUser().getCode());
        panelInstance.setPanelCode(panelCode);
        panelInstance.setPanelVersion(panel.getVersion());
        initSwitchFrequence(panelInstance);
        panelInstance.toParameters(generateParameters(panelCode));
        List<Kanban> kanbans = kanbanDao.findByPanelCode(panelCode);
        if (CollectionUtils.isEmpty(kanbans)) {
            throw new IllegalStateException("面板 '" + panel.getName() + "' 未关联看板");
        }
        panelInstance.initKanbanCodes(kanbans);
        return panelInstanceDao.save(panelInstance);
    }

    /**
     * 初始化切换频率
     *
     * @param panelInstance 面板实例
     */
    private void initSwitchFrequence(@NotEmpty("panelInstance") PanelInstance panelInstance)
            throws IllegalArgumentException {
        Panel panel = panelDao.checkExist(panelInstance.getPanelCode());
        switch (panel.getDisplay()) {
            case AutoSwitch:
                if (panelInstance.getSwitchFrequency() == null) {
                    panelInstance.setSwitchFrequency(PanelInstance.DEFAULT_SWITCH_FREQUENCY);
                }
                break;
            case SplitScreen:
                if (panelInstance.getSwitchFrequency() != null) {
                    panelInstance.setSwitchFrequency(null);
                }
                break;
        }
    }

}