void SetTreeStateBack(IEnumerable <IExplorerItemModel> expandedList, IExplorerItemModel selectedItem)
{
if (expandedList != null)
{
IStudioResourceRepository studioResourceRepository = StudioResourceRepository;
foreach (var item in expandedList)
{
var environment = studioResourceRepository.FindItemById(item.EnvironmentId);
if (environment != null)
{
IExplorerItemModel explorerItem = environment;
if (!string.IsNullOrEmpty(item.ResourcePath))
{
var strings = item.ResourcePath.Split('\\');
foreach (var s in strings)
{
if (explorerItem != null)
{
explorerItem = explorerItem.Children.FirstOrDefault(c => c.DisplayName == s);
}
}
}
if (explorerItem != null)
{
explorerItem.IsExplorerExpanded = true;
}
}
}
}
if (selectedItem != null)
{
BringItemIntoView(selectedItem.EnvironmentId, selectedItem.ResourceId);
}
}
void TreeViewDrop(object sender, DragEventArgs e)
{
TreeViewItem t = sender as TreeViewItem;
IStudioResourceRepository rep = StudioResourceRepository.Instance;
if (t != null)
{
ExplorerItemModel destination = t.Header as ExplorerItemModel;
if (destination != null)
{
var dataObject = e.Data;
if (dataObject != null && dataObject.GetDataPresent(GlobalConstants.ExplorerItemModelFormat))
{
var explorerItemModel = dataObject.GetData(GlobalConstants.ExplorerItemModelFormat);
try
{
ExplorerItemModel source = explorerItemModel as ExplorerItemModel;
if (ShouldNotMove(source, destination))
{
e.Handled = true;
}
else
{
MoveItem(source, destination, rep);
}
}
finally { e.Handled = true; }
}
}
}
}
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;
}
//, IWizardEngine wizardEngine
void Initialize(Guid id, IEnvironmentConnection environmentConnection, IResourceRepository resourceRepository, IStudioResourceRepository studioResourceRepository)
{
VerifyArgument.IsNotNull("environmentConnection", environmentConnection);
VerifyArgument.IsNotNull("studioResourceRepository", studioResourceRepository);
CanStudioExecute = true;
_studioRepo = studioResourceRepository;
ID = id; // The resource ID
Connection = environmentConnection;
// MUST subscribe to Guid.Empty as memo.InstanceID is NOT set by server!
ResourceRepository = resourceRepository ?? new ResourceRepository(this);
}
//, IWizardEngine wizardEngine
void Initialize(Guid id, IEnvironmentConnection environmentConnection, IResourceRepository resourceRepository, IStudioResourceRepository studioResourceRepository)
{
VerifyArgument.IsNotNull("environmentConnection", environmentConnection);
VerifyArgument.IsNotNull("studioResourceRepository", studioResourceRepository);
CanStudioExecute = true;
_studioRepo = studioResourceRepository;
ID = id; // The resource ID
Connection = environmentConnection;
// MUST subscribe to Guid.Empty as memo.InstanceID is NOT set by server!
ResourceRepository = resourceRepository ?? new ResourceRepository(this);
}
public void BringItemIntoView(Guid environmentId, Guid resourceId)
{
IStudioResourceRepository studioResourceRepository = StudioResourceRepository;
IExplorerItemModel item = studioResourceRepository.FindItemByIdAndEnvironment(resourceId, environmentId);
if (item != null)
{
item.IsExplorerSelected = true;
RecusiveExplorerExpandParent(item.Parent);
}
}
protected NavigationViewModelBase(IEventAggregator eventPublisher, IAsyncWorker asyncWorker, IEnvironmentRepository environmentRepository, IStudioResourceRepository studioResourceRepository)
{
VerifyArgument.IsNotNull("eventPublisher", eventPublisher);
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
VerifyArgument.IsNotNull("environmentRepository", environmentRepository);
AsyncWorker = asyncWorker;
EventAggregator = eventPublisher;
EventAggregator.Subscribe(this);
EnvironmentRepository = environmentRepository;
StudioResourceRepository = studioResourceRepository;
}
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();
}
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 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 DeployNavigationViewModel(IEventAggregator eventPublisher, IAsyncWorker asyncWorker, IEnvironmentRepository environmentRepository, IStudioResourceRepository studioResourceRepository, bool target, IConnectControlSingleton connectControlSingleton)
: base(eventPublisher, asyncWorker, environmentRepository, studioResourceRepository)
{
_target = target;
ConnectControlSingleton = connectControlSingleton;
}
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 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)
{
}
protected NavigationViewModelBase(IEventAggregator eventPublisher, IAsyncWorker asyncWorker, IEnvironmentRepository environmentRepository, IStudioResourceRepository studioResourceRepository, System.Action updateWorkSpaceItems)
: this(eventPublisher, asyncWorker, environmentRepository, studioResourceRepository)
{
VerifyArgument.IsNotNull("updateWorkSpaceItems", updateWorkSpaceItems);
UpdateWorkSpaceItems = updateWorkSpaceItems;
}
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 EnvironmentModel(Guid id, IEnvironmentConnection environmentConnection, IResourceRepository resourceRepository, IStudioResourceRepository studioResourceRepository)
{
VerifyArgument.IsNotNull("resourceRepository", resourceRepository);
Initialize(id, environmentConnection, resourceRepository, studioResourceRepository);
}
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 static void MoveItem(ExplorerItemModel source, ExplorerItemModel destination, IStudioResourceRepository rep)
{
if (source != null)
{
if(source.EnvironmentId != destination.EnvironmentId)
{
var popup = CustomContainer.Get<IPopupController>();
popup.Description = "You are not allowed to move items between Servers using the explorer. Please use the deploy instead";
popup.Buttons = MessageBoxButton.OK;
popup.Header = "Invalid Action";
popup.ImageType = MessageBoxImage.Error;
popup.Show();
}
else
switch (destination.ResourceType)
{
case ResourceType.Folder:
case ResourceType.Server:
rep.MoveItem(source, destination.ResourcePath);
break;
default:
rep.MoveItem(source, destination.Parent.ResourcePath);
break;
}
}
}
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)
{
}
//, IWizardEngine wizardEngine
public EnvironmentModel(Guid id, IEnvironmentConnection environmentConnection, IStudioResourceRepository studioResourceRepository)
{
Initialize(id, environmentConnection, null, studioResourceRepository);
}
//, IWizardEngine wizardEngine
public EnvironmentModel(Guid id, IEnvironmentConnection environmentConnection, IStudioResourceRepository studioResourceRepository)
{
Initialize(id, environmentConnection, null, studioResourceRepository);
}
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;
}
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;
}
public ExplorerItemModel(IStudioResourceRepository studioResourceRepository, IAsyncWorker asyncWorker, IConnectControlSingleton connectControlSingleton)
: this(connectControlSingleton, studioResourceRepository)
{
_studioResourceRepository = studioResourceRepository;
_asyncWorker = asyncWorker;
_connectControlSingleton = connectControlSingleton;
}
public static void MoveItem(ExplorerItemModel source, ExplorerItemModel destination, IStudioResourceRepository rep)
{
if (source != null)
{
if (source.EnvironmentId != destination.EnvironmentId)
{
var popup = CustomContainer.Get <IPopupController>();
popup.Description = "You are not allowed to move items between Servers using the explorer. Please use the deploy instead";
popup.Buttons = MessageBoxButton.OK;
popup.Header = "Invalid Action";
popup.ImageType = MessageBoxImage.Error;
popup.Show();
}
else
{
switch (destination.ResourceType)
{
case ResourceType.Folder:
case ResourceType.Server:
rep.MoveItem(source, destination.ResourcePath);
break;
default:
rep.MoveItem(source, destination.Parent.ResourcePath);
break;
}
}
}
}
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);
}
public EnvironmentModel(Guid id, IEnvironmentConnection environmentConnection, IResourceRepository resourceRepository, IStudioResourceRepository studioResourceRepository)
{
VerifyArgument.IsNotNull("resourceRepository", resourceRepository);
Initialize(id, environmentConnection, resourceRepository, studioResourceRepository);
}
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 DeployNavigationViewModel(IEventAggregator eventPublisher, IAsyncWorker asyncWorker, IEnvironmentRepository environmentRepository, IStudioResourceRepository studioResourceRepository, bool target, IConnectControlSingleton connectControlSingleton)
: base(eventPublisher, asyncWorker, environmentRepository, studioResourceRepository)
{
_target = target;
ConnectControlSingleton = connectControlSingleton;
}
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)
{
}
