QuartzPortalAction.java

package com.mycim.webapp.actions;

import com.fa.sesa.exception.Errors;
import com.fa.sesa.i18n.I18nUtils;
import com.mycim.framework.context.spring.SpringContext;
import com.mycim.framework.jdbc.Page;
import com.mycim.framework.utils.lang.StringUtils;
import com.mycim.quartz.service.QuartzOperateService;
import com.mycim.quartz.service.QuartzQueryService;
import com.mycim.valueobject.MessageIdList;
import com.mycim.valueobject.quartz.dto.JobInfoDto;
import com.mycim.valueobject.quartz.dto.TriggerInfoDto;
import com.mycim.valueobject.sys.ReferenceFileDetail;
import com.mycim.webapp.forms.QuartzJobForm;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author quan.li
 */
public class QuartzPortalAction extends AbstractAction {


    public static final String JOB_NAME = "jobName";

    public static final String SCHED_NAME = "schedName";

    public static final String JOB_GROUP = "jobGroup";

    public static final String TRIGGER_NAME = "triggerName";

    public static final String TRIGGER_GROUP = "triggerGroup";

    public static final String JOB_NAME_CANNOT_EMPTY = "Job Name can not empty";

    protected QuartzQueryService quartzQueryService = SpringContext.getBean(QuartzQueryService.class);

    protected QuartzOperateService quartzOperateService = SpringContext.getBean(QuartzOperateService.class);

    @Override
    public ActionForward init(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                              HttpServletResponse response) throws Exception {

        return mapping.getInputForward();
    }

    public ActionForward getJobDetail(ActionMapping mapping, QuartzJobForm form, HttpServletRequest request,
                                      HttpServletResponse response) throws Exception {

        Map<String, Object> params = new HashMap<>();
        params.put(SCHED_NAME, request.getParameter(SCHED_NAME));
        params.put(JOB_NAME, request.getParameter(JOB_NAME));
        params.put(JOB_GROUP, request.getParameter(JOB_GROUP));
        params.put(TRIGGER_NAME, request.getParameter(TRIGGER_NAME));
        params.put(TRIGGER_GROUP, request.getParameter(TRIGGER_GROUP));
        JobInfoDto jobInfoDto = quartzQueryService.getJobDetail(params);
        if (ObjectUtils.isEmpty(jobInfoDto)) {
            return mapping.getInputForward();
        }

        request.setAttribute(SCHED_NAME, jobInfoDto.getSchedName());
        request.setAttribute(JOB_NAME, jobInfoDto.getJobName());
        request.setAttribute(JOB_GROUP, jobInfoDto.getJobGroup());

        if (ObjectUtils.isEmpty(jobInfoDto.getTriggerInfo())) {
            return mapping.getInputForward();
        }
        TriggerInfoDto triggerInfoDto = jobInfoDto.getTriggerInfo();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        request.setAttribute(TRIGGER_NAME, triggerInfoDto.getName());
        request.setAttribute(TRIGGER_GROUP, triggerInfoDto.getTriggerGroup());
        request.setAttribute("cronExpression", triggerInfoDto.getCronExpression());
        request.setAttribute("nextFireTime", sdf.format(triggerInfoDto.getNextFireTime()));
        request.setAttribute("previousFireTime", sdf.format(triggerInfoDto.getPreviousFireTime()));
        request.setAttribute("priority", triggerInfoDto.getPriority());
        request.setAttribute("triggerState", triggerInfoDto.getTriggerState());
        request.setAttribute("triggerType", triggerInfoDto.getTriggerType());
        request.setAttribute("startTime", sdf.format(triggerInfoDto.getStartTime()));
        request.setAttribute("endTime", sdf.format(triggerInfoDto.getEndTime()));
        request.setAttribute("triggerInfo", triggerInfoDto);
        return mapping.findForward("getJobDetail");
    }

    /**
     * @param params
     * @return
     * @throws Exception
     */
    public Map<String, Object> queryJobInfos(Map<String, Object> params) throws Exception {
        Page page = quartzQueryService.queryJobInfos(params);
        Map<String, Object> result = new HashMap<>();
        result.put("results", page.getResults());
        result.put("totalCount", page.getTotalItems());
        return result;
    }

