congrats Icon
New! Announcing our next generation AI code completions
Read here
Tabnine Logo
FormRenderContextManager
Code IndexAdd Tabnine to your IDE (free)

How to use
FormRenderContextManager
in
org.jbpm.formModeler.api.client

Best Java code snippets using org.jbpm.formModeler.api.client.FormRenderContextManager (Showing top 20 results out of 315)

  • Add the Codota plugin to your IDE and get smart completions
private void myMethod () {
List l =
  • Codota Iconnew ArrayList()
  • Codota Iconnew LinkedList()
  • Smart code suggestions by Tabnine
}
origin: org.jbpm/jbpm-form-modeler-form-provider

@Override
public Form getForm( String ctxUID ) {
  FormRenderContext renderContext = formRenderContextManager.getRootContext( ctxUID );
  if ( renderContext != null ) return renderContext.getForm();
  return null;
}
origin: org.jbpm/jbpm-wb-forms-modeler-backend

@Override
public void completeTaskFromContext(String ctxUID,
                  String serverTemplateId,
                  String containerId,
                  Long taskId) {
  Map<String, Object> params = formRenderContextManager.getFormRenderContext(ctxUID).getOutputData();
  formRenderContextManager.removeContext(ctxUID);
  taskService.completeTask(serverTemplateId,
               containerId,
               taskId,
               params);
}
origin: org.jbpm/jbpm-form-modeler-form-provider

protected String renderProcessForm(ProcessDefinition process, InputStream template, Map<String, Object> renderContext) {
  String result = null;
  try {
    Form form = formSerializationManager.loadFormFromXML(template);
    Map ctx = new HashMap();
    ctx.put("process", process);
    // Adding forms to context while forms are'nt available on marshaller classloader
    FormRenderContext context = formRenderContextManager.newContext(form, process.getDeploymentId(), ctx, new HashMap<String, Object>());
    formRenderContentMarshaller.addContentMarshaller(context.getUID(), (ContentMarshallerContext) renderContext.get("marshallerContext"));
    result = context.getUID();
  } catch (Exception e) {
    log.warn("Error rendering form: ", e);
  }
  return result;
}
origin: org.jbpm/jbpm-form-modeler-ui

  protected void initContext() {
    context = new FormRenderContext(CTX_UID,
                    form,
                    inputs,
                    outputs);

    when(formRenderContextManager.getFormRenderContext(anyString())).thenReturn(context);
    when(formRenderContextManager.getRootContext(anyString())).thenReturn(context);
  }
}
origin: org.jbpm/jbpm-form-modeler-ui

public void actionSubmitForm(CommandRequest request) {
  String ctxUID = request.getRequestObject().getParameter("ctxUID");
  if (ctx == null || ctx.getUID().equals(ctxUID)) ctx = formRenderContextManager.getFormRenderContext(ctxUID);
  if (ctx == null) return;
  try {
    Form form = ctx.getForm();
    formProcessor.setValues(form, ctxUID, request.getRequestObject().getParameterMap(), request.getFilesByParamName());
    FormStatusData fsd = formProcessor.read(ctxUID);
    ctx.setErrors(fsd.getWrongFields().size());
    String persist = request.getRequestObject().getParameter("persistForm");
    if (fsd.isValid()) {
      ctx.setSubmit(true);
      if (Boolean.parseBoolean(persist)) formRenderContextManager.persistContext(ctx);
    }
    formRenderContextManager.fireContextSubmit(new FormSubmittedEvent(new FormRenderContextTO(ctx)));
  } catch (Exception e) {
    log.error("Error submitting form: ", e);
    formRenderContextManager.fireContextSubmitError(new FormSubmitFailEvent(new FormRenderContextTO(ctx), e.getMessage()));
  }
}
origin: org.jbpm/jbpm-form-modeler-ui

@Override
public void doStart(CommandRequest commandRequest) {
  String ctxUID = commandRequest.getRequestObject().getParameter("ctxUID");
  if (StringUtils.isEmpty(ctxUID)) return;
  ctx = formRenderContextManager.getFormRenderContext(ctxUID);
}
origin: org.jbpm/jbpm-form-modeler-ui

public CommandResponse actionDoResize(CommandRequest request) {
  String ctxUID = request.getRequestObject().getParameter("ctxUID");
  if (ctx == null || ctx.getUID().equals(ctxUID)) ctx = formRenderContextManager.getFormRenderContext(ctxUID);
  if (ctx != null) {
    String width = request.getRequestObject().getParameter("width");
    String height = request.getRequestObject().getParameter("height");
    if (!StringUtils.isEmpty(width) && !StringUtils.isEmpty(height)) {
      ResizeFormcontainerEvent event = new ResizeFormcontainerEvent();
      event.setContext(new FormRenderContextTO(ctx));
      event.setWidth(Integer.decode(width));
      event.setHeight(Integer.decode(height));
      formRenderContextManager.fireContextFormResize(event);
    }
  }
  return new DoNothingResponse();
}
origin: org.jbpm/jbpm-form-modeler-ui

