org.activiti.engine.repository.Model.getId java code examples

@GetMapping(value = "/{modelId}/json")
@Authorize(action = Permission.ACTION_GET)
public Object getEditorJson(@PathVariable String modelId) {
  JSONObject modelNode;
  Model model = repositoryService.getModel(modelId);
  if (model == null) throw new NullPointerException("模型不存在");
  if (StringUtils.isNotEmpty(model.getMetaInfo())) {
    modelNode = JSON.parseObject(model.getMetaInfo());
  } else {
    modelNode = new JSONObject();
    modelNode.put(MODEL_NAME, model.getName());
  }
  modelNode.put(MODEL_ID, model.getId());
  modelNode.put("model", JSON.parse(new String(repositoryService.getModelEditorSource(model.getId()))));
  return modelNode;
}

@PutMapping(value = "/{modelId}")
@ResponseStatus(value = HttpStatus.OK)
@Authorize(action = Permission.ACTION_UPDATE)
public void saveModel(@PathVariable String modelId,
           @RequestParam Map<String, String> values) throws TranscoderException, IOException {
  Model model = repositoryService.getModel(modelId);
  JSONObject modelJson = JSON.parseObject(model.getMetaInfo());
  modelJson.put(MODEL_NAME, values.get("name"));
  modelJson.put(MODEL_DESCRIPTION, values.get("description"));
  model.setMetaInfo(modelJson.toString());
  model.setName(values.get("name"));
  repositoryService.saveModel(model);
  repositoryService.addModelEditorSource(model.getId(), values.get("json_xml").getBytes("utf-8"));
  InputStream svgStream = new ByteArrayInputStream(values.get("svg_xml").getBytes("utf-8"));
  TranscoderInput input = new TranscoderInput(svgStream);
  PNGTranscoder transcoder = new PNGTranscoder();
  // Setup output
  ByteArrayOutputStream outStream = new ByteArrayOutputStream();
  TranscoderOutput output = new TranscoderOutput(outStream);
  // Do the transformation
  transcoder.transcode(input, output);
  final byte[] result = outStream.toByteArray();
  repositoryService.addModelEditorSourceExtra(model.getId(), result);
  outStream.close();
}

@PostMapping
@ResponseStatus(value = HttpStatus.CREATED)
@ApiOperation("创建模型")
public ResponseMessage<Model> createModel(@RequestBody ModelCreateRequest model) throws Exception {
  JSONObject stencilset = new JSONObject();
  stencilset.put("namespace", "http://b3mn.org/stencilset/bpmn2.0#");
  JSONObject editorNode = new JSONObject();
  editorNode.put("id", "canvas");
  editorNode.put("resourceId", "canvas");
  editorNode.put("stencilset", stencilset);
  JSONObject modelObjectNode = new JSONObject();
  modelObjectNode.put(MODEL_REVISION, 1);
  modelObjectNode.put(MODEL_DESCRIPTION, model.getDescription());
  modelObjectNode.put(MODEL_KEY, model.getKey());
  modelObjectNode.put(MODEL_NAME, model.getName());
  Model modelData = repositoryService.newModel();
  modelData.setMetaInfo(modelObjectNode.toJSONString());
  modelData.setName(model.getName());
  modelData.setKey(model.getKey());
  repositoryService.saveModel(modelData);
  repositoryService.addModelEditorSource(modelData.getId(), editorNode.toString().getBytes("utf-8"));
  return ResponseMessage.ok(modelData).status(201);
}

byte[] modelEditorSource = repositoryService.getModelEditorSource(modelData.getId());

repositoryService.addModelEditorSource(modelData.getId(), modelNode.toString().getBytes("utf-8"));
return ResponseMessage.ok(modelData.getId());

@PostMapping("/{modelId}/deploy")
@ApiOperation("发布模型")
@Authorize(action = "deploy")
public ResponseMessage<Deployment> deployModel(@PathVariable String modelId) throws Exception {
  Model modelData = repositoryService.getModel(modelId);
  if (modelData == null) {
    throw new NotFoundException("模型不存在!");
  }
  ObjectNode modelNode = (ObjectNode) new ObjectMapper().readTree(repositoryService.getModelEditorSource(modelData.getId()));
  BpmnModel model = new BpmnJsonConverter().convertToBpmnModel(modelNode);
  byte[] bpmnBytes = new BpmnXMLConverter().convertToXML(model);
  String processName = modelData.getName() + ".bpmn20.xml";
  Deployment deployment = repositoryService.createDeployment()
      .name(modelData.getName())
      .addString(processName, new String(bpmnBytes, "utf8"))
      .deploy();
  return ResponseMessage.ok(deployment).include(Deployment.class, "id", "name", "new");
}

/**
 * 导出model的png文件
 */
