How to use org.jbpm.console.ng.ga.forms.service.providing

@Override
protected String getFormName( TaskRenderingSettings settings ) {
  return settings.getTask().getFormName();
}

@Override
protected String getFormName( ProcessRenderingSettings settings ) {
  return settings.getProcess().getId();
}

@Dependent
@DefaultFormProvider
public class DefaultKieWorkbenchFormsProvider extends AbstractKieWorkbenchFormsProvider implements FormProvider<KieWorkbenchFormRenderingSettings> {


  @Inject
  public DefaultKieWorkbenchFormsProvider( ProcessFormsValuesProcessor processFormsValuesProcessor,
                       TaskFormValuesProcessor taskFormValuesProcessor ) {
    super( processFormsValuesProcessor, taskFormValuesProcessor );
  }

  @Override
  public int getPriority() {
    return 7000;
  }

  @Override
  public KieWorkbenchFormRenderingSettings render( ProcessRenderingSettings settings ) {
    return processFormsValuesProcessor.generateRenderingContext( settings, true );
  }

  @Override
  public KieWorkbenchFormRenderingSettings render( TaskRenderingSettings settings ) {
    return taskFormValuesProcessor.generateRenderingContext( settings, true );
  }
}

@Override
public StaticHTMLFormRenderingSettings render( ProcessRenderingSettings settings ) {
  Map<String, Object> renderContext = new HashMap<String, Object>();
  renderContext.put( "process", settings.getProcess() );
  renderContext.put( "outputs", settings.getProcessData() );
  renderContext.put( "marshallerContext", settings.getMarshallerContext() );
  return renderForm( settings.getProcess().getName(), getProcessTemplateInputStream( settings ), renderContext );
}

@Override
public StaticHTMLFormRenderingSettings render( TaskRenderingSettings settings ) {
  Map<String, Object> renderContext = new HashMap<String, Object>();
  renderContext.put( "task", settings.getTask() );
  renderContext.put( "marshallerContext", settings.getMarshallerContext() );
  Map<String, Object> inputs = settings.getInputs();
  if ( inputs != null && !inputs.isEmpty() ) {
    renderContext.put( "inputs", inputs );
    renderContext.putAll( inputs );
  }
  Map<String, Object> outputs = settings.getOutputs();
  if ( outputs != null && !outputs.isEmpty() ) {
    renderContext.put( "outputs", outputs );
    renderContext.putAll( outputs );
    settings.getTask().setOutputIncluded( true );
  }
  return renderForm( settings.getTask().getName(), getTaskTemplateInputStream( settings ), renderContext );
}

