/** Unit test to check for regression of [JACKSON-18]. */
  public void testSmallNumbers() throws Exception {
    ObjectMapper mapper = new ObjectMapper();
    ArrayNode root = mapper.createArrayNode();
    for (int i = -20; i <= 20; ++i) {
      JsonNode n = root.numberNode(i);
      root.add(n);
      // Hmmh. Not sure why toString() won't be triggered otherwise...
      assertEquals(String.valueOf(i), n.toString());
    }

    // Loop over 2 different serialization methods
    for (int type = 0; type < 2; ++type) {
      StringWriter sw = new StringWriter();
      if (type == 0) {
        JsonGenerator gen = new JsonFactory().createGenerator(sw);
        root.serialize(gen, null);
        gen.close();
      } else {
        mapper.writeValue(sw, root);
      }

      String doc = sw.toString();
      JsonParser p = new JsonFactory().createParser(new StringReader(doc));

      assertEquals(JsonToken.START_ARRAY, p.nextToken());
      for (int i = -20; i <= 20; ++i) {
        assertEquals(JsonToken.VALUE_NUMBER_INT, p.nextToken());
        assertEquals(i, p.getIntValue());
        assertEquals("" + i, p.getText());
      }
      assertEquals(JsonToken.END_ARRAY, p.nextToken());
      p.close();
    }
  }
Beispiel #2
0
  // Processes parameters of javaMethod and enters the proper key-values into the methodNode
  private void processParameters(JavaMethod javaMethod, ObjectNode methodNode) {
    ArrayNode parameters = mapper.createArrayNode();
    methodNode.set("parameters", parameters);
    boolean required = true;

    for (JavaParameter javaParameter : javaMethod.getParameters()) {
      ObjectNode individualParameterNode = mapper.createObjectNode();
      Optional<JavaAnnotation> optional =
          javaParameter
              .getAnnotations()
              .stream()
              .filter(
                  annotation ->
                      annotation.getType().getName().equals(PATH_PARAM)
                          || annotation.getType().getName().equals(QUERY_PARAM))
              .findAny();
      JavaAnnotation pathType = optional.isPresent() ? optional.get() : null;

      String annotationName = javaParameter.getName();

      if (pathType != null) { // the parameter is a path or query parameter
        individualParameterNode.put(
            "name", pathType.getNamedParameter("value").toString().replace("\"", ""));
        if (pathType.getType().getName().equals(PATH_PARAM)) {
          individualParameterNode.put("in", "path");
        } else if (pathType.getType().getName().equals(QUERY_PARAM)) {
          individualParameterNode.put("in", "query");
        }
        individualParameterNode.put("type", getType(javaParameter.getType()));
      } else { // the parameter is a body parameter
        individualParameterNode.put("name", annotationName);
        individualParameterNode.put("in", "body");

        // TODO add actual hardcoded schemas and a type
        // body parameters must have a schema associated with them
        ArrayNode schema = mapper.createArrayNode();
        individualParameterNode.set("schema", schema);
      }
      for (DocletTag p : javaMethod.getTagsByName("param")) {
        if (p.getValue().contains(annotationName)) {
          try {
            String description = p.getValue().split(" ", 2)[1].trim();
            if (description.contains("optional")) {
              required = false;
            }
            individualParameterNode.put("description", description);
          } catch (Exception e) {
            e.printStackTrace();
          }
        }
      }
      individualParameterNode.put("required", required);
      parameters.add(individualParameterNode);
    }
  }
