public void ShowErrorTooltip(FrameworkElement attachTo, UIElement errorElement)
{
if (attachTo == null)
{
throw new ArgumentNullException("attachTo");
}
if (errorElement == null)
{
throw new ArgumentNullException("errorElement");
}
AttachedErrorBalloon b = new AttachedErrorBalloon(attachTo, errorElement);
Point pos = attachTo.PointToScreen(new Point(0, attachTo.ActualHeight));
b.Left = pos.X;
b.Top = pos.Y - 8;
b.Focusable = false;
ITopLevelWindowService windowService = services.GetService <ITopLevelWindowService>();
ITopLevelWindow ownerWindow = (windowService != null) ? windowService.GetTopLevelWindow(attachTo) : null;
if (ownerWindow != null)
{
ownerWindow.SetOwner(b);
}
b.Show();
if (ownerWindow != null)
{
ownerWindow.Activate();
}
b.AttachEvents();
}
/// <summary>
/// Opens an expression editor for the specified stored procedure parameter expression.
/// </summary>
/// <param name="parentWindow">The parent window.</param>
/// <param name="process">The process.</param>
/// <param name="parameter">The parameter.</param>
public void EditExpression(ITopLevelWindow parentWindow, ProcessEdit process, DataTriggerStoredProcedureParameterEdit parameter)
{
EditExpression(
parentWindow,
process,
DbTypeConverter.ConvertToType(parameter.DataType),
parameter.Expression,
() => SetExpression(parameter, GetXml()),
null,
() => SetExpression(parameter, null));
}
/// <summary>
/// Opens an expression designer window and initializes the designer with the specified expression.
/// </summary>
/// <param name="parentWindow">The parent window.</param>
/// <param name="process">The source process.</param>
/// <param name="resultType">The result type.</param>
/// <param name="expression">The expression.</param>
/// <param name="saveAction">The save action.</param>
/// <param name="cancelAction">The cancel action.</param>
/// <param name="removeAction">The remove action.</param>
protected void EditExpression(
ITopLevelWindow parentWindow,
IProcessEdit process,
Type resultType,
string expression,
Action saveAction,
Action cancelAction,
Action removeAction)
{
SaveAction = saveAction;
CancelAction = cancelAction;
RemoveAction = removeAction;
ExpressionDesigner.Value.LoadFromExpressionObjects(new List<IExpressionObjectBase>());
WindowManager.Value.ShowStatus(new Status { IsBusy = true });
var expressions = new List<IExpressionObjectBase>();
var newExpressions = new List<IExpressionObjectBase>();
var syncContext = new NotifyClientAction(
() =>
{
ExpressionDesigner.Value.LoadFromExpressionObjects(expressions);
WindowManager.Value.ShowStatus(new Status());
});
syncContext.OperationStarted();
newExpressions.Add(CreateSourceItem(process));
newExpressions.Add(CreateUserInformationItem(CurrentUserInformationItemName, 10, 400));
newExpressions.Add(CreateDestinationItem(resultType));
if (!string.IsNullOrWhiteSpace(expression))
{
try
{
var expressionsContainer = Serializer.Deserialize(expression);
expressions.AddRange(expressionsContainer.Expressions);
}
catch
{
// Do nothing, new expressions will be used.
}
}
UpdateStateList(process);
UpdateStoredExpressions(expressions, newExpressions, syncContext);
syncContext.OperationCompleted();
WindowManager.Value.ShowChildWindow(parentWindow, this);
}
/// <summary>
/// Gets a value indicating whether the dialog is visible.
/// </summary>
/// <param name="timeout">The timeout.</param>
/// <param name="retryWaitTime">The retry wait time.</param>
/// <returns>
/// <c>true</c> if main window is visible; otherwise, <c>false</c>.
/// </returns>
public bool IsDialogVisible(TimeSpan timeout, TimeSpan retryWaitTime)
{
mApp = null;
mWindow = null;
var tts = TcAppLangDependentStrings.TechnologyTableSelection;
var startTime = DateTime.Now;
while (DateTime.Now - startTime < timeout)
{
bool processFound;
var index = 1; // first index is 1
do
{
// search process
processFound = mDriver.TryFind <IProcess>(new ProcessPattern()
{
ProcessName = "cut",
Index = index
}, 1, out var proc);
if (processFound) // search dialog
{
mApp = new TcAppProcess(proc, mDriver);
if (mApp.Node.TryFind <ITopLevelWindow>(new WindowPattern()
{
WndClass = "GritDialogWindow",
WndCaption = tts
}, out var window, 1))
{
if (window.VisibleOnScreen) // -> found, store dialog window and return
{
mWindow = window;
return(true);
}
}
}
index++; // -> not found, search next process
} while(processFound);
Thread.Sleep(retryWaitTime); // nothing found, wait and retry until timeout
}
mApp = null;
mWindow = null;
return(false);
}
public void HelloWorldTest()
{
IProcess process = Driver.Applications.Run("notepad.exe");
// Get the top-level window of Notepad.
// You can get object identification code from the TestLeft UI Spy panel:
// From the main menu, select View -> TestLeft UI Spy.
ITopLevelWindow window = process.Find <ITopLevelWindow>(new WindowPattern()
{
WndClass = "Notepad"
});
window.Keys("Hello world!!"); // Simulate text input
}
/// <summary>
/// Opens the data trigger field mapping designer window.
/// </summary>
/// <param name="parentWindow">The parent window.</param>
/// <param name="sourceProcess">The process.</param>
/// <param name="trigger">The trigger.</param>
/// <param name="saveAction">The save action.</param>
/// <param name="cancelAction">The cancel action.</param>
/// <param name="removeAction">The remove action.</param>
public async void EditExpression(
ITopLevelWindow parentWindow,
IProcessEdit sourceProcess,
ProcessDataTriggerEdit trigger,
Action saveAction,
Action cancelAction,
Action removeAction)
{
SaveAction = saveAction;
CancelAction = cancelAction;
RemoveAction = removeAction;
KeyFieldsEnabled = false;
ProcessEdit = sourceProcess;
ExpressionDesigner.LoadFromExpressionObjects(new List<IExpressionObjectBase>());
if (string.IsNullOrEmpty(trigger.ProcessToModifySystemName))
{
PopupFactory.NotifyFailure("Process to modify not found. Please select a process and try again.");
CancelCommand.Execute(null);
return;
}
ProcessInfo destinationProcess;
try
{
WindowManager.Value.ShowStatus(new Status { IsBusy = true });
try
{
destinationProcess = await ProcessInfo.GetProcessAsync(trigger.ProcessToModifySystemName);
}
finally
{
WindowManager.Value.ShowStatus(new Status());
}
}
catch (Exception ex)
{
PopupFactory.NotifyFailure(ex);
CancelCommand.Execute(null);
return;
}
LoadExpressionItems(sourceProcess, destinationProcess, trigger);
_itemHashes = ExpressionDesigner.Diagram.Items.Select(x => x.GetHashCode()).ToList();
WindowManager.Value.ShowChildWindow(parentWindow, this);
}
/// <summary>
/// Initializes a new instance of the <see cref="ProcessItemUpdatedEvent"/> class.
/// </summary>
/// <param name="item">
/// The item that was modified.
/// </param>
/// <param name="rootWindow">
/// The root window.
/// </param>
/// <param name="depth">
/// The depth.
/// </param>
public ProcessItemUpdatedEvent(IEditableRoot item, ITopLevelWindow rootWindow, int depth)
{
if (item == null)
throw new ArgumentNullException("item");
if (rootWindow == null)
throw new ArgumentNullException("rootWindow");
if (depth < 0)
throw new ArgumentOutOfRangeException("depth", @"Depth cannot be negative.");
Item = item;
RootWindow = rootWindow;
Depth = depth;
}
/// <summary>
/// Converts a point in this Visual to screen coordinates.
/// </summary>
/// <param name="point">The client coordinate.</param>
/// <returns>The screen coordinate.</returns>
public Point PointToScreen(Point point)
{
foreach (Visual v in VisualTreeHelper.GetAncestors(this))
{
point += v.VisualOffset;
ITopLevelWindow window = v as ITopLevelWindow;
if (window != null)
{
point += (Vector)window.PresentationSource.PointToScreen(new Point(0, 0));
}
}
return(point);
}
/// <summary>
/// Gets a value indicating whether the main window is visible.
/// </summary>
/// <param name="timeout">The timeout.</param>
/// <param name="retryWaitTime">The retry wait time.</param>
/// <returns></returns>
/// <value>
/// <c>true</c> if main window is visible; otherwise, <c>false</c>.
/// </value>
public override bool IsMainWindowVisible(TimeSpan timeout, TimeSpan retryWaitTime)
{
mApp = null;
mMainWindow = null;
var startTime = DateTime.Now;
while (DateTime.Now - startTime < timeout)
{
bool processFound;
var index = 1; // first index is 1
do
{
// search process
processFound = Driver.TryFind <IProcess>(new ProcessPattern()
{
ProcessName = "SpaceClaim",
Index = index
}, 1, out var proc);
if (processFound) // search MainWindow
{
mApp = new TcAppProcess(proc, Driver);
if (mApp.Node.TryFind <ITopLevelWindow>(new WinFormsPattern {
WinFormsControlName = "MainForm"
}, out var window, 1))
{
if (window.VisibleOnScreen) // -> found, store MainWindow and return
{
mMainWindow = window;
return(true);
}
}
}
index++; // -> not found, search next process
} while(processFound);
Thread.Sleep(retryWaitTime); // nothing found, wait and retry until timeout
}
mApp = null;
mMainWindow = null;
return(false);
}
private void OnDataContextChanged(object sender, DependencyPropertyChangedEventArgs args)
{
var oldDataContext = args.OldValue as ITopLevelWindow;
if (oldDataContext != null)
{
oldDataContext.Closed -= DisposeSpreadsheet;
((IDetailsViewModel) oldDataContext).OnFieldsRefreshed -= DisposeSpreadsheet;
}
var dataContext = args.NewValue as IFieldViewModel;
if (dataContext != null)
{
_window = dataContext.ParentDetailsVM;
_window.Closed += DisposeSpreadsheet;
((IDetailsViewModel)_window).OnFieldsRefreshed += DisposeSpreadsheet;
}
}
private void DisposeSpreadsheet(object sender, EventArgs eventArgs)
{
if (spreadsheet != null)
spreadsheet.Dispose();
DataContextChanged -= OnDataContextChanged;
DataContext = null;
if (_window != null)
{
_window.Closed -= DisposeSpreadsheet;
((IDetailsViewModel) _window).OnFieldsRefreshed -= DisposeSpreadsheet;
_window = null;
}
busyIndicator.ClearValue(RadBusyIndicator.IsBusyProperty);
busyIndicator.ClearValue(RadBusyIndicator.IsIndeterminateProperty);
busyIndicator.ClearValue(RadBusyIndicator.ProgressValueProperty);
busyIndicator.ClearValue(RadBusyIndicator.BusyContentProperty);
}
private void DoLayout()
{
List <ITopLevelWindow> windows = new List <ITopLevelWindow>();
foreach (UIElement entry in this.entries)
{
ITopLevelWindow window = VisualTreeHelper.GetTopLevelWindow(entry);
if (window != null && !windows.Contains(window))
{
windows.Add(window);
}
}
foreach (ITopLevelWindow window in windows)
{
window.DoLayoutPass();
}
this.entries.Clear();
this.layoutPassQueued = false;
}
/// <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="saveAction">The save action.</param>
/// <param name="cancelAction">The cancel action.</param>
/// <param name="removeAction">The remove action.</param>
public void EditExpression(ITopLevelWindow parentWindow, ProcessExternalDataEdit model, ProcessEdit process, ExternalDataConfigurationEdit externalData, Action saveAction, Action cancelAction, Action removeAction)
{
SaveAction = saveAction;
CancelAction = cancelAction;
RemoveAction = removeAction;
ProcessEdit = process;
ExpressionDesigner.LoadFromExpressionObjects(new List<IExpressionObjectBase>());
if (externalData == null)
{
PopupFactory.NotifyFailure("Please select a Connection and try again.");
CancelCommand.Execute(null);
return;
}
LoadExpressionItems(process, externalData, model);
_itemHashes = ExpressionDesigner.Diagram.Items.Select(x => x.GetHashCode()).ToList();
WindowManager.Value.ShowChildWindow(parentWindow, this);
}
/// <summary>
/// Edits the expression.
/// </summary>
/// <param name="parentWindow">The parent window.</param>
/// <param name="process">The process.</param>
/// <param name="syncProcess">The synchronize process.</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,
ESyncProcessEdit syncProcess,
Action saveAction,
Action cancelAction,
Action removeAction)
{
_saveAction = saveAction;
_cancelAction = cancelAction;
_removeAction = removeAction;
_expressionDesigner.LoadFromExpressionObjects(new List<IExpressionObjectBase>());
LoadExpressionItems(process, syncProcess);
WindowManager.Value.ShowChildWindow(parentWindow, this);
}
/// <summary>
/// The edit expression.
/// </summary>
/// <param name="parentWindow">
/// The parent window.
/// </param>
/// <param name="variableList">
/// The variable list.
/// </param>
/// <param name="connection">
/// The connection.
/// </param>
/// <param name="expressionDesignerString">
/// The expression designer string.
/// </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,
DataVariableEditList variableList,
ConnectionSetupEdit connection,
string expressionDesignerString,
Action saveAction,
Action cancelAction,
Action removeAction)
{
const string expressionResult = "Expression Result";
this.saveAction = saveAction;
this.cancelAction = cancelAction;
this.removeAction = removeAction;
var source = new SourceFieldList { ExpressionName = "Received Data", Top = 10, Left = 10 };
source.Fields.Add(new SourceField(null)
{
DataType = NodeDataType.String,
Name = "Data",
SetName = "Data",
SystemName = "Data",
ConnectorOut =
{
DataType = NodeDataType.String,
Name = "Data"
}
});
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;
var destinationFieldList = expressionsContainer.Expressions.FirstOrDefault(x => x.ExpressionName == expressionResult) as DestinationFieldList;
if (destinationFieldList != null)
{
var newVariablesField = GetVariableList(variableList, expressionResult).Fields;
var oldEdited = from f in newVariablesField
where destinationFieldList.Fields.Select(x => x.SystemName).Contains(f.SystemName)
select f;
if (oldEdited.Any())
{
foreach (var field in oldEdited)
{
var nf = destinationFieldList.Fields.First(x => x.SystemName == field.SystemName);
nf.DataType = field.DataType;
nf.Name = field.Name;
}
}
foreach (var field in newVariablesField)
{
if (destinationFieldList.Fields.All(x => x.SystemName != field.SystemName))
{
destinationFieldList.Fields.Add(field);
}
}
//remove old field
var oldList = new HashSet<string>();
foreach (var des in destinationFieldList.Fields)
{
if (newVariablesField.All(x => x.SystemName != des.SystemName))
{
oldList.Add(des.SystemName);
}
}
if (oldList.Any())
{
foreach (var item in oldList)
{
var remove = destinationFieldList.Fields.FirstOrDefault(x => x.SystemName == item);
if (remove != null)
{
destinationFieldList.Fields.Remove(remove);
}
}
}
}
expressions.AddRange(expressionsContainer.Expressions);
}
else
{
expressions.Add(source);
expressions.Add(GetVariableList(variableList, expressionResult));
}
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;
}
this.expressionDesigner.Diagram.Items.Clear();
ExpressionTranslator.TranslateToDiagram(expressions, this.expressionDesigner.Diagram);
WindowManager.Value.ShowChildWindow(parentWindow, this);
}
/// <summary>
/// Opens the expression designer window.
/// </summary>
/// <param name="parentWindow">
/// The parent window.
/// </param>
/// <param name="process">
/// The process.
/// </param>
/// <param name="method">
/// The method.
/// </param>
/// <param name="serviceTypes">
/// The service types.
/// </param>
public void EditExpression(
ITopLevelWindow parentWindow,
IProcessEdit process,
ServiceMethodEdit method,
IEnumerable<ServiceExposedTypeEdit> serviceTypes)
{
if (parentWindow == null)
throw new ArgumentNullException("parentWindow");
if (process == null)
throw new ArgumentNullException("process");
if (method == null)
throw new ArgumentNullException("method");
if (serviceTypes == null)
throw new ArgumentNullException("serviceTypes");
_method = method;
_knownTypes = serviceTypes.ToArray();
ExpressionDesigner.Value.LoadFromExpressionObjects(new List<IExpressionObjectBase>());
WindowManager.Value.ShowStatus(new Status { IsBusy = true });
var expressions = new List<IExpressionObjectBase>();
var newExpressions = new List<IExpressionObjectBase>();
var syncContext = new NotifyClientAction(
() =>
{
ExpressionDesigner.Value.LoadFromExpressionObjects(expressions);
WindowManager.Value.ShowStatus(new Status());
});
syncContext.OperationStarted();
newExpressions.Add(CreateSourceItem(process));
newExpressions.Add(CreateDestinationItem(method.ResultTypeGuid));
if (!string.IsNullOrWhiteSpace(method.ResultMapping))
{
try
{
var expressionsContainer = Serializer.Deserialize(method.ResultMapping);
expressions.AddRange(expressionsContainer.Expressions);
}
catch
{
// Do nothing, new expressions will be used.
}
}
UpdateStateList(process);
UpdateStoredExpressions(expressions, newExpressions, syncContext);
syncContext.OperationCompleted();
WindowManager.Value.ShowChildWindow(parentWindow, this);
}
/// <summary>
/// Finalizes the update.
/// </summary>
/// <param name="sourceFieldList">The source field list.</param>
/// <param name="fieldList">The field list.</param>
/// <param name="source">The source.</param>
/// <param name="expressions">The expressions.</param>
/// <param name="parentWindow">The parent window.</param>
private void FinalizeUpdate(SourceFieldList sourceFieldList, List<IExpressionField> fieldList, SourceFieldList source, List<IExpressionObjectBase> expressions, ITopLevelWindow parentWindow)
{
sourceFieldList.Fields.Clear();
foreach (var field in fieldList)
{
sourceFieldList.Fields.Add((SourceField)field);
}
// delete obsolete fields (removed from process)
var sourceListArray = sourceFieldList.Fields.ToArray();
foreach (var field in sourceListArray)
{
if (source.Fields.All(t => t.Name != field.Name))
{
var removed = sourceFieldList.Fields.First(t => t.Name == field.Name);
expressions.Remove(removed.ConnectorOut.Connection);
sourceFieldList.Fields.Remove(removed);
}
}
this.expressionDesigner.LoadFromExpressionObjects(expressions);
WindowManager.Value.ShowChildWindow(parentWindow, this);
}
/// <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);
});
}
/// <summary>
/// Initializes the specified model.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="parentWindow">The parent window.</param>
public void Initialize(EndpointsDescriptorEdit model, ITopLevelWindow parentWindow)
{
Model = model;
ParentWindow = parentWindow;
SourceViewModel.Initialize(Model.Source, ParentWindow);
}
/// <summary>
/// Opens an expression designer window and initializes the designer with the specified expression.
/// </summary>
/// <param name="parentWindow">The parent window.</param>
/// <param name="process">The source process.</param>
/// <param name="expression">The expression.</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, string expression, Action saveAction, Action cancelAction, Action removeAction)
{
EditExpression(parentWindow, process, typeof(string), expression, saveAction, cancelAction, removeAction);
}
public BreadcrumbItem(ITopLevelWindow window)
{
_windowRef = new WeakReference(window);
}
/// <summary>
/// Initializes the specified model.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="parentWindow">The parent window.</param>
public void Initialize(SourceDescriptorEdit model, ITopLevelWindow parentWindow)
{
Model = model;
ParentWindow = parentWindow;
if (Model.DataProviders.Any())
{
SetDataProvider(Model.DataProviders[0]);
SelectDataProvider(Model.DataProviders[0]);
}
else
{
var dataProvider = DataProviders.FirstOrDefault(dp => dp.Metadata.ProviderName == SqlDataProviderEdit.CN_SQL_DATA_PROVIDER)
?? DataProviders.FirstOrDefault();
if (dataProvider != null)
{
var newModel = DataProviderFactory.NewProvider(dataProvider.Metadata.ProviderName);
Model.DataProviders.Add(newModel);
SetDataProvider(newModel);
SelectDataProvider(Model.DataProviders.First());
}
}
SourceFieldsViewModel.Initialize(Model.ProviderFields, ParentWindow);
}
/// <summary>
/// Edits the <see cref="WebMethodCallSettingsEdit.ResultMapping"/> expression.
/// </summary>
/// <param name="parentWindow">
/// The parent window.
/// </param>
/// <param name="method">
/// The method.
/// </param>
/// <param name="process">
/// The process.
/// </param>
/// <param name="callSettings">
/// The call settings.
/// </param>
public void EditExpression(
ITopLevelWindow parentWindow,
IWebServiceMethodDescription method,
IProcessEdit process,
WebMethodCallSettingsEdit callSettings)
{
SaveAction = CreateSaveAction(callSettings);
RemoveAction = CreateRemoveAction(callSettings);
ExpressionDesigner.Value.LoadFromExpressionObjects(new List<IExpressionObjectBase>());
WindowManager.Value.ShowStatus(new Status { IsBusy = true });
var expressions = new List<IExpressionObjectBase>();
var newExpressions = new List<IExpressionObjectBase>();
var syncContext = new NotifyClientAction(
() =>
{
ExpressionDesigner.Value.LoadFromExpressionObjects(expressions);
WindowManager.Value.ShowStatus(new Status());
});
syncContext.OperationStarted();
newExpressions.Add(
CreateSourceItem(
"Soap Headers",
Constants.WebMethodCallOutputHeadersExpressionName,
10,
10,
method.OutputParameters.Where(p => p.IsSoapHeader),
callSettings.ResultFields));
newExpressions.Add(
CreateSourceItem(
"Output Parameters",
Constants.WebMethodCallOutputParametersExpressionName,
160,
10,
method.OutputParameters.Where(p => !p.IsSoapHeader),
callSettings.ResultFields));
newExpressions.Add(CreateUserInformationItem(CurrentUserInformationItemName, 310, 10));
newExpressions.Add(CreateDestinationItem(process));
if (!string.IsNullOrWhiteSpace(callSettings.ResultMapping))
{
try
{
var expressionsContainer = Serializer.Deserialize(callSettings.ResultMapping);
expressions.AddRange(expressionsContainer.Expressions);
}
catch
{
// Do nothing, new expressions will be used.
}
}
UpdateStateList(process);
UpdateStoredExpressions(expressions, newExpressions, syncContext);
syncContext.OperationCompleted();
WindowManager.Value.ShowChildWindow(parentWindow, this);
}
public void Initialize(ESyncProcessEdit process, ProcessEdit parentModel, ITopLevelWindow parentWindow)
{
if (process == null) throw new ArgumentNullException("process");
Model = process;
ParentModel = parentModel;
ParentWindow = parentWindow;
EndpointsViewModel.Initialize(process.Endpoints, parentWindow);
SchedulerViewModel.Initialize(process.Scheduler);
JobStatus = ESyncJobStatus.Unknown;
}
/// <summary>
/// Initiates expression editing.
/// </summary>
/// <param name="parentWindow">The parent window.</param>
/// <param name="process">The process containing rule.</param>
/// <param name="rule">The rule containing expression.</param>
/// <param name="saveAction">The save action.</param>
/// <param name="cancelAction">The cancel action.</param>
/// <param name="removeAction">The remove action.</param>
public async void EditExpression(
ITopLevelWindow parentWindow,
IProcessEdit process,
ProcessActionRuleEdit rule,
Action saveAction,
Action cancelAction,
Action removeAction)
{
WindowManager.Value.ShowStatus(new Status { IsBusy = true });
SaveAction = saveAction;
CancelAction = cancelAction;
RemoveAction = removeAction;
ProcessEdit = process;
ExpressionDesigner.LoadFromExpressionObjects(new List<IExpressionObjectBase>());
var expressions = new List<IExpressionObjectBase>();
var newExpressions = new List<IExpressionObjectBase>();
var syncContext = new NotifyClientAction(
() =>
{
ExpressionDesigner.LoadFromExpressionObjects(expressions);
WindowManager.Value.ShowStatus(new Status());
_itemHashes = ExpressionDesigner.Diagram.Items.Select(x => x.GetHashCode()).ToList();
});
syncContext.OperationStarted();
var oldSourceName = string.Format("Old {0}", process.SystemName);
var sourceName = process.SystemName;
newExpressions.Add(CreateSourceItem(process, oldSourceName, OldSourceItemName, OldItemObjectName, 10, 10));
newExpressions.Add(CreateSourceItem(process, sourceName, NewSourceItemName, NewItemObjectName, 10, 300));
newExpressions.Add(CreateUserInfoSourceItem());
newExpressions.Add(CreateDestinationItem());
SourceFieldList systemParameters;
try
{
systemParameters = await CreateSystemParametersItemAsync(SystemParametersItemName);
}
catch (Exception)
{
systemParameters = null;
}
if (systemParameters != null)
newExpressions.Add(systemParameters);
if (!string.IsNullOrWhiteSpace(rule.Expression))
{
try
{
var expressionsContainer = Serializer.Deserialize(rule.Expression);
expressions.AddRange(expressionsContainer.Expressions);
}
catch
{
// Do nothing, new expressions will be used.
}
}
UpdateStateList(process);
UpdateStoredExpressions(expressions, newExpressions, syncContext);
syncContext.OperationCompleted();
WindowManager.Value.ShowChildWindow(parentWindow, this);
}
/// <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);
}
/// <summary>
/// Initializes the expression designer and opens the expression designer window.
/// </summary>
/// <param name="parentWindow">The parent window.</param>
/// <param name="process">The parent process.</param>
/// <param name="method">The service method.</param>
/// <param name="serviceTypes">The collection of known service types.</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,
ServiceMethodEdit method,
IEnumerable<ServiceExposedTypeEdit> serviceTypes,
Action saveAction,
Action cancelAction,
Action removeAction)
{
SaveAction = saveAction;
CancelAction = cancelAction;
RemoveAction = removeAction;
_knownTypes = serviceTypes.ToArray();
ExpressionDesigner.Value.LoadFromExpressionObjects(new List<IExpressionObjectBase>());
WindowManager.Value.ShowStatus(new Status { IsBusy = true });
var expressions = new List<IExpressionObjectBase>();
var newExpressions = new List<IExpressionObjectBase>();
var syncContext = new NotifyClientAction(
() =>
{
ExpressionDesigner.Value.LoadFromExpressionObjects(expressions);
WindowManager.Value.ShowStatus(new Status());
});
syncContext.OperationStarted();
newExpressions.Add(CreateSourceItem(method.InputParameters));
newExpressions.Add(CreateDestinationItem(process));
if (!string.IsNullOrWhiteSpace(method.EndpointMapping))
{
try
{
var expressionsContainer = Serializer.Deserialize(method.EndpointMapping);
expressions.AddRange(expressionsContainer.Expressions);
}
catch
{
// Do nothing, new expressions will be used.
}
}
UpdateStateList(process);
UpdateStoredExpressions(expressions, newExpressions, syncContext);
syncContext.OperationCompleted();
WindowManager.Value.ShowChildWindow(parentWindow, this);
}
/// <summary>
/// Initializes the specified model.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="parentWindow">The parent window.</param>
public void Initialize(ProviderFieldEditList model, ITopLevelWindow parentWindow)
{
Model = model;
ParentWindow = parentWindow;
}
/// <summary>
/// Determines whether the specified view model is registered.
/// </summary>
/// <param name="viewModel">The view model.</param>
/// <returns><c>true</c> if the specified view model is registered; otherwise, <c>false</c>.</returns>
public bool IsRegistered(ITopLevelWindow viewModel)
{
UserControl view;
return _registeredViews.TryGetValue(viewModel, out view);
}
