private JSONObject storeTaskFormInRepository(
      String formType, String taskName, String packageName, String formValue, Repository repository)
      throws Exception {

    repository.deleteAssetFromPath(
        packageName + "/" + taskName + TASKFORM_NAME_EXTENSION + "." + formType);

    AssetBuilder builder = AssetBuilderFactory.getAssetBuilder(Asset.AssetType.Byte);
    builder
        .location(packageName)
        .name(taskName + TASKFORM_NAME_EXTENSION)
        .type(formType)
        .content(formValue.getBytes("UTF-8"));

    repository.createAsset(builder.getAsset());

    Asset newFormAsset =
        repository.loadAssetFromPath(
            packageName + "/" + taskName + TASKFORM_NAME_EXTENSION + "." + formType);

    String uniqueId = newFormAsset.getUniqueId();
    if (Base64Backport.isBase64(uniqueId)) {
      byte[] decoded = Base64.decodeBase64(uniqueId);
      try {
        uniqueId = new String(decoded, "UTF-8");
      } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
      }
    }

    JSONObject retObj = new JSONObject();
    retObj.put("formid", uniqueId);

    return retObj;
  }
  @Test
  public void testLoadDictionary() throws Exception {
    Repository repository = new VFSRepository(producer.getIoService());
    ((VFSRepository) repository).setDescriptor(descriptor);
    profile.setRepository(repository);
    AssetBuilder builder = AssetBuilderFactory.getAssetBuilder(Asset.AssetType.Text);
    builder
        .content("test dictionary content")
        .type("json")
        .name("processdictionary")
        .location("/global");
    repository.createAsset(builder.getAsset());
    // setup parameters
    Map<String, String> params = new HashMap<String, String>();

    params.put("action", "load");
    params.put("profile", "jbpm");

    DictionaryServlet dictionaryServlet = new DictionaryServlet();
    dictionaryServlet.setProfile(profile);

    dictionaryServlet.init(new TestServletConfig(new TestServletContext(repository)));
    TestHttpServletResponse response = new TestHttpServletResponse();
    dictionaryServlet.doPost(new TestHttpServletRequest(params), response);

    String dictionaryContent = new String(response.getContent());
    assertNotNull(dictionaryContent);
    assertEquals("test dictionary content", dictionaryContent);
  }
  @Test
  public void testGetAssetSourceByPath() throws Exception {

    Repository repository =
        new VFSRepository(fileSystem, producer.getIoService(), producer.getActiveFileSystems());
    ((VFSRepository) repository).init();
    profile.setRepository(repository);
    AssetBuilder builder = AssetBuilderFactory.getAssetBuilder(Asset.AssetType.Text);
    builder
        .content("custom editors content")
        .type("bpmn2")
        .name("testprocess")
        .location("/defaultPackage");
    String id = repository.createAsset(builder.getAsset());
    // setup parameters
    Map<String, String> params = new HashMap<String, String>();

    params.put("profile", "jbpm");
    params.put("action", "getassetsource");
    params.put("assetlocation", "/defaultPackage/testprocess.bpmn2");
    params.put("loadoption", "optionbypath");
    boolean assetExists = repository.assetExists(id);
    assertTrue(assetExists);

    AssetServiceServlet assetServiceServlet = new AssetServiceServlet();
    assetServiceServlet.setProfile(profile);

    assetServiceServlet.init(new TestServletConfig(new TestServletContext(repository)));
    TestHttpServletResponse response = new TestHttpServletResponse();
    assetServiceServlet.doPost(new TestHttpServletRequest(params), response);

    String jsonResponse = new String(response.getContent());
    assertNotNull(jsonResponse);
    assertEquals(jsonResponse, "custom editors content\n");
  }
  @Test
  public void testCreateAsset() throws Exception {

    Repository repository =
        new VFSRepository(fileSystem, producer.getIoService(), producer.getActiveFileSystems());
    ((VFSRepository) repository).init();
    profile.setRepository(repository);
    // setup parameters
    Map<String, String> params = new HashMap<String, String>();

    params.put("profile", "jbpm");
    params.put("action", "createasset");
    params.put("assettype", "bpmn2");
    params.put("assetname", "testprocess");
    params.put("assetlocation", "/defaultPackage");
    params.put("", "");

    boolean processAssetExists = repository.assetExists("/defaultPackage/testprocess.bpmn2");
    assertFalse(processAssetExists);

    AssetServiceServlet assetServiceServlet = new AssetServiceServlet();
    assetServiceServlet.setProfile(profile);

    assetServiceServlet.init(new TestServletConfig(new TestServletContext(repository)));
    TestHttpServletResponse response = new TestHttpServletResponse();
    assetServiceServlet.doPost(new TestHttpServletRequest(params), response);

    String jsonResponse = new String(response.getContent());
    assertNotNull(jsonResponse);

    processAssetExists = repository.assetExists("/defaultPackage/testprocess.bpmn2");
    assertTrue(processAssetExists);
  }
  @Test
  public void testListDirectories() throws Exception {

    Repository repository =
        new VFSRepository(fileSystem, producer.getIoService(), producer.getActiveFileSystems());
    ((VFSRepository) repository).init();
    profile.setRepository(repository);
    repository.createDirectory("/defaultPackage");
    // setup parameters
    Map<String, String> params = new HashMap<String, String>();

    params.put("profile", "jbpm");
    params.put("action", "listdirs");
    params.put("assetlocation", "/");
    params.put("", "");

    AssetServiceServlet assetServiceServlet = new AssetServiceServlet();
    assetServiceServlet.setProfile(profile);

    assetServiceServlet.init(new TestServletConfig(new TestServletContext(repository)));
    TestHttpServletResponse response = new TestHttpServletResponse();
    assetServiceServlet.doPost(new TestHttpServletRequest(params), response);

    String jsonResponse = new String(response.getContent());
    assertNotNull(jsonResponse);
    System.out.println(jsonResponse);
    assertTrue(jsonResponse.indexOf("\"answer\":[{\"name\":\"defaultPackage\"}]") != -1);
  }
  @Test
  public void testDirectoryDoesNotExist() throws Exception {

    Repository repository =
        new VFSRepository(fileSystem, producer.getIoService(), producer.getActiveFileSystems());
    ((VFSRepository) repository).init();
    profile.setRepository(repository);
    // setup parameters
    Map<String, String> params = new HashMap<String, String>();

    params.put("profile", "jbpm");
    params.put("action", "existsdir");
    params.put("assetlocation", "/defaultPackage");
    params.put("", "");
    boolean directoryExits = repository.directoryExists("/defaultPackage");
    assertFalse(directoryExits);

    AssetServiceServlet assetServiceServlet = new AssetServiceServlet();
    assetServiceServlet.setProfile(profile);

    assetServiceServlet.init(new TestServletConfig(new TestServletContext(repository)));
    TestHttpServletResponse response = new TestHttpServletResponse();
    assetServiceServlet.doPost(new TestHttpServletRequest(params), response);

    String jsonResponse = new String(response.getContent());
    assertNotNull(jsonResponse);
    assertTrue(jsonResponse.indexOf("\"answer\":\"false\"") != -1);
  }
  @Test
  public void testStoreDictionary() throws Exception {
    Repository repository = new VFSRepository(producer.getIoService());
    ((VFSRepository) repository).setDescriptor(descriptor);
    profile.setRepository(repository);
    // setup parameters
    Map<String, String> params = new HashMap<String, String>();

    params.put("action", "save");
    params.put("profile", "jbpm");
    params.put("dvalue", "this is dictionary");

    DictionaryServlet dictionaryServlet = new DictionaryServlet();
    dictionaryServlet.setProfile(profile);

    dictionaryServlet.init(new TestServletConfig(new TestServletContext(repository)));
    TestHttpServletResponse response = new TestHttpServletResponse();
    dictionaryServlet.doPost(new TestHttpServletRequest(params), response);

    String responseText = new String(response.getContent());
    assertNotNull(responseText);
    assertEquals("saved", responseText);

    Collection<Asset> dictionary = repository.listAssets("/global", new FilterByExtension("json"));
    assertNotNull(dictionary);
    assertEquals(1, dictionary.size());

    Asset<String> dictionaryAsset =
        repository.loadAsset(dictionary.iterator().next().getUniqueId());
    assertNotNull(dictionaryAsset);
    assertEquals("this is dictionary", dictionaryAsset.getAssetContent());
  }
  @Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    String action = req.getParameter("action");
    String uuid = Utils.getUUID(req);
    String profileName = req.getParameter("profile");
    String taskName = req.getParameter("taskname");
    String taskFormValue = req.getParameter("tfvalue");
    String formType = req.getParameter("formtype");

    if (profile == null) {
      profile = _profileService.findProfile(req, profileName);
    }
    Repository repository = profile.getRepository();

    Asset<String> processAsset = null;
    try {
      processAsset = repository.loadAsset(uuid);

      if (action != null && action.equals(ACTION_LOAD)) {
        resp.setContentType("text/html");
        resp.setCharacterEncoding("UTF-8");
        PrintWriter pw = resp.getWriter();
        String taskResponse =
            getTaskFormFromRepository(
                formType, taskName, processAsset.getAssetLocation(), repository);
        pw.write(taskResponse);
      } else if (action != null && action.equals(ACTION_SAVE)) {
        resp.setContentType("application/json");
        resp.setCharacterEncoding("UTF-8");
        PrintWriter pw = resp.getWriter();
        try {
          pw.write(
              storeTaskFormInRepository(
                      formType,
                      taskName,
                      processAsset.getAssetLocation(),
                      taskFormValue,
                      repository)
                  .toString());
        } catch (Exception e) {
          e.printStackTrace();
          pw.write(new JSONObject().toString());
        }
      }
    } catch (Exception e) {
      PrintWriter pw = resp.getWriter();
      pw.write("error: " + e.getMessage());
    }
  }
  private String getCustomEditorsJSON(
      IDiagramProfile profile, ServletContext servletContext, String uuid) {

    String retStr = "";
    Repository repository = profile.getRepository();
    try {
      Asset<String> customEditorAsset =
          repository.loadAssetFromPath(
              profile.getRepositoryGlobalDir(uuid) + "/" + CUSTOMEDITORS_NAME + ".json");

      retStr = customEditorAsset.getAssetContent();

    } catch (Exception e) {
      _logger.error("Error retriving custom editors info: " + e.getMessage());
    }

    return retStr;
  }
  private String createAssetIfNotExisting(
      Repository repository, String location, String name, String type, byte[] content) {
    try {
      boolean assetExists = repository.assetExists(location + "/" + name + "." + type);
      if (!assetExists) {
        // create theme asset
        AssetBuilder assetBuilder = AssetBuilderFactory.getAssetBuilder(Asset.AssetType.Byte);
        assetBuilder.content(content).location(location).name(name).type(type).version("1.0");

        Asset<byte[]> customEditorsAsset = assetBuilder.getAsset();

        return repository.createAsset(customEditorsAsset);
      }

    } catch (Exception e) {
      logger.error(e.getMessage());
    }

    return null;
  }
  @Test
  public void testSaveFormAsset() throws Exception {
    Repository repository =
        new VFSRepository(fileSystem, producer.getIoService(), producer.getActiveFileSystems());
    ((VFSRepository) repository).init();
    profile.setRepository(repository);
    AssetBuilder builder = AssetBuilderFactory.getAssetBuilder(Asset.AssetType.Text);
    builder.content("bpmn2 content").type("bpmn2").name("testprocess").location("/defaultPackage");
    String uniqueId = repository.createAsset(builder.getAsset());
    // setup parameters
    Map<String, String> params = new HashMap<String, String>();
    params.put("uuid", uniqueId);
    params.put("action", "save");
    params.put("profile", "jbpm");
    params.put("taskname", "evaluate");
    params.put("tfvalue", "this is simple task content");

    TaskFormsEditorServlet taskFormsEditorServlet = new TaskFormsEditorServlet();
    taskFormsEditorServlet.setProfile(profile);

    taskFormsEditorServlet.init(new TestServletConfig(new TestServletContext(repository)));

    taskFormsEditorServlet.doPost(
        new TestHttpServletRequest(params), new TestHttpServletResponse());

    Collection<Asset> forms =
        repository.listAssets("/defaultPackage", new FilterByExtension("flt"));
    assertNotNull(forms);
    assertEquals(1, forms.size());
    Iterator<Asset> assets = forms.iterator();

    Asset asset1 = assets.next();
    assertEquals("evaluate-taskform", asset1.getName());
    assertEquals("/defaultPackage", asset1.getAssetLocation());

    Asset<String> form1 = repository.loadAsset(asset1.getUniqueId());
    assertNotNull(form1.getAssetContent());
    assertEquals("this is simple task content\n", form1.getAssetContent());
  }
  @Test
  public void testGetAssetInfoById() throws Exception {

    Repository repository =
        new VFSRepository(fileSystem, producer.getIoService(), producer.getActiveFileSystems());
    ((VFSRepository) repository).init();
    profile.setRepository(repository);
    AssetBuilder builder = AssetBuilderFactory.getAssetBuilder(Asset.AssetType.Text);
    builder
        .content("custom editors content")
        .type("bpmn2")
        .name("testprocess")
        .location("/defaultPackage");
    String id = repository.createAsset(builder.getAsset());
    // setup parameters
    Map<String, String> params = new HashMap<String, String>();

    params.put("profile", "jbpm");
    params.put("action", "getassetinfo");
    params.put("assetid", id);
    params.put("loadoption", "optionbyid");
    boolean assetExists = repository.assetExists(id);
    assertTrue(assetExists);

    AssetServiceServlet assetServiceServlet = new AssetServiceServlet();
    assetServiceServlet.setProfile(profile);

    assetServiceServlet.init(new TestServletConfig(new TestServletContext(repository)));
    TestHttpServletResponse response = new TestHttpServletResponse();
    assetServiceServlet.doPost(new TestHttpServletRequest(params), response);

    String jsonResponse = new String(response.getContent());
    assertNotNull(jsonResponse);
    assertTrue(
        jsonResponse.indexOf(
                "\"location\":\"/defaultPackage\",\"description\":\"\",\"name\":\"testprocess\",\"owner\":\"\",\"type\":\"bpmn2\",\"fullname\":\"testprocess.bpmn2\"")
            != -1);
  }
  @Test
  public void testLoadFormAsset() throws Exception {
    Repository repository =
        new VFSRepository(fileSystem, producer.getIoService(), producer.getActiveFileSystems());
    ((VFSRepository) repository).init();
    profile.setRepository(repository);
    AssetBuilder builder = AssetBuilderFactory.getAssetBuilder(Asset.AssetType.Text);
    builder.content("bpmn2 content").type("bpmn2").name("testprocess").location("/defaultPackage");
    String uniqueId = repository.createAsset(builder.getAsset());

    AssetBuilder builderForm = AssetBuilderFactory.getAssetBuilder(Asset.AssetType.Text);
    builderForm
        .content("this is simple task content")
        .type("flt")
        .name("evaluate-taskform")
        .location("/defaultPackage");
    String uniqueIdForm = repository.createAsset(builderForm.getAsset());

    // setup parameters
    Map<String, String> params = new HashMap<String, String>();
    params.put("uuid", uniqueId);
    params.put("action", "load");
    params.put("profile", "jbpm");
    params.put("taskname", "evaluate");
    params.put("tfvalue", "this is simple task content");

    TaskFormsEditorServlet taskFormsEditorServlet = new TaskFormsEditorServlet();
    taskFormsEditorServlet.setProfile(profile);

    taskFormsEditorServlet.init(new TestServletConfig(new TestServletContext(repository)));
    TestHttpServletResponse response = new TestHttpServletResponse();
    taskFormsEditorServlet.doPost(new TestHttpServletRequest(params), response);

    String formData = new String(response.getContent());
    System.out.println(formData);
    assertEquals("this is simple task content\n", formData);
  }
  @Override
  public Path createProcess(final Path context, final String fileName) {
    final Path path = paths.convert(paths.convert(context).resolve(fileName), false);

    String location = paths.convert(path).getParent().toString();
    String name = path.getFileName();
    String processId = buildProcessId(location, name);

    String processContent = PROCESS_STUB.replaceAll("\\$\\{processid\\}", processId);

    AssetBuilder builder = AssetBuilderFactory.getAssetBuilder(name);
    builder.location(location).content(processContent).uniqueId(path.toURI());
    Asset<String> processAsset = builder.getAsset();

    repository.createAsset(processAsset);

    return path;
  }
  @Test
  public void testProprocess() {
    Repository repository = new VFSRepository(producer.getIoService());
    ((VFSRepository) repository).setDescriptor(descriptor);
    profile.setRepository(repository);
    // prepare folders that will be used
    repository.createDirectory("/myprocesses");
    repository.createDirectory("/global");

    // prepare process asset that will be used to preprocess
    AssetBuilder builder = AssetBuilderFactory.getAssetBuilder(Asset.AssetType.Text);
    builder.content("bpmn2 content").type("bpmn2").name("process").location("/myprocesses");
    String uniqueId = repository.createAsset(builder.getAsset());

    // create instance of preprocessing unit
    JbpmPreprocessingUnit preprocessingUnitVFS =
        new JbpmPreprocessingUnit(new TestServletContext(), "/", null);

    // setup parameters
    Map<String, String> params = new HashMap<String, String>();
    params.put("uuid", uniqueId);

    // run preprocess
    preprocessingUnitVFS.preprocess(
        new TestHttpServletRequest(params), null, new TestIDiagramProfile(repository), null);

    // validate results
    Collection<Asset> globalAssets = repository.listAssets("/global");
    assertNotNull(globalAssets);
    assertEquals(30, globalAssets.size());
    repository.assetExists("/global/backboneformsinclude.fw");
    repository.assetExists("/global/backbonejsinclude.fw");
    repository.assetExists("/global/cancelbutton.fw");
    repository.assetExists("/global/checkbox.fw");
    repository.assetExists("/global/customeditors.json");
    repository.assetExists("/global/div.fw");
    repository.assetExists("/global/dropdownmenu.fw");
    repository.assetExists("/global/fieldset.fw");
    repository.assetExists("/global/form.fw");
    repository.assetExists("/global/handlebarsinclude.fw");
    repository.assetExists("/global/htmlbasepage.fw");
    repository.assetExists("/global/image.fw");
    repository.assetExists("/global/jqueryinclude.fw");
    repository.assetExists("/global/jquerymobileinclude.fw");
    repository.assetExists("/global/link.fw");
    repository.assetExists("/global/mobilebasepage.fw");
    repository.assetExists("/global/orderedlist.fw");
    repository.assetExists("/global/passwordfield.fw");
    repository.assetExists("/global/radiobutton.fw");
    repository.assetExists("/global/script.fw");
    repository.assetExists("/global/submitbutton.fw");
    repository.assetExists("/global/table.fw");
    repository.assetExists("/global/textarea.fw");
    repository.assetExists("/global/textfield.fw");
    repository.assetExists("/global/themes.json");
    repository.assetExists("/global/unorderedlist.fw");
    repository.assetExists("/global/defaultemailicon.gif");
    repository.assetExists("/global/defaultlogicon.gif");
    repository.assetExists("/global/defaultservicenodeicon.png");
    repository.assetExists("/global/.gitignore");

    Collection<Asset> defaultStuff = repository.listAssets("/myprocesses");
    assertNotNull(defaultStuff);
    assertEquals(3, defaultStuff.size());
    repository.assetExists("/myprocesses/WorkDefinitions.wid");
    // this is the process asset that was created for the test but let's check it anyway
    repository.assetExists("/myprocesses/process.bpmn2");
    repository.assetExists("/myprocesses/.gitignore");
  }
