public DropBoxSourceSourceCallbackHandler(IEnvironmentRepository environmentRepository, string token, string secret)
: base(environmentRepository)
{
VerifyArgument.AreNotNull(new Dictionary<string, object>{{"environmentRepository",environmentRepository},{"token",token},{"secret",secret}});
_token = token;
_secret = secret;
}
static IDebugTreeViewItemViewModel CreateItemViewModel <T>(IEnvironmentRepository envRepository, int n, bool isSelected, IDebugTreeViewItemViewModel parent)
where T : IDebugTreeViewItemViewModel
{
if (typeof(T) == typeof(DebugStateTreeViewItemViewModel))
{
var content = new DebugState {
DisplayName = "State " + n, ID = Guid.NewGuid(), ActivityType = ActivityType.Step
};
var viewModel = new DebugStateTreeViewItemViewModel(envRepository)
{
Parent = parent, Content = content
};
if (!isSelected)
{
// viewModel.IsSelected is true when the ActivityType is Step
viewModel.IsSelected = false;
}
return(viewModel);
}
return(new DebugStringTreeViewItemViewModel
{
Content = "String " + n,
IsSelected = isSelected
});
}
public DebugStateTreeViewItemViewModel(IEnvironmentRepository environmentRepository)
{
VerifyArgument.IsNotNull("environmentRepository", environmentRepository);
_environmentRepository = environmentRepository;
_inputs = new ObservableCollection <object>();
_outputs = new ObservableCollection <object>();
}
public static DsfActivity CreateDsfActivity(IContextualResourceModel resource, DsfActivity activity,
bool ifNullCreateNew, IEnvironmentRepository environmentRepository, bool isDesignerLocalhost)
{
var activityToUpdate = activity;
if (activityToUpdate == null)
{
if (ifNullCreateNew)
{
activityToUpdate = new DsfActivity();
}
else
{
return(null);
}
}
if (resource != null)
{
var activeEnvironment = environmentRepository.ActiveEnvironment;
activityToUpdate.ResourceID = resource.ID;
SetCorrectEnvironmentId(resource, activityToUpdate, isDesignerLocalhost, activeEnvironment);
activityToUpdate = SetActivityProperties(resource, activityToUpdate);
}
activityToUpdate.ExplicitDataList = null;
return(activityToUpdate);
}
public NewGamePresenterImpl(NewGameView view, IAirplanesRepository airplanesRepository, IEnvironmentRepository environmentRepository, IGamePlayRepository gamePlayRepository)
{
this.view = view;
this.airplanesRepository = airplanesRepository;
this.environmentRepository = environmentRepository;
this.gamePlayRepository = gamePlayRepository;
}
public SyncJobFacade(
ILogger <SyncJobFacade> logger,
ISyncLogRepository syncLogRepository,
IOctopusRepository octopusRepository,
ISpaceRepository spaceRepository,
IProjectRepository projectRepository,
IEnvironmentRepository environmentRepository,
ITenantRepository tenantRepository,
IReleaseRepository releaseRepository,
IDeploymentRepository deploymentRepository,
ISyncRepository syncRepository,
ISyncLogModelFactory syncLogModelFactory)
{
_logger = logger;
_syncLogRepository = syncLogRepository;
_octopusRepository = octopusRepository;
_spaceRepository = spaceRepository;
_projectRepository = projectRepository;
_environmentRepository = environmentRepository;
_tenantRepository = tenantRepository;
_releaseRepository = releaseRepository;
_deploymentRepository = deploymentRepository;
_syncRepository = syncRepository;
_syncLogModelFactory = syncLogModelFactory;
}
public static DsfActivity CreateDsfActivity(IContextualResourceModel resource, DsfActivity activity,
bool ifNullCreateNew, IEnvironmentRepository environmentRepository, bool isDesignerLocalhost)
{
var activityToUpdate = activity;
if(activityToUpdate == null)
{
if(ifNullCreateNew)
{
activityToUpdate = new DsfActivity();
}
else
{
return null;
}
}
if(resource != null)
{
var activeEnvironment = environmentRepository.ActiveEnvironment;
activityToUpdate.ResourceID = resource.ID;
SetCorrectEnvironmentId(resource, activityToUpdate, isDesignerLocalhost, activeEnvironment);
activityToUpdate = SetActivityProperties(resource, activityToUpdate);
}
activityToUpdate.ExplicitDataList = null;
return activityToUpdate;
}
DeployNavigationViewModel CreateViewModel(IEnvironmentRepository environmentRepository, Mock <IResourceRepository> mockResourceRepository)
{
StudioResourceRepository studioResourceRepository = BuildExplorerItems(mockResourceRepository.Object);
var navigationViewModel = new DeployNavigationViewModel(new Mock <IEventAggregator>().Object, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, environmentRepository, studioResourceRepository, _target, new Mock <IConnectControlSingleton>().Object);
return(navigationViewModel);
}
public EnvironmentRequestContext(
NancyContext nancyContextInstance,
IEnvironmentRepository environmentRepositoryInstance)
{
nancyContext = nancyContextInstance;
environmentRepository = environmentRepositoryInstance;
}
private IExplorerItemModel MapData(IExplorerItem item, IEnvironmentRepository environmentRepository, Guid environmentId)
{
if (item == null)
{
return(null);
}
string displayname = item.DisplayName;
// ReSharper disable ImplicitlyCapturedClosure
// ReSharper disable RedundantAssignment
IEnvironmentModel environmentModel = environmentRepository.FindSingle(model => GetEnvironmentModel(model, item, environmentId));
if ((item.ResourceType == ResourceType.Server && environmentId != Guid.Empty) || (environmentId == Guid.Empty && displayname.ToLower() == Environment.MachineName.ToLower()))
{
environmentModel = environmentRepository.FindSingle(model => GetEnvironmentModel(model, item, environmentId));
if (environmentModel != null && environmentModel.Connection != null)
{
displayname = environmentModel.DisplayName;
}
}
return(new ExplorerItemModel
{
Children = item.Children == null ? new ObservableCollection <IExplorerItemModel>() : new ObservableCollection <IExplorerItemModel>(item.Children.Select(i => MapData(i, environmentRepository, environmentId))),
DisplayName = displayname,
ResourceType = item.ResourceType,
ResourceId = item.ResourceId,
Permissions = item.Permissions,
ResourcePath = item.ResourcePath,
VersionInfo = item.VersionInfo
});
// ReSharper restore ImplicitlyCapturedClosure
}
private CosmosToggleDataContext GetCosmosToggleDataContext(IEnvironmentRepository environmentRepository)
{
var cosmosToggleDataContext = new CosmosToggleDataContext(_cosmosClientMock.Object);
cosmosToggleDataContext.EnvironmentRepository = _environmentRepositoryMock.Object;
return(cosmosToggleDataContext);
}
public SharepointServerSourceCallbackHandler(IEnvironmentRepository environmentRepository,string server,string userName,string password,AuthenticationType authenticationType)
: base(environmentRepository)
{
VerifyArgument.AreNotNull(new Dictionary<string, object>{{"environmentRepository",environmentRepository}});
_server = server;
_userName = userName;
_password = password;
_authenticationType = authenticationType;
}
public EnvironmentController(
IDeploymentRepository deploymentRepository,
IEnvironmentRepository environmentRepository,
IPipelineRepository pipelineRepository)
{
_deploymentRepository = deploymentRepository;
_environmentRepository = environmentRepository;
_pipelineRepository = pipelineRepository;
}
protected WebsiteCallbackHandler(IEventAggregator eventPublisher, IEnvironmentRepository currentEnvironmentRepository, IShowDependencyProvider showDependencyProvider = null)
{
VerifyArgument.IsNotNull("eventPublisher", eventPublisher);
VerifyArgument.IsNotNull("currentEnvironmentRepository", currentEnvironmentRepository);
EventPublisher = eventPublisher;
CurrentEnvironmentRepository = currentEnvironmentRepository;
ShowDependencyProvider = showDependencyProvider ?? new ShowDependencyProvider();
}
protected WebsiteCallbackHandler(IEventAggregator eventPublisher, IEnvironmentRepository currentEnvironmentRepository, IShowDependencyProvider showDependencyProvider = null)
{
VerifyArgument.IsNotNull("eventPublisher", eventPublisher);
VerifyArgument.IsNotNull("currentEnvironmentRepository", currentEnvironmentRepository);
EventPublisher = eventPublisher;
CurrentEnvironmentRepository = currentEnvironmentRepository;
ShowDependencyProvider = showDependencyProvider ?? new ShowDependencyProvider();
}
public DropBoxSourceSourceCallbackHandler(IEnvironmentRepository environmentRepository, string token, string secret)
: base(environmentRepository)
{
VerifyArgument.AreNotNull(new Dictionary <string, object> {
{ "environmentRepository", environmentRepository }, { "token", token }, { "secret", secret }
});
_token = token;
_secret = secret;
}
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;
}
public SharepointServerSourceCallbackHandler(IEnvironmentRepository environmentRepository, string server, string userName, string password, AuthenticationType authenticationType)
: base(environmentRepository)
{
VerifyArgument.AreNotNull(new Dictionary <string, object> {
{ "environmentRepository", environmentRepository }
});
_server = server;
_userName = userName;
_password = password;
_authenticationType = authenticationType;
}
public DeploymentService(
IEnvironmentRepository environmentRepository,
IPipelineRepository pipelineRepository,
IDeploymentRepository deploymentRepository,
IDeploymentUtility deploymentUtility)
{
this.deploymentRepository = deploymentRepository;
this.environmentRepository = environmentRepository;
this.pipelineRepository = pipelineRepository;
this.deploymentUtility = deploymentUtility;
}
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;
}
public async Task <CreateEnvironmentPayload?> CreateEnvironmentAsync(
CreateEnvironmentInput input,
[Service] IEnvironmentRepository repository,
CancellationToken cancellationToken)
{
var environment = new Environment(input.Name, input.Description);
await repository.AddEnvironmentAsync(environment, cancellationToken)
.ConfigureAwait(false);
return(new CreateEnvironmentPayload(environment, input.ClientMutationId));
}
public InitializeTogglOnCommandHandler(
IInitializeDbRepository initializeDbRepository,
INamespaceRepository namespaceRepository,
IEnvironmentRepository environmentRepository,
IFeatureGroupRepository featureGroupRepository,
IFeatureToggleRepository featureToggleRepository)
{
_initializeDbRepository = initializeDbRepository;
_namespaceRepository = namespaceRepository;
_environmentRepository = environmentRepository;
_featureGroupRepository = featureGroupRepository;
_featureToggleRepository = featureToggleRepository;
}
protected IEnvironmentRepository GetEnvironmentRepository()
{
var models = new List <IEnvironmentModel> {
EnvironmentModel.Object
};
var mock = new Mock <IEnvironmentRepository>();
mock.Setup(s => s.All()).Returns(models);
mock.Setup(c => c.ReadSession()).Returns(new[] { EnvironmentModel.Object.ID });
mock.Setup(s => s.Source).Returns(EnvironmentModel.Object);
EnvironmentRepo = mock.Object;
return(EnvironmentRepo);
}
public static IEnvironmentRepository GetEnvironmentRepository()
{
var models = new List <IEnvironmentModel> {
_environmentModel.Object
};
var mock = new Mock <IEnvironmentRepository>();
mock.Setup(s => s.All()).Returns(models);
mock.Setup(s => s.IsLoaded).Returns(true);
mock.Setup(repository => repository.Source).Returns(_environmentModel.Object);
_environmentRepo = mock.Object;
return(_environmentRepo);
}
public List <IEnvironmentModel> Load(IEnvironmentRepository environmentRepository)
{
// PBI 6597 : TWR
// BUG 9276 : TWR : 2013.04.19 - refactored so that we share environments
if (environmentRepository == null)
{
throw new ArgumentNullException("environmentRepository");
}
var environments = environmentRepository.All();
return(environments.ToList());
}
public List<IEnvironmentModel> Load(IEnvironmentRepository environmentRepository)
{
// PBI 6597 : TWR
// BUG 9276 : TWR : 2013.04.19 - refactored so that we share environments
if(environmentRepository == null)
{
throw new ArgumentNullException("environmentRepository");
}
var environments = environmentRepository.All();
return environments.ToList();
}
public static IEnvironmentRepository GetEnvironmentRepository()
{
var models = new List <IEnvironmentModel> {
_environmentModel.Object
};
var mock = new Mock <IEnvironmentRepository>();
mock.Setup(s => s.All()).Returns(models);
mock.Setup(s => s.IsLoaded).Returns(true);
mock.Setup(repository => repository.Source).Returns(_environmentModel.Object);
mock.Setup(repository => repository.FindSingle(It.IsAny <Expression <Func <IEnvironmentModel, bool> > >())).Returns(_environmentModel.Object);
_environmentRepo = mock.Object;
return(_environmentRepo);
}
public AdminService(
IApplicationRepository applicationRepositoryInstance,
IEnvironmentRepository environmentRepositoryInstance,
IMapper mapperInstance,
IMessageTemplateRepository messageTemplateRepositoryInstance,
IPermissionRepository permissionRepositoryInstance,
IRoleRepository roleRepositoryInstance)
{
applicationRepository = applicationRepositoryInstance;
environmentRepository = environmentRepositoryInstance;
mapper = mapperInstance;
messageTemplateRepository = messageTemplateRepositoryInstance;
permissionRepository = permissionRepositoryInstance;
roleRepository = roleRepositoryInstance;
}
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 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);
}
/// <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;
}
/// <summary>
/// Find first environment by name
/// </summary>
/// <param name="environments">The environment repository</param>
/// <param name="environment">The environment name</param>
/// <returns>Environment object or null</returns>
public static Environment GetEnvironment(this IEnvironmentRepository environments, string environment)
{
var result = environments
.GetAll()
.Select(x => new DeploymentPlanner.Environment()
{
Id = x.Id,
Name = x.Name
})
.FirstOrDefault(x => x.Name == environment);
if (result == null)
{
throw new Exception(string.Format("Can't find environment name of {0}", environment));
}
return(result);
}
public DebugOutputViewModel(IEventPublisher serverEventPublisher, IEnvironmentRepository environmentRepository, IDebugOutputFilterStrategy debugOutputFilterStrategy)
{
VerifyArgument.IsNotNull("serverEventPublisher", serverEventPublisher);
VerifyArgument.IsNotNull("environmentRepository", environmentRepository);
VerifyArgument.IsNotNull("debugOutputFilterStrategy", debugOutputFilterStrategy);
_environmentRepository = environmentRepository;
_debugOutputFilterStrategy = debugOutputFilterStrategy;
_contentItems = new List <IDebugState>();
_contentItemMap = new Dictionary <Guid, IDebugTreeViewItemViewModel>();
_debugWriterSubscriptionService = new SubscriptionService <DebugWriterWriteMessage>(serverEventPublisher);
_debugWriterSubscriptionService.Subscribe(msg =>
{
IDebugState debugState = msg.DebugState;
Append(debugState);
});
SessionID = Guid.NewGuid();
}
public async Task <SchemaPublishReport?> GetPublishReportByEnvironmentAsync(
string environmentName,
[Parent] SchemaVersion schemaVersion,
[Service] ISchemaRepository schemaRepository,
[Service] IEnvironmentRepository environmentRepository,
CancellationToken cancellationToken)
{
Environment?environment = await environmentRepository.GetEnvironmentAsync(
environmentName, cancellationToken)
.ConfigureAwait(false);
if (environment is null)
{
throw new GraphQLException(
$"The specified environment `{environmentName}` does not exist.");
}
return(await schemaRepository.GetPublishReportAsync(
schemaVersion.Id, environment.Id, cancellationToken)
.ConfigureAwait(false));
}
private void AddWorkout()
{
transaction = new TransactionScope();
dailyMetricsRepo = new SqlDailyMetricsRepository(connectionString);
locationRepo = new SqlLocationRepository(connectionString);
weatherRepo = new SqlWeatherRepository(connectionString);
environmentRepo = new SqlEnvironmentRepository(connectionString);
sessionRepo = new SqlSessionRepository(connectionString);
workoutRepo = new SqlWorkoutRepository(connectionString);
transaction.Dispose();
var dailyMetric = dailyMetricsRepo.CreateDailyMetrics(Date, Weight, SleepDuration, Calories);
var location = locationRepo.CreateLocation(Location);
var weather = weatherRepo.CreateWeather(WeatherType);
var enviroment = environmentRepo.CreateEnvironment(weather.WeatherID, location.LocationID, IsIndoor);
var session = sessionRepo.CreateSession(dailyMetric.MetricID, enviroment.EnvironmentID, StartTime, EndTime, Rating);
var workout = workoutRepo.CreateWorkout(session.SessionID, Duration, AvgHeartRate);
}
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();
}
DeployNavigationViewModel CreateViewModel(IEnvironmentRepository environmentRepository, Mock<IResourceRepository> mockResourceRepository)
{
StudioResourceRepository studioResourceRepository = BuildExplorerItems(mockResourceRepository.Object);
var navigationViewModel = new DeployNavigationViewModel(new Mock<IEventAggregator>().Object, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, environmentRepository, studioResourceRepository, _target, new Mock<IConnectControlSingleton>().Object);
return navigationViewModel;
}
public WebServiceCallbackHandlerMock(IEnvironmentRepository environmentRepository)
: base(environmentRepository)
{
}
public ServiceCallbackHandlerMock(IEventAggregator eventPublisher, IEnvironmentRepository environmentRepository, IShowDependencyProvider provider)
: base(eventPublisher, environmentRepository, provider)
{
}
public IEnvironmentRepository GetEnvironmentRepository()
{
var models = new List<IEnvironmentModel> { _environmentModel.Object };
var mock = new Mock<IEnvironmentRepository>();
mock.Setup(s => s.All()).Returns(models);
_environmentRepo = mock.Object;
return _environmentRepo;
}
//For Testing Only!!!!!!!
public EnvironmentRepository(IEnvironmentRepository environmentRepository)
{
_instance = environmentRepository;
}
public ServiceCallbackHandler(IEnvironmentRepository currentEnvironmentRepository)
: base(EventPublishers.Aggregator, currentEnvironmentRepository)
{
}
public DebugStateTreeViewItemViewModelMock(IEnvironmentRepository environmentRepository)
: base(environmentRepository)
{
}
public static IEnvironmentRepository GetEnvironmentRepository()
{
var models = new List<IEnvironmentModel> { _environmentModel.Object };
var mock = new Mock<IEnvironmentRepository>();
mock.Setup(s => s.All()).Returns(models);
mock.Setup(s => s.IsLoaded).Returns(true);
mock.Setup(repository => repository.Source).Returns(_environmentModel.Object);
_environmentRepo = mock.Object;
return _environmentRepo;
}
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;
}
//NavigationViewModel CreateViewModel(Mock<IResourceRepository> mockResourceRepository, bool isFromActivityDrop = false, enDsfActivityType activityType = enDsfActivityType.All, Mock<IConnectControlSingleton> connectControlASingleton = null)
//{
// var importServiceContext = new ImportServiceContext();
// ImportService.CurrentContext = importServiceContext;
// ImportService.Initialize(new List<ComposablePartCatalog>());
// return CreateViewModel(EnvironmentRepository.Instance, mockResourceRepository, isFromActivityDrop, activityType, connectControlASingleton);
//}
NavigationViewModel CreateViewModel(IEnvironmentRepository environmentRepository, Mock<IResourceRepository> mockResourceRepository, bool isFromActivityDrop = false, enDsfActivityType activityType = enDsfActivityType.All, Mock<IConnectControlSingleton> connectControlASingleton = null, bool mockClone = true)
{
var studioResourceRepository = BuildExplorerItems(mockResourceRepository.Object,mockClone);
connectControlASingleton = connectControlASingleton ?? new Mock<IConnectControlSingleton>();
var navigationViewModel = new NavigationViewModel(new Mock<IEventAggregator>().Object, new TestAsyncWorker(), null, environmentRepository, studioResourceRepository, connectControlASingleton.Object, () => { }, isFromActivityDrop, activityType);
return navigationViewModel;
}
public SaveNewWorkflowCallbackHandler(IEventAggregator eventPublisher, IEnvironmentRepository currentEnvironmentRepository, IContextualResourceModel resourceModel, bool addToTabManager)
: base(eventPublisher, currentEnvironmentRepository)
{
AddToTabManager = addToTabManager;
_resourceModel = resourceModel;
}
private IExplorerItemModel MapData(IExplorerItem item, IEnvironmentRepository environmentRepository, Guid environmentId)
{
if(item == null)
{
return null;
}
string displayname = item.DisplayName;
// ReSharper disable ImplicitlyCapturedClosure
// ReSharper disable RedundantAssignment
IEnvironmentModel environmentModel = environmentRepository.FindSingle(model => GetEnvironmentModel(model, item, environmentId));
if((item.ResourceType == ResourceType.Server && environmentId != Guid.Empty) || (environmentId == Guid.Empty && displayname.ToLower() == Environment.MachineName.ToLower()))
{
environmentModel = environmentRepository.FindSingle(model => GetEnvironmentModel(model, item, environmentId));
if(environmentModel != null && environmentModel.Connection != null)
{
displayname = environmentModel.DisplayName;
}
}
return new ExplorerItemModel
{
Children = item.Children == null ? new ObservableCollection<IExplorerItemModel>() : new ObservableCollection<IExplorerItemModel>(item.Children.Select(i => MapData(i, environmentRepository, environmentId))),
DisplayName = displayname,
ResourceType = item.ResourceType,
ResourceId = item.ResourceId,
Permissions = item.Permissions,
ResourcePath = item.ResourcePath,
VersionInfo = item.VersionInfo
};
// ReSharper restore ImplicitlyCapturedClosure
}
public WebSourceCallbackHandler(IEnvironmentRepository environmentRepository)
: base(environmentRepository)
{
}
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 DeployNavigationViewModel(IEventAggregator eventPublisher, IAsyncWorker asyncWorker, IEnvironmentRepository environmentRepository, IStudioResourceRepository studioResourceRepository, bool target, IConnectControlSingleton connectControlSingleton)
: base(eventPublisher, asyncWorker, environmentRepository, studioResourceRepository)
{
_target = target;
ConnectControlSingleton = connectControlSingleton;
}
public ConnectCallbackHandler(IEnvironmentRepository currentEnvironmentRepository)
: this(EventPublishers.Aggregator, currentEnvironmentRepository)
{
}
public ConnectCallbackHandler(IEventAggregator eventPublisher, IEnvironmentRepository currentEnvironmentRepository)
: base(eventPublisher, currentEnvironmentRepository)
{
}
// ReSharper restore UnusedParameter.Local
// ReSharper disable UnusedParameter.Local
public DebugVM(IEventPublisher serverEventPublisher, IEnvironmentRepository environmentRepository)
: base(new Mock<IEventPublisher>().Object, new Mock<IEnvironmentRepository>().Object, new Mock<IDebugOutputFilterStrategy>().Object)
{
}
protected IEnvironmentRepository GetEnvironmentRepository()
{
var models = new List<IEnvironmentModel> { EnvironmentModel.Object };
var mock = new Mock<IEnvironmentRepository>();
mock.Setup(s => s.All()).Returns(models);
mock.Setup(c => c.ReadSession()).Returns(new[] { EnvironmentModel.Object.ID });
mock.Setup(s => s.Source).Returns(EnvironmentModel.Object);
EnvironmentRepo = mock.Object;
return EnvironmentRepo;
}
public EditActivityMessage(ModelItem modelItem, Guid parentEnvironmentID, IEnvironmentRepository environmentRepository)
{
ModelItem = modelItem;
ParentEnvironmentID = parentEnvironmentID;
EnvironmentRepository = environmentRepository ?? Core.EnvironmentRepository.Instance;
}
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)
{
}
