design/designer-base/src/main/java/com/fr/design/data/datapane/ESDStrategyConfigPane.java

package com.fr.design.data.datapane;

import com.fr.design.beans.BasicBeanPane;
import com.fr.design.gui.ibutton.UIRadioButton;
import com.fr.design.gui.icheckbox.UICheckBox;
import com.fr.design.gui.ilable.ActionLabel;
import com.fr.design.gui.ilable.UILabel;
import com.fr.design.gui.itextfield.UITextField;
import com.fr.design.i18n.LocaleLinkProvider;
import com.fr.design.layout.FRGUIPaneFactory;
import com.fr.design.utils.gui.GUICoreUtils;
import com.fr.esd.common.CacheConstants;
import com.fr.esd.core.strategy.config.StrategyConfig;
import com.fr.esd.core.strategy.config.StrategyConfigHelper;
import com.fr.esd.util.ESDUtils;
import com.fr.locale.InterProviderFactory;
import com.fr.log.FineLoggerFactory;
import com.fr.stable.StringUtils;
import com.fr.third.org.quartz.CronExpression;

import javax.swing.AbstractAction;
import javax.swing.JPanel;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Desktop;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URI;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;

/**
 * @author rinoux
 * @version 10.0
 * Created by rinoux on 2020/7/22
 */
public class ESDStrategyConfigPane extends BasicBeanPane<StrategyConfig> {

    /**
     * 云中心定时调度执行频率表达式设定帮助文档链接在配置文件中对应的配置文件key
     */
    private static final String PROPS_LINK_KEY = "Fine-Design-CloudCenter_Cron_Help";

    /**
     * 云中心定时调度执行频率表达式设定帮助文档默认链接在配置文件中对应的配置文件key
     */
    private static final String PROPS_LINK_KEY_DEFAULT = "Fine-Design-CloudCenter_Cron_Help_Default";

    private static final String CRON_HELP_URL = LocaleLinkProvider.getInstance().getLink(PROPS_LINK_KEY, PROPS_LINK_KEY_DEFAULT);
    private UIRadioButton selectAutoUpdate;
    private UIRadioButton selectBySchema;
    private UICheckBox shouldEvolve;
    private UILabel updateIntervalCheckTips;
    private UITextField updateInterval;
    private UITextField schemaTime;
    private ActionLabel actionLabel;
    private UILabel schemaTimeCheckTips;
    private final boolean global;
    private StrategyConfig strategyConfig;


    public ESDStrategyConfigPane(boolean global) {
        this.global = global;
        init();
    }

