org.camunda.bpm.engine.impl.persistence.entity.ResourceEntity Java Examples

@Override
protected List<DecisionRequirementsDefinitionEntity> transformDefinitions(DeploymentEntity deployment, ResourceEntity resource, Properties properties) {
  byte[] bytes = resource.getBytes();
  ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes);

  try {
    DecisionRequirementsDefinitionEntity drd = transformer
        .createTransform()
        .modelInstance(inputStream)
        .transformDecisionRequirementsGraph();

    return Collections.singletonList(drd);

  } catch (Exception e) {
    throw LOG.exceptionParseDmnResource(resource.getName(), e);
  }
}
 

protected String getFormTemplateString(FormData formInstance, String formKey) {
  String deploymentId = formInstance.getDeploymentId();

  ResourceEntity resourceStream = Context
    .getCommandContext()
    .getResourceManager()
    .findResourceByDeploymentIdAndResourceName(deploymentId, formKey);

  ensureNotNull("Form with formKey '" + formKey + "' does not exist", "resourceStream", resourceStream);

  byte[] resourceBytes = resourceStream.getBytes();
  String encoding = "UTF-8";
  String formTemplateString = "";
  try {
    formTemplateString = new String(resourceBytes, encoding);
  } catch (UnsupportedEncodingException e) {
    throw new ProcessEngineException("Unsupported encoding of :" + encoding, e);
  }
  return formTemplateString;
}
 

public void deploy(DeploymentEntity deployment) {
  if (!deployment.isNew()) {
    // only generate dmn xml once when deploying for the first time
    return;
  }

  List<ResourceEntity> generatedResources = new ArrayList<ResourceEntity>();

  for (ResourceEntity resource : deployment.getResources().values()) {
    if (canHandle(resource)) {
      XlsxDeploymentMetaData metaData = loadMetaData(deployment, resource.getName() + ".yaml");
      DmnModelInstance dmnModel = generateDmnModel(resource, metaData);
      ResourceEntity dmnResource = generateDeploymentResource(deployment, dmnModel, generateDmnResourceName(resource));
      generatedResources.add(dmnResource);
    }
  }

  addToDeployment(generatedResources, deployment);
}
 

protected ResourceEntity generateDeploymentResource(DeploymentEntity deployment, DmnModelInstance dmnModel, String name) {
  ResourceEntity resource = new ResourceEntity();

  ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
  Dmn.writeModelToStream(byteStream, dmnModel);
  byte[] bytes = byteStream.toByteArray();

  resource.setName(name);
  resource.setBytes(bytes);
  resource.setDeploymentId(deployment.getId());

  // Mark the resource as 'generated'
  resource.setGenerated(true);

  return resource;
}
 

@Override
public String execute(CommandContext commandContext) {
  AuthorizationManager authorizationManager = commandContext.getAuthorizationManager();
  authorizationManager.checkCamundaAdmin();

  // case I: license is stored as BLOB
  ResourceEntity licenseResource = commandContext.getResourceManager().findLicenseKeyResource();
  if (licenseResource != null) {
    return new String(licenseResource.getBytes(), StandardCharsets.UTF_8);
  }

  // case II: license is stored in properties
  PropertyEntity licenseProperty = commandContext.getPropertyManager().findPropertyById(LICENSE_KEY_PROPERTY_NAME);
  if (licenseProperty != null) {
    return licenseProperty.getValue();
  }

  return null;
}
 

protected void addResources(List<ResourceEntity> resources, DeploymentBuilderImpl deploymentBuilder) {
  DeploymentEntity deployment = deploymentBuilder.getDeployment();
  Map<String, ResourceEntity> existingResources = deployment.getResources();

  for (ResourceEntity resource : resources) {
    String resourceName = resource.getName();

    if (existingResources != null && existingResources.containsKey(resourceName)) {
      String message = String.format("Cannot add resource with id '%s' and name '%s' from "
          + "deployment with id '%s' to new deployment because the new deployment contains "
          + "already a resource with same name.", resource.getId(), resourceName, resource.getDeploymentId());

      throw new NotValidException(message);
    }

    ByteArrayInputStream inputStream = new ByteArrayInputStream(resource.getBytes());
    deploymentBuilder.addInputStream(resourceName, inputStream);
  }
}
 

