Example #1
0
        /// <summary>
        ///     Updates the worksapces for all environments
        /// </summary>
        public void UpdateWorkspaces(IConnectControlSingleton connectControlSingleton)
        {
            if (CircularProgressBarVisibility == Visibility.Visible)
            {
                return;
            }

            CircularProgressBarVisibility = Visibility.Visible;
            RefreshButtonVisibility       = Visibility.Hidden;

            var tmpSelected = SelectedItem;
            List <IExplorerItemModel> expandedList = new List <IExplorerItemModel>();
            List <Task> loadTasks    = new List <Task>();
            List <Guid> environments = new List <Guid>();

            foreach (var environment in Environments.Where(c => c.IsConnected || c.IsLocalHost))
            {
                var explorerItemModel = ExplorerItemModels.FirstOrDefault(c => c.EnvironmentId == environment.ID);
                if (explorerItemModel != null)
                {
                    expandedList = explorerItemModel.Descendants().Where(c => c.IsExplorerExpanded).ToList();
                }

                if (environment != null)
                {
                    environments.Add(environment.ID);
                    connectControlSingleton.SetConnectionState(environment.ID, ConnectionEnumerations.ConnectedState.Busy);
                    if (!environment.IsConnected)
                    {
                        var loadResourcesAsync = LoadResourcesAsync(environment, expandedList, tmpSelected);

                        if (loadResourcesAsync != null)
                        {
                            loadTasks.Add(loadResourcesAsync);
                        }
                    }
                    else
                    {
                        var taskref = TaskRefresh(connectControlSingleton, environment);
                        loadTasks.Add(taskref);
                    }
                }
            }

            var task = Task.WhenAll(loadTasks);

            task.ContinueWith(d =>
            {
                environments.ForEach(id => connectControlSingleton.SetConnectionState(id, ConnectionEnumerations.ConnectedState.Connected));
                CircularProgressBarVisibility = Visibility.Hidden;
                RefreshButtonVisibility       = Visibility.Visible;
            });
        }
Example #2
0
        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;
        }
        internal ConnectControlViewModel(IMainViewModel mainViewModel,
                                         IEnvironmentRepository environmentRepository,
                                         Action <IEnvironmentModel> callbackHandler,
                                         IConnectControlSingleton connectControlSingleton,
                                         string labelText,
                                         bool bindToActiveEnvironment, Action <IEnvironmentModel, ResourceType, string, string, string, string, string> openWizard = null)
        {
            VerifyArgument.IsNotNull("callbackHandler", callbackHandler);
            VerifyArgument.IsNotNull("connectControlSingleton", connectControlSingleton);
            VerifyArgument.IsNotNull("labelText", labelText);
            VerifyArgument.IsNotNull("environmentRepository", environmentRepository);

            if (Application.Current != null)
            {
                _dispatcher = Application.Current.Dispatcher;
            }

            IsEnabled                = true;
            IsDropDownEnabled        = true;
            LabelText                = labelText;
            _mainViewModel           = mainViewModel;
            _environmentRepository   = environmentRepository;
            _callbackHandler         = callbackHandler;
            _connectControlSingleton = connectControlSingleton;
            _bindToActiveEnvironment = bindToActiveEnvironment;
            _connectControlSingleton.ConnectedStatusChanged += ConnectedStatusChanged;
            _connectControlSingleton.ConnectedServerChanged += ConnectedServerChanged;

            if (openWizard == null)
            {
                _openWizard = (environmentModel, resourceType, resourcePath, category, resourceId, sourceId, resourceName) => RootWebSite.ShowDialog(environmentModel, resourceType, resourcePath, category, resourceId, sourceId, resourceName);
            }
            else
            {
                _openWizard = openWizard;
            }

            SetSelectedEnvironment();
        }
        internal ConnectControlViewModel(IMainViewModel mainViewModel,
                                        IEnvironmentRepository environmentRepository,
                                        Action<IEnvironmentModel> callbackHandler,
                                        IConnectControlSingleton connectControlSingleton,
                                        string labelText,
                                        bool bindToActiveEnvironment, Action<IEnvironmentModel, ResourceType, string, string, string, string, string> openWizard = null)
        {
            VerifyArgument.IsNotNull("callbackHandler", callbackHandler);
            VerifyArgument.IsNotNull("connectControlSingleton", connectControlSingleton);
            VerifyArgument.IsNotNull("labelText", labelText);
            VerifyArgument.IsNotNull("environmentRepository", environmentRepository);

            if(Application.Current != null)
            {
                _dispatcher = Application.Current.Dispatcher;
            }

            IsEnabled = true;
            IsDropDownEnabled = true;
            LabelText = labelText;
            _mainViewModel = mainViewModel;
            _environmentRepository = environmentRepository;
            _callbackHandler = callbackHandler;
            _connectControlSingleton = connectControlSingleton;
            _bindToActiveEnvironment = bindToActiveEnvironment;
            _connectControlSingleton.ConnectedStatusChanged += ConnectedStatusChanged;
            _connectControlSingleton.ConnectedServerChanged += ConnectedServerChanged;

            if(openWizard == null)
            {
                _openWizard = (environmentModel, resourceType, resourcePath, category, resourceId, sourceId, resourceName) => RootWebSite.ShowDialog(environmentModel, resourceType, resourcePath, category, resourceId, sourceId, resourceName);
            }
            else
            {
                _openWizard = openWizard;
            }

            SetSelectedEnvironment();
        }