    /**
     * 即执行一次
     *
     * @param params
     */
    public void fireNow(Map<String, Object> params) {
        String jobName = MapUtils.getString(params, JOB_NAME);
        Map<String, Object> jobDataMap = MapUtils.getMap(params, "jobDataMap");
        if (StringUtils.isEmpty(jobName)) {
            Errors.create().key(MessageIdList.QUARTZ_EMPTY_JOB_NAME).content(JOB_NAME_CANNOT_EMPTY).build();
        }
        if (MapUtils.isEmpty(jobDataMap)) {
            jobDataMap = new HashMap<>();
        }
        quartzOperateService.fireNow(jobName, jobDataMap);
    }


    /**
     * 暂停定时任务
     *
     * @param params
     */
    public void pauseJob(Map<String, Object> params) {
        String jobName = MapUtils.getString(params, JOB_NAME);
        if (StringUtils.isEmpty(jobName)) {
            Errors.create().key(MessageIdList.QUARTZ_EMPTY_JOB_NAME).content(JOB_NAME_CANNOT_EMPTY).build();
        }
        quartzOperateService.stopJob(jobName);
    }

    /**
     * 启动任务
     *
     * @param params
     */
    public void resumeJob(Map<String, Object> params) {
        String jobName = MapUtils.getString(params, JOB_NAME);
        if (StringUtils.isEmpty(jobName)) {
            Errors.create().key(MessageIdList.QUARTZ_EMPTY_JOB_NAME).content(JOB_NAME_CANNOT_EMPTY).build();
        }
        quartzOperateService.startJob(jobName);
    }


    /**
     * 调整调度规则(corn表达式)
     *
     * @param
     */
    public Map<String, Object> updateJobCron(Map<String, Object> params) {
        String jobName = MapUtils.getString(params, JOB_NAME);
        String triggerName = MapUtils.getString(params, TRIGGER_NAME);
        String cronExpression = MapUtils.getString(params, "cronExpression");
        Map<String, Object> results = new HashMap<>();
        StringBuilder errorMsg = new StringBuilder();
        if (StringUtils.isEmpty(jobName)) {
            errorMsg.append(I18nUtils.getMessage(MessageIdList.QUARTZ_EMPTY_JOB_NAME));
        }
        if (StringUtils.isEmpty(triggerName)) {
            errorMsg.append(I18nUtils.getMessage(MessageIdList.QUARTZ_EMPTY_TRIGGER_NAME));
        }
        if (StringUtils.isEmpty(cronExpression)) {
            errorMsg.append(I18nUtils.getMessage(MessageIdList.QUARTZ_EMPTY_CRON_EXPRESSION));
        }

        if (StringUtils.isNotBlank(errorMsg.toString())) {
            results.put("msg", errorMsg.toString());
            results.put("success", false);
            return results;
        }

        quartzOperateService.update(triggerName, cronExpression, jobName);
        results.put("success", true);
        return results;
    }

    public Map<String, Object> queryJobRecordWhereJobKey(HttpServletRequest request,
                                                         Map<String, Object> params) throws Exception {
        Page page = quartzQueryService.queryJobRecordWhereJobKey(params);
        Map<String, Object> result = new HashMap<>();
        result.put("results", page.getResults());
        result.put("totalCount", page.getTotalItems());
        return result;
    }


    /**
     * 获取任务状态下拉框数据
     * 类表: $$QUARTZ_JOB_STATUS
     *
     * @return
     */
    public List<Map<String, Object>> getComboboxData4JobStatus() {
        List<Map<String, Object>> list = new ArrayList<>();
        List<ReferenceFileDetail> details = getReferenceFileDetails("$$QUARTZ_JOB_STATUS");
        for (ReferenceFileDetail rfd : details) {
            Map<String, Object> combo = new HashMap<>(2);
            combo.put("key", rfd.getKey1Value());
            combo.put("value", rfd.getData1Value());
            list.add(combo);
        }
        Map<String, Object> combo = new HashMap<>(2);
        combo.put("key", "ALL");
        combo.put("value", "ALL");
        list.add(combo);
        return list;
    }

}