protected List<ResourceEntity> getResourcesByDeploymentId(Set<String> deploymentIds, CommandContext commandContext) {
  List<ResourceEntity> result = new ArrayList<>();

  if (!deploymentIds.isEmpty()) {

    DeploymentManager deploymentManager = commandContext.getDeploymentManager();

    for (String deploymentId : deploymentIds) {
      DeploymentEntity deployment = deploymentManager.findDeploymentById(deploymentId);
      Map<String, ResourceEntity> resources = deployment.getResources();
      Collection<ResourceEntity> values = resources.values();
      result.addAll(values);
    }
  }

  return result;
}
 

protected void checkDuplicateResourceName(List<ResourceEntity> resources) {
  Map<String, ResourceEntity> resourceMap = new HashMap<>();

  for (ResourceEntity resource : resources) {
    String name = resource.getName();

    ResourceEntity duplicate = resourceMap.get(name);
    if (duplicate != null) {
      String deploymentId = resource.getDeploymentId();
      if (!deploymentId.equals(duplicate.getDeploymentId())) {
        String message = String.format("The deployments with id '%s' and '%s' contain a resource with same name '%s'.", deploymentId, duplicate.getDeploymentId(), name);
        throw new NotValidException(message);
      }
    }
    resourceMap.put(name, resource);
  }
}
 

protected List<CaseDefinitionEntity> transform() {
  // convert the model to the XML string representation
  OutputStream outputStream = new ByteArrayOutputStream();
  Cmmn.writeModelToStream(outputStream, modelInstance);
  InputStream inputStream = IoUtil.convertOutputStreamToInputStream(outputStream);

  byte[] model = org.camunda.bpm.engine.impl.util.IoUtil.readInputStream(inputStream, "model");

  ResourceEntity resource = new ResourceEntity();
  resource.setBytes(model);
  resource.setName("test");

  transformer.setResource(resource);
  List<CaseDefinitionEntity> definitions = transformer.transform();

  IoUtil.closeSilently(outputStream);
  IoUtil.closeSilently(inputStream);

  return definitions;
}
 

protected void ensureResourcesWithKeysExist(String deploymentId, Set<String> expectedKeys, Map<String, ResourceEntity> actual, String valueProperty) {
  List<String> missingResources = getMissingElements(expectedKeys, actual);

  if (!missingResources.isEmpty()) {
    StringBuilder builder = new StringBuilder();

    builder.append("The deployment with id '");
    builder.append(deploymentId);
    builder.append("' does not contain the following resources with ");
    builder.append(valueProperty);
    builder.append(": ");
    builder.append(StringUtil.join(missingResources.iterator()));

    throw new NotFoundException(builder.toString());
  }
}
 

@Test
public void testFormsBinaries() {
  Date fixedDate = new Date();
  ClockUtil.setCurrentTime(fixedDate);

  String deploymentId = testRule.deploy("org/camunda/bpm/engine/test/api/form/DeployedFormsProcess.bpmn20.xml",
      "org/camunda/bpm/engine/test/api/form/start.form",
      "org/camunda/bpm/engine/test/api/form/task.form",
      "org/camunda/bpm/engine/test/api/authorization/renderedFormProcess.bpmn20.xml",
      "org/camunda/bpm/engine/test/api/authorization/oneTaskCase.cmmn").getId();

  List<Resource> deploymentResources = repositoryService.getDeploymentResources(deploymentId);
  assertEquals(5, deploymentResources.size());
  for (Resource resource : deploymentResources) {
    ResourceEntity entity = (ResourceEntity) resource;
    checkEntity(fixedDate, entity);
  }
}
 

@Override
protected List<ProcessDefinitionEntity> transformDefinitions(DeploymentEntity deployment, ResourceEntity resource, Properties properties) {
  byte[] bytes = resource.getBytes();
  ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes);

  BpmnParse bpmnParse = bpmnParser
      .createParse()
      .sourceInputStream(inputStream)
      .deployment(deployment)
      .name(resource.getName());

  if (!deployment.isValidatingSchema()) {
    bpmnParse.setSchemaResource(null);
  }

  bpmnParse.execute();

  if (!properties.contains(JOB_DECLARATIONS_PROPERTY)) {
    properties.set(JOB_DECLARATIONS_PROPERTY, new HashMap<String, List<JobDeclaration<?, ?>>>());
  }
  properties.get(JOB_DECLARATIONS_PROPERTY).putAll(bpmnParse.getJobDeclarations());

  return bpmnParse.getProcessDefinitions();
}
 

public static Resource createMockDeploymentJsonResource() {
  Resource mockResource = mock(ResourceEntity.class);
  when(mockResource.getId()).thenReturn(EXAMPLE_DEPLOYMENT_JSON_RESOURCE_ID);
  when(mockResource.getName()).thenReturn(EXAMPLE_DEPLOYMENT_JSON_RESOURCE_NAME);
  when(mockResource.getDeploymentId()).thenReturn(EXAMPLE_DEPLOYMENT_ID);
  return mockResource;
}
 

