private List<Object[]> buildStepExecutionParameters(StepExecution stepExecution) {
   Assert.isNull(
       stepExecution.getId(),
       "to-be-saved (not updated) StepExecution can't already have an id assigned");
   Assert.isNull(
       stepExecution.getVersion(),
       "to-be-saved (not updated) StepExecution can't already have a version assigned");
   validateStepExecution(stepExecution);
   stepExecution.setId(stepExecutionIncrementer.nextLongValue());
   stepExecution.incrementVersion(); // Should be 0
   List<Object[]> parameters = new ArrayList<Object[]>();
   String exitDescription =
       truncateExitDescription(stepExecution.getExitStatus().getExitDescription());
   Object[] parameterValues =
       new Object[] {
         stepExecution.getId(),
         stepExecution.getVersion(),
         stepExecution.getStepName(),
         stepExecution.getJobExecutionId(),
         stepExecution.getStartTime(),
         stepExecution.getEndTime(),
         stepExecution.getStatus().toString(),
         stepExecution.getCommitCount(),
         stepExecution.getReadCount(),
         stepExecution.getFilterCount(),
         stepExecution.getWriteCount(),
         stepExecution.getExitStatus().getExitCode(),
         exitDescription,
         stepExecution.getReadSkipCount(),
         stepExecution.getWriteSkipCount(),
         stepExecution.getProcessSkipCount(),
         stepExecution.getRollbackCount(),
         stepExecution.getLastUpdated()
       };
   Integer[] parameterTypes =
       new Integer[] {
         Types.BIGINT,
         Types.INTEGER,
         Types.VARCHAR,
         Types.BIGINT,
         Types.TIMESTAMP,
         Types.TIMESTAMP,
         Types.VARCHAR,
         Types.INTEGER,
         Types.INTEGER,
         Types.INTEGER,
         Types.INTEGER,
         Types.VARCHAR,
         Types.VARCHAR,
         Types.INTEGER,
         Types.INTEGER,
         Types.INTEGER,
         Types.INTEGER,
         Types.TIMESTAMP
       };
   parameters.add(0, Arrays.copyOf(parameterValues, parameterValues.length));
   parameters.add(1, Arrays.copyOf(parameterTypes, parameterTypes.length));
   return parameters;
 }
 /**
  * Configure a base URL to prepend URI templates with. The base URL must have a scheme and host
  * but may optionally contain a port and a path. The base URL must be fully expanded and encoded
  * which can be done via {@link UriComponentsBuilder}.
  *
  * @param baseUrl the base URL.
  */
 public void setBaseUrl(String baseUrl) {
   if (baseUrl != null) {
     UriComponents uriComponents = UriComponentsBuilder.fromUriString(baseUrl).build();
     Assert.hasText(uriComponents.getScheme(), "'baseUrl' must have a scheme");
     Assert.hasText(uriComponents.getHost(), "'baseUrl' must have a host");
     Assert.isNull(uriComponents.getQuery(), "'baseUrl' cannot have a query");
     Assert.isNull(uriComponents.getFragment(), "'baseUrl' cannot have a fragment");
   }
   this.baseUrl = baseUrl;
 }
  public void create(Project project) {
    Assert.isNull(
        projectService.findProject(project.getName()),
        "project  [" + project.getName() + "] has exist");
    MongoTemplate template = project.fetchMongoTemplate();
    Assert.notNull(template, "mongo uri is not access");
    Assert.notNull(template.getDb(), "mongo uri is not access");
    Assert.isTrue(
        project.fetchMongoTemplate().collectionExists(project.getLogCollection()),
        " [" + project.getLogCollection() + "] 日志表不存在");
    try {
      List<Task> taskList = Lists.newArrayList();
      logger.debug("init task count:{}", project.getTasks().size());
      for (Task _task : project.getTasks()) {

        Task task = getTemplateTask(_task);
        Task tempTask = renderTemplateTask(task, project);
        if (tempTask != null) taskList.add(tempTask);
      }
      project.setTasks(taskList);
    } catch (Exception e) {
      logger.error("", e);
      throw new IllegalArgumentException("自动添加监控脚本错误:" + e.getMessage());
    }
    projectService.saveProject(project);
  }
  /**
   * Bind the given resource for the given key to the current thread.
   *
   * @param key the key to bind the value to (usually the resource factory)
   * @param value the value to bind (usually the active resource object)
   * @throws IllegalStateException if there is already a value bound to the thread
   */
  public static void bind(Object key, Object value) {
    Assert.notNull(value, "Value must not be null");
    Map<Object, Object> map = resources.get();
    // set ThreadLocal Map if none found
    if (map == null) {
      map = new HashMap<Object, Object>();
      resources.set(map);
    }
    Object oldValue = map.put(key, value);
    Assert.isNull(
        oldValue,
        "Already value ["
            + oldValue
            + "] for key ["
            + key
            + "] bound to thread ["
            + Thread.currentThread().getName()
            + "]");

    if (logger.isTraceEnabled()) {
      logger.trace(
          "Bound value ["
              + value
              + "] for key ["
              + key
              + "] to thread ["
              + Thread.currentThread().getName()
              + "]");
    }
  }
 public FileWritingMessageHandlerSpec fileNameExpression(String fileNameExpression) {
   Assert.isNull(
       this.fileNameGenerator,
       "'fileNameGenerator' and 'fileNameGeneratorExpression' are mutually exclusive.");
   this.defaultFileNameGenerator = new DefaultFileNameGenerator();
   this.defaultFileNameGenerator.setExpression(fileNameExpression);
   return fileNameGenerator(this.defaultFileNameGenerator);
 }
 @Transactional
 @Rollback(true)
 @Test
 public void testDeleteEventHandler() {
   EventHandler eventHandlerTest = eventService.getEventHandlerById(NUMBER_ONE);
   Assert.isTrue(eventHandlerTest.getEventHandlerName().equals("Users data import"));
   eventService.deleteEventHandlerById(NUMBER_ONE);
   EventHandler eventHandlerTestNew = eventService.getEventHandlerById(NUMBER_ONE);
   Assert.isNull(eventHandlerTestNew);
 }
 @Test
 @Transactional
 public void testHydratedCanvasForNonExistenceCanvas() throws Exception {
   Canvas canvas = null;
   try {
     canvas = this.uIService.getHydratedCanvas(30000L);
   } catch (Exception e) {
     Assert.isNull(canvas, "Canvas Shouldn't Exist for CanvasId 30000");
   }
 }
 @Transactional
 @Rollback(true)
 @Test
 public void testDeleteEvent() {
   Event eventTest = eventService.getEventById(NUMBER_ONE);
   Assert.isTrue(
       eventTest.getEventDescription().equals("Import user details to the lucas system"));
   eventService.deleteEventById(eventTest.getEventId());
   Event eventTestNew = eventService.getEventById(NUMBER_ONE);
   Assert.isNull(eventTestNew);
 }
 @Test
 @Transactional
 public void testOpenCanvasesForNonExistenceUser() throws Exception {
   List<OpenUserCanvas> openUserCanvases = null;
   try {
     openUserCanvases = this.uIService.getAllOpenCanvasForUser(99999L);
   } catch (Exception e) {
     Assert.isNull(
         openUserCanvases, "User have OpenCanvas , Open Canvas is not Null for User Annonimus ");
   }
 }
