Java CronExpression.isValidExpression方法代码示例

import org.quartz.CronExpression; //导入方法依赖的package包/类
private VmSchedule checkAndSaveSchedule(final VmScheduleVo schedule, final VmSchedule entity) {
	// Check the subscription is visible
	final Subscription subscription = subscriptionResource.checkVisibleSubscription(schedule.getSubscription());

	if (schedule.getCron().split(" ").length == 6) {
		// Add the missing "seconds" part
		schedule.setCron(schedule.getCron() + " *");
	}
	// Check expressions first
	if (!CronExpression.isValidExpression(schedule.getCron())) {
		throw new ValidationJsonException("cron", "vm-cron");
	}

	// Every second is not accepted
	if (schedule.getCron().startsWith("* ")) {
		throw new ValidationJsonException("cron", "vm-cron-second");
	}

	entity.setSubscription(subscription);
	entity.setOperation(schedule.getOperation());
	entity.setCron(schedule.getCron());

	// Persist the new schedules for each provided CRON
	vmScheduleRepository.saveAndFlush(entity);
	return entity;
}
 

import org.quartz.CronExpression; //导入方法依赖的package包/类
@RequestMapping("withoutAuth/validateCron.html")
@ResponseBody
public Object validateCronExpression(String cronExpression){
	try
	{
		boolean result = CronExpression.isValidExpression(cronExpression);
		if(result)
		{
			return true;
		}else
		{
			return false;
		}
	}catch(Exception e)
	{
		throw new AjaxException(e);
	}
}
 

import org.quartz.CronExpression; //导入方法依赖的package包/类
/**
 * Register cron job REST API
 * @param message - JSON with cron expressions.
 * @return JSON with status.OK
 * @throws IOException, IllegalArgumentException
 */
@POST
@Path("cron/{notebookId}")
public Response registerCronJob(@PathParam("notebookId") String notebookId, String message) throws
    IOException, IllegalArgumentException {
  LOG.info("Register cron job note={} request cron msg={}", notebookId, message);

  CronRequest request = gson.fromJson(message,
                        CronRequest.class);
  
  Note note = notebook.getNote(notebookId);
  if (note == null) {
    return new JsonResponse<>(Status.NOT_FOUND, "note not found.").build();
  }
  
  if (!CronExpression.isValidExpression(request.getCronString())) {
    return new JsonResponse<>(Status.BAD_REQUEST, "wrong cron expressions.").build();
  }

  Map<String, Object> config = note.getConfig();
  config.put("cron", request.getCronString());
  note.setConfig(config);
  notebook.refreshCron(note.id());
  
  return new JsonResponse<>(Status.OK).build();
}
 

import org.quartz.CronExpression; //导入方法依赖的package包/类
/**
 * Register cron job REST API
 *
 * @param message - JSON with cron expressions.
 * @return JSON with status.OK
 * @throws IOException, IllegalArgumentException
 */
@POST
@Path("cron/{noteId}")
@ZeppelinApi
public Response registerCronJob(@PathParam("noteId") String noteId, String message)
    throws IOException, IllegalArgumentException {
  LOG.info("Register cron job note={} request cron msg={}", noteId, message);

  CronRequest request = CronRequest.fromJson(message);

  Note note = notebook.getNote(noteId);
  checkIfNoteIsNotNull(note);
  checkIfUserCanRun(noteId, "Insufficient privileges you cannot set a cron job for this note");

  if (!CronExpression.isValidExpression(request.getCronString())) {
    return new JsonResponse<>(Status.BAD_REQUEST, "wrong cron expressions.").build();
  }

  Map<String, Object> config = note.getConfig();
  config.put("cron", request.getCronString());
  note.setConfig(config);
  notebook.refreshCron(note.getId());

  return new JsonResponse<>(Status.OK).build();
}
 

import org.quartz.CronExpression; //导入方法依赖的package包/类
/**
 * Register cron job REST API
 *
 * @param message - JSON with cron expressions.
 * @return JSON with status.OK
 * @throws IOException, IllegalArgumentException
 */
@POST
@Path("cron/{noteId}")
public Response registerCronJob(@PathParam("noteId") String noteId, String message)
        throws IOException, IllegalArgumentException {
  LOG.info("Register cron job note={} request cron msg={}", noteId, message);

  CronRequest request = CronRequest.fromJson(message);

  Note note = notebook.getNote(noteId);
  checkIfNoteIsNotNull(note);
  checkIfUserCanWrite(noteId, "Insufficient privileges you cannot set a cron job for this note");

  if (!CronExpression.isValidExpression(request.getCronString())) {
    return new JsonResponse<>(Status.BAD_REQUEST, "wrong cron expressions.").build();
  }

  Map<String, Object> config = note.getConfig();
  config.put("cron", request.getCronString());
  note.setConfig(config);
  notebook.refreshCron(note.getId());

  return new JsonResponse<>(Status.OK).build();
}
 