    private void init() {
        setLayout(FRGUIPaneFactory.createM_BorderLayout());

        this.selectAutoUpdate = new UIRadioButton(InterProviderFactory.getDesignI18nProvider().i18nText("Fine-Design_ESD_Every_Interval"));

        this.updateInterval = new UITextField(4);
        this.shouldEvolve = new UICheckBox(InterProviderFactory.getDesignI18nProvider().i18nText("Fine-Design_ESD_Auto_Evolved_Strategy"), false);
        this.shouldEvolve.setEnabled(false);
        this.updateIntervalCheckTips = new UILabel(InterProviderFactory.getDesignI18nProvider().i18nText("Fine-Design_ESD_Error_Interval_Format"));
        this.updateIntervalCheckTips.setForeground(Color.RED);
        this.updateIntervalCheckTips.setVisible(false);

        this.selectBySchema = new UIRadioButton(InterProviderFactory.getDesignI18nProvider().i18nText("Fine-Design_ESD_Cron"));
        this.schemaTime = new UITextField(10);
        this.schemaTimeCheckTips = new UILabel(InterProviderFactory.getDesignI18nProvider().i18nText("Fine-Design_ESD_Error_Time_Format"));
        this.schemaTimeCheckTips.setVisible(false);
        this.schemaTimeCheckTips.setForeground(Color.RED);


        this.selectAutoUpdate.addActionListener(new AbstractAction() {
            public void actionPerformed(ActionEvent e) {
                ESDStrategyConfigPane.this.selectBySchema.setSelected(!ESDStrategyConfigPane.this.selectAutoUpdate.isSelected());
                ESDStrategyConfigPane.this.schemaTime.setEnabled(false);
                ESDStrategyConfigPane.this.updateInterval.setEnabled(true);
                ESDStrategyConfigPane.this.shouldEvolve.setEnabled(true);
            }
        });

        this.selectBySchema.addActionListener(new AbstractAction() {
            public void actionPerformed(ActionEvent e) {
                ESDStrategyConfigPane.this.selectAutoUpdate.setSelected(!ESDStrategyConfigPane.this.selectBySchema.isSelected());
                ESDStrategyConfigPane.this.schemaTime.setEnabled(true);
                ESDStrategyConfigPane.this.updateInterval.setEnabled(false);
                ESDStrategyConfigPane.this.shouldEvolve.setEnabled(false);
            }
        });

        JPanel pane = FRGUIPaneFactory.createVerticalTitledBorderPane(InterProviderFactory.getDesignI18nProvider().i18nText("Fine-Design_ESD_Cache_Update_Strategy"));
        add(pane, BorderLayout.NORTH);

        JPanel row1 = GUICoreUtils.createFlowPane(new Component[]{
                this.selectAutoUpdate,
                this.updateInterval,
                new UILabel(InterProviderFactory.getDesignI18nProvider().i18nText("Fine-Design_ESD_Minute_Update_Cache")),
                this.shouldEvolve,
                this.updateIntervalCheckTips
        }, 0, 5);
        pane.add(row1);

        ActionLabel actionLabel = new ActionLabel(InterProviderFactory.getDesignI18nProvider().i18nText("Fine-Design_ESD_Cron_Help"));
        actionLabel.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    Desktop.getDesktop().browse(new URI(CRON_HELP_URL));
                } catch (Exception exp) {
                    FineLoggerFactory.getLogger().error(exp.getMessage(), e);
                }
            }
        });

        JPanel row2 = GUICoreUtils.createFlowPane(new Component[]{
                this.selectBySchema,
                this.schemaTime,
                actionLabel,
                this.schemaTimeCheckTips
        }, 0, 5);
        pane.add(row2);
    }


    public void populateBean(StrategyConfig ob) {

        if (ob == null && !global) {
            ob = StrategyConfigHelper.createStrategyConfig(true, false, true);
        }
        this.strategyConfig = ob;
        this.updateInterval.setText(ob.getUpdateInterval() <= 0 ? "0" : String.valueOf(ob.getUpdateInterval() / (double) CacheConstants.MILLIS_OF_MINUTE));
        this.schemaTime.setText(StringUtils.join(",", ob.getUpdateSchema().toArray(new String[0])));
        this.shouldEvolve.setSelected(ob.shouldEvolve());
        this.selectBySchema.setSelected(ob.isScheduleBySchema());
        this.selectAutoUpdate.setSelected(!ob.isScheduleBySchema());

        if (global) {
            //使用全局配置，禁用面板编辑
            disablePane();
        } else {
            setSchemaEnable(!this.selectAutoUpdate.isSelected());
        }
    }


    private void disablePane() {
        this.selectAutoUpdate.setEnabled(false);
        this.updateInterval.setEnabled(false);
        this.shouldEvolve.setEnabled(false);

        this.selectBySchema.setEnabled(false);
        this.schemaTime.setEnabled(false);
    }

    private void setSchemaEnable(boolean enable) {
        this.updateInterval.setEnabled(!enable);
        this.shouldEvolve.setEnabled(!enable);

        this.schemaTime.setEnabled(enable);
    }


    public StrategyConfig updateBean() {
        StrategyConfig config = null;
        if (!this.global) {
            try {
                //这里是new的config
                config = this.strategyConfig.clone();

                if (this.selectBySchema.isSelected()) {
                    List<String> schemaTimes = new ArrayList<>();
                    String text = this.schemaTime.getText();

                    if (ESDUtils.checkUpdateTimeSchema(text)) {
                        if (ESDUtils.isCronExpression(text)) {
                            if (checkCornTimeInterval(text)) {
                                schemaTimes.add(text);
                            } else {
                                this.schemaTimeCheckTips.setText(InterProviderFactory.getDesignI18nProvider().i18nText("Fine-Design_ESD_Error_Time_Interval_Too_Short"));
                                this.schemaTimeCheckTips.setVisible(true);
                                throw new IllegalArgumentException("[ESD]Update schema time interval is to short.");
                            }
                        } else {
                            Collections.addAll(schemaTimes, text.split(","));
                        }
                    } else {
                        this.schemaTimeCheckTips.setText(InterProviderFactory.getDesignI18nProvider().i18nText("Fine-Design_ESD_Error_Time_Format"));
                        this.schemaTimeCheckTips.setVisible(true);
                        throw new IllegalArgumentException("[ESD]Update schema time format error.");
                    }
                    config.setScheduleBySchema(true);
                    config.setUpdateSchema(schemaTimes);
                } else {
                    String interval = this.updateInterval.getText();
                    if (checkUpdateInterval(interval)) {
                        long intervalMillis = StringUtils.isEmpty(interval) ? 0 : (long) (Double.parseDouble(interval) * CacheConstants.MILLIS_OF_MINUTE);
                        if (intervalMillis >= CacheConstants.MILLIS_OF_MINUTE) {
                            config.setUpdateInterval(intervalMillis);
                        } else {
                            this.updateIntervalCheckTips.setText(InterProviderFactory.getDesignI18nProvider().i18nText("Fine-Design_ESD_Error_Time_Interval_Too_Short"));
                            this.updateIntervalCheckTips.setVisible(true);
                            throw new IllegalArgumentException("[ESD]Update schema time interval is to short.");
                        }
                    } else {
                        this.updateIntervalCheckTips.setText(InterProviderFactory.getDesignI18nProvider().i18nText("Fine-Design_ESD_Error_Time_Format"));
                        this.updateIntervalCheckTips.setVisible(true);
                        throw new IllegalArgumentException("[ESD]Error update interval format.");
                    }

                    config.setShouldEvolve(this.shouldEvolve.isSelected());
                    config.setScheduleBySchema(false);
                }
            } catch (CloneNotSupportedException e) {
                FineLoggerFactory.getLogger().error(e.getMessage(), e);
            }
        }

        return config;
    }


    private boolean checkUpdateInterval(String intervalValue) {
        try {
            return !StringUtils.isEmpty(intervalValue) && !(Double.parseDouble(intervalValue) <= 0);
        } catch (NumberFormatException e) {
            FineLoggerFactory.getLogger().error(e.getMessage(), e);
        }

        return false;
    }


    private boolean checkCornTimeInterval (String cronText) {
        // 判断后两次更新时间间隔，如果小于1分钟就返回false
        try {
            CronExpression cron = new CronExpression(cronText);
            Date next1 = cron.getNextValidTimeAfter(new Date());
            Date next2 = cron.getNextValidTimeAfter(next1);
            return next2.getTime() - next1.getTime() >= CacheConstants.MILLIS_OF_MINUTE;
        } catch (ParseException e) {
            FineLoggerFactory.getLogger().error(e.getMessage(), e);
        }
        return false;
    }

    protected String title4PopupWindow() {
        return InterProviderFactory.getDesignI18nProvider().i18nText("Fine-Design_ESD_Cache_Strategy_Config_Title");
    }
}