/// <summary>
/// Edits the expression.
/// </summary>
/// <param name="parentWindow">The parent window.</param>
/// <param name="process">The process.</param>
/// <param name="expressionDesignerString">The expression designer string.</param>
/// <param name="parameterType">Type of the parameter.</param>
/// <param name="saveAction">The save action.</param>
/// <param name="cancelAction">The cancel action.</param>
/// <param name="removeAction">The remove action.</param>
public void EditExpression(ITopLevelWindow parentWindow, ProcessEdit process, string expressionDesignerString, SystemParameterType parameterType, Action saveAction, Action cancelAction, Action removeAction)
{
this.saveAction = saveAction;
this.cancelAction = cancelAction;
this.removeAction = removeAction;
var source = new SourceFieldList {ExpressionName = process.Name, Top = 10, Left = 10};
AddIdFields(process, source);
AddProcessIdFields(process, source);
AddStateFields(process, source);
AddVersionFields(process, source);
AddLastModifiedOnField(process, source);
foreach (var field in process.GetAllFields())
{
if (field.FieldType.ColumnType == ColumnTypes.Reference)
{
var crossRefStep = (CrossRefRequiredStepEdit)field.StepList.FirstOrDefault(x => x is CrossRefRequiredStepEdit);
if (crossRefStep != null)
{
if (crossRefStep.AllowMultiple)
{
source.Fields.Add(BuildSourceFieldForList(source, field, new CrSubfieldsRetriever(field.Id)));
}
else
{
source.Fields.Add(new SourceField(source)
{
DataType = NodeDataType.CrossReference,
Name = field.Name,
ConnectorOut =
{
DataType = NodeDataType.CrossReference,
Name = field.Name
},
SetName = SourceFieldSetNames.Item,
InnerName = field.SystemName,
SystemName = string.Format("{0}Member", field.SystemName),
SubfieldsRetriever = new CrSubfieldsRetriever(field.Id)
});
}
}
}
else
{
if (field.FieldType.ColumnType == ColumnTypes.ReverseReference || field.FieldType.ColumnType == ColumnTypes.ReverseMultiReference)
{
var crossRefStep = (ReverseCrossRefRequiredStepEdit)field.StepList.FirstOrDefault(x => x is ReverseCrossRefRequiredStepEdit);
if (crossRefStep != null)
{
if (crossRefStep.DisplayMultiple)
{
source.Fields.Add(BuildSourceFieldForList(source, field, new ReverseCrSubfieldsRetriever(field.Id)));
}
else
{
source.Fields.Add(new SourceField(source)
{
DataType = NodeDataType.ReverseCrossReference,
Name = field.Name,
ConnectorOut =
{
DataType = NodeDataType.ReverseCrossReference,
Name = field.Name
},
SetName = SourceFieldSetNames.Item,
InnerName = field.SystemName,
SystemName = string.Format("{0}Member", field.SystemName),
SubfieldsRetriever = new ReverseCrSubfieldsRetriever(field.Id)
});
}
}
}
else if (field.FieldType.ColumnType == ColumnTypes.Checklist)
{
source.Fields.Add(BuildSourceFieldForList(source, field, new ChecklistSubFieldsRetriever(field.Id)));
}
else if (field.FieldType.ColumnType == ColumnTypes.DisplayList)
{
source.Fields.Add(BuildSourceFieldForList(source, field, new DisplayListSubFieldsRetriever(field.Id)));
}
else if (field.FieldType.ColumnType == ColumnTypes.Result)
{
source.Fields.Add(new SourceField(source)
{
DataType = NodeDataType.Result,
Name = field.Name,
ConnectorOut =
{
DataType = NodeDataType.Result,
Name = field.Name
},
SetName = SourceFieldSetNames.Item,
InnerName = field.SystemName,
SystemName = field.SystemName
});
}
else
{
//var fieldType = GetType(field.FieldType);
var dataType = SourceNodeFactory.GetDataType(GetType(field.FieldType));
var sf = new SourceField(source)
{
DataType = dataType,
Name = field.Name,
ConnectorOut = { DataType = dataType, Name = field.Name },
SetName = SourceFieldSetNames.Item,
InnerName = field.SystemName,
SystemName = field.SystemName
};
source.Fields.Add(sf);
}
}
}
var expressions = new List<IExpressionObjectBase>();
var isNew = true;
ExpressionContainer expressionsContainer;
try
{
expressionsContainer = Serializer.Deserialize(expressionDesignerString);
}
catch
{
expressionsContainer = null;
}
if (!string.IsNullOrWhiteSpace(expressionDesignerString) && expressionsContainer != null)
{
isNew = false;
expressions.AddRange(expressionsContainer.Expressions);
}
else
{
expressions.Add(source);
var destination = new DestinationFieldList
{
Top = 200,
Left = 600,
ExpressionName = "Expression Result"
};
destination.Fields.Add(new DestinationField(destination)
{
Name = "Result",
SystemName = "Result",
InnerName = "Result",
DataType = GetNodeType(parameterType),
ConnectorIn = { Name = "Result", DataType = GetNodeType(parameterType) }
});
expressions.Add(destination);
}
if (expressionsContainer != null)
{
var sourceFieldList =
(from fl in expressions
where fl is SourceFieldList
select fl).Cast<SourceFieldList>().FirstOrDefault();
if (sourceFieldList != null)
{
var fieldList = sourceFieldList.Fields.Cast<IExpressionField>().ToList();
UpdateStoredFields(fieldList, source.Fields, (sf) => FinalizeUpdate(sourceFieldList, fieldList, source, expressions, parentWindow)); // Here we load all subtypes async that's why we need reload window after all subtypes are loaded
}
}
if (!isNew)
{
return;
}
var userInfoSource = SourceNodeFactory.CreateUserInformationItem(CurrentUserInformationItemName);
userInfoSource.Left = 175;
userInfoSource.Top = 10;
expressions.Add(userInfoSource);
this.expressionDesigner.Diagram.Items.Clear();
ExpressionTranslator.TranslateToDiagram(expressions, this.expressionDesigner.Diagram);
WindowManager.Value.ShowChildWindow(parentWindow, this);
}
private async void LoadExpressionItems(ProcessEdit sourceProcess, ExternalDataConfigurationEdit externalDataConfiguration, ProcessExternalDataEdit model)
{
WindowManager.Value.ShowStatus(new Status { IsBusy = true });
var expressions = new List<IExpressionObjectBase>();
var newExpressions = new List<IExpressionObjectBase>();
var syncContext = new NotifyClientAction(
() =>
{
ExpressionDesigner.LoadFromExpressionObjects(expressions);
WindowManager.Value.ShowStatus(new Status());
});
syncContext.OperationStarted();
var source = new SourceFieldList
{
ExpressionName = string.Format("{0} (source)", sourceProcess.Name),
UniqueName = SourceItemName,
Top = 10,
Left = 10
};
foreach (var field in sourceProcess.GetAllFields().Where(CanBeSourceField))
{
var sourceField = CreateSourceField(field, source);
sourceField.ObjectName = SourceItemObjectName;
source.Fields.Add(sourceField);
}
newExpressions.Add(source);
var modifiedSource = new SourceFieldList
{
ExpressionName = string.Format("External Data: {0}", externalDataConfiguration.Name),
UniqueName = SourceToModifyItemName,
Top = 310,
Left = 10
};
// add data variable
foreach (var field in externalDataConfiguration.DataVariableList)
{
var sourceField = CreateSourceFieldFromDataVariable(field, modifiedSource);
sourceField.ObjectName = ModifiedItemObjectName;
modifiedSource.Fields.Add(sourceField);
}
newExpressions.Add(modifiedSource);
SourceFieldList systemParameters;
try
{
systemParameters = await CreateSystemParametersItemAsync(SystemParametersName);
}
catch (Exception)
{
systemParameters = null;
}
if (systemParameters != null)
{
systemParameters.Left = 350;
systemParameters.Top = 10;
newExpressions.Add(systemParameters);
}
var destination = new DestinationFieldList
{
ExpressionName = sourceProcess.Name,
UniqueName = DestinationItemName,
Top = 10,
Left = 500
};
foreach (var field in sourceProcess.GetAllFields().Where(CanBeDestinationField))
{
var destinationField = CreateDestinationField(field, destination);
destination.Fields.Add(destinationField);
}
newExpressions.Add(destination);
if (!string.IsNullOrWhiteSpace(model.Expression))
{
try
{
var expressionsContainer = Serializer.Deserialize(model.Expression);
expressions.AddRange(expressionsContainer.Expressions);
}
catch
{
// Do nothing, new expressions will be used.
}
}
UpdateStoredExpressions(expressions, newExpressions, syncContext);
syncContext.OperationCompleted();
}
/// <summary>
/// Loads the expression items.
/// </summary>
/// <param name="process">The process.</param>
/// <param name="syncProcess">The synchronize process.</param>
private void LoadExpressionItems(ProcessEdit process, ESyncProcessEdit syncProcess)
{
WindowManager.Value.ShowStatus(new Status { IsBusy = true });
var expressions = new List<IExpressionObjectBase>();
var newExpressions = new List<IExpressionObjectBase>();
var syncContext = new NotifyClientAction(
() =>
{
_expressionDesigner.LoadFromExpressionObjects(expressions);
WindowManager.Value.ShowStatus(new Status());
});
syncContext.OperationStarted();
var source = new SourceFieldList { ExpressionName = "Source", Top = 10, Left = 10 };
foreach (var providerField in syncProcess.Endpoints.Source.ProviderFields)
{
var sourceField = CreateSourceField(providerField, source);
if (sourceField != null)
source.Fields.Add(sourceField);
}
newExpressions.Add(source);
var destination = new DestinationFieldList { ExpressionName = process.Name, Top = 10, Left = 600 };
AddIdFields(destination);
AddStateFields(process, destination);
AddVersionFields(process, destination);
foreach (var field in process.GetAllFields().Where(CanBeDestinationField))
{
var destinationField = CreateDestinationField(field, destination);
if (destinationField != null)
destination.Fields.Add(destinationField);
}
newExpressions.Add(destination);
if (!string.IsNullOrWhiteSpace(syncProcess.Map.Designer))
{
try
{
var expressionsContainer = ExpressionsSerializer.Deserialize(syncProcess.Map.Designer);
ExpressionNodeFactory.RestoreConnections(expressionsContainer.Expressions);
expressions.AddRange(expressionsContainer.Expressions);
}
catch
{
// Do nothing, new expressions will be used.
}
}
UpdateStateList(process);
UpdateStoredExpressions(expressions, newExpressions, syncContext);
syncContext.OperationCompleted();
}
/// <summary>
/// Gets the field definition.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
/// <param name="process">
/// The process.
/// </param>
/// <param name="path">
/// The field path.
/// </param>
/// <param name="throwOnError">
/// True to throw an exception on error; otherwise, false.
/// </param>
/// <returns>
/// The ReferenceDisplayFieldDefinition.
/// </returns>
public ReferenceDisplayFieldDefinition GetFieldDefinition(ReferenceHelperContext context, ProcessEdit process, string path, bool throwOnError)
{
var index = path.IndexOf('.');
var fieldName = path;
if (index >= 0)
{
fieldName = path.Substring(0, index);
}
var fieldInfos = process.GetAllFields();
var fieldInfo = fieldInfos.FirstOrDefault(x => x.SystemName == fieldName);
if (fieldInfo == null)
{
if (throwOnError)
throw new Exception(string.Format(@"Field '{0}' not found in process '{1}'.", fieldName, process.SystemName));
return null;
}
if (index >= 0 && index < path.Length - 1)
{
var joinField = GetJoinField(fieldInfo);
if (joinField == null)
return null;
var fieldDefinition = GetFieldDefinition(context, joinField.ReferencedProcess.SystemName, path.Substring(index + 1, path.Length - index - 1), throwOnError);
fieldDefinition.JoinFields.Insert(0, joinField);
return fieldDefinition;
}
return GetDisplayField(context, fieldInfo, throwOnError);
}
