org.jbpm.designer.client.shared.AssignmentData Maven / Gradle / Ivy
/*
* Copyright 2015 Red Hat, Inc. and/or its affiliates.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jbpm.designer.client.shared;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import org.jboss.errai.common.client.api.annotations.Portable;
import org.jbpm.designer.client.resources.i18n.DesignerEditorConstants;
import org.jbpm.designer.client.shared.Variable.VariableType;
import org.jbpm.designer.client.shared.util.StringUtils;
/**
*
* Class which contains everything associated with Assignments which
* is passed between the Designer properties and the DataIOEditor, i.e.
* Assignments, InputVariables, OutputVariables, DataTypes and ProcessVariables
*/
@Portable
public class AssignmentData {
private List inputVariables = new ArrayList();
private List outputVariables = new ArrayList();
private List processVariables = new ArrayList();
private List assignments = new ArrayList();
private List dataTypes = new ArrayList();
private List dataTypeDisplayNames = new ArrayList();
private Map mapDisplayNameToDataType = new HashMap();
private Map mapDataTypeToDisplayName = new HashMap();
private Map mapSimpleDataTypeToDisplayName = new HashMap();
private List disallowedPropertyNames = new ArrayList();
private String variableCountsString = "";
public AssignmentData() {
}
public AssignmentData(String sInputVariables, String sOutputVariables, String sProcessVariables,
String sAssignments, String sDataTypes, String sDisallowedPropertyNames) {
// setDataTypes before variables because these determine whether variable datatypes are custom or not
setDataTypes(sDataTypes);
setProcessVariables(sProcessVariables);
setInputVariables(sInputVariables);
setOutputVariables(sOutputVariables);
setAssignments(sAssignments);
setDisallowedPropertyNames(sDisallowedPropertyNames);
}
public AssignmentData(String sInputVariables, String sOutputVariables, String sProcessVariables,
String sAssignments, String sDisallowedPropertyNames) {
this(sInputVariables, sOutputVariables, sProcessVariables, sAssignments, null, sDisallowedPropertyNames);
}
/**
* Creates AssignmentData based on a list of inputAssignmentRows and outputAssignmentRows.
*
* @param inputAssignmentRows
* @param outputAssignmentRows
*/
public AssignmentData(List inputAssignmentRows, List outputAssignmentRows,
List dataTypes, List dataTypeDisplayNames) {
setDataTypes(dataTypes, dataTypeDisplayNames);
if (inputAssignmentRows != null) {
for (AssignmentRow row : inputAssignmentRows) {
convertAssignmentRow(row);
}
}
if (outputAssignmentRows != null) {
for (AssignmentRow row : outputAssignmentRows) {
convertAssignmentRow(row);
}
}
}
protected void convertAssignmentRow(AssignmentRow assignmentRow) {
if (assignmentRow.getName() == null || assignmentRow.getName().isEmpty()) {
return;
}
if (findVariable(assignmentRow.getName(), assignmentRow.getVariableType()) == null) {
Variable var = new Variable(assignmentRow.getName(), assignmentRow.getVariableType(),
getDataTypeFromDisplayName(assignmentRow.getDataType()), assignmentRow.getCustomDataType());
addVariable(var);
}
String processVarName;
// If there's a constant, use it rather than processVar
String constant = assignmentRow.getConstant();
if (constant != null && !constant.isEmpty()) {
processVarName = null;
constant = StringUtils.createUnquotedConstant(constant);
}
else {
processVarName = assignmentRow.getProcessVar();
if (processVarName != null && !processVarName.isEmpty()) {
HashSet processVarsNames = new HashSet();
for(Variable var : processVariables) {
processVarsNames.add(var.getName());
}
if(!processVarsNames.contains(processVarName)) {
Variable processVar = new Variable(processVarName, VariableType.PROCESS,
assignmentRow.getDataType(), assignmentRow.getCustomDataType());
processVariables.add(processVar);
}
}
}
if ((constant == null || constant.isEmpty()) && (processVarName == null || processVarName.isEmpty()))
{
return;
}
Assignment assignment = new Assignment(this, assignmentRow.getName(), assignmentRow.getVariableType(),
processVarName, constant);
assignments.add(assignment);
}
public List getInputVariables() {
return inputVariables;
}
public String getInputVariablesString() {
return getStringForList(inputVariables);
}
public void setInputVariables(String sInputVariables) {
inputVariables.clear();
if (sInputVariables != null && !sInputVariables.isEmpty()) {
String[] inputs = sInputVariables.split(",");
for (String input : inputs) {
if (!input.isEmpty()) {
Variable var = Variable.deserialize(input, Variable.VariableType.INPUT, dataTypes);
if (var != null && var.getName() != null && !var.getName().isEmpty()) {
inputVariables.add(var);
}
}
}
}
}
public List getOutputVariables() {
return outputVariables;
}
public String getOutputVariablesString() {
return getStringForList(outputVariables);
}
public void setOutputVariables(String sOutputVariables) {
outputVariables.clear();
if (sOutputVariables != null && !sOutputVariables.isEmpty()) {
String[] outputs = sOutputVariables.split(",");
for (String output : outputs) {
if (!output.isEmpty()) {
Variable var = Variable.deserialize(output, Variable.VariableType.OUTPUT, dataTypes);
if (var != null && var.getName() != null && !var.getName().isEmpty()) {
outputVariables.add(var);
}
}
}
}
}
public List getProcessVariables() {
return processVariables;
}
public String getProcessVariablesString() {
return getStringForList(processVariables);
}
public void setProcessVariables(String sProcessVariables) {
processVariables.clear();
if (sProcessVariables != null && !sProcessVariables.isEmpty()) {
HashSet procVarNames = new HashSet();
String[] processVars = sProcessVariables.split(",");
for (String processVar : processVars) {
if (!processVar.isEmpty()) {
Variable var = Variable.deserialize(processVar, Variable.VariableType.PROCESS, dataTypes);
if (var != null && var.getName() != null && !var.getName().isEmpty()) {
if (!procVarNames.contains(var.getName())) {
procVarNames.add(var.getName());
processVariables.add(var);
}
}
}
}
}
}
public List getAssignments() {
return assignments;
}
public String getAssignmentsString() {
return getStringForList(assignments);
}
public void setAssignments(String sAssignments) {
assignments.clear();
if (sAssignments != null && !sAssignments.isEmpty()) {
String[] as = sAssignments.split(",");
for (String a : as) {
if (!a.isEmpty()) {
Assignment ass = Assignment.deserialize(this, a);
if (ass != null && ass.getName() != null && !ass.getName().isEmpty()) {
assignments.add(ass);
}
}
}
}
}
public List getDataTypes() {
return dataTypes;
}
protected void setDataTypes(String dataTypes) {
this.dataTypes.clear();
this.dataTypeDisplayNames.clear();
mapDisplayNameToDataType.clear();
mapDataTypeToDisplayName.clear();
mapSimpleDataTypeToDisplayName.clear();
if (dataTypes != null && !dataTypes.isEmpty()) {
String[] dts = dataTypes.split(",");
for (String dt : dts) {
dt = dt.trim();
if (!dt.isEmpty() && !dt.startsWith("*")) {
String dtName = "";
String dtDisplayName = "";
String dtSimpleType = "";
if (dt.contains(":")) {
dtDisplayName = dt.substring(0, dt.indexOf(':')).trim();
dtName = dt.substring(dt.indexOf(':') + 1).trim();
}
else {
dtDisplayName = dt.trim();
dtName = dt.trim();
}
if (dtDisplayName.indexOf(' ') > 0) {
dtSimpleType = dtDisplayName.substring(0, dtDisplayName.indexOf(' '));
}
else {
dtSimpleType = dtDisplayName;
}
if (!dtName.isEmpty()) {
this.dataTypeDisplayNames.add(dtDisplayName);
this.dataTypes.add(dtName);
mapDisplayNameToDataType.put(dtDisplayName, dtName);
mapDataTypeToDisplayName.put(dtName, dtDisplayName);
}
if (!dtSimpleType.isEmpty()){
mapSimpleDataTypeToDisplayName.put(dtSimpleType, dtDisplayName);
}
}
}
}
}
protected void setDataTypes(List dataTypes, List dataTypeDisplayNames) {
this.dataTypes.clear();
this.dataTypeDisplayNames.clear();
mapDisplayNameToDataType.clear();
mapDataTypeToDisplayName.clear();
mapSimpleDataTypeToDisplayName.clear();
this.dataTypes = dataTypes;
this.dataTypeDisplayNames = dataTypeDisplayNames;
for (int i = 0; i < dataTypeDisplayNames.size(); i++) {
if (i < dataTypes.size()) {
mapDisplayNameToDataType.put(dataTypeDisplayNames.get(i), dataTypes.get(i));
mapDataTypeToDisplayName.put(dataTypes.get(i), dataTypeDisplayNames.get(i));
}
else {
mapDisplayNameToDataType.put(dataTypeDisplayNames.get(i), dataTypeDisplayNames.get(i));
mapDataTypeToDisplayName.put(dataTypeDisplayNames.get(i), dataTypeDisplayNames.get(i));
}
}
}
public List getDisallowedPropertyNames() {
return disallowedPropertyNames;
}
protected void setDisallowedPropertyNames(String disallowedPropertyNames) {
this.disallowedPropertyNames.clear();
if (disallowedPropertyNames != null && !disallowedPropertyNames.isEmpty()) {
String[] hps = disallowedPropertyNames.split(",");
for (String hp : hps) {
hp = hp.trim();
if (!hp.isEmpty()) {
this.disallowedPropertyNames.add(hp);
}
}
}
}
public Variable findProcessVariable(String processVarName) {
if (processVarName == null || processVarName.isEmpty()) {
return null;
}
for (Variable var : processVariables) {
if (processVarName.equals(var.getName())) {
return var;
}
}
return null;
}
public Variable findVariable(String variableName, VariableType variableType) {
if (variableName == null || variableName.isEmpty()) {
return null;
}
if (variableType == Variable.VariableType.INPUT) {
for (Variable var : inputVariables) {
if (variableName.equals(var.getName())) {
return var;
}
}
} else if (variableType == Variable.VariableType.OUTPUT) {
for (Variable var : outputVariables) {
if (variableName.equals(var.getName())) {
return var;
}
}
}
return null;
}
public void addVariable(Variable variable) {
if (variable.getName() == null || variable.getName().isEmpty()) {
return;
}
if (findVariable(variable.getName(), variable.getVariableType()) != null) {
return;
}
if (variable.getVariableType() == VariableType.INPUT) {
inputVariables.add(variable);
}
else if (variable.getVariableType() == VariableType.OUTPUT) {
outputVariables.add(variable);
}
else if (variable.getVariableType() == VariableType.PROCESS) {
processVariables.add(variable);
}
}
public List getDataTypeDisplayNames() {
return dataTypeDisplayNames;
}
public String getDataTypeFromDisplayName(String dataTypeDisplayName) {
if (mapDisplayNameToDataType.get(dataTypeDisplayName) != null) {
return mapDisplayNameToDataType.get(dataTypeDisplayName);
}
else {
return dataTypeDisplayName;
}
}
public String getDisplayNameFromDataType(String dataType) {
if (mapDataTypeToDisplayName.get(dataType) != null) {
return mapDataTypeToDisplayName.get(dataType);
}
else {
return dataType;
}
}
public String getDataTypeDisplayNameForUserString(String userValue) {
if (mapDataTypeToDisplayName.containsKey(userValue)) {
return mapDataTypeToDisplayName.get(userValue);
}
else if (mapSimpleDataTypeToDisplayName.containsKey(userValue)) {
return mapSimpleDataTypeToDisplayName.get(userValue);
}
return null;
}
public String getDataTypesString() {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < dataTypes.size(); i++) {
String dataTypeDisplayName = dataTypes.get(i);
String dataType = dataTypes.get(i);
sb.append(dataTypeDisplayName).append(':').append(dataType).append(',');
}
if(sb.length() > 0) {
sb.setLength(sb.length() - 1);
}
return sb.toString();
}
public String getDisallowedPropertyNamesString() {
return getStringForList(disallowedPropertyNames);
}
public List getProcessVariableNames() {
List processVarNames = new ArrayList();
for (Variable processVar : processVariables) {
processVarNames.add(processVar.getName());
}
return processVarNames;
}
/**
* Gets a list of AssignmentRows based on the current Assignments
*
* @return
*/
public List getAssignmentRows(VariableType varType) {
List rows = new ArrayList();
List handledVariables = new ArrayList();
// Create an AssignmentRow for each Assignment
for (Assignment assignment : assignments) {
if (assignment.getVariableType() == varType) {
String dataType = getDisplayNameFromDataType(assignment.getDataType());
AssignmentRow row = new AssignmentRow(assignment.getName(), assignment.getVariableType(), dataType,
assignment.getCustomDataType(), assignment.getProcessVarName(), assignment.getConstant());
rows.add(row);
handledVariables.add(assignment.getVariable());
}
}
List vars = null;
if (varType == VariableType.INPUT) {
vars = inputVariables;
}
else {
vars = outputVariables;
}
// Create an AssignmentRow for each Variable that doesn't have an Assignment
for (Variable var : vars) {
if (!handledVariables.contains(var)) {
AssignmentRow row = new AssignmentRow(var.getName(), var.getVariableType(), var.getDataType(),
var.getCustomDataType(), null, null);
rows.add(row);
}
}
return rows;
}
public void setVariableCountsString(String variableCountsString) {
this.variableCountsString = variableCountsString;
}
public void setVariableCountsString(boolean hasInputVars, boolean isSingleInputVar, boolean hasOutputVars, boolean isSingleOutputVar) {
StringBuilder sb = new StringBuilder();
if (hasInputVars) {
List inputAssignments = getAssignmentRows(Variable.VariableType.INPUT);
inputAssignments = removeDisallowedInputAssignmentRows(inputAssignments);
if (inputAssignments == null || inputAssignments.isEmpty())
{
if (isSingleInputVar) {
sb.append(DesignerEditorConstants.INSTANCE.No_Data_Input());
}
else {
sb.append("0 " + DesignerEditorConstants.INSTANCE.Data_Inputs());
}
}
else if (inputAssignments.size() == 1) {
sb.append("1 " + DesignerEditorConstants.INSTANCE.Data_Input());
}
else if (inputAssignments.size() > 1) {
sb.append(inputAssignments.size() + " " + DesignerEditorConstants.INSTANCE.Data_Inputs());
}
}
if (hasOutputVars) {
if (sb.length() > 0) {
sb.append(", ");
}
List outputAssignments = getAssignmentRows(Variable.VariableType.OUTPUT);
if (outputAssignments == null || outputAssignments.isEmpty())
{
if (isSingleOutputVar) {
sb.append(DesignerEditorConstants.INSTANCE.No_Data_Output());
}
else {
sb.append("0 " + DesignerEditorConstants.INSTANCE.Data_Outputs());
}
}
else if (outputAssignments.size() == 1) {
sb.append("1 " + DesignerEditorConstants.INSTANCE.Data_Output());
}
else if (outputAssignments.size() > 1) {
sb.append(outputAssignments.size() + " " + DesignerEditorConstants.INSTANCE.Data_Outputs());
}
}
variableCountsString = sb.toString();
}
public String getVariableCountsString() {
return variableCountsString;
}
public String getVariableCountsString(boolean hasInputVars, boolean isSingleInputVar, boolean hasOutputVars, boolean isSingleOutputVar) {
setVariableCountsString(hasInputVars, isSingleInputVar, hasOutputVars, isSingleOutputVar);
return getVariableCountsString();
}
List removeDisallowedInputAssignmentRows(List inputAssignments) {
if (inputAssignments == null) {
return null;
}
List allowedRows = new ArrayList();
for (AssignmentRow inputAssignment: inputAssignments) {
String name = inputAssignment.getName();
if (name != null && !name.isEmpty()) {
if (!isDisallowedPropertyName(name)) {
allowedRows.add(inputAssignment);
}
}
}
return allowedRows;
}
private boolean isDisallowedPropertyName(String name) {
if (disallowedPropertyNames != null) {
for (String disallowedPropertyName : disallowedPropertyNames) {
if (disallowedPropertyName.equalsIgnoreCase(name)) {
return true;
}
}
}
return false;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("\"inputVariables\":\"").append(getInputVariablesString()).append("\"").append(",\n");
sb.append("\"outputVariables\":\"").append(getOutputVariablesString()).append("\"").append(",\n");
sb.append("\"processVariables\":\"").append(getProcessVariablesString()).append("\"").append(",\n");
sb.append("\"assignments\":\"").append(getAssignmentsString()).append("\"").append(",\n");
sb.append("\"dataTypes\":\"").append(getDataTypesString()).append("\"").append(",\n");
sb.append("\"disallowedPropertyNames\":\"").append(getDisallowedPropertyNamesString()).append("\"");
return sb.toString();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof AssignmentData)) return false;
AssignmentData that = (AssignmentData) o;
if (getInputVariables() != null ? !getInputVariables().equals(that.getInputVariables()) : that.getInputVariables() != null)
return false;
if (getOutputVariables() != null ? !getOutputVariables().equals(that.getOutputVariables()) : that.getOutputVariables() != null)
return false;
if (getProcessVariables() != null ? !getProcessVariables().equals(that.getProcessVariables()) : that.getProcessVariables() != null)
return false;
if (getAssignments() != null ? !getAssignments().equals(that.getAssignments()) : that.getAssignments() != null)
return false;
if (getVariableCountsString() != null ? !getVariableCountsString().equals(that.getVariableCountsString()) : that.getVariableCountsString() != null)
return false;
if (getDataTypes() != null ? !getDataTypes().equals(that.getDataTypes()) : that.getDataTypes() != null)
return false;
if (getDataTypeDisplayNames() != null ? !getDataTypeDisplayNames().equals(that.getDataTypeDisplayNames()) : that.getDataTypeDisplayNames() != null)
return false;
return getDisallowedPropertyNames() != null ? getDisallowedPropertyNames().equals(that.getDisallowedPropertyNames()) : that.getDisallowedPropertyNames() == null;
}
@Override
public int hashCode() {
int result = getInputVariables() != null ? getInputVariables().hashCode() : 0;
result = 31 * result + (getOutputVariables() != null ? getOutputVariables().hashCode() : 0);
result = 31 * result + (getProcessVariables() != null ? getProcessVariables().hashCode() : 0);
result = 31 * result + (getAssignments() != null ? getAssignments().hashCode() : 0);
result = 31 * result + (getVariableCountsString() != null ? getVariableCountsString().hashCode() : 0);
result = 31 * result + (getDataTypes() != null ? getDataTypes().hashCode() : 0);
result = 31 * result + (getDataTypeDisplayNames() != null ? getDataTypeDisplayNames().hashCode() : 0);
result = 31 * result + (getDisallowedPropertyNames() != null ? getDisallowedPropertyNames().hashCode() : 0);
return result;
}
private String getStringForList(List objects) {
StringBuilder sb = new StringBuilder();
for (Object o : objects) {
sb.append(o.toString()).append(',');
}
if(sb.length() > 0) {
sb.setLength(sb.length() - 1);
}
return sb.toString();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy