/// <summary>
/// Creates the source item.
/// </summary>
/// <param name="process">The process.</param>
/// <param name="expressionName">Name of the expression.</param>
/// <param name="uniqueName">Name of the unique.</param>
/// <param name="objectName">Name of the object.</param>
/// <param name="left">The left position.</param>
/// <param name="top">The top position.</param>
/// <returns>List of Source Fields.</returns>
private static SourceFieldList CreateSourceItem(
IProcessEdit process,
string expressionName,
string uniqueName,
string objectName,
int left,
int top)
{
var result = new SourceFieldList
{
ExpressionName = expressionName,
Top = top,
Left = left,
UniqueName = uniqueName
};
AddIdFields(process, result, objectName);
AddStateFields(process, result, objectName);
AddVersionFields(process, result, objectName);
AddLastModifiedOnField(result, objectName);
foreach (var field in process.GetAllFields())
{
var sourceField = CreateSourceField(new ProcessFieldEditWrapper(field), result);
sourceField.ObjectName = objectName;
result.Fields.Add(sourceField);
}
return result;
}
/// <summary>
/// Opens the data trigger field mapping designer window.
/// </summary>
/// <param name="parentWindow">The parent window.</param>
/// <param name="process">The process.</param>
/// <param name="trigger">The trigger.</param>
/// <param name="fieldMapping">The field mapping.</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,
IProcessEdit process,
ProcessDataTriggerEdit trigger,
DataTriggerFieldMappingEdit fieldMapping,
Action saveAction,
Action cancelAction,
Action removeAction)
{
SaveAction = saveAction;
CancelAction = cancelAction;
RemoveAction = removeAction;
ProcessEdit = process;
KeyFieldsEnabled = fieldMapping.ModificationType != DataTriggerModificationType.Link
&& fieldMapping.ModificationType != DataTriggerModificationType.Unlink;
ExpressionDesigner.LoadFromExpressionObjects(new List<IExpressionObjectBase>());
var criteria = new DataTriggerListFieldsMappingCriteria
{
ModifiedProcessSystemName = trigger.ProcessToModifySystemName,
DestinationFieldSystemName = fieldMapping.DestinationFieldSystemName
};
var processFields = process.GetAllFields().ToArray();
if (fieldMapping.ModificationType == DataTriggerModificationType.Link || fieldMapping.ModificationType == DataTriggerModificationType.Unlink)
{
if (string.IsNullOrEmpty(fieldMapping.SourceDataProcessName))
{
PopupFactory.NotifyFailure("Source field is invalid. Please select a valid source field and try again.");
CancelCommand.Execute(null);
return;
}
criteria.SourceDataProcessName = fieldMapping.SourceDataProcessName;
}
else
{
foreach (var dataSource in fieldMapping.DataSources)
{
var sourceField = processFields.FirstOrDefault(f => f.SystemName == dataSource.SourceFieldSystemName);
if (sourceField == null)
{
PopupFactory.NotifyFailure("Source field not found. Please select a valid source field and try again.");
CancelCommand.Execute(null);
return;
}
var requiredStep = (CrossRefRequiredStepEdit)sourceField.StepList.FirstOrDefault(s => s is CrossRefRequiredStepEdit);
if (requiredStep == null || !requiredStep.CrossRefProcessId.HasValue)
{
PopupFactory.NotifyFailure("Source field is invalid. Please select a valid source field and try again.");
CancelCommand.Execute(null);
return;
}
criteria.DataSourcesCriteria.Add(
new DataTriggerFieldMappingDataSourceCriteria
{
SourceName = dataSource.Name,
PublishedProcessId = requiredStep.CrossRefProcessId.Value,
SourceFieldName = sourceField.Name,
PropertyPath = dataSource.GetPropertyPath()
});
}
}
WindowManager.Value.ShowStatus(new Status { IsBusy = true });
DataTriggerMappingDataRetriever.GetDataTriggerMappingDataRetriever(
criteria,
result =>
{
WindowManager.Value.ShowStatus(new Status());
if (result.Error != null)
{
PopupFactory.NotifyFailure(result.Error);
CancelCommand.Execute(null);
return;
}
LoadExpressionItems(
process,
result.Object.DataSources,
result.Object.SourceDataProcess,
result.Object.DestinationListField,
result.Object.DestinationProcess,
fieldMapping);
_itemHashes = ExpressionDesigner.Diagram.Items.Select(x => x.GetHashCode()).ToList();
WindowManager.Value.ShowChildWindow(parentWindow, this);
});
}
private SourceFieldList CreateSourceItem(IProcessEdit process, string uniqueName, string name, string objectName)
{
var source = new SourceFieldList { ExpressionName = name, UniqueName = uniqueName };
AddIdFields(process, source, objectName);
AddStateFields(process, source, objectName);
AddVersionFields(process, source, objectName);
AddLastModifiedOnField(source, objectName);
foreach (var field in process.GetAllFields().Where(CanBeSourceField))
{
var sourceField = CreateSourceField(field, source);
sourceField.ObjectName = objectName;
source.Fields.Add(sourceField);
}
return source;
}
/// <summary>
/// Creates the destination item.
/// </summary>
/// <param name="process">The process.</param>
/// <returns> The DestinationFieldList. </returns>
private DestinationFieldList CreateDestinationItem(IProcessEdit process)
{
var result = new DestinationFieldList { ExpressionName = process.Name, UniqueName = DestinationItemName, Top = 10, Left = 600 };
AddIdField(result);
AddStateFields(process, result);
AddVersionFields(process, result);
AddLastModifiedOnField(process, result);
foreach (var field in process.GetAllFields().Where(CanBeDestinationField))
result.Fields.Add(CreateDestinationField(field, result));
return result;
}
/// <summary>
/// Creates the source item.
/// </summary>
/// <param name="process">The process.</param>
/// <returns> The List of Source Field. </returns>
private SourceFieldList CreateSourceItem(IProcessEdit process)
{
var result = new SourceFieldList { ExpressionName = process.Name, UniqueName = SourceItemName, Top = 10, Left = 10 };
AddIdFields(process, result, SourceItemObjectName, SourceFieldSetNames.Item);
AddProcessIdFields(process, result, SourceItemObjectName, SourceFieldSetNames.Item);
AddStateFields(process, result, SourceItemObjectName, SourceFieldSetNames.Item);
AddVersionFields(process, result, SourceItemObjectName, SourceFieldSetNames.Item);
AddLastModifiedOnField(process, result, SourceItemObjectName, SourceFieldSetNames.Item);
foreach (var field in process.GetAllFields().Where(CanBeSourceField))
{
var sourceField = CreateSourceField(field, result);
sourceField.ObjectName = SourceItemObjectName;
result.Fields.Add(sourceField);
}
return result;
}
/// <summary>
/// Checks the rule.
/// </summary>
/// <param name="expression">The expression.</param>
/// <param name="process">The process.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
private bool CheckRule(string expression, IProcessEdit process)
{
if (expression.Contains("DateTime.Now"))
return true;
var fields = ExpressionServiceBase.GetExpressionSourceFields(expression, true);
foreach(var field in fields)
{
//TODO ELMTSUP-552 - if we get all ExpressionSourceFields (not root only) and CR process has a field with the same SystemName,
// FirstOrDefault() may return the same field which will lead to circular recursion.
//Not sure if we need to check CR fields here, if we do, we'd have to rely on field.Guid, not SystemName
var expr = process.GetAllFields().Where(x => x.SystemName == field).Select(x =>
{
var expressionsStepEdit =
(ExpressionsStepEdit)x.StepList.FirstOrDefault(y => y.GetType() == typeof (ExpressionsStepEdit));
return expressionsStepEdit != null ? expressionsStepEdit.CalculatedExpression : null;
}).FirstOrDefault();
//This will also stop circular recursion
//if (!string.IsNullOrEmpty(expr) && !expression.Equals(expr))
if (!string.IsNullOrEmpty(expr))
return CheckRule(expr, process);
}
return false;
}
/// <summary>
/// Gets the list of process fields that are compatible with the specified UDP type.
/// </summary>
/// <param name="process">
/// The process.
/// </param>
/// <param name="memberType">
/// The UDP type.
/// </param>
/// <returns>
/// The list of process fields.
/// </returns>
public static IList<ProcessField> GetProcessFields(IProcessEdit process, Type memberType)
{
if (process == null)
throw new ArgumentNullException("process");
var fields = new List<ProcessField>();
if (memberType == typeof(int) || memberType == typeof(int?) || memberType == typeof(IInfoClass))
{
fields.Add(new ProcessField("Id", Constants.IdColumnName));
if (process.ProcessOptionChoose == ProcessOption.VersionEnabled)
fields.Add(new ProcessField("Version Master Id", Constants.VersionMasterId));
}
if (memberType == typeof(string))
{
if (process.ProcessOptionChoose == ProcessOption.VersionEnabled)
{
fields.Add(new ProcessField(Constants.VersionNumberName, Constants.VersionNumber));
}
}
if (memberType == typeof(DateTime))
{
if (process.ProcessOptionChoose == ProcessOption.VersionEnabled)
{
fields.Add(new ProcessField("Version Date", Constants.VersionDate));
}
}
fields.AddRange(
from field in process.GetAllFields()
where !Constants.CurrentStateColumnName.Equals(field.SystemName)
where TypesCompatible(field.FieldType.ColumnType, memberType)
select new ProcessField(field.Name, field.SystemName));
return fields;
}
/// <summary>
/// Creates the dependencies.
/// </summary>
/// <param name="process">The process.</param>
/// <param name="fullPath">The full path.</param>
/// <returns>IEnumerable{ExpressionDependency}.</returns>
/// <exception cref="System.ArgumentException">Invalid field path.;fullPath</exception>
/// <exception cref="System.InvalidOperationException"></exception>
private IEnumerable<ExpressionDependency> CreateDependencies(IProcessEdit process, string fullPath)
{
if (string.IsNullOrWhiteSpace(fullPath))
throw new ArgumentException("Invalid field path.", "fullPath");
var tokens = fullPath.Split(new[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
var dependentProcess = CreateProcessDefinition(process);
if (IsSystemField(tokens[0]))
{
if (tokens.Length > 1)
{
var join = CreateJoinFromSystemField(dependentProcess, tokens[0]);
foreach (var dependency in CreateDependencies(join.ReferencedProcess, tokens[1]))
{
dependency.DependentProcess = dependentProcess;
dependency.JoinFields.Insert(0, join);
yield return dependency;
}
yield break;
}
foreach (var dependency in CreateDependenciesFromSystemField(dependentProcess, tokens[0]))
{
dependency.DependentProcess = dependentProcess;
yield return dependency;
}
yield break;
}
var field = process.GetAllFields().FirstOrDefault(f => f.SystemName == tokens[0]);
if (field == null)
throw new InvalidOperationException(
string.Format(CultureInfo.InvariantCulture, "Could not find field \"{0}\" in process \"{1}\".", tokens[0], process.SystemName));
if (field.ColumnType == ColumnTypes.DisplayList)
{
// Since we can't determine which items should recalculate expressions when a DL item changes
// and recalculating expressions for all items is too slow, we'll skip DL dependencies.
yield break;
}
if (tokens.Length > 1 && IsJoinField(field))
{
var join = CreateJoin(dependentProcess, field);
foreach (var dependency in CreateDependencies(join.ReferencedProcess, tokens[1]))
{
dependency.DependentProcess = dependentProcess;
dependency.JoinFields.Insert(0, join);
yield return dependency;
}
yield break;
}
foreach (var dependency in CreateDependencies(dependentProcess, field))
{
dependency.DependentProcess = dependentProcess;
yield return dependency;
}
}
private SourceFieldList CreateSourceItem(IProcessEdit process)
{
var result = new SourceFieldList { ExpressionName = process.Name, UniqueName = SourceItemName, Top = 10, Left = 10 };
AddIdFields(process, result, string.Empty, SourceFieldSetNames.IntegrationServiceResultItem);
AddStateFields(process, result, string.Empty, SourceFieldSetNames.IntegrationServiceResultItem);
AddVersionFields(process, result, string.Empty, SourceFieldSetNames.IntegrationServiceResultItem);
AddLastModifiedOnField(process, result, string.Empty, SourceFieldSetNames.IntegrationServiceResultItem);
result.Fields.AddRange(process.GetAllFields().Where(CanBeSourceField).Select(field => CreateSourceField(field, result)));
return result;
}
private static async void LoadFilterAdditionalParameters(FilterDescriptorDecorator filterDescriptor, IProcessEdit process)
{
if (string.IsNullOrEmpty(filterDescriptor.ColumnName))
{
return;
}
var filterFormat = new FilterFormatType { MemberType = filterDescriptor.MemberType };
if (filterDescriptor.ColumnName == Constants.CurrentStateIdColumnName)
{
filterDescriptor.FilteringProcessSystemName = process.SystemName;
filterDescriptor.FilterFormatMemberType = filterFormat;
filterDescriptor.CrossRefProcessName = Constants.StateProcessName;
filterDescriptor.CrossRefDisplayFieldsList = Constants.Name;
filterDescriptor.CrossRefFieldName = Constants.CurrentStateColumnName;
return;
}
if (Constants.CurrentStateGuidColumnName.Equals(filterDescriptor.ColumnName))
{
var states = new CustomInfoList();
states.AddRange(
process.StateList.OrderBy(s => s.Name).Select(state => new StateInfoClass { Id = state.Id, Name = state.Name, Guid = state.Guid }));
filterDescriptor.FilteringProcessSystemName = null;
filterDescriptor.FilterFormatMemberType = filterFormat;
filterDescriptor.CrossRefItems = states;
filterDescriptor.CrossRefDisplayFieldsList = Constants.Name;
filterDescriptor.CrossRefFieldName = Constants.CurrentStateColumnName;
filterDescriptor.ItemsRetriever = new FilterValueEditorProcessStatesRetriever(process);
filterDescriptor.CrossRefProcessName = Constants.StateProcessName;
return;
}
var fieldNames = filterDescriptor.ColumnName.Split(new[] { Constants.FilterDescriptorMemberSeparator }, StringSplitOptions.None);
FieldEdit field = null;
foreach (var fieldEdit in process.GetAllFields())
{
var fieldName = fieldEdit.SystemName;
if (fieldNames.Length == 1 && IsFilteredById(fieldEdit))
{
fieldName = fieldName + "Id";
}
if (fieldName == fieldNames[0])
{
field = fieldEdit;
break;
}
}
if (field == null)
{
return;
}
if (fieldNames.Length == 1)
{
if (field.ColumnType == ColumnTypes.DateTime)
{
var dateTimeFormat = GetDateTimeFormat(field);
if (dateTimeFormat != null)
{
filterFormat.FormatType = dateTimeFormat.ToString();
}
}
filterDescriptor.FilteringProcessSystemName = process.SystemName;
filterDescriptor.FilterFormatMemberType = filterFormat;
var referencedProcessId = GetReferencedProcessId(field);
if (referencedProcessId != null)
{
filterDescriptor.CrossRefDisplayFieldsList = GetDisplayFieldName(field);
filterDescriptor.CrossRefFieldName = field.SystemName;
PublishedProcessInfo.BeginGetProcessInfo(
referencedProcessId.Value,
(sender, result) =>
{
if (result.Error == null)
filterDescriptor.CrossRefProcessName = result.Object.SystemName;
});
}
}
else
{
var referencedProcessId = GetReferencedProcessId(field);
if (referencedProcessId != null)
{
var fieldPath = string.Join(Constants.FilterDescriptorMemberSeparator, fieldNames.Skip(1));
var fieldInfo = await MemberInfoRetriever.GetMemberInfoAsync(referencedProcessId.Value, fieldPath);
if (fieldInfo == null)
{
return;
}
if (fieldInfo.ColumnType == ColumnTypes.DateTime && fieldInfo.DateTimeFormat != null)
{
filterFormat.FormatType = fieldInfo.DateTimeFormat.ToString();
}
filterDescriptor.FilteringProcessSystemName = fieldInfo.DefinedIn;
filterDescriptor.FilterFormatMemberType = filterFormat;
if (!string.IsNullOrEmpty(fieldInfo.ReferencedProcessSystemName))
{
filterDescriptor.CrossRefDisplayFieldsList = fieldInfo.ReferencedFieldSystemName;
filterDescriptor.CrossRefFieldName = fieldInfo.SystemName;
filterDescriptor.CrossRefProcessName = fieldInfo.ReferencedProcessSystemName;
}
}
}
}
public void Prepare(IProcessEdit process, IList<SourceField> fields, string xml, ExpressionOwner expressionOwner, Action onClosedChildWindow)
{
if (process == null)
throw new ArgumentNullException("process");
if (fields == null)
{
return;
}
Xml = xml;
ExpressionOwner = expressionOwner;
OnClosedWindow = onClosedChildWindow;
var fieldEdits = process.GetAllFields().ToList();
foreach (var field in fields)
{
if (field.InnerName == Constants.SampleNumeric
|| field.InnerName == Constants.SampleBoolean
|| field.InnerName == Constants.SampleAlphanumeric)
{
continue;
}
ExportLifetimeContext<IFieldViewModel> vm = null;
switch (field.DataType)
{
case NodeDataType.DateTime:
var dateTimeFieldViewModel = TheViewModelsList.FirstOrDefault(x => x.Metadata.Type == typeof(DateTimeFieldViewModel));
if (dateTimeFieldViewModel != null)
{
vm = dateTimeFieldViewModel.CreateExport();
var dateFieldEdit = fieldEdits.FirstOrDefault(x => x.SystemName == field.InnerName);
if (dateFieldEdit != null)
{
var step = dateFieldEdit.GetStep<DateRequiredSettingsStepEdit>();
if (step != null)
((DateTimeFieldViewModel)vm.Value).DateTimeFormat = step.SelectedDateTimeFormat;
}
}
break;
case NodeDataType.String:
var textFieldViewModel = TheViewModelsList.FirstOrDefault(x => x.Metadata.Type == typeof(TextFieldViewModel));
if (textFieldViewModel != null)
{
vm = textFieldViewModel.CreateExport();
}
break;
case NodeDataType.Boolean:
var boolFieldViewModel = TheViewModelsList.FirstOrDefault(x => x.Metadata.Type == typeof(BoolFieldViewModel));
if (boolFieldViewModel != null)
{
vm = boolFieldViewModel.CreateExport();
}
break;
case NodeDataType.Int:
var intFieldViewModel = TheViewModelsList.FirstOrDefault(x => x.Metadata.Type == typeof (IntegerFieldViewModel));
if (intFieldViewModel != null)
{
vm = intFieldViewModel.CreateExport();
}
break;
case NodeDataType.Double:
case NodeDataType.Decimal:
case NodeDataType.Result:
if (field.SetName == SourceFieldSetNames.MsaItem)
{
var numericFieldViewModel = TheViewModelsList.FirstOrDefault(x => x.Metadata.Type == typeof(DecimalFieldViewModel));
if (numericFieldViewModel != null)
{
vm = numericFieldViewModel.CreateExport();
((DecimalFieldViewModel)vm.Value).NumberOfDigits = 5;
}
}
else
{
var numericFieldEdit = fieldEdits.FirstOrDefault(x => x.SystemName == field.InnerName);
if (numericFieldEdit != null)
{
if (numericFieldEdit.ColumnType != ColumnTypes.Integer)
{
var numericFieldViewModel = TheViewModelsList.FirstOrDefault(x => x.Metadata.Type == typeof(DecimalFieldViewModel));
if (numericFieldViewModel != null)
{
var step = (NumericRequiredStepEdit)numericFieldEdit.StepList.First(x => x is NumericRequiredStepEdit);
vm = numericFieldViewModel.CreateExport();
((DecimalFieldViewModel)vm.Value).NumberOfDigits = step.NumberOfDigits;
}
}
}
}
break;
case NodeDataType.GageRR:
var msaFieldViewModel = TheViewModelsList.FirstOrDefault(x => x.Metadata.Type == typeof(GageRRFieldViewModel));
if (msaFieldViewModel != null)
{
vm = msaFieldViewModel.CreateExport();
}
break;
case NodeDataType.List:
if (field.SetName == SourceFieldSetNames.Item)
{
var systemName = field.DataType == NodeDataType.List ? field.InnerName.Replace("List", null) : field.InnerName;
var fieldEdit = fieldEdits.FirstOrDefault(x => x.SystemName == systemName);
if (fieldEdit != null && fieldEdit.ColumnType == ColumnTypes.Sample)
{
var sampleFieldViewModel = TheViewModelsList.FirstOrDefault(x => x.Metadata.Type == typeof(SampleFieldViewModel));
if (sampleFieldViewModel != null)
{
vm = sampleFieldViewModel.CreateExport();
var sampleField = fields.FirstOrDefault(x => x.ParentField != null && x.ParentField.Id == field.Id);
if (sampleField != null)
{
((SampleFieldViewModel)vm.Value).DataType = sampleField.DataType;
}
var step = (SampleFieldStepEdit)fieldEdit.StepList.First(x => x is SampleFieldStepEdit);
var sampleSizeField = fieldEdits.FirstOrDefault(x => x.SystemName == step.SampleSizeFieldName);
if (sampleSizeField != null)
{
((SampleFieldViewModel)vm.Value).SampleSizeFieldName = sampleSizeField.Name;
}
}
}
}
else if (field.SetName == SourceFieldSetNames.CurrentUserInfo)
{
var listFieldViewModel = TheViewModelsList.FirstOrDefault(x => x.Metadata.Type == typeof(UserRolesFieldViewModel));
if (listFieldViewModel != null)
{
vm = listFieldViewModel.CreateExport();
var parent = field;
var subfields = fields
.Where(x => x.ParentField != null &&
x.ParentField.Id == parent.Id);
((UserRolesFieldViewModel)vm.Value).CreateColumns(subfields);
}
}
break;
}
if (vm == null)
{
continue;
}
vm.Value.Field = field;
ExpressionViewsList.Add(vm);
}
}
/// <summary>
/// Gets the process fields.
/// </summary>
/// <param name="process">The process.</param>
/// <returns>ICollection{System.String}.</returns>
private static ICollection<string> GetProcessFields(IProcessEdit process)
{
var fields = new HashSet<string>(process.GetAllFields().Select(f => f.SystemName))
{
Constants.IdColumnName
};
if (process.IsStateEnabled)
{
fields.Add(Constants.CurrentStateIdColumnName);
fields.Add(Constants.CurrentStateGuidColumnName);
}
if (process.ProcessOptionChoose == ProcessOption.VersionEnabled)
{
fields.Add(Constants.VersionMasterId);
fields.Add(Constants.VersionNumber);
fields.Add(Constants.VersionDate);
}
return fields;
}