import org.quartz.CronExpression; //导入方法依赖的package包/类
/**
 * update alert config's cron and activation by id
 * @param id alert config id
 * @param cron cron expression for alert
 * @param isActive activate or not
 * @return Response
 * @throws Exception
 */
@PUT
@Path("/alert/{id}")
public Response updateAlertConfig(@NotNull @PathParam("id") Long id,
    @QueryParam("cron") String cron, @QueryParam("isActive") Boolean isActive) throws Exception {

  AlertConfigDTO alert = alertDAO.findById(id);
  if (alert == null) {
    throw new IllegalStateException("Alert Config with id " + id + " does not exist");
  }

  if (isActive != null) {
    alert.setActive(isActive);
  }

  if (StringUtils.isNotEmpty(cron)) {
    // validate cron
    if (!CronExpression.isValidExpression(cron)) {
      throw new IllegalArgumentException("Invalid cron expression for cron : " + cron);
    }
    alert.setCronExpression(cron);
  }

  alertDAO.update(alert);
  return Response.ok(id).build();
}
 

import org.quartz.CronExpression; //导入方法依赖的package包/类
/**
 * update alert config's holiday cron and activation by id
 * if this cron is not null then holiday mode is activate
 * @param id id of the config
 * @param cron holiday cron expression
 * @return Response
 * @throws Exception
 */
@PUT
@Path("/alert/{id}/holiday-mode")
public Response updateAlertConfigHolidayCron(@NotNull @PathParam("id") Long id,
    @QueryParam("cron") String cron) throws Exception {

  AlertConfigDTO alert = alertDAO.findById(id);
  if (alert == null) {
    throw new IllegalStateException("Alert Config with id " + id + " does not exist");
  }

  if (StringUtils.isNotEmpty(cron)) {
    // validate cron
    if (!CronExpression.isValidExpression(cron)) {
      throw new IllegalArgumentException("Invalid cron expression for cron : " + cron);
    }
    // as long as there is an valid holiday cron expression within the class
    // the holiday model is activate
    alert.setHolidayCronExpression(cron);
  } else {
    alert.setHolidayCronExpression(null);  // equivalent to deactivate holiday
  }

  alertDAO.update(alert);
  return Response.ok(id).build();
}
 

import org.quartz.CronExpression; //导入方法依赖的package包/类
/**
 * 校验cron表达式
 * @param unexpected
 * @param message
 */
public static void isCronExpression(String unexpected, String message) {
    boolean validExpression = CronExpression.isValidExpression(unexpected);
    if (!validExpression) {
        throw new IllegalArgumentException(message);
    }
}
 

import org.quartz.CronExpression; //导入方法依赖的package包/类
@RequestMapping(value = "exp.do",method= RequestMethod.POST)
@ResponseBody
public boolean validateCronExp(Integer cronType, String cronExp) {
    boolean pass = false;
    if (cronType == 0) pass = SchedulingPattern.validate(cronExp);
    if (cronType == 1) pass = CronExpression.isValidExpression(cronExp);
    return pass;
}
 

import org.quartz.CronExpression; //导入方法依赖的package包/类
public static JSONObject validate(InputDataConfig inputDataConfig) {
	JSONObject response = new JSONObject();

	if (inputDataConfig.getReportAccess().getMailReport().getMailList().size() == 0) {
		response.put(Constants.STATUS_CODE, 0);
		response.put(Constants.STATUS_MESSAGE, "Enter atleast 1 E-Mail ID");
		return response;
	}

	List<String> mailIDList = inputDataConfig.getReportAccess().getMailReport().getMailList();

	for (String mailID : mailIDList) {
		try {
			InternetAddress emailAddr = new InternetAddress(mailID);
			emailAddr.validate();
		} catch (AddressException e) {
			response.put(Constants.STATUS_CODE, 0);
			response.put(Constants.STATUS_MESSAGE, mailID + " is not a valid E-Mail ID");
			return response;
		}
	}

	if (inputDataConfig.getReportAccess().isScheduleReportEnabled()) {
		List<String> cronExpressionList = inputDataConfig.getReportAccess().getScheduleReport().getCronExpressionList();
		for (String cronExpression : cronExpressionList) {
			if (!CronExpression.isValidExpression(cronExpression)) {
				response.put(Constants.STATUS_CODE, 0);
				response.put(Constants.STATUS_MESSAGE, "CRON expression " + cronExpression + "is invalid");
				return response;
			}
		}
	}

	response.put(Constants.STATUS_CODE, 1);
	return response;
}
 

