private void GetDependencies(TargetsFileData dependencyDefinitionFilePath)
{
Logger.LogMsg(String.Format("Get dependencies (Dependency definition file: {0}):", dependencyDefinitionFilePath.LocalPath));
Logger.ShowMessages();
DependencyService.BeginGetDependencyGraph(dependencyDefinitionFilePath.LocalPath, Logger, OnGetDependencyGraphCompleted, null);
}
private void InitializeContainer()
{
// create the MEF catalog and container
var catalog = new AggregateCatalog();
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
catalog.Catalogs.Add(assemblyCatalog);
_compositionContainer = new CompositionContainer(catalog);
// add externally provided values
_compositionContainer.ComposeExportedValue(DependencyService);
_compositionContainer.ComposeExportedValue(Logger);
var targetsFileData = new TargetsFileData();
targetsFileData.LocalPath = LocalPath;
_compositionContainer.ComposeExportedValue(targetsFileData);
var tpcData = new TeamProjectCollectionData();
tpcData.TPCUri = TeamProjectCollectionUrl;
_compositionContainer.ComposeExportedValue(tpcData);
// initialize the service
DependencyInjectionService.Instance.Initialize(_compositionContainer);
}
private void Save(TargetsFileData targetsFileData)
{
// this is where the actual saving is triggered,
// including a check to see if we can save at all
// first check if we can save
var allValid = AreAllDependenciesValid();
if (!allValid)
{
UserMessageService.ShowWarning("Please correct all errors before saving.");
return;
}
try
{
SaveDependencies(targetsFileData);
}
catch (Exception ex)
{
// TODO: this should throw well-known exceptions only
UserMessageService.ShowError("An error occurred while saving the dependencies file: " + ex.Message);
}
}
private void SaveDependencies(TargetsFileData dependencyDefinitionFilePath)
{
// save
XmlComponentRepository.SaveXmlComponent(_xmlComponent, dependencyDefinitionFilePath);
_xmlComponentViewModel.AcceptChanges();
Logger.LogMsg(String.Format("Saved dependency definition file {0}\n", dependencyDefinitionFilePath.LocalPath));
Logger.ShowMessages();
}
public void SaveXmlComponent(IXmlComponent component, TargetsFileData targetsFileData)
{
if (DependencyService == null)
{
return;
}
if (Logger == null)
{
return;
}
DependencyService.StoreXmlComponent(component, targetsFileData.LocalPath, Logger);
}
public IXmlComponent GetXmlComponent(TargetsFileData targetsFileData)
{
if (DependencyService == null)
{
return(null);
}
if (Logger == null)
{
return(null);
}
return(DependencyService.LoadXmlComponent(targetsFileData.LocalPath, Logger));
}
/// <summary>
/// Save original dependency definition file into another file (Use for "Save As ...").
/// </summary>
/// <param name="dependencyDefinitionFilePath"></param>
private void Save(string dependencyDefinitionFilePath)
{
// normal save?
if (string.IsNullOrEmpty(dependencyDefinitionFilePath))
{
Save();
return;
}
var targetsFileData = new TargetsFileData
{
LocalPath = dependencyDefinitionFilePath
};
Save(targetsFileData);
}
private List <object> _InitializeViewModelDependencies()
{
const DependencyType usedDependencyType = DependencyType.BinaryDependency;
var resolverTypeLookUp = "Resolver_" + usedDependencyType;
var result = new List <object>();
// the fake editor
var fakeDefinitionEditor = new TextBox();
result.Add(fakeDefinitionEditor as FrameworkElement);
// create xml dependency fakes
var dependencyProviderConfigFake = new Mock <IDependencyProviderConfig>();
dependencyProviderConfigFake.Setup(o => o.Type)
.Returns(usedDependencyType.ToString());
result.Add(dependencyProviderConfigFake);
var xmlDependencyFake = new Mock <IXmlDependency>();
xmlDependencyFake.Setup(o => o.Type)
.Returns(usedDependencyType);
xmlDependencyFake.Setup(o => o.ProviderConfiguration)
.Returns(dependencyProviderConfigFake.Object);
result.Add(xmlDependencyFake);
var xmlDependencyViewModel = new XmlDependencyViewModel(xmlDependencyFake.Object, true);
result.Add(xmlDependencyViewModel);
// create the fake resolver
var dependencyResolverTypeFake = new Mock <IDependencyResolverType>();
dependencyResolverTypeFake.Setup(o => o.ReferenceName)
.Returns(resolverTypeLookUp);
dependencyResolverTypeFake.Setup(o => o.GetDefinitionEditor(It.IsAny <IDependencyInjectionService>(), xmlDependencyViewModel, "component.targets", FakeTPCUrl))
.Returns(fakeDefinitionEditor);
result.Add(dependencyResolverTypeFake);
// create the IDependencyService fake
var dependencyServiceFake = new Mock <IDependencyService>();
dependencyServiceFake.Setup(o => o.GetDependencyResolvers())
.Returns(new List <IDependencyResolverType>(new[] { dependencyResolverTypeFake.Object }));
result.Add(dependencyServiceFake);
// create event fakes
var selectedXmlDependencyChangedEvent = new SelectedXmlDependencyChangedEvent(null, xmlDependencyViewModel);
result.Add(selectedXmlDependencyChangedEvent);
// create an event observable fake
Action <SelectedXmlDependencyChangedEvent> eventHandler = null;
var selectedXmlDependencyChangedEventObservableFake = new Mock <IObservable <SelectedXmlDependencyChangedEvent> >();
result.Add(selectedXmlDependencyChangedEventObservableFake);
// use moles to stub the static extension method
_hasCalledIObservableSubscribe = false;
System.Moles.MObservableExtensions.SubscribeIObservableOfTSourceActionOfTSource <SelectedXmlDependencyChangedEvent>((func, action) =>
{
_hasCalledIObservableSubscribe = true;
eventHandler = action;
return(null);
});
// create an IEventPublisher fake
var eventPublisherFake = new Mock <IEventPublisher>();
eventPublisherFake.Setup(o => o.GetEvent <SelectedXmlDependencyChangedEvent>())
.Returns(selectedXmlDependencyChangedEventObservableFake.Object);
eventPublisherFake.Setup(o => o.Publish(selectedXmlDependencyChangedEvent))
.Callback <SelectedXmlDependencyChangedEvent>(o => eventHandler(o));
result.Add(eventPublisherFake);
// create targets file data
var targetsFileData = new TargetsFileData();
targetsFileData.LocalPath = FakePath;
result.Add(targetsFileData);
// create team project collection data
var tpcUrlData = new TeamProjectCollectionData();
tpcUrlData.TPCUri = FakeTPCUrl;
result.Add(tpcUrlData);
// initialize injection service
_InitializeDependenyInjectionService <ProviderSettingsEditorViewModel>(vm =>
{
vm.DependencyService = dependencyServiceFake.Object;
vm.EventPublisher = eventPublisherFake.Object;
vm.TargetsFileData = targetsFileData;
vm.TeamProjectCollectionData = tpcUrlData;
});
return(result);
}