public static Resource createMockDeploymentXmlResource() {
  Resource mockResource = mock(ResourceEntity.class);
  when(mockResource.getId()).thenReturn(EXAMPLE_DEPLOYMENT_XML_RESOURCE_ID);
  when(mockResource.getName()).thenReturn(EXAMPLE_DEPLOYMENT_XML_RESOURCE_NAME);
  when(mockResource.getDeploymentId()).thenReturn(EXAMPLE_DEPLOYMENT_ID);
  return mockResource;
}
 

public static Resource createMockDeploymentDmnXmlResource() {
  Resource mockResource = mock(ResourceEntity.class);
  when(mockResource.getId()).thenReturn(EXAMPLE_DEPLOYMENT_DMN_XML_RESOURCE_ID);
  when(mockResource.getName()).thenReturn(EXAMPLE_DEPLOYMENT_DMN_XML_RESOURCE_NAME);
  when(mockResource.getDeploymentId()).thenReturn(EXAMPLE_DEPLOYMENT_ID);
  return mockResource;
}
 

public static Resource createMockDeploymentDmnResource() {
  Resource mockResource = mock(ResourceEntity.class);
  when(mockResource.getId()).thenReturn(EXAMPLE_DEPLOYMENT_DMN_RESOURCE_ID);
  when(mockResource.getName()).thenReturn(EXAMPLE_DEPLOYMENT_DMN_RESOURCE_NAME);
  when(mockResource.getDeploymentId()).thenReturn(EXAMPLE_DEPLOYMENT_ID);
  return mockResource;
}
 

public static Resource createMockDeploymentJpegResource() {
  Resource mockResource = mock(ResourceEntity.class);
  when(mockResource.getId()).thenReturn(EXAMPLE_DEPLOYMENT_JPEG_RESOURCE_ID);
  when(mockResource.getName()).thenReturn(EXAMPLE_DEPLOYMENT_JPEG_RESOURCE_NAME);
  when(mockResource.getDeploymentId()).thenReturn(EXAMPLE_DEPLOYMENT_ID);
  return mockResource;
}
 

public static Resource createMockDeploymentPhpResource() {
  Resource mockResource = mock(ResourceEntity.class);
  when(mockResource.getId()).thenReturn(EXAMPLE_DEPLOYMENT_PHP_RESOURCE_ID);
  when(mockResource.getName()).thenReturn(EXAMPLE_DEPLOYMENT_PHP_RESOURCE_NAME);
  when(mockResource.getDeploymentId()).thenReturn(EXAMPLE_DEPLOYMENT_ID);
  return mockResource;
}
 

public static Resource createMockDeploymentJpgResource() {
  Resource mockResource = mock(ResourceEntity.class);
  when(mockResource.getId()).thenReturn(EXAMPLE_DEPLOYMENT_JPG_RESOURCE_ID);
  when(mockResource.getName()).thenReturn(EXAMPLE_DEPLOYMENT_JPG_RESOURCE_NAME);
  when(mockResource.getDeploymentId()).thenReturn(EXAMPLE_DEPLOYMENT_ID);
  return mockResource;
}
 

public static Resource createMockDeploymentPythonResource() {
  Resource mockResource = mock(ResourceEntity.class);
  when(mockResource.getId()).thenReturn(EXAMPLE_DEPLOYMENT_PYTHON_RESOURCE_ID);
  when(mockResource.getName()).thenReturn(EXAMPLE_DEPLOYMENT_PYTHON_RESOURCE_NAME);
  when(mockResource.getDeploymentId()).thenReturn(EXAMPLE_DEPLOYMENT_ID);
  return mockResource;
}
 

public static Resource createMockDeploymentPngResource() {
  Resource mockResource = mock(ResourceEntity.class);
  when(mockResource.getId()).thenReturn(EXAMPLE_DEPLOYMENT_PNG_RESOURCE_ID);
  when(mockResource.getName()).thenReturn(EXAMPLE_DEPLOYMENT_PNG_RESOURCE_NAME);
  when(mockResource.getDeploymentId()).thenReturn(EXAMPLE_DEPLOYMENT_ID);
  return mockResource;
}
 