Beispiel #3
0
 public JsonNode toObjectArray(ObjectMapper mapper) throws WampError {
   ArrayNode messageNode = mapper.createArrayNode();
   messageNode.add(ID);
   messageNode.add(requestId);
   if (details != null) messageNode.add(details);
   else messageNode.add(mapper.createObjectNode());
   if (arguments != null) messageNode.add(arguments);
   else if (argumentsKw != null) messageNode.add(mapper.createArrayNode());
   if (argumentsKw != null) messageNode.add(argumentsKw);
   return messageNode;
 }
  protected void createDataAssociation(
      DataAssociation dataAssociation, boolean incoming, Activity activity) {
    String sourceRef = null;
    String targetRef = null;
    if (incoming) {
      sourceRef = dataAssociation.getSourceRef();
      targetRef = activity.getId();

    } else {
      sourceRef = activity.getId();
      targetRef = dataAssociation.getTargetRef();
    }

    ObjectNode flowNode =
        BpmnJsonConverterUtil.createChildShape(
            dataAssociation.getId(), STENCIL_DATA_ASSOCIATION, 172, 212, 128, 212);
    ArrayNode dockersArrayNode = objectMapper.createArrayNode();
    ObjectNode dockNode = objectMapper.createObjectNode();

    dockNode.put(EDITOR_BOUNDS_X, model.getGraphicInfo(sourceRef).getWidth() / 2.0);
    dockNode.put(EDITOR_BOUNDS_Y, model.getGraphicInfo(sourceRef).getHeight() / 2.0);
    dockersArrayNode.add(dockNode);

    if (model.getFlowLocationGraphicInfo(dataAssociation.getId()).size() > 2) {
      for (int i = 1;
          i < model.getFlowLocationGraphicInfo(dataAssociation.getId()).size() - 1;
          i++) {
        GraphicInfo graphicInfo = model.getFlowLocationGraphicInfo(dataAssociation.getId()).get(i);
        dockNode = objectMapper.createObjectNode();
        dockNode.put(EDITOR_BOUNDS_X, graphicInfo.getX());
        dockNode.put(EDITOR_BOUNDS_Y, graphicInfo.getY());
        dockersArrayNode.add(dockNode);
      }
    }

    dockNode = objectMapper.createObjectNode();
    dockNode.put(EDITOR_BOUNDS_X, model.getGraphicInfo(targetRef).getWidth() / 2.0);
    dockNode.put(EDITOR_BOUNDS_Y, model.getGraphicInfo(targetRef).getHeight() / 2.0);
    dockersArrayNode.add(dockNode);
    flowNode.put("dockers", dockersArrayNode);
    ArrayNode outgoingArrayNode = objectMapper.createArrayNode();
    outgoingArrayNode.add(BpmnJsonConverterUtil.createResourceNode(targetRef));
    flowNode.put("outgoing", outgoingArrayNode);
    flowNode.put("target", BpmnJsonConverterUtil.createResourceNode(targetRef));

    ObjectNode propertiesNode = objectMapper.createObjectNode();
    propertiesNode.put(PROPERTY_OVERRIDE_ID, dataAssociation.getId());

    flowNode.put(EDITOR_SHAPE_PROPERTIES, propertiesNode);
    shapesArrayNode.add(flowNode);
  }
Beispiel #5
0
 public JsonNode toObjectArray(ObjectMapper mapper) throws WampError {
   ArrayNode messageNode = mapper.createArrayNode();
   if (details != null) messageNode.add(details);
   else messageNode.add(mapper.createObjectNode());
   messageNode.add(reason.toString());
   return messageNode;
 }
  public void testFromArray() throws Exception {
    ObjectMapper mapper = new ObjectMapper();
    ArrayNode root = mapper.createArrayNode();
    root.add(TEXT1);
    root.add(3);
    ObjectNode obj = root.addObject();
    obj.put(FIELD1, true);
    obj.putArray(FIELD2);
    root.add(false);

    /* Ok, ready... let's serialize using one of two alternate
     * methods: first preferred (using generator)
     * (there are 2 variants here too)
     */
    for (int i = 0; i < 2; ++i) {
      StringWriter sw = new StringWriter();
      if (i == 0) {
        JsonGenerator gen = new JsonFactory().createGenerator(sw);
        root.serialize(gen, null);
        gen.close();
      } else {
        mapper.writeValue(sw, root);
      }
      verifyFromArray(sw.toString());
    }

    // And then convenient but less efficient alternative:
    verifyFromArray(root.toString());
  }
Beispiel #7
0
  // Checks whether javaClass has a path tag associated with it and if it does
  // processes its methods and creates a tag for the class on the root
  void processClass(JavaClass javaClass, ObjectNode paths, ArrayNode tags) {
    // If the class does not have a Path tag then ignore it
    JavaAnnotation annotation = getPathAnnotation(javaClass);
    if (annotation == null) {
      return;
    }

    String path = getPath(annotation);
    if (path == null) {
      return;
    }

    String resourcePath = "/" + path;
    String tagPath = path.isEmpty() ? "/" : path;

    // Create tag node for this class.
    ObjectNode tagObject = mapper.createObjectNode();
    tagObject.put("name", tagPath);
    if (javaClass.getComment() != null) {
      tagObject.put("description", shortText(javaClass.getComment()));
    }
    tags.add(tagObject);

    // Create an array node add to all methods from this class.
    ArrayNode tagArray = mapper.createArrayNode();
    tagArray.add(tagPath);

    processAllMethods(javaClass, resourcePath, paths, tagArray);
  }
  /**
   * Converts partition info into a JSON object.
   *
   * @param partitionInfo partition descriptions
   */
  private JsonNode json(List<PartitionInfo> partitionInfo) {
    ObjectMapper mapper = new ObjectMapper();
    ArrayNode partitions = mapper.createArrayNode();

    // Create a JSON node for each partition
    partitionInfo
        .stream()
        .forEach(
            info -> {
              ObjectNode partition = mapper.createObjectNode();

              // Add each member to the "members" array for this partition
              ArrayNode members = partition.putArray("members");
              info.members().stream().forEach(members::add);

              // Complete the partition attributes and add it to the array
              partition
                  .put("name", info.name())
                  .put("term", info.term())
                  .put("leader", info.leader());
              partitions.add(partition);
            });

    return partitions;
  }