@RequestMapping(value = "/model/export/image/{modelId}", method = RequestMethod.GET)
public void exportPng(@PathVariable("modelId") String modelId, HttpServletResponse response) {
  try {
    Model modelData = repositoryService.getModel(modelId);
    byte[] pngBytes = repositoryService.getModelEditorSourceExtra(modelData.getId());
    ByteArrayInputStream in = new ByteArrayInputStream(pngBytes);
    IOUtils.copy(in, response.getOutputStream());
    String filename = modelData.getKey() + ".process.model.png";
    response.setHeader("Content-Disposition", "attachment; filename=" + filename);
    response.flushBuffer();
  } catch (Exception e) {
    LOGGER.error("导出model的png文件失败：modelId={}", modelId, e);
  }
}

public static Model createNewModel(RepositoryService repositoryService, String name, String description)
    throws IOException
{
  ObjectMapper objectMapper = new ObjectMapper();
  Model modelData = repositoryService.newModel();
  ObjectNode modelObjectNode = objectMapper.createObjectNode();
  modelObjectNode.put(ModelDataJsonConstants.MODEL_NAME, name);
  modelObjectNode.put(ModelDataJsonConstants.MODEL_REVISION, 1);
  modelObjectNode.put(ModelDataJsonConstants.MODEL_DESCRIPTION, description);
  modelData.setMetaInfo(modelObjectNode.toString());
  modelData.setName(name);
  repositoryService.saveModel(modelData);
  repositoryService.addModelEditorSource(modelData.getId(), EMPTY_MODEL_XML.getBytes("utf-8"));
  return modelData;
}

 @RequestMapping(value="/model/{modelId}/json", method = RequestMethod.GET, produces = "application/json")
 @ResponseBody
 public ObjectNode getEditorJson(@PathVariable("modelId") String modelId) {
  ObjectNode modelNode = null;
  
  Model model = repositoryService.getModel(modelId);
   
  if (model != null) {
   try {
    if (StringUtils.isNotEmpty(model.getMetaInfo())) {
     modelNode = (ObjectNode) objectMapper.readTree(model.getMetaInfo());
    } else {
     modelNode = objectMapper.createObjectNode();
     modelNode.put(MODEL_NAME, model.getName());
    }
    modelNode.put(MODEL_ID, model.getId());
    ObjectNode editorJsonNode = (ObjectNode) objectMapper.readTree(
      new String(repositoryService.getModelEditorSource(model.getId()), "utf-8"));
    modelNode.put("model", editorJsonNode);
    
   } catch (Exception e) {
    LOGGER.error("Error creating model JSON", e);
    throw new ActivitiException("Error creating model JSON", e);
   }
  }
  return modelNode;
 }
}

@RequestMapping(value = "/model/uniquekey", method = RequestMethod.POST)
@ResponseBody
public Map uniqueKey(String key, String id) {
  Map<String, Boolean> map = new HashMap<>();
  if (StrUtil.isEmpty(key)) {
    map.put("valid", true);
  } else {
    List<Model> models = repositoryService.createModelQuery().modelKey(key).list();
    if (StrUtil.isEmpty(id)) {
      if (models.isEmpty())
        map.put("valid", true);
      else
        map.put("valid", false);
    } else {
      map.put("valid", false);
      for (Model model : models) {
        if (model.getId().equals(id)) {
          map.put("valid", true);
          break;
        }
      }
    }
  }
  return map;
}

/**
 * 校验资源文件是否存在
 *
 * @param type    xml image 类型
 * @param modelId 模型id
 * @return
 * @throws IOException
 */
@RequestMapping(value = "/model/exist/{type}/{modelId}", method = RequestMethod.POST)
@ResponseBody
public Result resourceExist(@PathVariable("type") String type, @PathVariable("modelId") String modelId) throws IOException {
  Model modelData = repositoryService.getModel(modelId);
  if (type.equals("xml")) {
    BpmnJsonConverter jsonConverter = new BpmnJsonConverter();
    JsonNode editorNode = objectMapper.readTree(repositoryService.getModelEditorSource(modelData.getId()));
    BpmnModel bpmnModel = jsonConverter.convertToBpmnModel(editorNode);
    return new Result(!bpmnModel.getProcesses().isEmpty());
  } else {
    byte[] pngBytes = repositoryService.getModelEditorSourceExtra(modelData.getId());
    return new Result(pngBytes.length > 0);
  }
}

String id = model.getId();

/**
 * 导出model的xml文件
 */
