// ReSharper disable MemberCanBeProtected.Global
public ServerProxy(string serverUri, ICredentials credentials, IAsyncWorker worker)
// ReSharper restore MemberCanBeProtected.Global
{
_wrappedConnection = new ServerProxyWithoutChunking(serverUri,credentials,worker);
SetupPassthroughEvents();
}
public SettingsViewModel(IEventAggregator eventPublisher, IPopupController popupController, IAsyncWorker asyncWorker, IWin32Window parentWindow, IConnectControlViewModel connectControlViewModel)
: base(eventPublisher)
{
Settings = new Data.Settings.Settings();
VerifyArgument.IsNotNull("popupController", popupController);
_popupController = popupController;
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
_asyncWorker = asyncWorker;
VerifyArgument.IsNotNull("parentWindow", parentWindow);
_parentWindow = parentWindow;
SaveCommand = new RelayCommand(o => SaveSettings(), o => IsDirty);
ServerChangedCommand = new DelegateCommand(OnServerChanged);
ConnectControlViewModel = connectControlViewModel ?? new ConnectControlViewModel(OnServerChanged, "Server:", false);
}
internal ConnectControlSingleton(IStudioResourceRepository studioResourceRepository,
IAsyncWorker asyncWorker,
IEnvironmentModelProvider serverProvider,
IEnvironmentRepository environmentRepository)
{
VerifyArgument.IsNotNull("studioResourceRepository", studioResourceRepository);
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
VerifyArgument.IsNotNull("serverProvider", serverProvider);
VerifyArgument.IsNotNull("environmentRepository", environmentRepository);
_studioResourceRepository = studioResourceRepository;
_asyncWorker = asyncWorker;
_serverProvider = serverProvider;
_environmentRepository = environmentRepository;
Servers = new ObservableCollection<IConnectControlEnvironment>();
LoadServers();
}
public SettingsViewModel(IEventAggregator eventPublisher, IPopupController popupController, IAsyncWorker asyncWorker, IWin32Window parentWindow, IConnectControlViewModel connectControlViewModel)
: base(eventPublisher)
{
Settings = new Data.Settings.Settings();
VerifyArgument.IsNotNull("popupController", popupController);
_popupController = popupController;
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
_asyncWorker = asyncWorker;
VerifyArgument.IsNotNull("parentWindow", parentWindow);
_parentWindow = parentWindow;
SaveCommand = new RelayCommand(o => SaveSettings(), o => IsDirty);
ServerChangedCommand = new DelegateCommand(OnServerChanged);
ConnectControlViewModel = connectControlViewModel ?? new ConnectControlViewModel(OnServerChanged, "Server:", false);
}
public ManageWcfSourceViewModel(IWcfSourceModel updateManager, IEventAggregator aggregator, IAsyncWorker asyncWorker, IServer environment)
: base("WcfSource")
{
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
VerifyArgument.IsNotNull("updateManager", updateManager);
VerifyArgument.IsNotNull("aggregator", aggregator);
AsyncWorker = asyncWorker;
_environment = environment;
_updateManager = updateManager;
_endPointUrl = string.Empty;
HeaderText = Resources.Languages.Core.WcfServiceNewHeaderLabel;
Header = Resources.Languages.Core.WcfServiceNewHeaderLabel;
TestCommand = new Microsoft.Practices.Prism.Commands.DelegateCommand(TestConnection, CanTest);
SaveCommand = new Microsoft.Practices.Prism.Commands.DelegateCommand(SaveConnection, CanSave);
CancelTestCommand = new Microsoft.Practices.Prism.Commands.DelegateCommand(CancelTest, CanCancelTest);
}
/// <summary>
/// Shared Ctor initialisation
/// </summary>
/// <param name="asyncWorker"></param>
/// <param name="serverProvider"></param>
/// <param name="environmentRepository"></param>
/// <param name="eventAggregator"></param>
/// <param name="connectControl"></param>
/// <param name="deployStatsCalculator"></param>
private void Initialize(IAsyncWorker asyncWorker, IEnvironmentModelProvider serverProvider, IEnvironmentRepository environmentRepository, IEventAggregator eventAggregator, IConnectControlSingleton connectControl, IDeployStatsCalculator deployStatsCalculator = null)
{
EnvironmentRepository = environmentRepository;
_deployStatsCalculator = deployStatsCalculator ?? new DeployStatsCalculator();
_serverProvider = serverProvider;
_servers = new ObservableCollection <IEnvironmentModel>();
_targetStats = new ObservableCollection <DeployStatsTO>();
_sourceStats = new ObservableCollection <DeployStatsTO>();
Target = new DeployNavigationViewModel(eventAggregator, asyncWorker, environmentRepository, StudioResourceRepository, true, connectControl);
Source = new DeployNavigationViewModel(eventAggregator, asyncWorker, environmentRepository, StudioResourceRepository, false, connectControl);
SetupPredicates();
SetupCommands();
LoadServers();
ExplorerItemModel.OnCheckedStateChangedAction += OnCheckedStateChangedAction;
}
public TriggerQueueView(IServer server, IAsyncWorker asyncWorker)
{
VerifyArgument.IsNotNull(nameof(asyncWorker), asyncWorker);
var activeServer = CustomContainer.Get <IShellViewModel>().ActiveServer;
_server = server is null ? activeServer : server;
_resourceRepository = _server.ResourceRepository;
_asyncWorker = asyncWorker;
_popupController = CustomContainer.Get <IPopupController>();
IsNewQueue = false;
NewQueue = true;
Options = new ObservableCollection <OptionView>();
DeadLetterOptions = new ObservableCollection <OptionView>();
Inputs = new List <IServiceInputBase>();
VerifyCommand = new DelegateCommand(ExecuteVerify);
MapEntireMessage = true;
}
public DeployViewModel(IAsyncWorker asyncWorker, IEnvironmentModelProvider serverProvider, IEnvironmentRepository environmentRepository, IEventAggregator eventAggregator, IStudioResourceRepository studioResourceRepository, IConnectControlViewModel sourceConnectControlVm, IConnectControlViewModel destinationConnectControlVm, IDeployStatsCalculator deployStatsCalculator = null, Guid?resourceID = null, Guid?environmentID = null, IConnectControlSingleton connectControlSingleton = null)
: base(eventAggregator)
{
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
if (connectControlSingleton == null)
{
connectControlSingleton = ConnectControlSingleton.Instance;
}
if (environmentID.HasValue)
{
_initialItemEnvironmentID = environmentID.Value;
}
_initialItemResourceID = resourceID.GetValueOrDefault(Guid.Empty);
DestinationServerHasDropped = false;
StudioResourceRepository = studioResourceRepository;
Initialize(asyncWorker, serverProvider, environmentRepository, eventAggregator, connectControlSingleton, deployStatsCalculator);
SourceConnectControlViewModel = sourceConnectControlVm ?? new ConnectControlViewModel(ChangeSourceServer, "Source Server:", false);
TargetConnectControlViewModel = destinationConnectControlVm ?? new ConnectControlViewModel(ChangeDestinationServer, "Destination Server:", false);
TargetConnectControlViewModel.SetTargetEnvironment();
}
public SharepointServerSourceViewModel(ISharePointSourceModel updateManager, IEventAggregator aggregator, IAsyncWorker asyncWorker, IServer environment)
: base("SharepointServerSource")
{
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
VerifyArgument.IsNotNull("updateManager", updateManager);
VerifyArgument.IsNotNull("aggregator", aggregator);
AsyncWorker = asyncWorker;
_environment = environment;
_updateManager = updateManager;
_authenticationType = AuthenticationType.Windows;
_serverName = string.Empty;
_userName = string.Empty;
_password = string.Empty;
IsWindows = true;
HeaderText = Resources.Languages.Core.SharePointServiceNewHeaderLabel;
Header = Resources.Languages.Core.SharePointServiceNewHeaderLabel;
TestCommand = new Microsoft.Practices.Prism.Commands.DelegateCommand(TestConnection, CanTest);
SaveCommand = new Microsoft.Practices.Prism.Commands.DelegateCommand(SaveConnection, CanSave);
CancelTestCommand = new Microsoft.Practices.Prism.Commands.DelegateCommand(CancelTest, CanCancelTest);
}
public static void Send(WebServerMethod method, IContextualResourceModel resourceModel, string payload, IAsyncWorker asyncWorker)
{
if(resourceModel == null || resourceModel.Environment == null || !resourceModel.Environment.IsConnected)
{
return;
}
var clientContext = resourceModel.Environment.Connection;
if(clientContext == null)
{
return;
}
asyncWorker.Start(() =>
{
var controller = new CommunicationController { ServiceName = resourceModel.Category };
controller.AddPayloadArgument("DebugPayload", payload);
controller.ExecuteCommand<string>(clientContext, clientContext.WorkspaceID);
}, () => { });
}
public TriggersViewModel(IEventAggregator eventPublisher, IPopupController popupController, IAsyncWorker asyncWorker, IServer server, Func <IServer, IServer> toEnvironmentModel)
: base(eventPublisher)
{
Server = server;
Server.NetworkStateChanged += ServerNetworkStateChanged;
VerifyArgument.IsNotNull(nameof(popupController), popupController);
_popupController = popupController;
VerifyArgument.IsNotNull(nameof(asyncWorker), asyncWorker);
_asyncWorker = asyncWorker;
SaveCommand = new RelayCommand(o => SaveTriggers(), o =>
{
return(IsSaveEnabled());
});
ToEnvironmentModel = toEnvironmentModel ?? (a => a.ToEnvironmentModel());
CurrentEnvironment = ToEnvironmentModel?.Invoke(server);
DisplayName = StringResources.TriggersHeader + " - " + Server.DisplayName;
LoadTasks();
}
public SettingsViewModel(IEventAggregator eventPublisher, IPopupController popupController, IAsyncWorker asyncWorker, IWin32Window parentWindow, IServer server, Func <IServer, IServer> toEnvironmentModel)
: base(eventPublisher)
{
Server = server;
Server.NetworkStateChanged += ServerNetworkStateChanged;
Settings = new Data.Settings.Settings();
VerifyArgument.IsNotNull("popupController", popupController);
_popupController = popupController;
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
_asyncWorker = asyncWorker;
VerifyArgument.IsNotNull("parentWindow", parentWindow);
_parentWindow = parentWindow;
SaveCommand = new RelayCommand(o => SaveSettings(), o => IsDirty);
ToEnvironmentModel = toEnvironmentModel ?? (a => a.ToEnvironmentModel());
CurrentEnvironment = ToEnvironmentModel?.Invoke(server);
LoadSettings();
// ReSharper disable once VirtualMemberCallInContructor
DisplayName = StringResources.SettingsTitle + " - " + Server.DisplayName;
}
public RedisSourceViewModel(IRedisSourceModel redisSourceModel, IEventAggregator aggregator, IAsyncWorker asyncWorker, IExternalProcessExecutor executor)
: base("RedisSource")
{
VerifyArgument.IsNotNull(nameof(executor), executor);
VerifyArgument.IsNotNull(nameof(asyncWorker), asyncWorker);
VerifyArgument.IsNotNull(nameof(redisSourceModel), redisSourceModel);
VerifyArgument.IsNotNull(nameof(aggregator), aggregator);
AsyncWorker = asyncWorker;
Executor = executor;
_redisSourceModel = redisSourceModel;
_warewolfserverName = redisSourceModel.ServerName;
_authenticationType = AuthenticationType.Anonymous;
_hostName = string.Empty;
_port = "6379";
_password = string.Empty;
HeaderText = Resources.Languages.Core.RedisNewHeaderLabel;
Header = Resources.Languages.Core.RedisNewHeaderLabel;
TestCommand = new DelegateCommand(TestConnection, CanTest);
OkCommand = new DelegateCommand(SaveConnection, CanSave);
CancelTestCommand = new DelegateCommand(CancelTest, CanCancelTest);
}
/// <exception cref="Exception">A delegate callback throws an exception.</exception>
public ManageComPluginSourceViewModel(IManageComPluginSourceModel updateManager, Microsoft.Practices.Prism.PubSubEvents.IEventAggregator aggregator, IAsyncWorker asyncWorker)
: base("ComPluginSource")
{
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
VerifyArgument.IsNotNull("updateManager", updateManager);
VerifyArgument.IsNotNull("aggregator", aggregator);
_updateManager = updateManager;
AsyncWorker = asyncWorker;
HeaderText = Resources.Languages.Core.ComPluginSourceNewHeaderLabel;
Header = Resources.Languages.Core.ComPluginSourceNewHeaderLabel;
OkCommand = new DelegateCommand(Save, CanSave);
CancelCommand = new DelegateCommand(() => CloseAction.Invoke());
ClearSearchTextCommand = new DelegateCommand(() => SearchTerm = "");
RefreshCommand = new DelegateCommand(() => PerformLoadAll());
_warewolfserverName = updateManager.ServerName;
if (Application.Current != null && Application.Current.Dispatcher != null)
{
DispatcherAction = Application.Current.Dispatcher.Invoke;
}
}
public NavigationViewModel(IEventAggregator eventPublisher, IAsyncWorker asyncWorker, Guid?context, IEnvironmentRepository environmentRepository, IStudioResourceRepository studioResourceRepository, IConnectControlSingleton connectControlSingleton, System.Action updateWorkSpaceItems, bool isFromActivityDrop = false, enDsfActivityType activityType = enDsfActivityType.All, NavigationViewModelType navigationViewModelType = NavigationViewModelType.Explorer)
: base(eventPublisher, asyncWorker, environmentRepository, studioResourceRepository, updateWorkSpaceItems)
{
VerifyArgument.IsNotNull("eventPublisher", eventPublisher);
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
VerifyArgument.IsNotNull("environmentRepository", environmentRepository);
VerifyArgument.IsNotNull("connectControlSingleton", connectControlSingleton);
_eventPublisher = eventPublisher;
_connectControlSingleton = connectControlSingleton;
_eventPublisher.Subscribe(this);
EnvironmentRepository = environmentRepository;
Context = context;
DsfActivityType = activityType;
_fromActivityDrop = isFromActivityDrop;
_navigationViewModelType = navigationViewModelType;
Environments = new List <IEnvironmentModel>();
ExplorerItemModels = new ObservableCollection <IExplorerItemModel>();
CircularProgressBarVisibility = Visibility.Hidden;
RefreshButtonVisibility = Visibility.Visible;
}
public ExchangeNewEmailDesignerViewModel(ModelItem modelItem, IAsyncWorker asyncWorker, IServer server, IEventAggregator eventPublisher)
: base(modelItem)
{
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
VerifyArgument.IsNotNull("eventPublisher", eventPublisher);
_asyncWorker = asyncWorker;
_server = server;
_eventPublisher = eventPublisher;
_eventPublisher.Subscribe(this);
AddTitleBarLargeToggle();
TestEmailAccountCommand = new RelayCommand(o => TestEmailAccount(), o => CanTestEmailAccount);
ChooseAttachmentsCommand = new DelegateCommand(o => ChooseAttachments());
var shellViewModel = CustomContainer.Get <IShellViewModel>();
var model = CustomContainer.CreateInstance <IExchangeServiceModel>(server.UpdateRepository, server.QueryProxy, shellViewModel, server);
Model = model;
SetupCommonProperties();
HelpText = Warewolf.Studio.Resources.Languages.HelpText.Tool_Email_Exchange_Send;
}
public ManageWebserviceSourceViewModel(IManageWebServiceSourceModel updateManager, IEventAggregator aggregator, IAsyncWorker asyncWorker, IExternalProcessExecutor executor)
: base("WebSource")
{
VerifyArgument.IsNotNull("executor", executor);
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
VerifyArgument.IsNotNull("updateManager", updateManager);
VerifyArgument.IsNotNull("aggregator", aggregator);
AsyncWorker = asyncWorker;
Executor = executor;
_updateManager = updateManager;
_warewolfserverName = updateManager.ServerName;
_authenticationType = AuthenticationType.Anonymous;
_hostName = string.Empty;
_defaultQuery = string.Empty;
_userName = string.Empty;
_password = string.Empty;
HeaderText = Resources.Languages.Core.WebserviceNewHeaderLabel;
Header = Resources.Languages.Core.WebserviceNewHeaderLabel;
TestCommand = new DelegateCommand(TestConnection, CanTest);
OkCommand = new DelegateCommand(SaveConnection, CanSave);
CancelTestCommand = new DelegateCommand(CancelTest, CanCancelTest);
ViewInBrowserCommand = new DelegateCommand(ViewInBrowser, CanViewInBrowser);
}
public ElasticsearchSourceViewModel(IElasticsearchSourceModel elasticsearchSourceModel, IEventAggregator aggregator, IAsyncWorker asyncWorker, IExternalProcessExecutor executor, IServer currentEnvironment)
: base("ElasticsearchSource")
{
VerifyArgument.IsNotNull(nameof(executor), executor);
VerifyArgument.IsNotNull(nameof(asyncWorker), asyncWorker);
VerifyArgument.IsNotNull(nameof(elasticsearchSourceModel), elasticsearchSourceModel);
VerifyArgument.IsNotNull(nameof(aggregator), aggregator);
CurrentEnvironment = currentEnvironment ?? throw new ArgumentNullException(nameof(currentEnvironment));
AsyncWorker = asyncWorker;
Executor = executor;
_elasticsearchSourceModel = elasticsearchSourceModel;
_authenticationType = AuthenticationType.Anonymous;
_hostName = string.Empty;
_port = "9200";
_password = string.Empty;
_searchIndex = string.Empty;
_username = string.Empty;
HeaderText = Resources.Languages.Core.ElasticsearchNewHeaderLabel;
Header = Resources.Languages.Core.ElasticsearchNewHeaderLabel;
TestCommand = new DelegateCommand(TestConnection, CanTest);
OkCommand = new DelegateCommand(SaveConnection, CanSave);
CancelTestCommand = new DelegateCommand(CancelTest, CanCancelTest);
}
public ExchangeNewEmailDesignerViewModel(ModelItem modelItem, IAsyncWorker asyncWorker, IServer server, IEventAggregator eventPublisher, IShellViewModel shellViewModel, IActiveDataList activeDataList)
: base(modelItem)
{
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
VerifyArgument.IsNotNull("eventPublisher", eventPublisher);
_asyncWorker = asyncWorker;
_server = server;
_eventPublisher = eventPublisher;
_eventPublisher.Subscribe(this);
AddTitleBarLargeToggle();
TestEmailAccountCommand = new RelayCommand(o => TestEmailAccount(), o => CanTestEmailAccount);
ChooseAttachmentsCommand = new DelegateCommand(o => ChooseAttachments());
_shellViewModel = shellViewModel;
_activeDataList = activeDataList;
var model = new ExchangeServiceModel(_server, _shellViewModel);
Model = model;
SetupCommonProperties();
HelpText = Warewolf.Studio.Resources.Languages.HelpText.Tool_Email_Exchange_Send;
}
public SettingsViewModel(IEventAggregator eventPublisher, IPopupController popupController, IAsyncWorker asyncWorker, IWin32Window parentWindow, IServer server, Func <IServer, IServer> toEnvironmentModel)
: base(eventPublisher)
{
Server = server;
Server.NetworkStateChanged += ServerNetworkStateChanged;
Settings = new Data.Settings.Settings();
VerifyArgument.IsNotNull("popupController", popupController);
_popupController = popupController;
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
_asyncWorker = asyncWorker;
VerifyArgument.IsNotNull("parentWindow", parentWindow);
_parentWindow = parentWindow;
SaveCommand = new RelayCommand(o => SaveSettings(), o => IsDirty);
IShellViewModel vm = CustomContainer.Get <IShellViewModel>();
CreateEnvironmentFromServer(vm.LocalhostServer);
ToEnvironmentModel = toEnvironmentModel ?? (a => a.ToEnvironmentModel());
CurrentEnvironment = ToEnvironmentModel(server);
LoadSettings();
DisplayName = "Settings - " + Server.DisplayName;
}
public ManageOracleSourceViewModel(IManageDatabaseSourceModel updateManager, Task <IRequestServiceNameViewModel> requestServiceNameViewModel, IEventAggregator aggregator, IAsyncWorker asyncWorker)
: base(updateManager, requestServiceNameViewModel, aggregator, asyncWorker, "Oracle")
{
HeaderText = Resources.Languages.Core.OracleSourceNewHeaderLabel;
Header = Resources.Languages.Core.OracleSourceNewHeaderLabel;
InitializeViewModel();
}
public ManageMySqlSourceViewModel(IAsyncWorker asyncWorker)
: base(asyncWorker, "MySqlDatabase")
{
}
public SchedulerViewModel(IEventAggregator eventPublisher, DirectoryObjectPickerDialog directoryObjectPicker, IPopupController popupController, IAsyncWorker asyncWorker, IConnectControlViewModel connectControlViewModel)
: base(eventPublisher)
{
VerifyArgument.IsNotNull("directoryObjectPicker", directoryObjectPicker);
DirectoryObjectPickerDialog directoryObjectPicker1 = directoryObjectPicker;
VerifyArgument.IsNotNull("popupController", popupController);
_popupController = popupController;
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
_asyncWorker = asyncWorker;
IsLoading = false;
directoryObjectPicker1.AllowedObjectTypes = ObjectTypes.Users;
directoryObjectPicker1.DefaultObjectTypes = ObjectTypes.Users;
directoryObjectPicker1.AllowedLocations = Locations.All;
directoryObjectPicker1.DefaultLocations = Locations.JoinedDomain;
directoryObjectPicker1.MultiSelect = false;
directoryObjectPicker1.TargetComputer = string.Empty;
directoryObjectPicker1.ShowAdvancedView = false;
InitializeHelp();
var taskServiceConvertorFactory = new TaskServiceConvertorFactory();
SchedulerFactory = new ClientSchedulerFactory(new Dev2TaskService(taskServiceConvertorFactory), taskServiceConvertorFactory);
ConnectControlViewModel = connectControlViewModel ?? new ConnectControlViewModel(OnServerChanged, "Server: ", false);
}
public ManageSqlServerSourceViewModel(IAsyncWorker asyncWorker)
: base(asyncWorker, "SqlDatabase")
{
}
public DeployNavigationViewModel(IEventAggregator eventPublisher, IAsyncWorker asyncWorker, IEnvironmentRepository environmentRepository, IStudioResourceRepository studioResourceRepository, bool target, IConnectControlSingleton connectControlSingleton)
: base(eventPublisher, asyncWorker, environmentRepository, studioResourceRepository)
{
_target = target;
ConnectControlSingleton = connectControlSingleton;
}
public MySqlDatabaseDesignerViewModel(ModelItem modelItem, IDbServiceModel model, IAsyncWorker worker, IViewPropertyBuilder propertyBuilder)
: base(modelItem)
{
Model = model;
_worker = worker;
_propertyBuilder = propertyBuilder;
SetupCommonProperties();
}
public MergePreviewWorkflowDesignerViewModel(IWorkflowDesignerWrapper workflowDesignerHelper, IEventAggregator eventPublisher, IContextualResourceModel resource, IWorkflowHelper workflowHelper, IPopupController popupController, IAsyncWorker asyncWorker, bool createDesigner, bool liteInit)
: base(eventPublisher, resource, workflowHelper, popupController, asyncWorker, createDesigner, liteInit)
{
}
public void Load(Guid environmentId, IAsyncWorker asyncWorker, Action<Guid> onCompletion)
{
if(asyncWorker == null)
{
throw new ArgumentNullException("asyncWorker");
}
var environmentRepository = GetEnvironmentRepository();
if(!_isRegistered)
{
_isRegistered = true;
}
// ReSharper disable ImplicitlyCapturedClosure
IEnvironmentModel environmentModel = environmentRepository.FindSingle(c => c.ID == environmentId);
// ReSharper restore ImplicitlyCapturedClosure
if(environmentModel != null)
{
if(!environmentModel.IsConnected)
{
// ReSharper disable ImplicitlyCapturedClosure
asyncWorker.Start(environmentModel.Connect, () => LoadEnvironmentTree(environmentId, onCompletion, environmentModel), e => onCompletion(environmentId));
// ReSharper restore ImplicitlyCapturedClosure
}
else
{
asyncWorker.Start(()=>{}, () => LoadEnvironmentTree(environmentId, onCompletion, environmentModel), e => onCompletion(environmentId));
}
}
}
public void ClientClosed(IAsyncWorker worker)
{
if (this.fWorkers == null)
return;
lock (this.fWorkers)
{
this.fWorkers.Remove(worker);
}
}
public MainViewModelMock(IEventAggregator eventPublisher, IAsyncWorker asyncWorker, IEnvironmentRepository environmentRepository, IVersionChecker versionChecker, IStudioResourceRepository studioResourceRepository, IConnectControlSingleton connectControlSingleton, IConnectControlViewModel connectControlViewModel, bool createDesigners = true, IBrowserPopupController browserPopupController = null)
: base(eventPublisher, asyncWorker, environmentRepository, versionChecker, createDesigners, browserPopupController, studioResourceRepository:studioResourceRepository, connectControlSingleton:connectControlSingleton, connectControlViewModel: connectControlViewModel)
{
}
// ReSharper disable MemberCanBeProtected.Global
public ServerProxy(string serverUri, ICredentials credentials, IAsyncWorker worker)
{
_wrappedConnection = new ServerProxyWithoutChunking(serverUri,credentials,worker);
SetupPassthroughEvents();
}
public TestSettingsViewModel(IEventAggregator eventPublisher, IPopupController popupController, IAsyncWorker asyncWorker, IWin32Window parentWindow)
: base(eventPublisher, popupController, asyncWorker, parentWindow, new Mock<IConnectControlViewModel>().Object)
{
}
static DeployNavigationViewModel CreateDeployNavigationViewModel(IEnvironmentModel environmentModel, IEventAggregator eventAggregator, IAsyncWorker asyncWorker, IEnvironmentRepository environmentRepository, StudioResourceRepository studioResourceRepository)
{
DeployNavigationViewModel navigationViewModel = new DeployNavigationViewModel(eventAggregator, asyncWorker, environmentRepository, studioResourceRepository, true, new Mock<IConnectControlSingleton>().Object)
{
Environment = environmentModel
};
return navigationViewModel;
}
public ExplorerItemModel(IConnectControlSingleton connectControlSingleton, IStudioResourceRepository studioResourceRepository)
{
Children = new ObservableCollection<IExplorerItemModel>();
_isAuthorized = true;
_isConnected = true;
_studioResourceRepository = studioResourceRepository;
Children.CollectionChanged -= ChildrenCollectionChanged;
Children.CollectionChanged += ChildrenCollectionChanged;
_asyncWorker = new AsyncWorker();
_activityNames = new Dictionary<ResourceType, Type>
{
{
ResourceType.DbService, typeof(DsfDatabaseActivity)
},
{
ResourceType.PluginService, typeof(DsfPluginActivity)
},
{
ResourceType.WebService, typeof(DsfWebserviceActivity)
}
};
_connectControlSingleton = connectControlSingleton;
_connectControlSingleton.ConnectedStatusChanged += ConnectedStatusChanged;
ToggleVersionHistoryHeader = "Show Version History";
}
public ExplorerItemModel(IStudioResourceRepository studioResourceRepository, IAsyncWorker asyncWorker, IConnectControlSingleton connectControlSingleton)
: this(connectControlSingleton, studioResourceRepository)
{
_studioResourceRepository = studioResourceRepository;
_asyncWorker = asyncWorker;
_connectControlSingleton = connectControlSingleton;
}
public SchedulerViewModelForTest(IEventAggregator eventPublisher, DirectoryObjectPickerDialog directoryObjectPicker, IPopupController popupController, IAsyncWorker asyncWorker)
: base(eventPublisher, directoryObjectPicker, popupController, asyncWorker, new Mock<IConnectControlViewModel>().Object)
{
}
public DeployNavigationViewModel(IEventAggregator eventPublisher, IAsyncWorker asyncWorker, IEnvironmentRepository environmentRepository, IStudioResourceRepository studioResourceRepository, bool target, IConnectControlSingleton connectControlSingleton)
: base(eventPublisher, asyncWorker, environmentRepository, studioResourceRepository)
{
_target = target;
ConnectControlSingleton = connectControlSingleton;
}
public MainViewModelPersistenceMock(IEnvironmentRepository environmentRepository,IAsyncWorker asyncWorker, bool createDesigners = true)
: base(new Mock<IEventAggregator>().Object, asyncWorker, environmentRepository, new VersionChecker(), createDesigners,
studioResourceRepository: new Mock<IStudioResourceRepository>().Object, connectControlSingleton: new Mock<IConnectControlSingleton>().Object, connectControlViewModel: new Mock<IConnectControlViewModel>().Object)
{
}
public SharePointFileDownLoadDesignerViewModel(ModelItem modelItem, IAsyncWorker asyncWorker, IServer envModel)
: base(modelItem, asyncWorker, envModel, EventPublishers.Aggregator, false)
{
HelpText = Warewolf.Studio.Resources.Languages.HelpText.Tool_SharePoint_Download_File;
}
public void Load(Guid environmentId, IAsyncWorker asyncWorker)
{
Load(environmentId, asyncWorker, id => { });
}
static DeployNavigationViewModel CreateDeployNavigationViewModel(IEnvironmentModel environmentModel, IEventAggregator eventAggregator, IAsyncWorker asyncWorker, IEnvironmentRepository environmentRepository, StudioResourceRepository studioResourceRepository)
{
DeployNavigationViewModel navigationViewModel = new DeployNavigationViewModel(eventAggregator, asyncWorker, environmentRepository, studioResourceRepository, true, new Mock <IConnectControlSingleton>().Object)
{
Environment = environmentModel
};
return(navigationViewModel);
}
// ReSharper disable TooManyDependencies
public SchedulerViewModelForTesting(IEventAggregator eventPublisher, DirectoryObjectPickerDialog directoryObjectPicker, IPopupController popupController, IAsyncWorker asyncWorker)
// ReSharper restore TooManyDependencies
: base(eventPublisher, directoryObjectPicker, popupController, asyncWorker, new Mock<IConnectControlViewModel>().Object)
{
}
public ManageSqlServerSourceViewModel(IManageDatabaseSourceModel updateManager, Task <IRequestServiceNameViewModel> requestServiceNameViewModel, IEventAggregator aggregator, IAsyncWorker asyncWorker)
: base(updateManager, requestServiceNameViewModel, aggregator, asyncWorker, "SqlDatabase")
{
HeaderText = Resources.Languages.Core.SqlServerSourceServerNewHeaderLabel;
Header = Resources.Languages.Core.SqlServerSourceServerNewHeaderLabel;
}
// ReSharper disable TooManyDependencies
public SettingsViewModelForTest(IEventAggregator eventPublisher, IPopupController popupController,
// ReSharper restore TooManyDependencies
IAsyncWorker asyncWorker, IWin32Window parentWindow)
: base(eventPublisher, popupController, asyncWorker, parentWindow, new Mock<IConnectControlViewModel>().Object)
{
}
public void Load(Guid environmentId, IAsyncWorker asyncWorker)
{
Load(environmentId, asyncWorker, id => { });
}
public TestResourcePickerDialog(enDsfActivityType activityType, IEnvironmentRepository environmentRepository, IEventAggregator eventPublisher, IAsyncWorker asyncWorker, bool isFromDrop, IStudioResourceRepository studioResourceRepository)
: base(activityType, environmentRepository, eventPublisher, asyncWorker, isFromDrop, studioResourceRepository, new Mock<IConnectControlSingleton>().Object)
{
}
public ManageMySqlSourceViewModel(IManageDatabaseSourceModel updateManager, IEventAggregator aggregator, IDbSource dbSource, IAsyncWorker asyncWorker)
: base(updateManager, aggregator, dbSource, asyncWorker, "MySqlDatabase")
{
VerifyArgument.IsNotNull("mySqlSource", dbSource);
}
public RuntimeServiceBuilder RegisterAsyncWorker(IAsyncWorker worker)
{
context.Register(worker);
return this;
}
public ManageOracleSourceViewModel(IAsyncWorker asyncWorker)
: base(asyncWorker, "Oracle")
{
}
public ServiceDesignerViewModel(ModelItem modelItem, IContextualResourceModel rootModel, IEnvironmentRepository environmentRepository, IEventAggregator eventPublisher, IAsyncWorker asyncWorker)
: base(modelItem)
{
AddTitleBarEditToggle();
AddTitleBarMappingToggle();
// PBI 6690 - 2013.07.04 - TWR : added
// BUG 9634 - 2013.07.17 - TWR : resourceModel may be null if it is a remote resource whose environment is not connected!
VerifyArgument.IsNotNull("rootModel", rootModel);
VerifyArgument.IsNotNull("environmentRepository", environmentRepository);
VerifyArgument.IsNotNull("eventPublisher", eventPublisher);
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
_worker = asyncWorker;
_eventPublisher = eventPublisher;
eventPublisher.Subscribe(this);
ButtonDisplayValue = DoneText;
ShowExampleWorkflowLink = Visibility.Collapsed;
RootModel = rootModel;
DesignValidationErrors = new ObservableCollection <IErrorInfo>();
FixErrorsCommand = new DelegateCommand(o =>
{
FixErrors();
IsFixed = IsWorstErrorReadOnly;
});
DoneCommand = new DelegateCommand(o => Done());
DoneCompletedCommand = new DelegateCommand(o => DoneCompleted());
InitializeDisplayName();
InitializeProperties();
InitializeImageSource();
IsAsyncVisible = ActivityTypeToActionTypeConverter.ConvertToActionType(Type) == Common.Interfaces.Core.DynamicServices.enActionType.Workflow;
OutputMappingEnabled = !RunWorkflowAsync;
// When the active environment is not local, we need to get smart around this piece of logic.
// It is very possible we are treating a remote active as local since we cannot logically assign
// an environment id when this is the case as it will fail with source not found since the remote
// does not contain localhost's connections ;)
var activeEnvironment = environmentRepository.ActiveEnvironment;
if (EnvironmentID == Guid.Empty && !activeEnvironment.IsLocalHostCheck())
{
_environment = activeEnvironment;
}
else
{
var environment = environmentRepository.FindSingle(c => c.ID == EnvironmentID);
if (environment == null)
{
IList <IEnvironmentModel> environments = EnvironmentRepository.Instance.LookupEnvironments(activeEnvironment);
environment = environments.FirstOrDefault(model => model.ID == EnvironmentID);
}
_environment = environment;
}
InitializeValidationService(_environment);
if (!InitializeResourceModel(_environment))
{
return;
}
if (!IsDeleted)
{
// MUST InitializeMappings() first!
InitializeMappings();
InitializeLastValidationMemo(_environment);
if (IsItemDragged.Instance.IsDragged)
{
Expand();
IsItemDragged.Instance.IsDragged = false;
}
}
if (_environment != null)
{
_environment.AuthorizationServiceSet += OnEnvironmentOnAuthorizationServiceSet;
AuthorizationServiceOnPermissionsChanged(null, null);
}
}
public ManageOracleSourceViewModel(IManageDatabaseSourceModel updateManager, IEventAggregator aggregator, IDbSource dbSource, IAsyncWorker asyncWorker)
: base(updateManager, aggregator, dbSource, asyncWorker, "Oracle")
{
VerifyArgument.IsNotNull("oracleSource", dbSource);
InitializeViewModel();
}
static IExplorerItemModel SetupExplorerItemModelWithFolderAndOneChild(string displayName, Guid envID, Guid resourceId, out IExplorerItemModel resourceItem, IStudioResourceRepository rep, IAsyncWorker worker, IConnectControlSingleton connectControlSingleton)
{
var serverItem = new ExplorerItemModel(rep, worker, connectControlSingleton)
{
ResourceType = ResourceType.Server,
DisplayName = displayName,
ResourceId = Guid.Empty,
Permissions = Permissions.Administrator,
EnvironmentId = envID
};
var folderItem = new ExplorerItemModel(rep, worker, connectControlSingleton)
{
ResourceType = ResourceType.Folder,
DisplayName = Guid.NewGuid().ToString(),
ResourceId = Guid.Empty,
Permissions = Permissions.Administrator,
EnvironmentId = envID
};
resourceItem = new ExplorerItemModel(rep, worker, connectControlSingleton)
{
ResourceType = ResourceType.WorkflowService,
DisplayName = Guid.NewGuid().ToString(),
ResourceId = resourceId,
Permissions = Permissions.Administrator,
EnvironmentId = envID,
ResourcePath = "Path",
IsExplorerSelected = true,
Parent = folderItem
};
folderItem.Children.Add(resourceItem);
serverItem.Children.Add(folderItem);
return serverItem;
}