@Override
public void clear(String ctxUID) {
  clear(formRenderContextManager.getFormRenderContext(ctxUID));
}
origin: org.jbpm/jbpm-wb-forms-modeler-backend

@Override
public Form getForm(String ctxUID) {
  FormRenderContext renderContext = formRenderContextManager.getRootContext(ctxUID);
  if (renderContext != null) {
    return renderContext.getForm();
  }
  return null;
}
origin: org.jbpm/jbpm-wb-forms-modeler-backend

@Override
public Long startProcessFromRenderContext(String ctxUID,
                     String serverTemplateId,
                     String domainId,
                     String processId,
                     String correlationKey,
                     Long parentProcessInstanceId) {
  Map<String, Object> params = formRenderContextManager.getFormRenderContext(ctxUID).getOutputData();
  formRenderContextManager.removeContext(ctxUID);
  return processService.startProcess(serverTemplateId,
                    domainId,
                    processId,
                    correlationKey,
                    params);
}
origin: org.jbpm/jbpm-form-modeler-ui

public void persist(String ctxUid) throws Exception {
  ctxUid = StringUtils.defaultIfEmpty(ctxUid, FormProcessor.DEFAULT_NAMESPACE);
  persist(formRenderContextManager.getFormRenderContext(ctxUid));
}
origin: org.jbpm/jbpm-form-modeler-form-provider

protected String renderTaskForm(Task task, InputStream template, Map<String, Object> renderContext) {
  String result = null;
  try {
    Form form = formSerializationManager.loadFormFromXML(template);
    Map inputs = new HashMap();
    Map outputs;
    if (task.getTaskData().getOutputContentId() == -1) outputs = new HashMap();
    else outputs = (Map) renderContext.get("outputs");
    Map m = (Map) renderContext.get("inputs");
    if (m != null) inputs.putAll(m);
    inputs.put("task", task);
    // Adding forms to context while forms are'nt available on marshaller classloader
    FormRenderContext context = formRenderContextManager.newContext(form, task.getTaskData().getDeploymentId(), inputs, outputs);
    formRenderContentMarshaller.addContentMarshaller(context.getUID(), (ContentMarshallerContext) renderContext.get("marshallerContext"));
    String status = task.getTaskData().getStatus().name();
    boolean readonly = !"InProgress".equals(status);
    context.setReadonly(readonly);
    result = context.getUID();
  } catch (Exception e) {
    log.warn("Error rendering form: ", e);
  }
  return result;
}
origin: org.jbpm/jbpm-wb-forms-modeler-backend

@Override
public Form getFormByPath(String ctxUID,
             String formPath) {
  FormRenderContext renderContext = formRenderContextManager.getRootContext(ctxUID);
  if (renderContext != null) {
    try {
      Object form = renderContext.getContextForms().get(formPath);
      if (form != null) {
        if (form instanceof Form) {
          return (Form) form;
        } else if (form instanceof String) {
          Form result = formSerializationManager.loadFormFromXML((String) form);
          renderContext.getContextForms().put(formPath,
                            result);
          return result;
        }
      }
    } catch (Exception e) {
      log.warn("Error getting form {} from context {}: {}",
           formPath,
           ctxUID,
           e);
    }
  }
  return null;
}
origin: org.jbpm/jbpm-wb-forms-modeler-backend

@Override
public Long saveTaskStateFromRenderContext(String ctxUID,
                      String serverTemplateId,
                      String containerId,
                      Long taskId,
                      boolean clearStatus) {
  Map<String, Object> params = formRenderContextManager.getFormRenderContext(ctxUID).getOutputData();
  if (clearStatus) {
    formRenderContextManager.removeContext(ctxUID);
  }
  taskService.saveTaskContent(serverTemplateId,
                containerId,
                taskId,
                params);
  return -1l;
}
origin: org.jbpm/jbpm-form-modeler-ui

public FormStatusData read(String ctxUid) {
  FormStatusDataImpl data = null;
  try {
    FormRenderContext context = formRenderContextManager.getFormRenderContext(ctxUid);
    if (context == null ) return null;
    FormStatus formStatus = getContextFormStatus(context);
    boolean isNew = formStatus == null;
    if (isNew) {
      formStatus = createContextFormStatus(context);
    }
    data = new FormStatusDataImpl(formStatus, isNew);
  } catch (Exception e) {
    log.error("Error: ", e);
  }
  return data;
}
origin: org.jbpm/jbpm-wb-forms-modeler-backend