Example #5
0
        Task TaskRefresh(IConnectControlSingleton connectControlSingleton, IEnvironmentModel environment)
        {
            var taskref = AsyncWorker.Start(() => {}, () => connectControlSingleton.Refresh(environment.ID));

            return(taskref);
        }
        public ExplorerViewModel(IEventAggregator eventPublisher, IAsyncWorker asyncWorker, IEnvironmentRepository environmentRepository, IStudioResourceRepository studioResourceRepository, IConnectControlSingleton connectControlSingleton, IMainViewModel mainViewModel, bool isFromActivityDrop = false, enDsfActivityType activityType = enDsfActivityType.All, System.Action updateWorkSpaceItems = null, IConnectControlViewModel connectControlViewModel = null)
            : base(eventPublisher)
        {
            VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
            VerifyArgument.IsNotNull("environmentRepository", environmentRepository);
            VerifyArgument.IsNotNull("connectControlSingleton", connectControlSingleton);

            EnvironmentRepository = environmentRepository;

            NavigationViewModel = new NavigationViewModel(eventPublisher, asyncWorker, Context, environmentRepository, studioResourceRepository, connectControlSingleton, updateWorkSpaceItems, isFromActivityDrop, activityType)
            {
                Parent = this
            };

            ConnectControlViewModel = connectControlViewModel ?? new ConnectControlViewModel(mainViewModel, AddEnvironment, "Connect:", true);
        }
Example #7
0
        /// <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;
        }
Example #8
0
 public DeployNavigationViewModel(IEventAggregator eventPublisher, IAsyncWorker asyncWorker, IEnvironmentRepository environmentRepository, IStudioResourceRepository studioResourceRepository, bool target, IConnectControlSingleton connectControlSingleton)
     : base(eventPublisher, asyncWorker, environmentRepository, studioResourceRepository)
 {
     _target = target;
     ConnectControlSingleton = connectControlSingleton;
 }
        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;
        }
        static ExplorerItemModel SetupExplorerItemModelWithFolderNoChild(string displayName, Guid envID, IConnectControlSingleton connectControlSingleton, out ExplorerItemModel resourceItem)
        {
            var serverItem = new ExplorerItemModel(connectControlSingleton, new Mock<IStudioResourceRepository>().Object)
            {
                ResourceType = ResourceType.Server,
                DisplayName = displayName,
                ResourceId = Guid.Empty,
                Permissions = Permissions.Administrator,
                EnvironmentId = envID
            };
            var folderItem = new ExplorerItemModel(connectControlSingleton, new Mock<IStudioResourceRepository>().Object)
            {
                ResourceType = ResourceType.Folder,
                DisplayName = Guid.NewGuid().ToString(),
                ResourceId = Guid.Empty,
                Permissions = Permissions.Administrator,
                EnvironmentId = envID,
                Parent = serverItem
            };

            resourceItem = folderItem;
            serverItem.Children.Add(folderItem);
            return serverItem;
        }
