private void ChangeExistingToolkitId(IInstalledToolkitInfo existingToolkitInfo)
{
var currentElement = this.DataContext as IProductElement;
if (currentElement != null)
{
// Update the element properties
var toolkit = currentElement.As <IPatternToolkit>();
var toolkitInfo = toolkit.Development.PatternToolkitInfo.AsElement();
toolkit.ExistingToolkitId = existingToolkitInfo != null?existingToolkitInfo.Id.ToString() : string.Empty;
var property = toolkitInfo.Properties.FirstOrDefault(p => p.DefinitionName == Reflector <IToolkitInfo> .GetPropertyName(x => x.Description));
if (property != null)
{
property.Value = existingToolkitInfo != null ? existingToolkitInfo.Description : property.Info.DefaultValue.Value;
}
property = currentElement.Properties.FirstOrDefault(p => p.DefinitionName == Reflector <IPatternToolkit> .GetPropertyName(x => x.PatternName));
if (property != null)
{
property.Value = existingToolkitInfo != null ? existingToolkitInfo.Schema.Pattern.Name : property.Info.DefaultValue.Value;
}
property = currentElement.Properties.FirstOrDefault(p => p.DefinitionName == Reflector <IPatternToolkit> .GetPropertyName(x => x.PatternDescription));
if (property != null)
{
property.Value = existingToolkitInfo != null ? existingToolkitInfo.Schema.Pattern.Description : property.Info.DefaultValue.Value;
}
}
}
/// <summary>
/// Retrieves the custom extensions that match the given content type within the extension.
/// </summary>
public static IEnumerable <string> GetCustomExtensions(this IInstalledToolkitInfo registration, string contentType)
{
Guard.NotNull(() => registration, registration);
Guard.NotNullOrEmpty(() => contentType, contentType);
return(registration.Extension.Content.Where(
content => content.ContentTypeName.Equals(contentType, StringComparison.OrdinalIgnoreCase))
.Select(content => content.RelativePath));
}
public void InitializeContext()
{
this.solution = VsIdeTestHostContext.ServiceProvider.GetService <ISolution>();
this.solution.CreateInstance(this.DeploymentDirectory, "Blank");
this.patternManager = VsIdeTestHostContext.ServiceProvider.GetService <IPatternManager>();
this.toolkit = patternManager.InstalledToolkits
.SingleOrDefault(t => t.Id == "NuPattern.Runtime.IntegrationTests.TestToolkit");
}
public void InitializeContext()
{
this.solution = VsIdeTestHostContext.ServiceProvider.GetService<ISolution>();
this.solution.CreateInstance(this.DeploymentDirectory, "Blank");
this.patternManager = VsIdeTestHostContext.ServiceProvider.GetService<IPatternManager>();
this.toolkit = patternManager.InstalledToolkits
.SingleOrDefault(t => t.Id == "NuPattern.Runtime.IntegrationTests.TestToolkit");
}
/// <summary>
/// Determines whether the specified toolkit contains the schema.
/// </summary>
/// <param name="toolkitInfo">The toolkit info.</param>
/// <param name="product">The product to verify the schema.</param>
/// <returns>
/// <c>true</c> if the specified toolkit info contains the schema; otherwise, <c>false</c>.
/// </returns>
public static bool ContainsSchema(this IInstalledToolkitInfo toolkitInfo, IProduct product)
{
Guard.NotNull(() => toolkitInfo, toolkitInfo);
Guard.NotNull(() => product, product);
return(product.ExtensionId.Equals(toolkitInfo.Id, StringComparison.OrdinalIgnoreCase) &&
toolkitInfo.Schema != null &&
toolkitInfo.Schema.Pattern != null &&
product.DefinitionId == toolkitInfo.Schema.Pattern.Id);
}
public void Initialize()
{
this.store = new DslTestStore<ProductStateStoreDomainModel>();
this.toolkit = Mocks.Of<IInstalledToolkitInfo>().First(
f => f.Id == "foo" && f.Schema.Pattern.Id == Guid.NewGuid());
var serviceProvider = Mock.Get(this.store.ServiceProvider);
serviceProvider.Setup(sp => sp.GetService(typeof(IPatternManager)))
.Returns(Mocks.Of<IPatternManager>().First(x => x.InstalledToolkits == new[] { this.toolkit }));
}
public void Initialize()
{
this.store = new DslTestStore <ProductStateStoreDomainModel>();
this.toolkit = Mocks.Of <IInstalledToolkitInfo>().First(
f => f.Id == "foo" && f.Schema.Pattern.Id == Guid.NewGuid());
var serviceProvider = Mock.Get(this.store.ServiceProvider);
serviceProvider.Setup(sp => sp.GetService(typeof(IPatternManager)))
.Returns(Mocks.Of <IPatternManager>().First(x => x.InstalledToolkits == new[] { this.toolkit }));
}
public void InitializeContext()
{
var solution = VsIdeTestHostContext.ServiceProvider.GetService <ISolution>();
solution.Open(PathTo(@"EmptySolution.sln"));
this.manager = VsIdeTestHostContext.ServiceProvider.GetService <IPatternManager>();
var componentModel = VsIdeTestHostContext.ServiceProvider.GetService <SComponentModel, IComponentModel>();
var installedToolkits = componentModel.GetService <IEnumerable <IInstalledToolkitInfo> >();
this.toolkit = installedToolkits
.SingleOrDefault(toolkit => toolkit.Id.Equals("1530D736-97EA-4B4A-8A25-C6C7A089D1BB", StringComparison.OrdinalIgnoreCase));
}
public void InitializeContext()
{
var solution = VsIdeTestHostContext.ServiceProvider.GetService<ISolution>();
solution.Open(PathTo(@"EmptySolution.sln"));
this.manager = VsIdeTestHostContext.ServiceProvider.GetService<IPatternManager>();
var componentModel = VsIdeTestHostContext.ServiceProvider.GetService<SComponentModel, IComponentModel>();
var installedToolkits = componentModel.GetService<IEnumerable<IInstalledToolkitInfo>>();
this.toolkit = installedToolkits
.SingleOrDefault(toolkit => toolkit.Id.Equals("1530D736-97EA-4B4A-8A25-C6C7A089D1BB", StringComparison.OrdinalIgnoreCase));
}
/// <summary>
/// Creates the pattern from the specified <see cref="IInstalledToolkitInfo"/>.
/// </summary>
/// <param name="toolkitInfo">The toolkit info.</param>
/// <param name="name">The pattern name.</param>
/// <param name="raiseInstantiateEvents">Whether instantiation events should be raised.</param>
public virtual IProduct CreateProduct(IInstalledToolkitInfo toolkitInfo, string name, bool raiseInstantiateEvents = true)
{
Guard.NotNull(() => toolkitInfo, toolkitInfo);
Guard.NotNullOrEmpty(() => name, name);
if (!this.IsOpen)
{
this.OpenDefaultState();
}
if (this.Find(name) != null)
{
throw new ArgumentException(Resources.DuplicateProductName);
}
IProduct product;
using (var tx = this.productStore.Store.TransactionManager.BeginTransaction())
using (tracer.StartActivity(Resources.PatternManager_TraceCreatingProduct, name, toolkitInfo.Extension.Header.Name))
using (new StorePropertyBag(this.productStore.Store, ProductState.IsCreatingElementKey, true))
{
product = this.productStore.CreateProduct(p =>
{
p.ExtensionId = toolkitInfo.Id;
p.DefinitionId = toolkitInfo.Schema.Pattern.Id;
p.InstanceName = name;
var prod = p as Product;
if (p != null)
{
prod.ExtensionName = toolkitInfo.Name;
prod.Author = toolkitInfo.Author;
prod.Version = toolkitInfo.Version.ToString();
}
});
// Flag the element in the state so that the ProductState class sees it and doesn't
// raise the instantiation event.
if (!raiseInstantiateEvents)
{
this.productStore.Store.PropertyBag.Add(product, null);
}
tx.Commit();
}
return(product);
}
public void InitializeContext()
{
this.dte = VsIdeTestHostContext.ServiceProvider.GetService <EnvDTE.DTE>();
this.manager = VsIdeTestHostContext.ServiceProvider.GetService <IPatternManager>();
var componentModel = VsIdeTestHostContext.ServiceProvider.GetService <SComponentModel, IComponentModel>();
var installedToolkits = componentModel.GetService <IEnumerable <IInstalledToolkitInfo> >();
this.toolkit = installedToolkits.SingleOrDefault(t => t.Id == TestToolkitId);
#if VSVER11 || VSVER12
//Copy TestToolkit template to VSExp template cache
this.testToolkitTemplatePath = string.Format(CultureInfo.InvariantCulture, TestToolkitTemplateCacheFormat, dte.Version);
Directory.CreateDirectory(Environment.ExpandEnvironmentVariables(this.testToolkitTemplatePath + @"\~PC\Projects\MyTemplate1.zip"));
Directory.CreateDirectory(Environment.ExpandEnvironmentVariables(this.testToolkitTemplatePath + @"\~PC\Projects\MyTemplate2.zip"));
File.Copy(Path.Combine(this.TestContext.DeploymentDirectory, @"MyTemplate1.gen.vstemplate"),
Environment.ExpandEnvironmentVariables(this.testToolkitTemplatePath + @"\~PC\Projects\MyTemplate1.zip\MyTemplate1.gen.vstemplate"), true);
File.Copy(Path.Combine(this.TestContext.DeploymentDirectory, @"MyTemplate2.gen.vstemplate"),
Environment.ExpandEnvironmentVariables(this.testToolkitTemplatePath + @"\~PC\Projects\MyTemplate2.zip\MyTemplate2.gen.vstemplate"), true);
#endif
}
public void InitializeContext()
{
this.dte = VsIdeTestHostContext.ServiceProvider.GetService<EnvDTE.DTE>();
this.manager = VsIdeTestHostContext.ServiceProvider.GetService<IPatternManager>();
var componentModel = VsIdeTestHostContext.ServiceProvider.GetService<SComponentModel, IComponentModel>();
var installedToolkits = componentModel.GetService<IEnumerable<IInstalledToolkitInfo>>();
this.toolkit = installedToolkits.SingleOrDefault(t => t.Id == TestToolkitId);
#if VSVER11 || VSVER12
//Copy TestToolkit template to VSExp template cache
this.testToolkitTemplatePath = string.Format(CultureInfo.InvariantCulture, TestToolkitTemplateCacheFormat, dte.Version);
Directory.CreateDirectory(Environment.ExpandEnvironmentVariables(this.testToolkitTemplatePath + @"\~PC\Projects\MyTemplate1.zip"));
Directory.CreateDirectory(Environment.ExpandEnvironmentVariables(this.testToolkitTemplatePath + @"\~PC\Projects\MyTemplate2.zip"));
File.Copy(Path.Combine(this.TestContext.DeploymentDirectory, @"MyTemplate1.gen.vstemplate"),
Environment.ExpandEnvironmentVariables(this.testToolkitTemplatePath + @"\~PC\Projects\MyTemplate1.zip\MyTemplate1.gen.vstemplate"), true);
File.Copy(Path.Combine(this.TestContext.DeploymentDirectory, @"MyTemplate2.gen.vstemplate"),
Environment.ExpandEnvironmentVariables(this.testToolkitTemplatePath + @"\~PC\Projects\MyTemplate2.zip\MyTemplate2.gen.vstemplate"), true);
#endif
}
private static ITemplateSettings FindTemplateSettingsOrThrow(IInstalledToolkitInfo toolkit, Uri uri)
{
var uriString = uri.ToString();
var settings = toolkit.Schema.Pattern.AutomationSettings
.Where(info => info.As <ITemplateSettings>() != null &&
info.As <ITemplateSettings>().TemplateUri == uriString)
.Select(info => info.As <ITemplateSettings>())
.FirstOrDefault();
if (settings != null)
{
return(settings);
}
// Traverse the rest in a generic way and find the first match;
settings = toolkit.Schema.Pattern
.Views
.SelectMany(view => view.Elements)
.Traverse(element => element.Elements)
.SelectMany(element => element.AutomationSettings)
.Where(setting => setting.As <ITemplateSettings>() != null &&
setting.As <ITemplateSettings>().TemplateUri == uriString)
.Select(info => info.As <ITemplateSettings>())
.FirstOrDefault();
if (settings == null)
{
throw new InvalidOperationException(string.Format(
CultureInfo.CurrentCulture,
Resources.InstantiationTemplateWizard_SettingsUnavailable,
toolkit.Name,
uriString));
}
return(settings);
}
/// <summary>
/// Executes this commmand.
/// </summary>
public override void Execute()
{
this.ValidateObject();
tracer.Info(
Resources.InstantiateSolutionElementCommand_TraceInitial,
this.ToolkitIdentifier, this.InstanceName);
IInstalledToolkitInfo toolkitInfo = this.PatternManager.InstalledToolkits
.FirstOrDefault(element => element.Id == this.ToolkitIdentifier);
if (toolkitInfo == null)
{
throw new InvalidOperationException(string.Format(
CultureInfo.CurrentCulture,
Resources.InstantiateSolutionElementCommand_ErrorSolutionElementNotInstalled,
this.ToolkitIdentifier));
}
this.PatternManager.CreateProduct(toolkitInfo, this.InstanceName);
tracer.Info(
Resources.InstantiateSolutionElementCommand_TraceInstantiated, this.ToolkitIdentifier, this.InstanceName);
}
/// <summary>
/// Creates a new instance
/// </summary>
public InstalledToolkitInfo(IInstalledToolkitInfo info)
{
Guard.NotNull(() => info, info);
this.info = info;
}
/// <summary>
/// Gets the extension points.
/// </summary>
public static IEnumerable <IExtensionPointInfo> GetExtensionPoints(this IInstalledToolkitInfo registration)
{
Guard.NotNull(() => registration, registration);
return(registration.Schema.FindAll <IExtensionPointInfo>());
}
/// <summary>
/// Gets the customizable extensions.
/// </summary>
/// <param name="registration">The toolkit registration.</param>
/// <returns>The list of customizable extensions.</returns>
public static IEnumerable <IExtensionContent> GetCustomizableExtensions(this IInstalledToolkitInfo registration)
{
Guard.NotNull(() => registration, registration);
return(registration.Extension.Content.Where(content => IsCustomizable(content)));
}
private static ITemplateSettings FindTemplateSettingsOrThrow(IInstalledToolkitInfo toolkit, Uri uri)
{
var uriString = uri.ToString();
var settings = toolkit.Schema.Pattern.AutomationSettings
.Where(info => info.As<ITemplateSettings>() != null &&
info.As<ITemplateSettings>().TemplateUri == uriString)
.Select(info => info.As<ITemplateSettings>())
.FirstOrDefault();
if (settings != null)
{
return settings;
}
// Traverse the rest in a generic way and find the first match;
settings = toolkit.Schema.Pattern
.Views
.SelectMany(view => view.Elements)
.Traverse(element => element.Elements)
.SelectMany(element => element.AutomationSettings)
.Where(setting => setting.As<ITemplateSettings>() != null &&
setting.As<ITemplateSettings>().TemplateUri == uriString)
.Select(info => info.As<ITemplateSettings>())
.FirstOrDefault();
if (settings == null)
{
throw new InvalidOperationException(string.Format(
CultureInfo.CurrentCulture,
Resources.InstantiationTemplateWizard_SettingsUnavailable,
toolkit.Name,
uriString));
}
return settings;
}
/// <summary>
/// Creates a new instance
/// </summary>
public InstalledToolkitInfo(IInstalledToolkitInfo info)
{
Guard.NotNull(() => info, info);
this.info = info;
}
private void ChangeExistingToolkitId(IInstalledToolkitInfo existingToolkitInfo)
{
var currentElement = this.DataContext as IProductElement;
if (currentElement != null)
{
// Update the element properties
var toolkit = currentElement.As<IPatternToolkit>();
var toolkitInfo = toolkit.Development.PatternToolkitInfo.AsElement();
toolkit.ExistingToolkitId = existingToolkitInfo != null ? existingToolkitInfo.Id.ToString() : string.Empty;
var property = toolkitInfo.Properties.FirstOrDefault(p => p.DefinitionName == Reflector<IToolkitInfo>.GetPropertyName(x => x.Description));
if (property != null)
{
property.Value = existingToolkitInfo != null ? existingToolkitInfo.Description : property.Info.DefaultValue.Value;
}
property = currentElement.Properties.FirstOrDefault(p => p.DefinitionName == Reflector<IPatternToolkit>.GetPropertyName(x => x.PatternName));
if (property != null)
{
property.Value = existingToolkitInfo != null ? existingToolkitInfo.Schema.Pattern.Name : property.Info.DefaultValue.Value;
}
property = currentElement.Properties.FirstOrDefault(p => p.DefinitionName == Reflector<IPatternToolkit>.GetPropertyName(x => x.PatternDescription));
if (property != null)
{
property.Value = existingToolkitInfo != null ? existingToolkitInfo.Schema.Pattern.Description : property.Info.DefaultValue.Value;
}
}
}