@Override
public FormModelerFormRenderingSettings render(ProcessRenderingSettings settings) {
  if (!StringUtils.isEmpty(settings.getFormContent())) {
    try {
      Form form = formSerializationManager.loadFormFromXML(settings.getFormContent());
      Map ctx = new HashMap();
      ctx.put("process",
          settings.getProcess());
      // Adding forms to context while forms are'nt available on marshaller classloader
      FormRenderContext context = formRenderContextManager.newContext(form,
                                      settings.getServerTemplateId(),
                                      ctx,
                                      new HashMap<>());
      formRenderContentMarshaller.addContentMarshaller(context.getUID(),
                               settings.getMarshallerContext());
      return new FormModelerFormRenderingSettings(context.getUID());
    } catch (Exception e) {
      log.warn("Error rendering form: ",
           e);
    }
  }
  return null;
}
origin: org.jbpm/jbpm-wb-forms-modeler-backend

@Override
public Form getFormById(String ctxUID,
            long formId) {
  FormRenderContext renderContext = formRenderContextManager.getRootContext(ctxUID);
  if (renderContext != null) {
    try {
origin: org.jbpm/jbpm-wb-forms-modeler-backend

FormRenderContext context = formRenderContextManager.newContext(form,
                                settings.getServerTemplateId(),
                                inputs,
origin: org.jbpm/jbpm-form-modeler-ui

@Override
public Object persistFormHolder(Form form, String namespace, Map<String, Object> mapToPersist, DataHolder holder, Object loadedObject) throws Exception {
  if (holder == null) return null;
  if (loadedObject == null) {
    FormRenderContext context = formRenderContextManager.getRootContext(namespace);
    loadedObject = holder.createInstance(context);
  }
  for (Iterator it = mapToPersist.keySet().iterator(); it.hasNext();) {
    String fieldName = (String) it.next();
    Field field = form.getField(fieldName);
    if (field != null && holder.isAssignableForField(field)) {
      String bindingString = field.getOutputBinding();
      if (StringUtils.isEmpty(bindingString)) continue;
      bindingString = bindingExpressionUtil.extractBindingExpression(bindingString);
      String holderFieldId = bindingString.substring(holder.getOuputId().length() + 1);
      Object value = persistField(field, mapToPersist, holder, namespace);
      holder.writeValue(loadedObject, holderFieldId, value);
    }
  }
  return loadedObject;
}
origin: org.jbpm/jbpm-form-modeler-form-provider

@Override
public Form getFormById( String ctxUID, long formId ) {
  FormRenderContext renderContext = formRenderContextManager.getRootContext( ctxUID );
  if ( renderContext != null ) {
    try {
      if ( renderContext.getForm().getId().equals( new Long( formId ) ) ) {
        return renderContext.getForm();
      }
      Map forms = formManagerService.getAllFormsByDeployment( renderContext.getDeploymentId() );
      if ( forms == null ) forms = renderContext.getContextForms();
      String header = formSerializationManager.generateHeaderFormFormId( formId );
      for ( Iterator it = forms.keySet().iterator(); it.hasNext(); ) {
        String key = ( String ) it.next();
        Object form = forms.get( key );
        if ( form instanceof Form ) {
          if ( ( ( Form ) form ).getId().equals( formId ) ) {
            return ( Form ) form;
          }
        } else if ( form instanceof String && form.toString().trim().startsWith( header ) ) {
          Form result = formSerializationManager.loadFormFromXML( ( String ) form );
          renderContext.getContextForms().put( key, result );
          return result;
        }
      }
    } catch ( Exception e ) {
      log.warn( "Error getting form {} from context {}: {}", formId, ctxUID, e );
    }
  }
  return null;
}
org.jbpm.formModeler.api.clientFormRenderContextManager

Most used methods

  • getRootContext
  • getFormRenderContext
  • newContext
  • fireContextFormResize
  • fireContextSubmit
  • fireContextSubmitError
  • persistContext
  • removeContext

Popular in Java

  • Reading from database using SQL prepared statement
  • setScale (BigDecimal)
  • putExtra (Intent)
  • onCreateOptionsMenu (Activity)
  • OutputStream (java.io)
    A writable sink for bytes.Most clients will use output streams that write data to the file system (
  • TreeSet (java.util)
    TreeSet is an implementation of SortedSet. All optional operations (adding and removing) are support
  • ExecutorService (java.util.concurrent)
    An Executor that provides methods to manage termination and methods that can produce a Future for tr
  • Executors (java.util.concurrent)
    Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory,
  • Annotation (javassist.bytecode.annotation)
    The annotation structure.An instance of this class is returned bygetAnnotations() in AnnotationsAttr
  • HttpServlet (javax.servlet.http)
    Provides an abstract class to be subclassed to create an HTTP servlet suitable for a Web site. A sub
  • Top 25 Plugins for Webstorm
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now