import org.quartz.CronExpression; //导入方法依赖的package包/类
@Mapping("/check/cron")
@Jsonp
@ResponseReturn(contentType = ResponseReturnType.TEXT_JAVASCRIPT)
public String validateCron(WebAttributers was) {
	String cronExpr = was.get(StaticDict.PAGE_PARAM_TASK_TRIGGER_CRON_EXPR);
	ProcessLogger.debug("validating cron expression:" + cronExpr);
	if (CronExpression.isValidExpression(cronExpr)) {
		return OperationJson.build().sucess().toString();
	}
	return OperationJson.build().error().toString();
}
 

import org.quartz.CronExpression; //导入方法依赖的package包/类
/**
 * Create a new cron job and register it with the job scheduler. Parameters (cron expression and eval states) are read from the
 * values updated in the request.
 *  
 * @return true if the method successfully scheduled the cron job, and false if some error prevented the cron job from being scheduled.
 */
protected boolean scheduleCronJob() {
	boolean error = false;
	if(cronExpression == null || cronExpression.trim().equals("")) { 
		//messages.addMessage(new TargettedMessage("administrate.sync.cronExpression.null", null, TargettedMessage.SEVERITY_ERROR));
		error = true;
		
	} else if(! CronExpression.isValidExpression(cronExpression)) {
		// send an error message through targeted messages
		//messages.addMessage(new TargettedMessage("administrate.sync.cronExpression.err", new Object[]{ cronExpression.trim() }, TargettedMessage.SEVERITY_ERROR));
		error = true;
	} 

	String states = null;
	if(! error) {
		
		states = getStateValues();
		if(states == null || states.trim().equals("")) {
			//messages.addMessage(new TargettedMessage("administrate.sync.stateList.null", null, TargettedMessage.SEVERITY_ERROR));
			error = true;
		}
	}

	if(! error){
		Map<String,String> dataMap = new HashMap<>();
		String uniqueId = EvalUtils.makeUniqueIdentifier(99);
		dataMap.put(EvalConstants.CRON_SCHEDULER_TRIGGER_NAME, uniqueId);
		dataMap.put(EvalConstants.CRON_SCHEDULER_TRIGGER_GROUP, JOB_GROUP_NAME);
		dataMap.put(EvalConstants.CRON_SCHEDULER_JOB_NAME, uniqueId);
		dataMap.put(EvalConstants.CRON_SCHEDULER_JOB_GROUP, JOB_GROUP_NAME);
		
		dataMap.put(EvalConstants.CRON_SCHEDULER_CRON_EXPRESSION, this.cronExpression);
		
		dataMap.put(EvalConstants.CRON_SCHEDULER_SPRING_BEAN_NAME, GroupMembershipSync.GROUP_MEMBERSHIP_SYNC_BEAN_NAME);
		dataMap.put(GroupMembershipSync.GROUP_MEMBERSHIP_SYNC_PROPNAME_STATE_LIST, states);

		commonLogic.scheduleCronJob("org.sakaiproject.api.app.scheduler.JobBeanWrapper.GroupMembershipSync", dataMap);
	}
	return !error;
}
 

import org.quartz.CronExpression; //导入方法依赖的package包/类
public static void verifyBaseReplicationRequest(ReplicationBaseDescriptor replication) {
    if (StringUtils.isBlank(replication.getCronExp())) {
        throw new BadRequestException("cronExp is required");
    }
    if (!CronExpression.isValidExpression(replication.getCronExp())) {
        throw new BadRequestException("Invalid cronExp");
    }
}
 

import org.quartz.CronExpression; //导入方法依赖的package包/类
/**
 * Validates if the given {@code job} has cron expression, motech event and start date fields set.
 *
 * @param job  the job to be validated
 */
public static void validateCronSchedulableJob(CronSchedulableJob job) {
    notNull(job, JOB_CANNOT_BE_NULL);
    notEmpty(job.getCronExpression(), "Cron expression cannot be null or empty!");
    notNull(job.getMotechEvent(), MOTECH_EVENT_CANNOT_BE_NULL);

    if (!CronExpression.isValidExpression(job.getCronExpression())) {
        throw new MotechSchedulerException(format("Can not schedule job. Invalid Cron expression: %s",
                job.getCronExpression()),
                "scheduler.error.invalidCronExpression", Arrays.asList(job.getCronExpression()));
    }

    validateEndDate(job);
}
 

import org.quartz.CronExpression; //导入方法依赖的package包/类
public CronExpressionUtil(String expression) {
    if (!CronExpression.isValidExpression(expression)) {
        throw new CronExpressionException(expression);
    }

    String[] parts = expression.split(" ");

    time = new Time(Integer.valueOf(parts[2]), Integer.valueOf(parts[1]));

    daysOfWeek = new ArrayList<>();
    for (String part : parts[5].split(",")) {
        daysOfWeek.add(DayOfWeek.getDayOfWeek(getDayOfWeekValue(part)));
    }
}