Beispiel #9
0
 public JsonNode toObjectArray(ObjectMapper mapper) throws WampError {
   ArrayNode messageNode = mapper.createArrayNode();
   messageNode.add(ID);
   messageNode.add(requestId);
   messageNode.add(registrationId);
   return messageNode;
 }
Beispiel #10
0
  @Test
  public void testLoadTwoRootObjectsWithNoType() throws JsonProcessingException {
    JsonNode data =
        mapper
            .createArrayNode()
            .add(
                mapper.createObjectNode().put("userId", "1").put("name", "Paul").put("sex", "MALE"))
            .add(
                mapper
                    .createObjectNode()
                    .put("userId", "2")
                    .put("name", "Anna")
                    .put("sex", "FEMALE"));

    Resource result =
        mapper
            .reader()
            .withAttribute(RESOURCE_SET, resourceSet)
            .withAttribute(ROOT_ELEMENT, ModelPackage.Literals.USER)
            .treeToValue(data, Resource.class);

    assertNotNull(result);
    assertEquals(2, result.getContents().size());

    User first = (User) result.getContents().get(0);
    User second = (User) result.getContents().get(1);

    assertEquals("1", first.getUserId());
    assertEquals("Paul", first.getName());
    assertEquals("MALE", first.getSex().getLiteral());

    assertEquals("2", second.getUserId());
    assertEquals("Anna", second.getName());
    assertEquals("FEMALE", second.getSex().getLiteral());
  }
 public ArrayNode toObjectArray(ObjectMapper mapper) {
   ArrayNode messageNode = mapper.createArrayNode();
   messageNode.add(Messages.NOTIFY);
   messageNode.add(method);
   messageNode.add(args);
   return messageNode;
 }
Beispiel #12
0
  @Override
  public void execute() throws MojoExecutionException {
    try {
      JavaProjectBuilder builder = new JavaProjectBuilder();
      builder.addSourceTree(new File(srcDirectory, "src/main/java"));

      ObjectNode root = initializeRoot();
      ArrayNode tags = mapper.createArrayNode();
      ObjectNode paths = mapper.createObjectNode();

      root.set("tags", tags);
      root.set("paths", paths);

      builder.getClasses().forEach(jc -> processClass(jc, paths, tags));

      if (paths.size() > 0) {
        getLog().info("Generating ONOS REST API documentation...");
        genCatalog(root);

        if (!isNullOrEmpty(apiPackage)) {
          genRegistrator();
        }
      }

      project.addCompileSourceRoot(new File(dstDirectory, GEN_SRC).getPath());

    } catch (Exception e) {
      getLog().warn("Unable to generate ONOS REST API documentation", e);
      throw e;
    }
  }
Beispiel #13
0
 private void processConsumesProduces(ObjectNode methodNode, String type, String io) {
   if (!io.equals("")) {
     ArrayNode array = mapper.createArrayNode();
     methodNode.set(type, array);
     array.add(io);
   }
 }
Beispiel #14
0
  @Test
  public void testSaveTwoRootObjectsWithNoType() {
    JsonNode expected =
        mapper
            .createArrayNode()
            .add(mapper.createObjectNode().put("userId", "1").put("name", "Paul"))
            .add(
                mapper
                    .createObjectNode()
                    .put("userId", "2")
                    .put("name", "Anna")
                    .put("sex", "FEMALE"));

    User u1 = ModelFactory.eINSTANCE.createUser();
    u1.setUserId("1");
    u1.setName("Paul");

    User u2 = ModelFactory.eINSTANCE.createUser();
    u2.setUserId("2");
    u2.setName("Anna");
    u2.setSex(Sex.FEMALE);

    Resource resource = new JsonResource(URI.createURI("test"), mapper);
    resource.getContents().add(u1);
    resource.getContents().add(u2);

    JsonNode result = mapper.valueToTree(resource);

    assertEquals(expected, result);
  }