public static Resource createMockDeploymentSvgResource() {
  Resource mockResource = mock(ResourceEntity.class);
  when(mockResource.getId()).thenReturn(EXAMPLE_DEPLOYMENT_SVG_RESOURCE_ID);
  when(mockResource.getName()).thenReturn(EXAMPLE_DEPLOYMENT_SVG_RESOURCE_NAME);
  when(mockResource.getDeploymentId()).thenReturn(EXAMPLE_DEPLOYMENT_ID);
  return mockResource;
}
 

public static Resource createMockDeploymentRubyResource() {
  Resource mockResource = mock(ResourceEntity.class);
  when(mockResource.getId()).thenReturn(EXAMPLE_DEPLOYMENT_RUBY_RESOURCE_ID);
  when(mockResource.getName()).thenReturn(EXAMPLE_DEPLOYMENT_RUBY_RESOURCE_NAME);
  when(mockResource.getDeploymentId()).thenReturn(EXAMPLE_DEPLOYMENT_ID);
  return mockResource;
}
 

public static Resource createMockDeploymentResource() {
  Resource mockResource = mock(ResourceEntity.class);
  when(mockResource.getId()).thenReturn(EXAMPLE_DEPLOYMENT_RESOURCE_ID);
  when(mockResource.getName()).thenReturn(EXAMPLE_DEPLOYMENT_RESOURCE_NAME);
  when(mockResource.getDeploymentId()).thenReturn(EXAMPLE_DEPLOYMENT_ID);

  return mockResource;
}
 

public static Resource createMockDeploymentHtmlResource() {
  Resource mockResource = mock(ResourceEntity.class);
  when(mockResource.getId()).thenReturn(EXAMPLE_DEPLOYMENT_HTML_RESOURCE_ID);
  when(mockResource.getName()).thenReturn(EXAMPLE_DEPLOYMENT_HTML_RESOURCE_NAME);
  when(mockResource.getDeploymentId()).thenReturn(EXAMPLE_DEPLOYMENT_ID);
  return mockResource;
}
 

public static Resource createMockDeploymentTxtResource() {
  Resource mockResource = mock(ResourceEntity.class);
  when(mockResource.getId()).thenReturn(EXAMPLE_DEPLOYMENT_TXT_RESOURCE_ID);
  when(mockResource.getName()).thenReturn(EXAMPLE_DEPLOYMENT_TXT_RESOURCE_NAME);
  when(mockResource.getDeploymentId()).thenReturn(EXAMPLE_DEPLOYMENT_ID);
  return mockResource;
}
 

public static Resource createMockDeploymentResourceFilename() {
  Resource mockResource = mock(ResourceEntity.class);
  when(mockResource.getId()).thenReturn(EXAMPLE_DEPLOYMENT_RESOURCE_FILENAME_ID);
  when(mockResource.getName()).thenReturn(EXAMPLE_DEPLOYMENT_RESOURCE_FILENAME_PATH + EXAMPLE_DEPLOYMENT_RESOURCE_FILENAME_NAME);
  when(mockResource.getDeploymentId()).thenReturn(EXAMPLE_DEPLOYMENT_ID);
  return mockResource;
}
 

@Override
public Long execute(CommandContext commandContext) {
  ResourceEntity licenseKey = commandContext.getResourceManager().findLicenseKeyResource();
  assertNotNull("license key is expected to be not null", licenseKey);

  monitor.sync();

  licenseKey.setBytes("updatedTestLicenseKeyBySecondThread".getBytes());
  new SetLicenseKeyCmd(new String(licenseKey.getBytes())).execute(commandContext);
  return null;
}
 

public static Resource createMockDeploymentResourceFilenameBackslash() {
  Resource mockResource = mock(ResourceEntity.class);
  when(mockResource.getId()).thenReturn(EXAMPLE_DEPLOYMENT_RESOURCE_FILENAME_ID);
  when(mockResource.getName()).thenReturn(EXAMPLE_DEPLOYMENT_RESOURCE_FILENAME_PATH_BACKSLASH + EXAMPLE_DEPLOYMENT_RESOURCE_FILENAME_NAME);
  when(mockResource.getDeploymentId()).thenReturn(EXAMPLE_DEPLOYMENT_ID);
  return mockResource;
}
 

public static Resource createMockDeploymentJpeResource() {
  Resource mockResource = mock(ResourceEntity.class);
  when(mockResource.getId()).thenReturn(EXAMPLE_DEPLOYMENT_JPE_RESOURCE_ID);
  when(mockResource.getName()).thenReturn(EXAMPLE_DEPLOYMENT_JPE_RESOURCE_NAME);
  when(mockResource.getDeploymentId()).thenReturn(EXAMPLE_DEPLOYMENT_ID);
  return mockResource;
}