Exemple #10
0
  // ref: 18.3
  public void assignToClerkManual(Clerk clerk, Order order) {
    Assert.notNull(clerk);
    Assert.isTrue(clerk.getId() != 0);
    Assert.notNull(order);
    Assert.isTrue(order.getId() != 0);
    Assert.isNull(order.getClerk());

    order.setClerk(clerk);

    this.save(order);
  }
 @Transactional(propagation = Propagation.REQUIRED)
 public Ficha cancelarDeposito(final String fichaId) {
   Ficha bean = (Ficha) getHibernateTemplate().get(Ficha.class, fichaId);
   Assert.isNull(
       bean.getCorte(), "La ficha ya ha sido contabilizada en un ingreso al sistema de bancos");
   if (bean.getPartidas().size() == 0) return bean;
   bean.getPartidas().clear();
   bean.setComentario("CANCELADO");
   bean.setCancelada(new Date());
   bean.getImporte();
   return save(bean);
 }
Exemple #12
0
  // req: 16.1
  public void cancelOrder(Order order) {
    Assert.notNull(order);
    Assert.isTrue(order.getId() != 0);
    Assert.isTrue(
        order.getConsumer().equals(consumerService.findByPrincipal()),
        "Only the owner can cancel the order");
    Assert.isTrue(order.getCancelMoment() == null, "order.cancel.error.isCancelled");
    Clerk clerk;

    clerk = clerkService.findByOrder(order);

    Assert.isNull(clerk, "Can't remove a order when a clerk has assigned");

    order.setCancelMoment(new Date());
    this.save(order);
  }
  /**
   * Handle document type definition with validation of publicId and systemId.
   *
   * @param received
   * @param source
   * @param validationContext
   * @param namespaceContext
   */
  private void doDocumentTypeDefinition(
      Node received,
      Node source,
      XmlMessageValidationContext validationContext,
      NamespaceContext namespaceContext,
      TestContext context) {

    Assert.isTrue(
        source instanceof DocumentType,
        "Missing document type definition in expected xml fragment");

    DocumentType receivedDTD = (DocumentType) received;
    DocumentType sourceDTD = (DocumentType) source;

    if (log.isDebugEnabled()) {
      log.debug(
          "Validating document type definition: "
              + receivedDTD.getPublicId()
              + " ("
              + receivedDTD.getSystemId()
              + ")");
    }

    if (!StringUtils.hasText(sourceDTD.getPublicId())) {
      Assert.isNull(
          receivedDTD.getPublicId(),
          ValidationUtils.buildValueMismatchErrorMessage(
              "Document type public id not equal",
              sourceDTD.getPublicId(),
              receivedDTD.getPublicId()));
    } else if (sourceDTD.getPublicId().trim().equals(CitrusConstants.IGNORE_PLACEHOLDER)) {
      if (log.isDebugEnabled()) {
        log.debug(
            "Document type public id: '"
                + receivedDTD.getPublicId()
                + "' is ignored by placeholder '"
                + CitrusConstants.IGNORE_PLACEHOLDER
                + "'");
      }
    } else {
      Assert.isTrue(
          StringUtils.hasText(receivedDTD.getPublicId())
              && receivedDTD.getPublicId().equals(sourceDTD.getPublicId()),
          ValidationUtils.buildValueMismatchErrorMessage(
              "Document type public id not equal",
              sourceDTD.getPublicId(),
              receivedDTD.getPublicId()));
    }

    if (!StringUtils.hasText(sourceDTD.getSystemId())) {
      Assert.isNull(
          receivedDTD.getSystemId(),
          ValidationUtils.buildValueMismatchErrorMessage(
              "Document type system id not equal",
              sourceDTD.getSystemId(),
              receivedDTD.getSystemId()));
    } else if (sourceDTD.getSystemId().trim().equals(CitrusConstants.IGNORE_PLACEHOLDER)) {
      if (log.isDebugEnabled()) {
        log.debug(
            "Document type system id: '"
                + receivedDTD.getSystemId()
                + "' is ignored by placeholder '"
                + CitrusConstants.IGNORE_PLACEHOLDER
                + "'");
      }
    } else {
      Assert.isTrue(
          StringUtils.hasText(receivedDTD.getSystemId())
              && receivedDTD.getSystemId().equals(sourceDTD.getSystemId()),
          ValidationUtils.buildValueMismatchErrorMessage(
              "Document type system id not equal",
              sourceDTD.getSystemId(),
              receivedDTD.getSystemId()));
    }

    validateXmlTree(
        received.getNextSibling(),
        source.getNextSibling(),
        validationContext,
        namespaceContext,
        context);
  }
  private Map<String, Map<Class<?>, HandlerMethod>> findHandlerMethodsForTarget(
      final Object targetObject,
      final Class<? extends Annotation> annotationType,
      final String methodName,
      final boolean requiresReply) {

    Map<String, Map<Class<?>, HandlerMethod>> handlerMethods =
        new HashMap<String, Map<Class<?>, HandlerMethod>>();

    final Map<Class<?>, HandlerMethod> candidateMethods = new HashMap<Class<?>, HandlerMethod>();
    final Map<Class<?>, HandlerMethod> candidateMessageMethods =
        new HashMap<Class<?>, HandlerMethod>();
    final Map<Class<?>, HandlerMethod> fallbackMethods = new HashMap<Class<?>, HandlerMethod>();
    final Map<Class<?>, HandlerMethod> fallbackMessageMethods =
        new HashMap<Class<?>, HandlerMethod>();
    final AtomicReference<Class<?>> ambiguousFallbackType = new AtomicReference<Class<?>>();
    final AtomicReference<Class<?>> ambiguousFallbackMessageGenericType =
        new AtomicReference<Class<?>>();
    final Class<?> targetClass = this.getTargetClass(targetObject);
    MethodFilter methodFilter = new UniqueMethodFilter(targetClass);
    ReflectionUtils.doWithMethods(
        targetClass,
        new MethodCallback() {
          @Override
          public void doWith(Method method)
              throws IllegalArgumentException, IllegalAccessException {
            boolean matchesAnnotation = false;
            if (method.isBridge()) {
              return;
            }
            if (isMethodDefinedOnObjectClass(method)) {
              return;
            }
            if (method.getDeclaringClass().equals(Proxy.class)) {
              return;
            }
            if (!Modifier.isPublic(method.getModifiers())) {
              return;
            }
            if (requiresReply && void.class.equals(method.getReturnType())) {
              return;
            }
            if (methodName != null && !methodName.equals(method.getName())) {
              return;
            }
            if (annotationType != null
                && AnnotationUtils.findAnnotation(method, annotationType) != null) {
              matchesAnnotation = true;
            }
            HandlerMethod handlerMethod = null;
            try {
              handlerMethod = new HandlerMethod(method, canProcessMessageList);
            } catch (IneligibleMethodException e) {
              if (logger.isDebugEnabled()) {
                logger.debug(
                    "Method ["
                        + method
                        + "] is not eligible for Message handling "
                        + e.getMessage()
                        + ".");
              }
              return;
            } catch (Exception e) {
              if (logger.isDebugEnabled()) {
                logger.debug("Method [" + method + "] is not eligible for Message handling.", e);
              }
              return;
            }
            Class<?> targetParameterType = handlerMethod.getTargetParameterType();
            if (matchesAnnotation || annotationType == null) {
              if (handlerMethod.isMessageMethod()) {
                if (candidateMessageMethods.containsKey(targetParameterType)) {
                  throw new IllegalArgumentException(
                      "Found more than one method match for type "
                          + "[Message<"
                          + targetParameterType
                          + ">]");
                }
                candidateMessageMethods.put(targetParameterType, handlerMethod);
              } else {
                if (candidateMethods.containsKey(targetParameterType)) {
                  String exceptionMessage = "Found more than one method match for ";
                  if (Void.class.equals(targetParameterType)) {
                    exceptionMessage += "empty parameter for 'payload'";
                  } else {
                    exceptionMessage += "type [" + targetParameterType + "]";
                  }
                  throw new IllegalArgumentException(exceptionMessage);
                }
                candidateMethods.put(targetParameterType, handlerMethod);
              }
            } else {
              if (handlerMethod.isMessageMethod()) {
                if (fallbackMessageMethods.containsKey(targetParameterType)) {
                  // we need to check for duplicate type matches,
                  // but only if we end up falling back
                  // and we'll only keep track of the first one
                  ambiguousFallbackMessageGenericType.compareAndSet(null, targetParameterType);
                }
                fallbackMessageMethods.put(targetParameterType, handlerMethod);
              } else {
                if (fallbackMethods.containsKey(targetParameterType)) {
                  // we need to check for duplicate type matches,
                  // but only if we end up falling back
                  // and we'll only keep track of the first one
                  ambiguousFallbackType.compareAndSet(null, targetParameterType);
                }
                fallbackMethods.put(targetParameterType, handlerMethod);
              }
            }
          }
        },
        methodFilter);

    if (!candidateMethods.isEmpty() || !candidateMessageMethods.isEmpty()) {
      handlerMethods.put(CANDIDATE_METHODS, candidateMethods);
      handlerMethods.put(CANDIDATE_MESSAGE_METHODS, candidateMessageMethods);
      return handlerMethods;
    }
    if ((ambiguousFallbackType.get() != null || ambiguousFallbackMessageGenericType.get() != null)
        && ServiceActivator.class.equals(annotationType)) {
      /*
       * When there are ambiguous fallback methods,
       * a Service Activator can finally fallback to RequestReplyExchanger.exchange(m).
       * Ambiguous means > 1 method that takes the same payload type, or > 1 method
       * that takes a Message with the same generic type.
       */
      List<Method> frameworkMethods = new ArrayList<Method>();
      Class<?>[] allInterfaces =
          org.springframework.util.ClassUtils.getAllInterfacesForClass(targetClass);
      for (Class<?> iface : allInterfaces) {
        try {
          if ("org.springframework.integration.gateway.RequestReplyExchanger"
              .equals(iface.getName())) {
            frameworkMethods.add(targetClass.getMethod("exchange", Message.class));
            if (logger.isDebugEnabled()) {
              logger.debug(
                  targetObject.getClass()
                      + ": Ambiguous fallback methods; using RequestReplyExchanger.exchange()");
            }
          }
        } catch (Exception e) {
          // should never happen (but would fall through to errors below)
        }
      }
      if (frameworkMethods.size() == 1) {
        HandlerMethod handlerMethod =
            new HandlerMethod(frameworkMethods.get(0), canProcessMessageList);
        handlerMethods.put(
            CANDIDATE_METHODS,
            Collections.<Class<?>, HandlerMethod>singletonMap(Object.class, handlerMethod));
        handlerMethods.put(CANDIDATE_MESSAGE_METHODS, candidateMessageMethods);
        return handlerMethods;
      }
    }

    try {
      Assert.state(
          !fallbackMethods.isEmpty() || !fallbackMessageMethods.isEmpty(),
          "Target object of type ["
              + this.targetObject.getClass()
              + "] has no eligible methods for handling Messages.");
    } catch (Exception e) {
      // TODO backward compatibility
      throw new IllegalArgumentException(e.getMessage());
    }

    Assert.isNull(
        ambiguousFallbackType.get(),
        "Found ambiguous parameter type ["
            + ambiguousFallbackType
            + "] for method match: "
            + fallbackMethods.values());
    Assert.isNull(
        ambiguousFallbackMessageGenericType.get(),
        "Found ambiguous parameter type ["
            + ambiguousFallbackMessageGenericType
            + "] for method match: "
            + fallbackMethods.values());

    handlerMethods.put(CANDIDATE_METHODS, fallbackMethods);
    handlerMethods.put(CANDIDATE_MESSAGE_METHODS, fallbackMessageMethods);
    return handlerMethods;
  }
 @Override
 public Integer addApplication(Application application) {
   LOGGER.info("SERVICE: addApplication");
   Assert.isNull(application.getApplicationId(), "Id should be null!");
   return applicationDao.addApplication(application);
 }
 private void assertFormRemoveSuccess() {
   DynaProcessForm fromExpected =
       DynaProcessForm.queryActiveDynaProcessFormByProcessId(PROCESS_ID);
   Assert.isNull(fromExpected);
 }
 /**
  * Registers a TcpSender; for server sockets, used to provide connection information so a sender
  * can be used to reply to incoming messages.
  *
  * @param sender The sender
  */
 public void registerSender(TcpSender sender) {
   Assert.isNull(
       this.sender, this.getClass().getName() + " may only be used by one outbound adapter");
   this.sender = sender;
 }
 /**
  * Registers a TcpListener to receive messages after the payload has been converted from the input
  * data.
  *
  * @param listener the TcpListener.
  */
 public void registerListener(TcpListener listener) {
   Assert.isNull(
       this.listener, this.getClass().getName() + " may only be used by one inbound adapter");
   this.listener = listener;
 }