Beispiel #15
0
 public JsonNode toObjectArray(ObjectMapper mapper) throws WampError {
   ArrayNode messageNode = mapper.createArrayNode();
   messageNode.add(ID);
   messageNode.add(signature);
   if (extra != null) messageNode.add(extra);
   else messageNode.add(mapper.createObjectNode());
   return messageNode;
 }
Beispiel #16
0
 public JsonNode toObjectArray(ObjectMapper mapper) throws WampError {
   ArrayNode messageNode = mapper.createArrayNode();
   messageNode.add(ID);
   messageNode.add(requestId);
   if (options != null) messageNode.add(options);
   else messageNode.add(mapper.createObjectNode());
   messageNode.add(procedure.toString());
   return messageNode;
 }
  protected void addFormProperties(List<FormProperty> formProperties, ObjectNode propertiesNode) {
    if (CollectionUtils.isEmpty(formProperties)) return;

    ObjectNode formPropertiesNode = objectMapper.createObjectNode();
    ArrayNode propertiesArrayNode = objectMapper.createArrayNode();
    for (FormProperty property : formProperties) {
      ObjectNode propertyItemNode = objectMapper.createObjectNode();
      propertyItemNode.put(PROPERTY_FORM_ID, property.getId());
      propertyItemNode.put(PROPERTY_FORM_NAME, property.getName());
      propertyItemNode.put(PROPERTY_FORM_TYPE, property.getType());
      if (StringUtils.isNotEmpty(property.getExpression())) {
        propertyItemNode.put(PROPERTY_FORM_EXPRESSION, property.getExpression());
      } else {
        propertyItemNode.putNull(PROPERTY_FORM_EXPRESSION);
      }
      if (StringUtils.isNotEmpty(property.getVariable())) {
        propertyItemNode.put(PROPERTY_FORM_VARIABLE, property.getVariable());
      } else {
        propertyItemNode.putNull(PROPERTY_FORM_VARIABLE);
      }
      if (StringUtils.isNotEmpty(property.getDatePattern())) {
        propertyItemNode.put(PROPERTY_FORM_DATE_PATTERN, property.getDatePattern());
      }
      if (CollectionUtils.isNotEmpty(property.getFormValues())) {
        ArrayNode valuesNode = objectMapper.createArrayNode();
        for (FormValue formValue : property.getFormValues()) {
          ObjectNode valueNode = objectMapper.createObjectNode();
          valueNode.put(PROPERTY_FORM_ENUM_VALUES_NAME, formValue.getName());
          valueNode.put(PROPERTY_FORM_ENUM_VALUES_ID, formValue.getId());
          valuesNode.add(valueNode);
        }
        propertyItemNode.put(PROPERTY_FORM_ENUM_VALUES, valuesNode);
      }
      propertyItemNode.put(PROPERTY_FORM_REQUIRED, property.isRequired());
      propertyItemNode.put(PROPERTY_FORM_READABLE, property.isReadable());
      propertyItemNode.put(PROPERTY_FORM_WRITABLE, property.isWriteable());

      propertiesArrayNode.add(propertyItemNode);
    }

    formPropertiesNode.put("formProperties", propertiesArrayNode);
    propertiesNode.put(PROPERTY_FORM_PROPERTIES, formPropertiesNode);
  }
Beispiel #18
0
  // initializes top level root with Swagger required specifications
  private ObjectNode initializeRoot() {
    ObjectNode root = mapper.createObjectNode();
    root.put("swagger", "2.0");
    ObjectNode info = mapper.createObjectNode();
    root.set("info", info);

    root.put("basePath", webContext);
    info.put("version", apiVersion);
    info.put("title", apiTitle);
    info.put("description", apiDescription);

    ArrayNode produces = mapper.createArrayNode();
    produces.add("application/json");
    root.set("produces", produces);

    ArrayNode consumes = mapper.createArrayNode();
    consumes.add("application/json");
    root.set("consumes", consumes);

    return root;
  }