Exemplo n.º 16
0
  private String getTaskFormFromRepository(
      String formType, String taskName, String packageName, Repository repository) {
    try {
      Asset<String> formAsset =
          repository.loadAssetFromPath(
              packageName + "/" + taskName + TASKFORM_NAME_EXTENSION + "." + formType);

      if (formType.equals(FORMMODELER_FILE_EXTENSION)) {
        String uniqueId = formAsset.getUniqueId();
        if (Base64Backport.isBase64(uniqueId)) {
          byte[] decoded = Base64.decodeBase64(uniqueId);
          try {
            uniqueId = new String(decoded, "UTF-8");
          } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
          }
        }
        return formAsset.getName() + "." + formAsset.getAssetType() + "|" + uniqueId;
      } else {
        return formAsset.getAssetContent();
      }
    } catch (NoSuchFileException anfe) {
      try {
        String formValue = "";
        if (formType.equals(FORMMODELER_FILE_EXTENSION)) {
          formValue =
              formModelerService.buildEmptyFormXML(
                  taskName + TASKFORM_NAME_EXTENSION + "." + formType);
        }

        AssetBuilder builder = AssetBuilderFactory.getAssetBuilder(Asset.AssetType.Byte);
        builder
            .location(packageName)
            .name(taskName + TASKFORM_NAME_EXTENSION)
            .type(formType)
            .content(formValue.getBytes("UTF-8"));
        repository.createAsset(builder.getAsset());

        Asset<String> newFormAsset =
            repository.loadAssetFromPath(
                packageName + "/" + taskName + TASKFORM_NAME_EXTENSION + "." + formType);

        String uniqueId = newFormAsset.getUniqueId();
        if (Base64Backport.isBase64(uniqueId)) {
          byte[] decoded = Base64.decodeBase64(uniqueId);
          try {
            uniqueId = new String(decoded, "UTF-8");
          } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
          }
        }

        if (formType.equals(FORMMODELER_FILE_EXTENSION)) {
          return newFormAsset.getName() + "." + newFormAsset.getAssetType() + "|" + uniqueId;
        } else {
          return formValue;
        }
      } catch (Exception e) {
        e.printStackTrace();
        _logger.error(e.getMessage());
      }
    }
    return "false";
  }
 private void createDirectoryIfNotExist(Repository repository, String location) throws Exception {
   if (!repository.directoryExists(location)) {
     repository.createDirectory(location);
   }
 }