private ObservableCollection <IPropertyBindingSettings> GetPropertySettings() { var properties = string.IsNullOrEmpty(this.Properties) ? new ObservableCollection <IPropertyBindingSettings>() : BindingSerializer.Deserialize <ObservableCollection <IPropertyBindingSettings> >(this.Properties); properties.CollectionChanged += (sender, args) => { if (args.OldItems != null) { args.OldItems.OfType <IPropertyBindingSettings>() .ToList() .ForEach(binding => binding.PropertyChanged -= OnSaveRules); } if (args.NewItems != null) { args.NewItems.OfType <IPropertyBindingSettings>() .ToList() .ForEach(binding => binding.PropertyChanged += OnSaveRules); } }; properties .ForEach(binding => binding.PropertyChanged += OnSaveRules); return(properties); }
public void WhenChangingSavedValidatorBindingSettings_ThenPersistsChanges() { var settings = new ValidationBindingSettings { TypeId = "Foo", Properties = { new PropertyBindingSettings { Name = "Message", Value = "Hello", }, new PropertyBindingSettings { Name = "From", ValueProvider = new ValueProviderBindingSettings { TypeId = "CurrentUserProvider", } }, }, }; ((PropertySchema)this.property).RawValidationRules = BindingSerializer.Serialize <ValidationBindingSettings[]>(new ValidationBindingSettings[] { settings }); ((BindingSettings)this.property.ValidationSettings.First()).Properties[0].Value = "World"; ((BindingSettings)this.property.ValidationSettings.First()).Properties[1].ValueProvider.TypeId = "AnotherProvider"; var saved = BindingSerializer.Deserialize <ValidationBindingSettings[]>(((PropertySchema)this.property).RawValidationRules); Assert.Equal(1, saved.Length); Assert.Equal("World", saved[0].Properties[0].Value); Assert.Equal("AnotherProvider", saved[0].Properties[1].ValueProvider.TypeId); }
private void SetArtifactLink(UnfoldScope scope) { var container = scope.Automation.Owner; // Determine created item IItemContainer createdItem = null; createdItem = this.Solution.Find <IProject>(p => p.PhysicalPath == this.projectCreated).SingleOrDefault(); if (createdItem == null) { createdItem = this.Solution.Find <IItem>(pi => pi.PhysicalPath == this.projectItemCreated).SingleOrDefault(); } if (createdItem != null) { if (this.UriService.CanCreateUri <IItemContainer>(createdItem)) { // Set the artifact link SolutionArtifactLinkReference .SetReference(container, this.UriService.CreateUri <IItemContainer>(createdItem)) .Tag = BindingSerializer.Serialize(scope.ReferenceTag); } else { tracer.Warn(Properties.Resources.InstantiationTemplateWizard_CantCreateUri, createdItem.GetLogicalPath()); } } }
public void WhenSettingValidatorBindingSettings_ThenPersistsChanges() { var settings = new ValidationBindingSettings { TypeId = "Foo", Properties = { new PropertyBindingSettings { Name = "Message", Value = "Hello", }, new PropertyBindingSettings { Name = "From", ValueProvider = new ValueProviderBindingSettings { TypeId = "CurrentUserProvider", } }, }, }; this.property.ValidationSettings = new IBindingSettings[] { settings }; var saved = BindingSerializer.Deserialize <ValidationBindingSettings[]>(((PropertySchema)this.property).RawValidationRules); Assert.Equal(1, saved.Length); Assert.Equal("Foo", saved[0].TypeId); Assert.Equal(2, saved[0].Properties.Count); Assert.Equal("Message", saved[0].Properties[0].Name); Assert.Equal("Hello", saved[0].Properties[0].Value); Assert.Equal("From", saved[0].Properties[1].Name); Assert.Equal("CurrentUserProvider", saved[0].Properties[1].ValueProvider.TypeId); }
/// <summary> /// Initializes the child element after it is created and added to the parent for the given item. /// </summary> protected override void InitializeCreatedElement(string itemId, IAbstractElement childElement) { Guard.NotNull(() => childElement, childElement); // Get the solution item for this imported file. var solutionItem = GetItemInSolution(itemId); if (solutionItem != null) { tracer.Info( Resources.CreateElementFromFileCommand_TraceAddingReference, this.CurrentElement.InstanceName, childElement.InstanceName, solutionItem.GetLogicalPath()); // Create artifact link var reference = SolutionArtifactLinkReference.AddReference(childElement, this.UriService.CreateUri(solutionItem)); reference.AddTag(this.Tag); reference.AddTag(BindingSerializer.Serialize(new ReferenceTag { SyncNames = this.SyncName })); } else { throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Resources.CreateElementFromFileCommand_ErrorNoSolutionItem, this.CurrentElement.InstanceName, childElement.InstanceName)); } }
private ConditionBindingSettings[] GetConditionSettings() { if (string.IsNullOrEmpty(this.Conditions)) { return(new ConditionBindingSettings[0]); } return(BindingSerializer.Deserialize <ConditionBindingSettings[]>(this.Conditions)); }
private List <ConditionBindingSettings> GetConditionSettings() { if (string.IsNullOrEmpty(this.Conditions)) { return(new List <ConditionBindingSettings>()); } return(BindingSerializer.Deserialize <List <ConditionBindingSettings> >(this.Conditions)); }
private ValidationBindingSettings[] GetValidationSettings() { if (string.IsNullOrEmpty(this.ValidationRules)) { return(new ValidationBindingSettings[0]); } return(BindingSerializer.Deserialize <ValidationBindingSettings[]>(this.ValidationRules)); }
/// <summary> /// Saves the <see cref="Collection{T}"/> instances as a serialized string. /// </summary> public override void SetValue(object component, object value) { var values = value as Collection <T>; if (values != null) { var serializedValue = values.Count == 0 ? null : BindingSerializer.Serialize(values); base.SetValue(component, serializedValue); } }
public void WhenChangingValueProviderSettings_ThenPersistsChangesAutomatically() { var settings = this.property.ValueProvider; settings.TypeId = "Foo"; var saved = BindingSerializer.Deserialize <IValueProviderBindingSettings>(this.property.RawValueProvider); Assert.Equal("Foo", saved.TypeId); }
public void WhenChangingDefaultValueSettings_ThenPersistsChangesAutomatically() { var settings = (PropertyBindingSettings)this.property.DefaultValue; settings.Value = "hello"; var saved = BindingSerializer.Deserialize <PropertyBindingSettings>(this.property.RawDefaultValue); Assert.Equal("hello", saved.Value); }
private ValueProviderBindingSettings CreateValueProviderSettings() { var settings = string.IsNullOrEmpty(this.rawValueGetter()) ? new ValueProviderBindingSettings() : BindingSerializer.Deserialize <ValueProviderBindingSettings>(this.rawValueGetter()); // Automatically serialize whenever something is changed in the binding. settings.PropertyChanged += OnSaveValue; return(settings); }
private IBindingSettings[] GetValidationSettings() { if (string.IsNullOrEmpty(this.RawValidationRules)) { return(new IBindingSettings[0]); } this.validationSettings = BindingSerializer.Deserialize <ValidationBindingSettings[]>(this.RawValidationRules); MonitorValidationRules(); return(this.validationSettings); }
/// <summary> /// Processes the document /// </summary> /// <param name="document">The document to process.</param> public void ProcessSchema(XDocument document) { Guard.NotNull(() => document, document); this.IsModified = false; // Locate all <commandSettings> var commandSettings = document.Descendants(CommandSettingsElementName) .Distinct(); if (commandSettings.Any()) { tracer.Info(Resources.CommandSettingsUpgradeProcessor_TraceDeserialize); // Enumerate each <commandSettings> element commandSettings.ForEach(cmdSettingsElement => { var id = cmdSettingsElement.Attribute(CommandSettingsIdName) != null ? cmdSettingsElement.Attribute(CommandSettingsIdName).Value : string.Empty; var cmdPropsElement = cmdSettingsElement.Descendants(CommandSettingsPropertiesElementName).FirstOrDefault(); if (cmdPropsElement != null) { // Determine if has any <propertySettings> var propSettingsElements = cmdPropsElement.Descendants(PropertySettingsElementName); if (propSettingsElements.Any()) { tracer.Info(Resources.CommandSettingsUpgradeProcessor_TraceDeserializeCommandSettings, id); var bindings = new List <IPropertyBindingSettings>(); var processedPropertySettings = new List <XElement>(); // Enumerate each <propertySettings> element propSettingsElements.ForEach(propSettingElement => { // Ensure we have not already processed this <propertySettings> element // (i.e. that it is not a nested <propertySettings> element) if (!processedPropertySettings.Contains(propSettingElement)) { // Add to processed cache processedPropertySettings.Add(propSettingElement); // Create bindings AddPropertySettings(cmdPropsElement, bindings, propSettingElement, processedPropertySettings); } }); // Update value of <properties> element cmdPropsElement.SetValue(BindingSerializer.Serialize <IEnumerable <IPropertyBindingSettings> >(bindings)); this.IsModified = true; } } }); } }
/// <summary> /// Gets the deserialized <see cref="Collection{T}"/> from the underlying serialized string. /// </summary> public override object GetValue(object component) { var value = base.GetValue(component) as string; var values = string.IsNullOrEmpty(value) ? new Collection <T>() : BindingSerializer.Deserialize <Collection <T> >(value); if (this.IsReadOnly) { return(new ReadOnlyCollection <T>(values)); } return(values); }
private void UpdateReferenceTagTo1113() { var references = this.CurrentElement.References.Where(r => r.Tag == this.ReferenceTag); foreach (var reference in references) { reference.Tag = BindingSerializer.Serialize(new ReferenceTag { SyncNames = true, TargetFileName = string.Empty }); } this.ReferenceTag = string.Empty; }
internal static ReferenceTag GetReference(string referenceTag) { try { return(BindingSerializer.Deserialize <ReferenceTag>(referenceTag)); } catch { return(new ReferenceTag { SyncNames = false, TargetFileName = string.Empty }); } }
/// <summary> /// Saves the new instances as a serialized string. /// </summary> public override void SetValue(object component, object value) { var values = value as ICollection <object>; if (values != null) { var serializedValue = values.Count == 0 ? null : BindingSerializer.Serialize(values); var property = GetPropertySettings(component); if (property != null) { property.Value = serializedValue; } } }
private static string GetSerializedLinkExistsCondition() { // Set the conditions var condition = new[] { new ConditionBindingSettings { TypeId = typeof(ArtifactReferenceExistsCondition).FullName, } }; return(BindingSerializer.Serialize(condition)); }
private static readonly string guidanceIconPath = ""; //"Resources/CommandShowGuidance.png"; /// <summary> /// Ensures the associated commands and launchpoint automation are created and configured correctly. /// </summary> internal void EnsureGuidanceExtensionAutomation() { IPatternElementSchema element = this.Extends as IPatternElementSchema; Func <bool> existanceCondition = () => !string.IsNullOrEmpty(this.ExtensionId); // Configure the instantiate command, event. var instantiateCommand = element.EnsureCommandAutomation <InstantiateGuidanceWorkflowCommand>(Properties.Resources.GuidanceExtension_InstantiateCommandName, existanceCondition); if (instantiateCommand != null) { instantiateCommand.SetPropertyValue <InstantiateGuidanceWorkflowCommand, string>(cmd => cmd.ExtensionId, this.ExtensionId); instantiateCommand.SetPropertyValue <InstantiateGuidanceWorkflowCommand, string>(cmd => cmd.DefaultInstanceName, this.GuidanceInstanceName); instantiateCommand.SetPropertyValue <InstantiateGuidanceWorkflowCommand, bool>(cmd => cmd.SharedInstance, this.GuidanceSharedInstance); instantiateCommand.SetPropertyValue <InstantiateGuidanceWorkflowCommand, bool>(cmd => cmd.ActivateOnInstantiation, this.GuidanceActivateOnCreation); } element.EnsureEventLaunchPoint <IOnElementInstantiatedEvent>(Properties.Resources.GuidanceExtension_InstantiateEventName, instantiateCommand, () => !String.IsNullOrEmpty(this.ExtensionId)); // Configure the activate command and menu. var activateCommand = element.EnsureCommandAutomation <ActivateGuidanceWorkflowCommand>(Properties.Resources.GuidanceExtension_ActivateCommandName, existanceCondition); var activateMenu = element.EnsureMenuLaunchPoint(Resources.GuidanceExtension_ActivateContextMenuName, activateCommand, Resources.GuidanceExtension_ActivateMenuItemText, guidanceIconPath, existanceCondition); if (activateMenu != null) { // Set the conditions activateMenu.Conditions = BindingSerializer.Serialize( new List <ConditionBindingSettings> { new ConditionBindingSettings { TypeId = typeof(ElementReferenceExistsCondition).FullName, Properties = { new PropertyBindingSettings { Name = Reflector <ElementReferenceExistsCondition> .GetPropertyName(cond => cond.Kind), Value = ReferenceKindConstants.GuidanceTopic }, } } }); } }
/// <summary> /// Attemps to deserialize a <see cref="ReferenceTag"/> from a /// serialized string. /// </summary> /// <param name="serialized">The serialized reference tag.</param> /// <returns>The deserialized instance, or <see langword="null"/> if it can't be deserialized.</returns> public static ReferenceTag TryDeserialize(string serialized) { if (string.IsNullOrEmpty(serialized)) { return(null); } try { return(BindingSerializer.Deserialize <ReferenceTag>(serialized)); } catch { return(null); } }
private IAutomationSettingsSchema AssertActivateContextMenu(bool verifySettings) { var menu = this.container.AutomationSettings.FirstOrDefault(set => set.Name.Equals(Properties.Resources.GuidanceExtension_ActivateContextMenuName)); Assert.NotNull(menu); var menuSettings = menu.GetExtensions <MenuSettings>().FirstOrDefault(); Assert.NotNull(menuSettings); if (verifySettings) { Assert.Equal(CustomizationState.False, menu.IsCustomizable); Assert.True(menu.IsSystem); var command = AssertActivateCommand(false); var commandSettings = command.GetExtensions <ICommandSettings>().FirstOrDefault(); Assert.Equal(menuSettings.Text, Properties.Resources.GuidanceExtension_ActivateMenuItemText); Assert.Equal(menuSettings.CommandId, commandSettings.Id); Assert.Equal(menuSettings.WizardId, Guid.Empty); var conditions = BindingSerializer.Serialize( new[] { new ConditionBindingSettings { TypeId = typeof(ElementReferenceExistsCondition).FullName, Properties = { new PropertyBindingSettings { Name = Reflector <ElementReferenceExistsCondition> .GetPropertyName(cond => cond.Kind), Value = ReferenceKindConstants.GuidanceTopic }, } } }); Assert.Equal(menuSettings.Conditions, conditions); } return(menu); }
private static Guid GetIdFromReferenceTag(IReference r) { try { return(BindingSerializer.Deserialize <ReferenceTag>(r.Tag).Id); } catch { Guid result; if (Guid.TryParse(r.Tag, out result)) { // Try to get the legacy settings guid return(result); } else { return(Guid.Empty); } } }
public void WhenSerialingAnObjectWithAStringProperty_ThenItDeserializesItProperly() { var foos = new List <Foo> { new Foo { Bar = 1, Baz = "Baz1" }, new Foo { Bar = 2, Baz = "Baz2" } }; var ser = BindingSerializer.Serialize(foos); var dserFoos = BindingSerializer.Deserialize <List <Foo> >(ser); Assert.Equal(dserFoos.Count, foos.Count); Assert.Equal(dserFoos.ElementAt(0).Bar, foos.ElementAt(0).Bar); Assert.Equal(dserFoos.ElementAt(0).Baz, foos.ElementAt(0).Baz); Assert.Equal(dserFoos.ElementAt(1).Bar, foos.ElementAt(1).Bar); Assert.Equal(dserFoos.ElementAt(1).Baz, foos.ElementAt(1).Baz); }
public void WhenItemAlreadyExistsAndTargetFileNameHasExtension_ThenVsItemRenamedWithVerifiedName() { var projectItem = Mock.Get <EnvDTE.ProjectItem>(this.solutionItem.Object.As <EnvDTE.ProjectItem>()); var parent = Mock.Get <IProject>(this.solutionItem.Object.Parent as IProject); Mock <IItem> anotherItem = new Mock <IItem>(); anotherItem.Setup(i => i.Name).Returns(this.OwnerElement.Object.InstanceName + ".cs"); parent.Setup(p => p.Items).Returns(new[] { solutionItem.Object, anotherItem.Object }); var reference = Mock.Get <IReference>(this.OwnerElement.Object.References.First()); reference.Setup(r => r.Tag).Returns(BindingSerializer.Serialize <ReferenceTag>(new ReferenceTag { TargetFileName = "TestElementName1.cs" })); Command.Execute(); projectItem.VerifySet(pi => pi.Name = "TestElementName1.cs", Times.Once()); }
public override void Initialize() { base.Initialize(); this.status = new Mock <ICommandStatus>(); this.bindingFactory = new Mock <IBindingFactory>(); this.statusBinding = new Mock <IDynamicBinding <ICommandStatus> > { DefaultValue = DefaultValue.Mock }; this.statusBinding.Setup(b => b.Value).Returns(this.status.Object); this.statusBinding.Setup(b => b.Evaluate(It.IsAny <IDynamicBindingContext>())).Returns(true); this.bindingFactory.Setup(f => f.CreateBinding <ICommandStatus>(It.IsAny <IBindingSettings>())).Returns(this.statusBinding.Object); this.Settings.Setup(x => x.CustomStatus).Returns(BindingSerializer.Serialize(new BindingSettings { TypeId = "Foo" })); this.Automation.BindingFactory = this.bindingFactory.Object; }
public void WhenSettingValue_ThenSerializesToJson() { var property = new Mock <PropertyDescriptor>("foo", new Attribute[0]); property.Setup(x => x.Name).Returns("Property"); property.Setup(x => x.Attributes).Returns(new AttributeCollection()); string serializedValue = null; property .Setup(x => x.SetValue(It.IsAny <object>(), It.IsAny <object>())) .Callback <object, object>((component, value) => serializedValue = (string)value); var descriptor = new StringCollectionPropertyDescriptor <Model>(property.Object); descriptor.SetValue(new object(), this.models); var conditions = BindingSerializer.Deserialize <Collection <Model> >(serializedValue); Assert.Equal(2, conditions.Count); }
/// <summary> /// Finishes initialization, resolving the conditions and custom status bindings. /// </summary> public override void EndInit() { base.EndInit(); if (this.BindingFactory != null) { try { this.Conditions = this.Settings.ConditionSettings.Select(x => this.BindingFactory.CreateBinding <ICondition>(x)).ToArray(); } catch (Exception e) { tracer.Error(e, Resources.MenuAutomation_FailedToParseConditions, this.Name); if (Microsoft.VisualStudio.ErrorHandler.IsCriticalException(e)) { throw; } } if (!string.IsNullOrEmpty(this.Settings.CustomStatus)) { try { var bindingSettings = BindingSerializer.Deserialize <BindingSettings>(this.Settings.CustomStatus); if (!string.IsNullOrEmpty(bindingSettings.TypeId)) { this.CommandStatus = this.BindingFactory.CreateBinding <ICommandStatus>(bindingSettings); } } catch (Exception e) { tracer.Error(e, Resources.MenuAutomation_FailedToParseCustomStatus, this.Name); if (Microsoft.VisualStudio.ErrorHandler.IsCriticalException(e)) { throw; } } } } }
public void WhenRoundTrippingFullBinding_ThenSucceeds() { IBindingSettings binding = new BindingSettings { TypeId = "foo", Properties = { new PropertyBindingSettings { Name = "Name", Value = "Value", ValueProvider = new ValueProviderBindingSettings { TypeId = "ValueProvider", Properties = { new PropertyBindingSettings { Name = "Id", Value = "1" } } } } } }; var serialized = BindingSerializer.Serialize(binding); var deserialized = BindingSerializer.Deserialize <IBindingSettings>(serialized); Assert.Equal(binding.TypeId, deserialized.TypeId); Assert.Equal(binding.Properties.Count, deserialized.Properties.Count); Assert.Equal(binding.Properties[0].Name, deserialized.Properties[0].Name); Assert.Equal(binding.Properties[0].Value, deserialized.Properties[0].Value); Assert.Equal(binding.Properties[0].ValueProvider.TypeId, deserialized.Properties[0].ValueProvider.TypeId); Assert.Equal(binding.Properties[0].ValueProvider.Properties[0].Name, deserialized.Properties[0].ValueProvider.Properties[0].Name); Assert.Equal(binding.Properties[0].ValueProvider.Properties[0].Value, deserialized.Properties[0].ValueProvider.Properties[0].Value); }
private IAutomationSettingsSchema AssertSelectContextMenu(bool verifySettings) { var menu = this.container.AutomationSettings.FirstOrDefault(set => set.Name.Equals(Properties.Resources.ArtifactExtension_SelectContextMenuName)); Assert.NotNull(menu); var menuSettings = menu.GetExtensions <MenuSettings>().FirstOrDefault(); Assert.NotNull(menuSettings); if (verifySettings) { Assert.Equal(CustomizationState.False, menu.IsCustomizable); Assert.True(menu.IsSystem); var command = AssertSelectCommand(false); var commandSettings = command.GetExtensions <ICommandSettings>().FirstOrDefault(); Assert.Equal(menuSettings.Text, Resources.ArtifactExtension_SelectMenuItemText); Assert.Equal(menuSettings.CommandId, commandSettings.Id); Assert.Equal(menuSettings.WizardId, Guid.Empty); var conditions = BindingSerializer.Serialize( new[] { new ConditionBindingSettings { TypeId = typeof(ArtifactReferenceExistsCondition).FullName, } }); Assert.Equal(menuSettings.Conditions, conditions); } return(menu); }