Beispiel #19
0
	// TODO all this is very memory inefficient and will lead to stack overflows for very deep trees
	public static ObjectNode toJsonTree(ObjectMapper objectMapper, Tree<? extends JsonNode> tree)
	{
		final ObjectNode node = objectMapper.createObjectNode();
		node.put("_value", tree.value());
		
		final ArrayNode children = objectMapper.createArrayNode();
		for (Tree<? extends JsonNode> child : tree.children())
			children.add(toJsonTree(objectMapper, child));
		
		node.put("_children", children);
		
		return node;
	}
 private JsonNode createProduct(JsonNode node, String userName) throws Exception {
   ObjectMapper om = new ObjectMapper();
   ArrayNode anode = om.createArrayNode();
   if (node.isArray()) {
     Iterator<JsonNode> nodeiterator = node.iterator();
     while (nodeiterator.hasNext()) {
       ProductBack cbase = om.convertValue(nodeiterator.next(), ProductBack.class);
       anode.add(createProductToDb(om, cbase, userName));
     }
   } else {
     ProductBack cbase = JSON.parseObject(node.asText(), ProductBack.class);
     anode.add(createProductToDb(om, cbase, userName));
   }
   return anode;
 }
  protected void addFieldExtensions(List<FieldExtension> extensions, ObjectNode propertiesNode) {
    ObjectNode fieldExtensionsNode = objectMapper.createObjectNode();
    ArrayNode itemsNode = objectMapper.createArrayNode();
    for (FieldExtension extension : extensions) {
      ObjectNode propertyItemNode = objectMapper.createObjectNode();
      propertyItemNode.put(PROPERTY_SERVICETASK_FIELD_NAME, extension.getFieldName());
      if (StringUtils.isNotEmpty(extension.getStringValue())) {
        propertyItemNode.put(PROPERTY_SERVICETASK_FIELD_STRING_VALUE, extension.getStringValue());
      }
      if (StringUtils.isNotEmpty(extension.getExpression())) {
        propertyItemNode.put(PROPERTY_SERVICETASK_FIELD_EXPRESSION, extension.getExpression());
      }
      itemsNode.add(propertyItemNode);
    }

    fieldExtensionsNode.put("fields", itemsNode);
    propertiesNode.put(PROPERTY_SERVICETASK_FIELDS, fieldExtensionsNode);
  }
  @Deployment
  public void testSubmitFormData() throws Exception {
    Map<String, Object> variableMap = new HashMap<String, Object>();
    variableMap.put("SpeakerName", "John Doe");
    Address address = new Address();
    variableMap.put("address", address);
    ProcessInstance processInstance =
        runtimeService.startProcessInstanceByKey("oneTaskProcess", variableMap);
    String processInstanceId = processInstance.getId();
    String processDefinitionId = processInstance.getProcessDefinitionId();
    Task task = taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();

    ClientResource client =
        getAuthenticatedClient(RestUrls.createRelativeResourceUrl(RestUrls.URL_FORM_DATA));
    ObjectNode requestNode = objectMapper.createObjectNode();
    requestNode.put("taskId", task.getId());
    ArrayNode propertyArray = objectMapper.createArrayNode();
    requestNode.put("properties", propertyArray);
    ObjectNode propNode = objectMapper.createObjectNode();
    propNode.put("id", "room");
    propNode.put("value", 123l);
    propertyArray.add(propNode);
    try {
      client.post(requestNode);
    } catch (Exception e) {
      // expected
      assertEquals(Status.SERVER_ERROR_INTERNAL, client.getResponse().getStatus());
    }

    propNode = objectMapper.createObjectNode();
    propNode.put("id", "street");
    propNode.put("value", "test");
    propertyArray.add(propNode);
    client.release();
    client.post(requestNode);

    assertEquals(Status.SUCCESS_NO_CONTENT, client.getResponse().getStatus());
    task = taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();
    assertNull(task);
    processInstance =
        runtimeService
            .createProcessInstanceQuery()
            .processInstanceId(processInstanceId)
            .singleResult();
    assertNull(processInstance);
    List<HistoricVariableInstance> variables =
        historyService
            .createHistoricVariableInstanceQuery()
            .processInstanceId(processInstanceId)
            .list();
    Map<String, HistoricVariableInstance> historyMap =
        new HashMap<String, HistoricVariableInstance>();
    for (HistoricVariableInstance historicVariableInstance : variables) {
      historyMap.put(historicVariableInstance.getVariableName(), historicVariableInstance);
    }

    assertEquals("123", historyMap.get("room").getValue());
    assertEquals(processInstanceId, historyMap.get("room").getProcessInstanceId());

    processInstance = runtimeService.startProcessInstanceByKey("oneTaskProcess", variableMap);
    processInstanceId = processInstance.getId();
    task = taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();

    requestNode.put("taskId", task.getId());
    propNode = objectMapper.createObjectNode();
    propNode.put("id", "direction");
    propNode.put("value", "nowhere");
    propertyArray.add(propNode);
    try {
      client.release();
      client.post(requestNode);
    } catch (Exception e) {
      // expected
      assertEquals(Status.CLIENT_ERROR_BAD_REQUEST, client.getResponse().getStatus());
    }

    propNode.put("value", "up");
    client.release();
    client.post(requestNode);
    assertEquals(Status.SUCCESS_NO_CONTENT, client.getResponse().getStatus());
    task = taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();
    assertNull(task);
    processInstance =
        runtimeService
            .createProcessInstanceQuery()
            .processInstanceId(processInstanceId)
            .singleResult();
    assertNull(processInstance);
    variables =
        historyService
            .createHistoricVariableInstanceQuery()
            .processInstanceId(processInstanceId)
            .list();
    historyMap.clear();
    for (HistoricVariableInstance historicVariableInstance : variables) {
      historyMap.put(historicVariableInstance.getVariableName(), historicVariableInstance);
    }

    assertEquals("123", historyMap.get("room").getValue());
    assertEquals(processInstanceId, historyMap.get("room").getProcessInstanceId());
    assertEquals("up", historyMap.get("direction").getValue());

    requestNode = objectMapper.createObjectNode();
    requestNode.put("processDefinitionId", processDefinitionId);
    propertyArray = objectMapper.createArrayNode();
    requestNode.put("properties", propertyArray);
    propNode = objectMapper.createObjectNode();
    propNode.put("id", "number");
    propNode.put("value", 123);
    propertyArray.add(propNode);
    client.release();
    Representation response = client.post(requestNode);
    assertEquals(Status.SUCCESS_OK, client.getResponse().getStatus());
    JsonNode responseNode = objectMapper.readTree(response.getStream());
    assertNotNull(responseNode.get("id").asText());
    assertEquals(processDefinitionId, responseNode.get("processDefinitionId").asText());
    task =
        taskService
            .createTaskQuery()
            .processInstanceId(responseNode.get("id").asText())
            .singleResult();
    assertNotNull(task);
  }
  /**
   * 百度账户树
   *
   * @return
   */
  @Override
  public ArrayNode getAccountTree() {
    ObjectMapper mapper = new ObjectMapper();
    ArrayNode arrayNode = mapper.createArrayNode();
    ObjectNode objectNode;

    Long accountId = AppContext.getAccountId();
    MongoTemplate mongoTemplate = BaseMongoTemplate.getUserMongo();
    Aggregation aggregation1 =
        Aggregation.newAggregation(
            match(Criteria.where(ACCOUNT_ID).is(accountId)),
            project(CAMPAIGN_ID, NAME, SYSTEM_ID),
            sort(Sort.Direction.ASC, CAMPAIGN_ID));
    // 推广计划树
    AggregationResults<CampaignVO> results1 =
        mongoTemplate.aggregate(aggregation1, TBL_CAMPAIGN, CampaignVO.class);
    for (CampaignVO vo : results1) {
      objectNode = mapper.createObjectNode();

      if (vo.getCampaignId() == null) {
        objectNode.put("id", vo.getId());
      } else {
        objectNode.put("id", vo.getCampaignId());
      }

      objectNode.put("pId", 0);
      objectNode.put("name", vo.getCampaignName());
      arrayNode.add(objectNode);
    }

    Aggregation aggregation2 =
        Aggregation.newAggregation(
            match(Criteria.where(ACCOUNT_ID).is(accountId)),
            project(CAMPAIGN_ID, OBJ_CAMPAIGN_ID, ADGROUP_ID, SYSTEM_ID, NAME),
            sort(Sort.Direction.ASC, ADGROUP_ID));
    AggregationResults<AdgroupVO> results2 =
        mongoTemplate.aggregate(aggregation2, TBL_ADGROUP, AdgroupVO.class);
    for (AdgroupVO vo : results2) {
      objectNode = mapper.createObjectNode();
      objectNode.put("name", vo.getAdgroupName());
      if (vo.getCampaignId() == null) {
        objectNode.put("id", vo.getId());
        objectNode.put("pId", vo.getCampaignObjId());
        arrayNode.add(objectNode);
        continue;
      }

      if (vo.getAdgroupId() == null) {
        objectNode.put("id", vo.getId());
        objectNode.put("pId", vo.getCampaignId());
        arrayNode.add(objectNode);
        continue;
      }

      objectNode.put("id", vo.getAdgroupId());
      objectNode.put("pId", vo.getCampaignId());
      arrayNode.add(objectNode);
    }

    return arrayNode;
  }