@RequestMapping(value = "/model/export/xml/{modelId}", method = RequestMethod.GET)
public void exportXml(@PathVariable("modelId") String modelId, HttpServletResponse response) {
  try {
    Model modelData = repositoryService.getModel(modelId);
    BpmnJsonConverter jsonConverter = new BpmnJsonConverter();
    JsonNode editorNode = objectMapper.readTree(repositoryService.getModelEditorSource(modelData.getId()));
    BpmnModel bpmnModel = jsonConverter.convertToBpmnModel(editorNode);
    BpmnXMLConverter xmlConverter = new BpmnXMLConverter();
    //没有xml
    if (bpmnModel.getProcesses().isEmpty()) {
      response.setCharacterEncoding("utf-8");
      response.getWriter().print("<script>modals.error('xml文件不存在，生成错误');</script>");
      response.flushBuffer();
      return;
    }
    byte[] bpmnBytes = xmlConverter.convertToXML(bpmnModel);
    ByteArrayInputStream in = new ByteArrayInputStream(bpmnBytes);
    IOUtils.copy(in, response.getOutputStream());
    String filename = bpmnModel.getMainProcess().getId() + ".bpmn20.model.xml";
    response.setHeader("Content-Disposition", "attachment; filename=" + filename);
    response.flushBuffer();
  } catch (Exception e) {
    LOGGER.error("导出model的xml文件失败：modelId={}", modelId, e);
  }
}

repositoryService.addModelEditorSource(model.getId(), values.getFirst("json_xml").getBytes("utf-8"));
repositoryService.addModelEditorSourceExtra(model.getId(), result);
outStream.close();

  public static void importModel(RepositoryService repositoryService, File modelFile) throws IOException,
      XMLStreamException
  {
    InputStreamReader reader = new InputStreamReader(new FileInputStream(modelFile), "utf-8");
    String fileContent = IOUtils.readStringAndClose(reader, (int) modelFile.length());

    BpmnModel bpmnModel = new BpmnXMLConverter().convertToBpmnModel(new StringStreamSourceEx(fileContent), false,
      false);

    String processName = bpmnModel.getMainProcess().getName();
    if (processName == null || processName.isEmpty())
    {
      processName = bpmnModel.getMainProcess().getId();
    }

    Model modelData = repositoryService.newModel();
    ObjectNode modelObjectNode = new ObjectMapper().createObjectNode();
    modelObjectNode.put(ModelDataJsonConstants.MODEL_NAME, processName);
    modelObjectNode.put(ModelDataJsonConstants.MODEL_REVISION, 1);
    modelData.setMetaInfo(modelObjectNode.toString());
    modelData.setName(processName);
    modelData.setKey(modelFile.getName());

    repositoryService.saveModel(modelData);

    repositoryService.addModelEditorSource(modelData.getId(), fileContent.getBytes("utf-8"));
    Logger.getLogger(ModelUtils.class)
        .info(String.format("importing model file: %s", modelFile.getCanonicalPath()));
  }
}

Model modelData = repositoryService.getModel(modelId);
BpmnJsonConverter jsonConverter = new BpmnJsonConverter();
JsonNode editorNode = objectMapper.readTree(repositoryService.getModelEditorSource(modelData.getId()));
BpmnModel bpmnModel = jsonConverter.convertToBpmnModel(editorNode);
BpmnXMLConverter xmlConverter = new BpmnXMLConverter();

byte[] bytes = repositoryService.getModelEditorSource(modelData.getId());

 @ApiOperation(value = "Delete a model", tags = {"Models"})
 @ApiResponses(value = {
   @ApiResponse(code = 204, message = "Indicates the model was found and has been deleted. Response-body is intentionally empty."),
   @ApiResponse(code = 404, message = "Indicates the requested model was not found.")
 })
 @RequestMapping(value = "/repository/models/{modelId}", method = RequestMethod.DELETE)
 public void deleteModel(@ApiParam(name = "modelId", value="The id of the model to delete.") @PathVariable String modelId, HttpServletResponse response) {
  Model model = getModelFromRequest(modelId);
  repositoryService.deleteModel(model.getId());
  response.setStatus(HttpStatus.NO_CONTENT.value());
 }
}

protected void showModeler() throws MalformedURLException {
  URL explorerURL = ExplorerApp.get().getURL();
  URL url = new URL(explorerURL.getProtocol(), explorerURL.getHost(), explorerURL.getPort(),
      explorerURL.getPath().replace("/ui",  "") + "modeler.html?modelId=" + model.getId());
 ExplorerApp.get().getMainWindow().open(new ExternalResource(url));
}

 public void buttonClick(ClickEvent event) {
  repositoryService.deleteModel(modelData.getId());
  close();
  ExplorerApp.get().getViewManager().showEditorProcessDefinitionPage();
 }
});

How to use getIdmethodin org.activiti.engine.repository.Model

Best Java code snippets using org.activiti.engine.repository.Model.getId (Showing top 20 results out of 315)

How to use
getId
method
in
org.activiti.engine.repository.Model