content: package com.xxl.job.admin.controller;
  
  import com.xxl.job.admin.core.cron.CronExpression;
  import com.xxl.job.admin.core.exception.XxlJobException;
  import com.xxl.job.admin.core.model.XxlJobGroup;
  import com.xxl.job.admin.core.model.XxlJobInfo;
  import com.xxl.job.admin.core.model.XxlJobUser;
  import com.xxl.job.admin.core.route.ExecutorRouteStrategyEnum;
  import com.xxl.job.admin.core.thread.JobTriggerPoolHelper;
  import com.xxl.job.admin.core.trigger.TriggerTypeEnum;
  import com.xxl.job.admin.core.util.I18nUtil;
  import com.xxl.job.admin.dao.XxlJobGroupDao;
  import com.xxl.job.admin.service.LoginService;
  import com.xxl.job.admin.service.XxlJobService;
  import com.xxl.job.core.biz.model.ReturnT;
  import com.xxl.job.core.enums.ExecutorBlockStrategyEnum;
  import com.xxl.job.core.glue.GlueTypeEnum;
  import com.xxl.job.core.util.DateUtil;
  import org.springframework.stereotype.Controller;
  import org.springframework.ui.Model;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RequestParam;
  import org.springframework.web.bind.annotation.ResponseBody;
  
  import javax.annotation.Resource;
  import javax.servlet.http.HttpServletRequest;
  import java.text.ParseException;
  import java.util.*;
  
  /**
   * index controller
   *
   * @author xuxueli 2015-12-19 16:13:16
   */
  @Controller
  @RequestMapping("/jobinfo")
  public class JobInfoController {
  
      @Resource
      private XxlJobGroupDao xxlJobGroupDao;
      @Resource
      private XxlJobService xxlJobService;
  
      @RequestMapping
      public String index(HttpServletRequest request, Model model, @RequestParam(required = false, defaultValue = "-1") int jobGroup) {
  
          // 枚举-字典
          model.addAttribute("ExecutorRouteStrategyEnum", ExecutorRouteStrategyEnum.values());        // 路由策略-列表
          model.addAttribute("GlueTypeEnum", GlueTypeEnum.values());                                // Glue类型-字典
          model.addAttribute("ExecutorBlockStrategyEnum", ExecutorBlockStrategyEnum.values());        // 阻塞处理策略-字典
  
          // 执行器列表
          List<XxlJobGroup> jobGroupList_all = xxlJobGroupDao.findAll();
  
          // filter group
          List<XxlJobGroup> jobGroupList = filterJobGroupByRole(request, jobGroupList_all);
          if (jobGroupList == null || jobGroupList.size() == 0) {
              throw new XxlJobException(I18nUtil.getString("jobgroup_empty"));
          }
  
          model.addAttribute("JobGroupList", jobGroupList);
          model.addAttribute("jobGroup", jobGroup);
  
          return "jobinfo/jobinfo.index";
      }
  
      public static List<XxlJobGroup> filterJobGroupByRole(HttpServletRequest request, List<XxlJobGroup> jobGroupList_all) {
          List<XxlJobGroup> jobGroupList = new ArrayList<>();
          if (jobGroupList_all != null && jobGroupList_all.size() > 0) {
              XxlJobUser loginUser = (XxlJobUser) request.getAttribute(LoginService.LOGIN_IDENTITY_KEY);
              if (loginUser.getRole() == 1) {
                  jobGroupList = jobGroupList_all;
              } else {
                  List<String> groupIdStrs = new ArrayList<>();
                  if (loginUser.getPermission() != null && loginUser.getPermission().trim().length() > 0) {
                      groupIdStrs = Arrays.asList(loginUser.getPermission().trim().split(","));
                  }
                  for (XxlJobGroup groupItem : jobGroupList_all) {
                      if (groupIdStrs.contains(String.valueOf(groupItem.getId()))) {
                          jobGroupList.add(groupItem);
                      }
                  }
              }
          }
          return jobGroupList;
      }
  
      public static void validPermission(HttpServletRequest request, int jobGroup) {
          XxlJobUser loginUser = (XxlJobUser) request.getAttribute(LoginService.LOGIN_IDENTITY_KEY);
          if (!loginUser.validPermission(jobGroup)) {
              throw new RuntimeException(I18nUtil.getString("system_permission_limit") + "[username=" + loginUser.getUsername() + "]");
          }
      }
  
      @RequestMapping("/pageList")
      @ResponseBody
      public Map<String, Object> pageList(@RequestParam(required = false, defaultValue = "0") int start,
                                          @RequestParam(required = false, defaultValue = "10") int length, Integer id,
                                          Integer jobGroup, Integer triggerStatus, String jobDesc, String executorHandler, String author) {
  
          return xxlJobService.pageList(start, length, id, jobGroup, triggerStatus, jobDesc, executorHandler, author);
      }
  
      @RequestMapping("/add")
      @ResponseBody
      public ReturnT<String> add(XxlJobInfo jobInfo) {
          return xxlJobService.add(jobInfo);
      }
  
      @RequestMapping("/update")
      @ResponseBody
      public ReturnT<String> update(XxlJobInfo jobInfo) {
          return xxlJobService.update(jobInfo);
      }
  
      @RequestMapping("/remove")
      @ResponseBody
      public ReturnT<String> remove(int id) {
          return xxlJobService.remove(id);
      }
  
      @RequestMapping("/stop")
      @ResponseBody
      public ReturnT<String> pause(int id) {
          return xxlJobService.stop(id);
      }
  
      @RequestMapping("/start")
      @ResponseBody
      public ReturnT<String> start(int id) {
          return xxlJobService.start(id);
      }
  
      @RequestMapping("/trigger")
      @ResponseBody
      //@PermissionLimit(limit = false)
      public ReturnT<String> triggerJob(int id, String executorParam, String addressList) {
          // force cover job param
          if (executorParam == null) {
              executorParam = "";
          }
  
          JobTriggerPoolHelper.trigger(id, TriggerTypeEnum.MANUAL, -1, null, executorParam, addressList);
          return ReturnT.SUCCESS;
      }
  
      @RequestMapping("/nextTriggerTime")
      @ResponseBody
      public ReturnT<List<String>> nextTriggerTime(String cron) {
          List<String> result = new ArrayList<>();
          try {
              CronExpression cronExpression = new CronExpression(cron);
              Date lastTime = new Date();
              for (int i = 0; i < 5; i++) {
                  lastTime = cronExpression.getNextValidTimeAfter(lastTime);
                  if (lastTime != null) {
                      result.add(DateUtil.formatDateTime(lastTime));
                  } else {
                      break;
                  }
              }
          } catch (ParseException e) {
              return new ReturnT<List<String>>(ReturnT.FAIL_CODE, I18nUtil.getString("jobinfo_field_cron_unvalid"));
          }
          return new ReturnT<List<String>>(result);
      }
  
  }
  