Beispiel #24
0
 public static ArrayNode createArrayNode() {
   ObjectMapper objectMapper = new ObjectMapper();
   ArrayNode ArrayNode = objectMapper.createArrayNode();
   return ArrayNode;
 }
  public void convertToJson(
      BaseElement baseElement,
      ActivityProcessor processor,
      BpmnModel model,
      FlowElementsContainer container,
      ArrayNode shapesArrayNode,
      double subProcessX,
      double subProcessY) {

    this.model = model;
    this.processor = processor;
    this.subProcessX = subProcessX;
    this.subProcessY = subProcessY;
    this.shapesArrayNode = shapesArrayNode;
    GraphicInfo graphicInfo = model.getGraphicInfo(baseElement.getId());

    String stencilId = null;
    if (baseElement instanceof ServiceTask) {
      ServiceTask serviceTask = (ServiceTask) baseElement;
      if ("mail".equalsIgnoreCase(serviceTask.getType())) {
        stencilId = STENCIL_TASK_MAIL;
      } else if ("camel".equalsIgnoreCase(serviceTask.getType())) {
        stencilId = STENCIL_TASK_CAMEL;
      } else if ("mule".equalsIgnoreCase(serviceTask.getType())) {
        stencilId = STENCIL_TASK_MULE;
      } else {
        stencilId = getStencilId(baseElement);
      }
    } else {
      stencilId = getStencilId(baseElement);
    }

    flowElementNode =
        BpmnJsonConverterUtil.createChildShape(
            baseElement.getId(),
            stencilId,
            graphicInfo.getX() - subProcessX + graphicInfo.getWidth(),
            graphicInfo.getY() - subProcessY + graphicInfo.getHeight(),
            graphicInfo.getX() - subProcessX,
            graphicInfo.getY() - subProcessY);
    shapesArrayNode.add(flowElementNode);
    ObjectNode propertiesNode = objectMapper.createObjectNode();
    propertiesNode.put(PROPERTY_OVERRIDE_ID, baseElement.getId());

    if (baseElement instanceof FlowElement) {
      FlowElement flowElement = (FlowElement) baseElement;
      if (StringUtils.isNotEmpty(flowElement.getName())) {
        propertiesNode.put(PROPERTY_NAME, flowElement.getName());
      }

      if (StringUtils.isNotEmpty(flowElement.getDocumentation())) {
        propertiesNode.put(PROPERTY_DOCUMENTATION, flowElement.getDocumentation());
      }
    }

    convertElementToJson(propertiesNode, baseElement);

    flowElementNode.put(EDITOR_SHAPE_PROPERTIES, propertiesNode);
    ArrayNode outgoingArrayNode = objectMapper.createArrayNode();

    if (baseElement instanceof FlowNode) {
      FlowNode flowNode = (FlowNode) baseElement;
      for (SequenceFlow sequenceFlow : flowNode.getOutgoingFlows()) {
        outgoingArrayNode.add(BpmnJsonConverterUtil.createResourceNode(sequenceFlow.getId()));
      }

      for (MessageFlow messageFlow : model.getMessageFlows().values()) {
        if (messageFlow.getSourceRef().equals(flowNode.getId())) {
          outgoingArrayNode.add(BpmnJsonConverterUtil.createResourceNode(messageFlow.getId()));
        }
      }
    }

    if (baseElement instanceof Activity) {

      Activity activity = (Activity) baseElement;
      for (BoundaryEvent boundaryEvent : activity.getBoundaryEvents()) {
        outgoingArrayNode.add(BpmnJsonConverterUtil.createResourceNode(boundaryEvent.getId()));
      }

      propertiesNode.put(PROPERTY_ASYNCHRONOUS, activity.isAsynchronous());
      propertiesNode.put(PROPERTY_EXCLUSIVE, !activity.isNotExclusive());

      if (activity.getLoopCharacteristics() != null) {
        MultiInstanceLoopCharacteristics loopDef = activity.getLoopCharacteristics();
        if (StringUtils.isNotEmpty(loopDef.getLoopCardinality())
            || StringUtils.isNotEmpty(loopDef.getInputDataItem())
            || StringUtils.isNotEmpty(loopDef.getCompletionCondition())) {

          if (loopDef.isSequential() == false) {
            propertiesNode.put(PROPERTY_MULTIINSTANCE_TYPE, "Parallel");
          } else {
            propertiesNode.put(PROPERTY_MULTIINSTANCE_TYPE, "Sequential");
          }

          if (StringUtils.isNotEmpty(loopDef.getLoopCardinality())) {
            propertiesNode.put(PROPERTY_MULTIINSTANCE_CARDINALITY, loopDef.getLoopCardinality());
          }
          if (StringUtils.isNotEmpty(loopDef.getInputDataItem())) {
            propertiesNode.put(PROPERTY_MULTIINSTANCE_COLLECTION, loopDef.getInputDataItem());
          }
          if (StringUtils.isNotEmpty(loopDef.getElementVariable())) {
            propertiesNode.put(PROPERTY_MULTIINSTANCE_VARIABLE, loopDef.getElementVariable());
          }
          if (StringUtils.isNotEmpty(loopDef.getCompletionCondition())) {
            propertiesNode.put(PROPERTY_MULTIINSTANCE_CONDITION, loopDef.getCompletionCondition());
          }
        }
      }

      if (activity instanceof UserTask) {
        BpmnJsonConverterUtil.convertListenersToJson(
            ((UserTask) activity).getTaskListeners(), false, propertiesNode);
      }

      BpmnJsonConverterUtil.convertListenersToJson(
          activity.getExecutionListeners(), true, propertiesNode);

      if (CollectionUtils.isNotEmpty(activity.getDataInputAssociations())) {
        for (DataAssociation dataAssociation : activity.getDataInputAssociations()) {
          if (model.getFlowElement(dataAssociation.getSourceRef()) != null) {
            createDataAssociation(dataAssociation, true, activity);
          }
        }
      }

      if (CollectionUtils.isNotEmpty(activity.getDataOutputAssociations())) {
        for (DataAssociation dataAssociation : activity.getDataOutputAssociations()) {
          if (model.getFlowElement(dataAssociation.getTargetRef()) != null) {
            createDataAssociation(dataAssociation, false, activity);
            outgoingArrayNode.add(
                BpmnJsonConverterUtil.createResourceNode(dataAssociation.getId()));
          }
        }
      }
    }

    for (Artifact artifact : container.getArtifacts()) {
      if (artifact instanceof Association) {
        Association association = (Association) artifact;
        if (StringUtils.isNotEmpty(association.getSourceRef())
            && association.getSourceRef().equals(baseElement.getId())) {
          outgoingArrayNode.add(BpmnJsonConverterUtil.createResourceNode(association.getId()));
        }
      }
    }

    if (baseElement instanceof DataStoreReference) {
      for (Process process : model.getProcesses()) {
        processDataStoreReferences(process, baseElement.getId(), outgoingArrayNode);
      }
    }

    flowElementNode.put("outgoing", outgoingArrayNode);
  }
