public async Task <IExplorerItem> Load(bool reloadCatalogue, IPopupController popupController)
{
if (!Connection.IsConnected)
{
ShowServerDisconnectedPopup();
return(new ServerExplorerItem());
}
var comsController = CommunicationControllerFactory.CreateController("FetchExplorerItemsService");
comsController.AddPayloadArgument("ReloadResourceCatalogue", reloadCatalogue.ToString());
if (Connection.IsLocalHost)
{
var result = await comsController.ExecuteCompressedCommandAsync <IExplorerItem>(Connection, GlobalConstants.ServerWorkspaceID).ConfigureAwait(true);
return(result);
}
else
{
var fetchExplorerTask = comsController.ExecuteCompressedCommandAsync <IExplorerItem>(Connection, GlobalConstants.ServerWorkspaceID);
var delayTask = Task.Delay(60000).ContinueWith((t) =>
{
if (fetchExplorerTask.Status != TaskStatus.RanToCompletion)
{
popupController?.Show(string.Format(ErrorResource.ServerBusyError, Connection.DisplayName), ErrorResource.ServerBusyHeader, MessageBoxButton.OK,
MessageBoxImage.Warning, "", false, false, true, false, false, false);
}
}, System.Threading.Tasks.TaskScheduler.FromCurrentSynchronizationContext());
var result = await fetchExplorerTask.ConfigureAwait(true);
return(result);
}
}
private void ConnectionRetry()
{
HubConnection.Stop(new TimeSpan(0, 0, 0, 1));
IPopupController popup = CustomContainer.Get <IPopupController>();
var application = Application.Current;
MessageBoxResult res = MessageBoxResult.No;
if (application != null && application.Dispatcher != null)
{
application.Dispatcher.Invoke(() =>
{
res = popup.ShowConnectionTimeoutConfirmation(DisplayName);
});
}
if (res == MessageBoxResult.Yes)
{
if (!HubConnection.Start().Wait(5000))
{
ConnectionRetry();
}
}
else
{
throw new NotConnectedException();
}
}
/*
* DELETE THIS METHOD AND LOOSE A VERY IMPORTANT PART OF YOU ;)
*
* IT IS REQUIRED FOR UPDATES IN RELEASE MODE ;)
* REMOVING IT MEANS IT IS NOT POSSIBLE TO BUILD AN INSTALLER ;)
*/
// ReSharper disable once UnusedMember.Local
private bool CheckWindowsService()
{
IWindowsServiceManager windowsServiceManager = CustomContainer.Get <IWindowsServiceManager>();
IPopupController popup = CustomContainer.Get <IPopupController>();
ServerServiceConfiguration ssc = new ServerServiceConfiguration(windowsServiceManager, popup);
if (ssc.DoesServiceExist())
{
if (ssc.IsServiceRunning())
{
return(true);
}
if (ssc.PromptUserToStartService())
{
if (ssc.StartService())
{
_serverServiceStartedFromStudio = true;
return(true);
}
}
}
return(false);
}
public WorkSurfaceContextViewModel(IEventAggregator eventPublisher, WorkSurfaceKey workSurfaceKey, IWorkSurfaceViewModel workSurfaceViewModel, IPopupController popupController, Action <IContextualResourceModel, bool, System.Action> saveDialogAction)
: base(eventPublisher)
{
if (workSurfaceKey == null)
{
throw new ArgumentNullException(nameof(workSurfaceKey));
}
if (workSurfaceViewModel == null)
{
throw new ArgumentNullException(nameof(workSurfaceViewModel));
}
VerifyArgument.IsNotNull("popupController", popupController);
WorkSurfaceKey = workSurfaceKey;
WorkSurfaceViewModel = workSurfaceViewModel;
_windowManager = CustomContainer.Get <IWindowManager>();
var model = WorkSurfaceViewModel as IWorkflowDesignerViewModel;
if (model != null)
{
model.WorkflowChanged += UpdateForWorkflowChange;
_server = model.Server;
if (_server != null)
{
_server.IsConnectedChanged += EnvironmentModelOnIsConnectedChanged();
_server.Connection.ReceivedResourceAffectedMessage += OnReceivedResourceAffectedMessage;
}
}
_popupController = popupController;
_saveDialogAction = saveDialogAction;
}
public WorkflowInputDataViewModel(IServiceDebugInfoModel input, Guid sessionId)
{
VerifyArgument.IsNotNull(@"input", input);
CanDebug = true;
CanViewInBrowser = true;
DebugTo = new DebugTO
{
DataList = !string.IsNullOrEmpty(input.ResourceModel.DataList)
? input.ResourceModel.DataList
: @"<DataList></DataList>",
ServiceName = input.ResourceModel.ResourceName,
WorkflowID = input.ResourceModel.ResourceName,
WorkflowXaml = string.Empty,
XmlData = input.ServiceInputData,
ResourceID = input.ResourceModel.ID,
ServerID = input.ResourceModel.ServerID,
RememberInputs = input.RememberInputs,
SessionID = sessionId
};
if (input.DebugModeSetting == DebugMode.DebugInteractive)
{
DebugTo.IsDebugMode = true;
}
_resourceModel = input.ResourceModel;
DisplayName = @"Debug input data";
_popupController = CustomContainer.Get <IPopupController>();
}
public PersistenceSettingsViewModel(IServer currentEnvironment, IExternalProcessExecutor processExecutor)
{
CurrentEnvironment = currentEnvironment ?? throw new ArgumentNullException(nameof(currentEnvironment));
_resourceRepository = CurrentEnvironment.ResourceRepository;
_processExecutor = processExecutor ?? throw new ArgumentNullException(nameof(processExecutor));
var settingsData = CurrentEnvironment.ResourceRepository.GetPersistenceSettings <PersistenceSettingsData>(CurrentEnvironment);
var persistenceScheduler = PersistenceSchedulers.FirstOrDefault(o => o == settingsData.PersistenceScheduler);
SelectedPersistenceScheduler = persistenceScheduler;
var selectedDataSource = PersistenceDataSources.FirstOrDefault(o => o.ResourceID == settingsData.PersistenceDataSource.Value);
SelectedPersistenceDataSource = selectedDataSource;
_encryptDataSource = settingsData.EncryptDataSource ?? true;
_enable = settingsData.Enable ?? false;
_prepareSchemaIfNecessary = settingsData.PrepareSchemaIfNecessary ?? true;
_dashboardName = settingsData.DashboardName;
_dashboardHostname = settingsData.DashboardHostname;
_dashboardPort = settingsData.DashboardPort;
_serverName = settingsData.ServerName;
UpdateHangfireDashboardUrl();
HangfireDashboardBrowserCommand = new DelegateCommand(HangfireDashboardBrowser);
_popupController = CustomContainer.Get <IPopupController>();
IsDirty = false;
}
public MergeViewModel(IEventAggregator eventPublisher, IMergeWorkflowViewModel vm, IPopupController popupController, IView view)
: base(eventPublisher)
{
ViewModel = vm;
View = view;
_popupController = popupController;
ViewModel.PropertyChanged += (sender, args) =>
{
var mainViewModel = CustomContainer.Get <IShellViewModel>();
if (mainViewModel != null)
{
ViewModelUtils.RaiseCanExecuteChanged(mainViewModel.SaveCommand);
}
if (args.PropertyName == "DisplayName")
{
NotifyOfPropertyChange(() => DisplayName);
}
if (args.PropertyName == "DataListViewModel")
{
NotifyOfPropertyChange(() => DataListViewModel);
}
};
}
#pragma warning disable CC0091 // Use static method
#pragma warning disable CC0038 // You should use expression bodied members whenever possible.
bool CheckWindowsService()
#pragma warning restore CC0091 // Use static method
{
#if DEBUG
return(true);
#else
IWindowsServiceManager windowsServiceManager = CustomContainer.Get <IWindowsServiceManager>();
IPopupController popup = CustomContainer.Get <IPopupController>();
ServerServiceConfiguration ssc = new ServerServiceConfiguration(windowsServiceManager, popup);
if (ssc.DoesServiceExist())
{
if (ssc.IsServiceRunning())
{
return(true);
}
if (ssc.PromptUserToStartService())
{
if (ssc.StartService())
{
_serverServiceStartedFromStudio = true;
return(true);
}
}
}
return(false);
#endif
}
public SchedulerViewModel(IEventAggregator eventPublisher, DirectoryObjectPickerDialog directoryObjectPicker, IPopupController popupController, IAsyncWorker asyncWorker, IServer server, Func <IServer, IServer> toEnvironmentModel, Task <IResourcePickerDialog> getResourcePicker = null)
: base(eventPublisher)
{
SchedulerTaskManager = new SchedulerTaskManager(this, getResourcePicker);
VerifyArgument.IsNotNull("directoryObjectPicker", directoryObjectPicker);
DirectoryObjectPickerDialog directoryObjectPicker1 = directoryObjectPicker;
VerifyArgument.IsNotNull("popupController", popupController);
_popupController = popupController;
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
_asyncWorker = asyncWorker;
_toEnvironmentModel = toEnvironmentModel ?? (a => a.ToEnvironmentModel());
Errors = new ErrorResultTO();
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();
DebugOutputViewModel = new DebugOutputViewModel(new EventPublisher(), ServerRepository.Instance, new DebugOutputFilterStrategy());
Server = server;
SetupServer(server);
SetDisplayName(false);
}
public SearchViewModel(IShellViewModel shellViewModel, IEventAggregator aggregator)
: base(shellViewModel, aggregator, false)
{
_shellViewModel = shellViewModel;
PopupController = shellViewModel.PopupProvider;
ConnectControlViewModel = new ConnectControlViewModel(shellViewModel.LocalhostServer, aggregator, shellViewModel.ExplorerViewModel.ConnectControlViewModel.Servers);
ConnectControlViewModel.ServerConnected += async(sender, server) => { await ServerConnectedAsync(sender, server).ConfigureAwait(false); };
ConnectControlViewModel.ServerDisconnected += ServerDisconnected;
ConnectControlViewModel.SelectedEnvironmentChanged += UpdateServerCompareChanged;
SelectedEnvironment = _environments.FirstOrDefault();
RefreshCommand = new DelegateCommand(async(o) => await RefreshEnvironment(SelectedEnvironment.ResourceId));
SearchInputCommand = new DelegateCommand((o) => SearchWarewolf());
OpenResourceCommand = new DelegateCommand((searchObject) =>
{
var searchResult = searchObject as ISearchResult;
OpenResource(searchResult);
});
CanShowResults = true;
SearchResults = new ObservableCollection <ISearchResult>();
Search = new Common.Search.Search();
SelectedEnvironment?.Server?.ResourceRepository?.Load(false);
IsSearching = false;
DisplayName = $"Search";
UpdateHelpDescriptor(Warewolf.Studio.Resources.Languages.HelpText.MenuSearchHelp);
}
public DebugOutputViewModel(IEventPublisher serverEventPublisher, IServerRepository serverRepository, IDebugOutputFilterStrategy debugOutputFilterStrategy, IContextualResourceModel contextualResourceModel)
{
VerifyArgument.IsNotNull("serverEventPublisher", serverEventPublisher);
VerifyArgument.IsNotNull("environmentRepository", serverRepository);
VerifyArgument.IsNotNull("debugOutputFilterStrategy", debugOutputFilterStrategy);
_serverRepository = serverRepository;
_debugOutputFilterStrategy = debugOutputFilterStrategy;
if (contextualResourceModel != null)
{
_contextualResourceModel = contextualResourceModel;
ResourceID = _contextualResourceModel.ID;
}
IsTestView = false;
_contentItems = new List <IDebugState>();
_contentItemMap = new Dictionary <Guid, IDebugTreeViewItemViewModel>();
_debugWriterSubscriptionService = new SubscriptionService <DebugWriterWriteMessage>(serverEventPublisher);
_debugWriterSubscriptionService.Subscribe(msg =>
{
Append(msg.DebugState);
});
SessionID = Guid.NewGuid();
_popup = CustomContainer.Get <IPopupController>();
ClearSearchTextCommand = new Microsoft.Practices.Prism.Commands.DelegateCommand(() => SearchText = "");
AddNewTestCommand = new DelegateCommand(o => AddNewTest(EventPublishers.Aggregator), o => CanAddNewTest());
_outputViewModelUtil = new DebugOutputViewModelUtil(SessionID);
}
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 WorkflowDesignerViewModelMock(IContextualResourceModel resource, IWorkflowHelper workflowHelper, IPopupController popupController, bool createDesigner = false)
: base(new Mock<IEventAggregator>().Object,
resource, workflowHelper,
popupController, new TestAsyncWorker(), createDesigner, false, false)
{
_moq.SetupAllProperties();
_wd = _moq.Object;
}
public AuthenticationModel(
IFactory <ProxyPopupModel> proxyPopupModelFactory,
IAuthenticator authenticator,
IPopupController popupController
)
{
_modelDisposable = new CompositeDisposable();
SetProxyCommand = ReactiveCommand.Create(() =>
{
var popupModel = proxyPopupModelFactory.Create();
popupController.Show(popupModel);
});
var canSendCode = this
.WhenAnyValue(x => x.PhoneNumber)
.Select(phone => !string.IsNullOrWhiteSpace(phone));
SendCodeCommand = ReactiveCommand.CreateFromObservable(
() => authenticator.SetPhoneNumber(PhoneNumber),
canSendCode, RxApp.MainThreadScheduler);
var canCheckCode = this
.WhenAnyValue(x => x.ConfirmCode)
.Select(code => !string.IsNullOrWhiteSpace(code));
CheckCodeCommand = ReactiveCommand.CreateFromObservable(
() => authenticator.CheckCode(ConfirmCode, FirstName, LastName),
canCheckCode, RxApp.MainThreadScheduler);
var canCheckPassword = this
.WhenAnyValue(x => x.Password)
.Select(password => !string.IsNullOrWhiteSpace(password));
CheckPasswordCommand = ReactiveCommand.CreateFromObservable(
() => authenticator.CheckPassword(Password),
canCheckPassword, RxApp.MainThreadScheduler);
var stateObservable = authenticator
.ObserveState()
.ObserveOn(RxApp.MainThreadScheduler);
stateObservable
.OfType <TdApi.AuthorizationState.AuthorizationStateWaitPhoneNumber>()
.Subscribe(state => OnWaitingPhoneNumber())
.DisposeWith(_modelDisposable);
stateObservable
.OfType <TdApi.AuthorizationState.AuthorizationStateWaitCode>()
.Subscribe(state => OnWaitingConfirmCode(!state.IsRegistered))
.DisposeWith(_modelDisposable);
stateObservable
.OfType <TdApi.AuthorizationState.AuthorizationStateWaitPassword>()
.Subscribe(state => OnWaitingPassword())
.DisposeWith(_modelDisposable);
}
public DependencyVisualiserViewModel(DependencyVisualiserView view, IServer server, bool getDependsOnMe)
: base(EventPublishers.Aggregator)
{
_view = view;
_server = server;
GetDependsOnMe = getDependsOnMe;
GetDependsOnOther = !GetDependsOnMe;
NestingLevel = "0";
_popupController = new PopupController();
}
public static IDisposable BindProxySettings(
this AuthenticationModel model,
IPopupController popupController)
{
model.SetProxyCommand = ReactiveCommand.Create(
() => popupController.Show(new ProxyPopupContext()),
null,
RxApp.MainThreadScheduler);
return(Disposable.Empty);
}
public PopupModel(
PopupKind popupKind,
IPopupController popupController
)
{
PopupTitle = "";
IsPopupVisible = true;
PopupIndex = (int)popupKind;
PopupCloseCommand = ReactiveCommand.Create(popupController.Hide);
}
internal static void IntellisenseTextBoxTabInsertedEvent(object sender, RoutedEventArgs e)
{
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
IPopupController popup = CustomContainer.Get <IPopupController>();
popup.Show("You have pasted text which contins tabs into a textbox on the design surface. Tabs are not allowed in textboxes on the design surface and will be replaced with spaces. "
+ Environment.NewLine + Environment.NewLine +
"Please note that tabs are fully supported but the runtime, in variables and when reading from files.",
"Tabs Pasted", MessageBoxButton.OK, MessageBoxImage.Information, GlobalConstants.Dev2MessageBoxDesignSurfaceTabPasteDialog);
}), null);
}
public static IDisposable BindPopup(
this PopupModel model,
IPopupController popupController)
{
return(model.Context.CloseCommand
.SubscribeOn(RxApp.TaskpoolScheduler)
.ObserveOn(RxApp.MainThreadScheduler)
.Accept(_ =>
{
popupController.Hide();
}));
}
void ServerDisconnectDetected(object _, IServer server)
{
Application.Current.Dispatcher.Invoke(() =>
{
IPopupController controller = CustomContainer.Get <IPopupController>();
ServerDisconnected(_, server);
if (!ShowServerDownError)
{
controller.ShowServerNotConnected(server.DisplayName);
ShowServerDownError = true;
}
});
}
public void RemovePopupActive(IPopupController _popup)
{
if (popupsActive.Count == 0)
{
return;
}
popupsActive.Remove(_popup);
_popup.SelfDestruction();
if (popupsActive.Count == 0)
{
//gpRaycaster.enabled = false;
}
}
public static void ShowTrustRelationshipError(IPopupController popupController, SystemException exception)
{
if (exception.Message.Contains("The trust relationship between this workstation and the primary domain failed"))
{
var popup = popupController;
popup.Header = "Error connecting to server";
popup.Description = "This computer cannot contact the Domain Controller."
+ Environment.NewLine + "If it does not belong to a domain, please ensure it is removed from the domain in computer management.";
popup.Buttons = MessageBoxButton.OK;
popup.ImageType = MessageBoxImage.Error;
popup.Show();
}
}
/**
* RemovePopupActive : remove các popup đang active ra khỏi list
* */
public void RemovePopupActive(IPopupController _popup)
{
if (popupsActive.Count == 0)
{
return;
}
popupsActive.Remove(_popup);
_popup.SelfDestruction();
if (popupsActive.Count == 0)
{
myCanvasGroup.alpha = 0f;
myCanvasGroup.blocksRaycasts = false;
}
}
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 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 QueueEventsViewModel(IServer server, IExternalProcessExecutor externalProcessExecutor, IResourcePickerDialog resourcePickerDialog)
{
_server = server;
_resourceRepository = server.ResourceRepository;
_externalProcessExecutor = externalProcessExecutor;
AddWorkflowCommand = new DelegateCommand(OpenResourcePicker);
_source = new EnvironmentViewModel(server, CustomContainer.Get <IShellViewModel>(), true);
_currentResourcePicker = resourcePickerDialog ?? CreateResourcePickerDialog();
InitializeHelp();
PopupController = CustomContainer.Get <IPopupController>();
PopulateQueues();
AddDummyTriggerQueueView();
}
public SingleExplorerDeployViewModel(IDeployDestinationExplorerViewModel destination, IDeploySourceExplorerViewModel source, IEnumerable <IExplorerTreeItem> selectedItems, IDeployStatsViewerViewModel stats, IShellViewModel shell, IPopupController popupController, IAsyncWorker asyncWorker)
{
VerifyArgument.AreNotNull(new Dictionary <string, object> {
{ "destination", destination }, { "source", source }, { "selectedItems", selectedItems }, { "stats", stats }, { "popupController", popupController }
});
_destination = destination;
PopupController = popupController;
_source = source;
_errorMessage = "";
_source.Preselected = selectedItems;
_stats = stats;
_shell = shell;
_stats.CalculateAction = () =>
{
IsDeployLoading = true;
ServicesCount = _stats.Services.ToString();
SourcesCount = _stats.Sources.ToString();
TestsCount = _stats.Tests.ToString();
TriggersCount = _stats.Triggers.ToString();
NewResourcesCount = _stats.NewResources.ToString();
NewTestsCount = _stats.NewTests.ToString();
NewTriggersCount = _stats.NewTriggers.ToString();
OverridesCount = _stats.Overrides.ToString();
OverridesTestsCount = _stats.OverridesTests.ToString();
OverridesTriggersCount = _stats.OverridesTriggers.ToString();
ConflictItems = _stats.Conflicts;
NewItems = _stats.New;
ShowConflicts = false;
ViewModelUtils.RaiseCanExecuteChanged(DeployCommand);
IsDeployLoading = false;
};
SourceConnectControlViewModel = _source.ConnectControlViewModel;
DestinationConnectControlViewModel = _destination.ConnectControlViewModel;
SourceConnectControlViewModel.SelectedEnvironmentChanged += UpdateServerCompareChanged;
DestinationConnectControlViewModel.SelectedEnvironmentChanged += UpdateServerCompareChanged;
DeployCommand = new DelegateCommand(Deploy, () => CanDeploy);
SelectDependenciesCommand = new DelegateCommand(SelectDependencies, () => CanSelectDependencies);
NewResourcesViewCommand = new DelegateCommand(ViewNewResources);
OverridesViewCommand = new DelegateCommand(ViewOverrides);
Destination.ServerStateChanged += DestinationServerStateChanged;
Destination.PropertyChanged += DestinationOnPropertyChanged;
ShowConflicts = false;
}
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 DeployWorksurfaceViewModel(IEventAggregator eventPublisher, SingleExplorerDeployViewModel vm, IPopupController popupController, IView view)
: base(eventPublisher)
{
ViewModel = vm;
View = view;
_popupController = popupController;
ViewModel.PropertyChanged += (sender, args) =>
{
if (args.PropertyName == "Header")
{
OnPropertyChanged("DisplayName");
}
var mainViewModel = CustomContainer.Get <IShellViewModel>();
if (mainViewModel != null)
{
ViewModelUtils.RaiseCanExecuteChanged(mainViewModel.SaveCommand);
}
};
}
static void IsConnectionValid(IEnvironmentConnection connection, IPopupController popupController)
{
if (connection != null)
{
try
{
if (!connection.IsConnecting)
{
popupController?.Show(string.Format(ErrorResource.ServerDisconnected, connection.DisplayName) + Environment.NewLine +
ErrorResource.ServerReconnectForActions, ErrorResource.ServerDisconnectedHeader, MessageBoxButton.OK,
MessageBoxImage.Information, "", false, false, true, false, false, false);
}
}
catch (Exception e)
{
Dev2Logger.Error("Error popup", e, "Warewolf Error");
}
}
}
public WorkSurfaceContextViewModel(IEventAggregator eventPublisher, WorkSurfaceKey workSurfaceKey, IWorkSurfaceViewModel workSurfaceViewModel, IPopupController popupController, Action <IContextualResourceModel, bool> saveDialogAction)
: base(eventPublisher)
{
if (workSurfaceKey == null)
{
throw new ArgumentNullException("workSurfaceKey");
}
if (workSurfaceViewModel == null)
{
throw new ArgumentNullException("workSurfaceViewModel");
}
VerifyArgument.IsNotNull("popupController", popupController);
WorkSurfaceKey = workSurfaceKey;
WorkSurfaceViewModel = workSurfaceViewModel;
_windowManager = CustomContainer.Get <IWindowManager>();
_workspaceItemRepository = WorkspaceItemRepository.Instance;
var model = WorkSurfaceViewModel as IWorkflowDesignerViewModel;
if (model != null)
{
_environmentModel = model.EnvironmentModel;
if (_environmentModel != null)
{
// MUST use connection server event publisher - debug events are published from the server!
DebugOutputViewModel = new DebugOutputViewModel(_environmentModel.Connection.ServerEvents, EnvironmentRepository.Instance, new DebugOutputFilterStrategy());
_environmentModel.IsConnectedChanged += EnvironmentModelOnIsConnectedChanged();
_environmentModel.Connection.ReceivedResourceAffectedMessage += OnReceivedResourceAffectedMessage;
}
}
if (WorkSurfaceKey.WorkSurfaceContext == WorkSurfaceContext.Scheduler)
{
if (DebugOutputViewModel == null)
{
DebugOutputViewModel = new DebugOutputViewModel(new EventPublisher(), EnvironmentRepository.Instance, new DebugOutputFilterStrategy());
}
}
_popupController = popupController;
_saveDialogAction = saveDialogAction;
}
public SingleExplorerDeployViewModel(IDeployDestinationExplorerViewModel destination, IDeploySourceExplorerViewModel source, IEnumerable <IExplorerTreeItem> selectedItems, IDeployStatsViewerViewModel stats, IShellViewModel shell, IPopupController popupController)
{
VerifyArgument.AreNotNull(new Dictionary <string, object> {
{ "destination", destination }, { "source", source }, { "selectedItems", selectedItems }, { "stats", stats }, { "popupController", popupController }
});
_destination = destination;
// ReSharper disable once VirtualMemberCallInContructor
PopupController = popupController;
_source = source;
_errorMessage = "";
_source.Preselected = selectedItems;
_stats = stats;
_shell = shell;
_stats.CalculateAction = () =>
{
ServicesCount = _stats.Services.ToString();
SourcesCount = _stats.Sources.ToString();
NewResourcesCount = _stats.NewResources.ToString();
OverridesCount = _stats.Overrides.ToString();
ConflictItems = _stats.Conflicts;
NewItems = _stats.New;
ShowConflicts = false;
if (!string.IsNullOrEmpty(_stats.RenameErrors))
{
PopupController.ShowDeployNameConflict(_stats.RenameErrors);
}
ViewModelUtils.RaiseCanExecuteChanged(DeployCommand);
};
SourceConnectControlViewModel = _source.ConnectControlViewModel;
DestinationConnectControlViewModel = _destination.ConnectControlViewModel;
SourceConnectControlViewModel.SelectedEnvironmentChanged += UpdateServerCompareChanged;
DestinationConnectControlViewModel.SelectedEnvironmentChanged += UpdateServerCompareChanged;
DeployCommand = new DelegateCommand(Deploy, () => CanDeploy);
SelectDependenciesCommand = new DelegateCommand(SelectDependencies, () => CanSelectDependencies);
NewResourcesViewCommand = new DelegateCommand(ViewNewResources);
OverridesViewCommand = new DelegateCommand(ViewOverrides);
Destination.ServerStateChanged += DestinationServerStateChanged;
Destination.PropertyChanged += DestinationOnPropertyChanged;
ShowConflicts = false;
}
static TestSettingsViewModel CreateSettingsViewModel(IPopupController popupController, string executeCommandReadResult = "", string executeCommandWriteResult = "", SecurityViewModel securityViewModel = null)
{
var viewModel = new TestSettingsViewModel(new Mock<IEventAggregator>().Object, popupController, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, new Mock<IWin32Window>().Object) { TheSecurityViewModel = securityViewModel };
var mockResourceRepo = new Mock<IResourceRepository>();
ExecuteMessage writeMsg = null;
if(!string.IsNullOrEmpty(executeCommandWriteResult))
{
writeMsg = new ExecuteMessage { HasError = executeCommandWriteResult != "Success" };
writeMsg.SetMessage(executeCommandWriteResult);
}
mockResourceRepo.Setup(c => c.ReadSettings(It.IsAny<IEnvironmentModel>())).Returns(executeCommandReadResult == null ? null : new Dev2JsonSerializer().Deserialize<Data.Settings.Settings>(executeCommandReadResult));
mockResourceRepo.Setup(c => c.WriteSettings(It.IsAny<IEnvironmentModel>(), It.IsAny<Data.Settings.Settings>())).Returns(writeMsg);
var environment = new Mock<IEnvironmentModel>();
environment.Setup(e => e.IsConnected).Returns(true);
environment.Setup(c => c.ResourceRepository).Returns(mockResourceRepo.Object);
Mock<IAuthorizationService> authService = new Mock<IAuthorizationService>();
authService.Setup(c => c.IsAuthorized(It.IsAny<AuthorizationContext>(), It.IsAny<string>())).Returns(true);
environment.Setup(c => c.AuthorizationService).Returns(authService.Object);
// simulate auto-loading of ConnectControl ComboBox
viewModel.ServerChangedCommand.Execute(environment.Object);
return viewModel;
}
public ServerServiceConfiguration(IWindowsServiceManager serviceManager, IPopupController popupController)
: this(serviceManager)
{
PopupController = popupController;
}
// 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)
{
}
// 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 SchedulerViewModelForTest(IEventAggregator eventPublisher, DirectoryObjectPickerDialog directoryObjectPicker, IPopupController popupController, IAsyncWorker asyncWorker)
: base(eventPublisher, directoryObjectPicker, popupController, asyncWorker, new Mock<IConnectControlViewModel>().Object)
{
}
public TestSettingsViewModel(IEventAggregator eventPublisher, IPopupController popupController, IAsyncWorker asyncWorker, IWin32Window parentWindow)
: base(eventPublisher, popupController, asyncWorker, parentWindow, new Mock<IConnectControlViewModel>().Object)
{
}
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 static void ShowExampleWorkflow(string activityName, IEnvironmentModel environment, IPopupController popupController)
{
var resourceID = GetExampleID(activityName);
var resource = environment.ResourceRepository
.FindSingle(r => r.ID.Equals(resourceID));
if(resource == null)
{
if(popupController == null)
{
var message =
string.Format(
StringResources.ExampleWorkflowNotFound,
GetExampleName(activityName));
MessageBox.Show(message, "Information", MessageBoxButton.OK, MessageBoxImage.Information);
}
else
{
popupController.Buttons = MessageBoxButton.OK;
popupController.Description = string.Format(StringResources.ExampleWorkflowNotFound, resourceID);
popupController.Header = "Example Workflow Not Found";
popupController.ImageType = MessageBoxImage.Information;
popupController.Show();
}
}
else
{
resource.ResourceType = ResourceType.WorkflowService;
EditResource(resource, EventPublishers.Aggregator);
}
}