org.jbpm.console.ng.ga.forms.service.providing.model.ProcessDefinition processDesc = new org.jbpm.console.ng.ga.forms.service.providing.model.ProcessDefinition();
processDesc.setId( processDefinition.getId() );
processDesc.setName( processDefinition.getName() );
processDesc.setPackageName( processDefinition.getPackageName() );
processDesc.setDeploymentId( serverTemplateId + "@" + processDefinition.getContainerId() + "@" + System.currentTimeMillis() );
  ProcessRenderingSettings settings = new ProcessRenderingSettings( processDesc,
                                   processData,
                                   formContent,
    FormRenderingSettings renderingSettings = provider.render( settings );

@Override
protected Map<String, Object> generateRawFormData( TaskRenderingSettings settings,
                          FormDefinition form ) {
  final Map<String, Object> formData = new HashMap<>();
  if ( isValid( form ) ) {
    Map<String, Object> inputs = settings.getInputs();
    Map<String, Object> outputs = settings.getOutputs();
    formData.putAll( inputs );
    if ( settings.getTask().isOutputIncluded() ) {
      formData.putAll( outputs );
    }
  }
  return formData;
}

private FormRenderingSettings renderDefaultProcessForm( org.jbpm.console.ng.ga.forms.service.providing.model.ProcessDefinition processDesc,
                            Map<String, String> processData,
                            KieServicesClient kieServicesClient ) {
  try {
    return defaultFormProvider.render( new ProcessRenderingSettings( processDesc,
                                     processData,
                                     "",
                                     new ContentMarshallerContext( null,
                                                    kieServicesClient.getClassLoader() ) ) );
  } catch ( Exception ex ) {
    logger.warn( "Unable to generate default form for process '" + processDesc.getName() + "': {}",
           ex.getMessage() );
  }
  return null;
}

private FormRenderingSettings renderDefaultTaskForm( TaskDefinition taskInstance,
                           Map<String, Object> inputs,
                           Map<String, Object> outputs,
                           KieServicesClient kieServicesClient ) {
  try {
    return defaultFormProvider.render( new TaskRenderingSettings( taskInstance,
                                   inputs,
                                   outputs,
                                   "",
                                   new ContentMarshallerContext( null,
                                                  kieServicesClient.getClassLoader() ) ) );
  } catch ( Exception ex ) {
    logger.warn( "Unable to generate default form for task '" + taskInstance.getName() + "': {}",
           ex.getMessage() );
  }
  return null;
}

@Override
protected Map<String, Object> getOutputValues( Map<String, Object> values,
                        FormDefinition form,
                        TaskRenderingSettings settings ) {
  if ( isValid( form ) ) {
    TaskDefinition task = settings.getTask();
    // Removing task inputs
    task.getTaskInputDefinitions().keySet().forEach( key -> {
      if ( !task.getTaskOutputDefinitions().containsKey( key ) ) {
        values.remove( key );
      }
    } );
    return values;
  }
  throw new IllegalArgumentException( "Form not valid for task" );
}

@Override
protected ProcessRenderingSettings generateSettigns() {
  when( process.getId() ).thenReturn( "invoices" );
  Map<String, String> formData = new HashMap<>();
  formData.put( "invoice", Invoice.class.getName() );
  return new ProcessRenderingSettings( process,
                     formData,
                     getFormContent(),
                     marshallerContext );
}

@Override
protected TaskRenderingSettings generateSettigns() {
  when( task.getFormName() ).thenReturn( "modify" );
  Invoice invoice = new Invoice();
  invoice.setClient( new Client( new Long( 1234 ), "John Snow", "Winterfell" ) );
  invoice.setDate( new Date() );
  invoice.setComments( "Everything was perfect" );
  invoice.setTotal( 150.5 );
  List<InvoiceLine> lines = new ArrayList<>();
  lines.add( new InvoiceLine( "Really Dangerous Sword", 1, 100.5, 100.5 ) );
  lines.add( new InvoiceLine( "A comfortable black jacket", 1, 50.0, 50.0 ) );
  invoice.setLines( lines );
  Map<String, Object> inputs = new HashMap<>();
  inputs.put( "in_invoice", invoice );
  return new TaskRenderingSettings( task, inputs, new HashMap<>(), getFormContent(), marshallerContext );
}

@Override
protected void prepareContext( TaskRenderingSettings settings, BackendFormRenderingContext context ) {
  context.getRenderingContext().setRenderMode( !"InProgress".equals( settings.getTask().getStatus() ) ? RenderMode.READ_ONLY_MODE : RenderMode.EDIT_MODE );
}

public KieWorkbenchFormRenderingSettings generateRenderingContext( T settings, boolean generateDefaultForms ) {
  if ( generateDefaultForms || !StringUtils.isEmpty( settings.getFormContent() ) ) {
    try {
      ContextForms forms = generateDefaultForms ? generateDefaultForms( settings ) : parseForms( settings );
      if ( forms.getRootForm() == null || !isValid( forms.getRootForm() ) ) {
        return null;
      }
      Map<String, Object> rawData = generateRawFormData( settings, forms.getRootForm() );
      BackendFormRenderingContext context = contextManager.registerContext( forms.getRootForm(),
                                         rawData,
                                         settings.getMarshallerContext().getClassloader(),
                                         forms.getNestedForms().toArray(
                                             new FormDefinition[forms.getNestedForms().size()] ) );
      prepareContext( settings, context );
      context.getAttributes().put( SETTINGS_ATRA_NAME, settings );
      return new KieWorkbenchFormRenderingSettings( context.getTimestamp(), context.getRenderingContext() );
    } catch ( Exception ex ) {
      getLogger().debug( "Unable to generate render form: ", ex );
    }
  }
  return null;
}

@Override
protected InputStream getTaskTemplateInputStream( TaskRenderingSettings settings ) {
  if ( StringUtils.isEmpty( settings.getFormContent() ) ) {
    return null;
  }
  return new ByteArrayInputStream( settings.getFormContent().getBytes() );
}

@Override
protected InputStream getProcessTemplateInputStream( ProcessRenderingSettings settings ) {
  if ( StringUtils.isEmpty( settings.getFormContent() ) ) {
    return null;
  }
  return new ByteArrayInputStream( settings.getFormContent().getBytes() );
}

protected ContextForms parseForms( T settings ) {
  ContextForms result = new ContextForms();
  JsonParser parser = new JsonParser();
  Gson gson = new Gson();
  JsonElement element = parser.parse( settings.getFormContent() );
  JsonArray forms = element.getAsJsonArray();
  forms.forEach( jsonForm -> {
    String content = gson.toJson( jsonForm );
    if ( !StringUtils.isEmpty( content ) ) {
      FormDefinition formDefinition = formSerializer.deserialize( content );
      if ( formDefinition != null ) {
        if ( formDefinition.getName().startsWith( getFormName( settings ) + BPMNVariableUtils.TASK_FORM_SUFFIX ) ) {
          result.setRootForm( formDefinition );
        } else {
          result.getNestedForms().add( formDefinition );
        }
      }
    }
  } );
  return result;
}

@Override
protected Collection<FormDefinition> generateDefaultFormsForContext( ProcessRenderingSettings settings ) {
  List<JBPMVariable> variables = new ArrayList<>();
  settings.getProcessData().forEach( ( name, type ) -> {
    variables.add( new JBPMVariable( name, type ) );
  } );
  BusinessProcessFormModel formModel = new BusinessProcessFormModel( settings.getProcess().getId(),
                                    settings.getProcess().getName(),
                                    variables );
  return dynamicBPMNFormGenerator.generateProcessForms( formModel,
                             settings.getMarshallerContext().getClassloader() );
}

@Inject
public FormServiceEntryPointImpl( Instance<FormProvider<? extends FormRenderingSettings>> providersInjected,
                 @DefaultFormProvider FormProvider<? extends FormRenderingSettings> defaultFormProvider ) {
  for ( FormProvider provider : providersInjected ) {
    providers.add( provider );
  }
  this.defaultFormProvider = defaultFormProvider;
}

@DefaultFormProvider
@Dependent
public class ClasspathFormProvider extends FreemakerFormProvider {
  @Override
  protected InputStream getProcessTemplateInputStream( ProcessRenderingSettings settings ) {
    return this.getClass().getResourceAsStream( "/forms/DefaultProcess.ftl" );
  }

  @Override
  protected InputStream getTaskTemplateInputStream( TaskRenderingSettings settings ) {
    return this.getClass().getResourceAsStream( "/forms/DefaultTask.ftl" );
  }

  @Override
  public int getPriority() {
    return 1000;
  }

}