Example #11
0
 public ExplorerItemModel(IStudioResourceRepository studioResourceRepository, IAsyncWorker asyncWorker, IConnectControlSingleton connectControlSingleton)
     : this(connectControlSingleton, studioResourceRepository)
 {
     _studioResourceRepository = studioResourceRepository;
     _asyncWorker = asyncWorker;
     _connectControlSingleton = connectControlSingleton;
 }
Example #12
0
 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";
 }
Example #13
0
 public ExplorerItemModel Clone(IConnectControlSingleton connectControlSingleton, IStudioResourceRepository studioResourceRepository)
 {
     ExplorerItemModel result = new ExplorerItemModel(connectControlSingleton, studioResourceRepository);
     var fieldInfos = GetType().GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
     foreach(FieldInfo field in fieldInfos)
     {
         if(field.FieldType.GetInterface("IList", false) == null)
         {
             field.SetValue(result, field.GetValue(this));
         }
         else
         {
             IList listObject = (IList)field.GetValue(result);
             if(listObject != null)
             {
                 foreach(ExplorerItemModel item in ((IList)field.GetValue(this)))
                 {
                     listObject.Add(item.Clone(connectControlSingleton, studioResourceRepository));
                 }
             }
         }
     }
     return result;
 }
 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)
 {
 }