Beispiel #26
0
 /**
  * Creates and returns a new child array within the specified parent and bound to the given key.
  *
  * @param parent parent object
  * @param key key for the new child array
  * @return child array
  */
 public ArrayNode newArray(ObjectNode parent, String key) {
   ArrayNode node = mapper.createArrayNode();
   parent.set(key, node);
   return node;
 }
Beispiel #27
0
  // Processes parameters of javaMethod and enters the proper key-values into the methodNode
  private void processParameters(
      JavaMethod javaMethod, ObjectNode methodNode, String method, DocletTag tag) {
    ArrayNode parameters = mapper.createArrayNode();
    methodNode.set("parameters", parameters);
    boolean required = true;

    for (JavaParameter javaParameter : javaMethod.getParameters()) {
      ObjectNode individualParameterNode = mapper.createObjectNode();
      Optional<JavaAnnotation> optional =
          javaParameter
              .getAnnotations()
              .stream()
              .filter(
                  annotation ->
                      annotation.getType().getName().equals(PATH_PARAM)
                          || annotation.getType().getName().equals(QUERY_PARAM))
              .findAny();
      JavaAnnotation pathType = optional.isPresent() ? optional.get() : null;

      String annotationName = javaParameter.getName();

      if (pathType != null) { // the parameter is a path or query parameter
        individualParameterNode.put(
            "name", pathType.getNamedParameter("value").toString().replace("\"", ""));
        if (pathType.getType().getName().equals(PATH_PARAM)) {
          individualParameterNode.put("in", "path");
        } else if (pathType.getType().getName().equals(QUERY_PARAM)) {
          individualParameterNode.put("in", "query");
        }
        individualParameterNode.put("type", getType(javaParameter.getType()));
      } else { // the parameter is a body parameter
        individualParameterNode.put("name", annotationName);
        individualParameterNode.put("in", "body");

        // Adds the reference to the Json model for the input
        // that goes in the post or put operation
        if (tag != null
            && (method.toLowerCase().equals("post") || method.toLowerCase().equals("put"))) {
          ObjectNode schema = mapper.createObjectNode();
          tag.getParameters()
              .stream()
              .forEach(
                  param -> {
                    schema.put("$ref", "#/definitions/" + param);
                  });
          individualParameterNode.set("schema", schema);
        }
      }
      for (DocletTag p : javaMethod.getTagsByName("param")) {
        if (p.getValue().contains(annotationName)) {
          try {
            String description = p.getValue().split(" ", 2)[1].trim();
            if (description.contains("optional")) {
              required = false;
            }
            individualParameterNode.put("description", description);
          } catch (Exception e) {
            e.printStackTrace();
          }
        }
      }
      individualParameterNode.put("required", required);
      parameters.add(individualParameterNode);
    }
  }