Example #15
0
 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)
 {
 }
        public ResourcePickerDialog(enDsfActivityType activityType, IEnvironmentViewModel environmentViewModel, IEventAggregator eventPublisher, IAsyncWorker asyncWorker, IConnectControlSingleton connectControlSingleton)
        {
            VerifyArgument.IsNotNull("environmentRepository", environmentViewModel);
            VerifyArgument.IsNotNull("eventPublisher", eventPublisher);
            VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
            VerifyArgument.IsNotNull("connectControlSingleton", connectControlSingleton);

            SingleEnvironmentExplorerViewModel = new SingleEnvironmentExplorerViewModel(environmentViewModel, Guid.Empty, true);
            SingleEnvironmentExplorerViewModel.SelectedItemChanged += (sender, item) => { SelectedResource = item; };
            _activityType = activityType;
        }
 public ResourcePickerDialog(enDsfActivityType activityType, IEnvironmentRepository environmentRepository, IEventAggregator eventPublisher, IAsyncWorker asyncWorker, bool isFromDrop, IStudioResourceRepository studioResourceRepository, IConnectControlSingleton connectControlSingleton)
 {
     VerifyArgument.IsNotNull("environmentRepository", environmentRepository);
     VerifyArgument.IsNotNull("eventPublisher", eventPublisher);
     VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
     VerifyArgument.IsNotNull("connectControlSingleton", connectControlSingleton);
     _studio = studioResourceRepository;
     _navigationViewModel = new NavigationViewModel(eventPublisher, asyncWorker, null, environmentRepository, studioResourceRepository,connectControlSingleton, () => {}, isFromDrop, activityType);
     _activityType = activityType;
 }
        static ExplorerItemModel SetupExplorerItemModelWithFolderAndFolderChildAndResources(string displayName, Guid envID, Guid resourceId, IConnectControlSingleton connectControlSingleton, out ExplorerItemModel resourceItem)
        {
            var serverItem = new ExplorerItemModel(connectControlSingleton, new Mock<IStudioResourceRepository>().Object)
            {
                ResourceType = ResourceType.Server,
                DisplayName = displayName,
                ResourceId = Guid.Empty,
                Permissions = Permissions.Administrator,
                EnvironmentId = envID
            };
            var folderItem = new ExplorerItemModel(connectControlSingleton, new Mock<IStudioResourceRepository>().Object)
            {
                ResourceType = ResourceType.Folder,
                DisplayName = Guid.NewGuid().ToString(),
                ResourceId = Guid.Empty,
                Permissions = Permissions.Administrator,
                EnvironmentId = envID
            };

            var folderItem2 = new ExplorerItemModel(connectControlSingleton, new Mock<IStudioResourceRepository>().Object)
            {
                ResourceType = ResourceType.Folder,
                DisplayName = Guid.NewGuid().ToString(),
                ResourceId = Guid.Empty,
                Permissions = Permissions.Administrator,
                EnvironmentId = envID
            };

            resourceItem = new ExplorerItemModel(connectControlSingleton, new Mock<IStudioResourceRepository>().Object)
            {
                ResourceType = ResourceType.WorkflowService,
                DisplayName = Guid.NewGuid().ToString(),
                ResourceId = resourceId,
                Permissions = Permissions.Administrator,
                EnvironmentId = envID,
                ResourcePath = "Path",
                IsExplorerSelected = true,
                Parent = folderItem
            };
            folderItem.Children.Add(resourceItem);
            folderItem2.Children.Add(folderItem);
            serverItem.Children.Add(folderItem2);
            return serverItem;
        }
 public DeployNavigationViewModel(IEventAggregator eventPublisher, IAsyncWorker asyncWorker, IEnvironmentRepository environmentRepository, IStudioResourceRepository studioResourceRepository, bool target, IConnectControlSingleton connectControlSingleton)
     : base(eventPublisher, asyncWorker, environmentRepository, studioResourceRepository)
 {
     _target = target;
     ConnectControlSingleton = connectControlSingleton;
 }
        static ExplorerItemModel SetupExplorerItemModelWithFolderAndOneChildMockedStudioRepository(string displayName, Guid envID, Guid resourceId, IConnectControlSingleton connectControlSingleton, out ExplorerItemModel resourceItem, IStudioResourceRepository repo)
        {
            var serverItem = new ExplorerItemModel(repo, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, connectControlSingleton)
            {
                ResourceType = ResourceType.Server,
                DisplayName = displayName,
                ResourceId = Guid.Empty,
                Permissions = Permissions.Administrator,
                EnvironmentId = envID
            };
            var folderItem = new ExplorerItemModel(repo, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, connectControlSingleton)
            {
                ResourceType = ResourceType.Folder,
                DisplayName = Guid.NewGuid().ToString(),
                ResourceId = Guid.Empty,
                Permissions = Permissions.Administrator,
                EnvironmentId = envID
            };

            resourceItem = new ExplorerItemModel(repo, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, connectControlSingleton)
            {
                ResourceType = ResourceType.WorkflowService,
                DisplayName = Guid.NewGuid().ToString(),
                ResourceId = resourceId,
                Permissions = Permissions.Administrator,
                EnvironmentId = envID,
                IsExplorerSelected = true,
                Parent = folderItem,
                ResourcePath = folderItem.DisplayName
            };
            folderItem.Children.Add(resourceItem);
            serverItem.Children.Add(folderItem);
            return serverItem;
        }
Example #21
0
        EnvironmentViewModel()
        {
            var connectControlSingleton = CustomContainer.Get <IConnectControlSingleton>();

            _connectControlSingleton = connectControlSingleton ?? ConnectControlSingleton.Instance;
        }
Example #22
0
 // ReSharper disable TooManyDependencies
 /// <summary>
 /// DI constructor
 /// </summary>
 /// <param name="asyncWorker"> async worker</param>
 /// <param name="serverProvider">server provider</param>
 /// <param name="environmentRepository"> environments </param>
 /// <param name="eventAggregator"> caliburn event handlers</param>
 /// <param name="studioResourceRepository"> studio repository </param>
 /// <param name="sourceConnectControlVm"> source server connect control</param>
 /// <param name="destinationConnectControlVm"> destination server connect control</param>
 /// <param name="deployStatsCalculator"> calculator for new overwritten totla resources</param>
 /// <param name="resourceID"> resource id</param>
 /// <param name="environmentID">environment id</param>
 /// <param name="connectControlSingleton">connect control</param>
 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)
 // ReSharper restore TooManyDependencies
     : 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();
 }