private void SetValueInternal(XElement sectionElement, string key, string value, IDictionary <string, string> attributes)
{
if (String.IsNullOrEmpty(key))
{
throw new ArgumentException(Resources.Argument_Cannot_Be_Null_Or_Empty, ConfigurationContants.KeyAttribute);
}
if (value == null)
{
throw new ArgumentNullException(ConfigurationContants.ValueAttribute);
}
var element = FindElementByKey(sectionElement, key, null);
if (element != null)
{
SetElementValues(element, key, value, attributes);
Save();
}
else
{
element = new XElement("add");
SetElementValues(element, key, value, attributes);
XElementUtility.AddIndented(sectionElement, element);
}
}
public bool DeleteSection(string section)
{
// machine wide settings cannot be changed.
if (IsMachineWideSettings)
{
if (_next == null)
{
throw new InvalidOperationException(Resources.Error_NoWritableConfig);
}
return(_next.DeleteSection(section));
}
if (String.IsNullOrEmpty(section))
{
throw new ArgumentException(Resources.Argument_Cannot_Be_Null_Or_Empty, nameof(section));
}
var sectionElement = GetSection(ConfigXDocument.Root, section);
if (sectionElement == null)
{
return(false);
}
XElementUtility.RemoveIndented(sectionElement);
Save();
return(true);
}
internal override void Update(SettingItem other)
{
var owners = other as OwnersItem;
if (!owners.Content.Any())
{
throw new InvalidOperationException(Resources.OwnersItemMustHaveAtLeastOneOwner);
}
base.Update(other);
if (!Equals(owners))
{
XElementUtility.RemoveIndented(_content.Node);
Content = owners.Content;
_content = new SettingText(string.Join(OwnersListSeparator.ToString(), Content));
if (Origin != null)
{
_content.SetOrigin(Origin);
if (Node != null)
{
_content.SetNode(_content.AsXNode());
(Node as XElement).Add(_content.Node);
Origin.IsDirty = true;
}
}
}
}
internal virtual bool Add(T setting)
{
if (setting == null)
{
throw new ArgumentNullException(nameof(setting));
}
if (Origin.IsMachineWide)
{
throw new InvalidOperationException(Resources.CannotUpdateMachineWide);
}
if (Origin.IsReadOnly)
{
throw new InvalidOperationException(Resources.CannotUpdateReadOnlyConfig);
}
if (!Children.Contains(setting) && !setting.IsEmpty())
{
Children.Add(setting);
setting.SetOrigin(Origin);
setting.SetNode(setting.AsXNode());
XElementUtility.AddIndented(Node as XElement, setting.Node);
Origin.IsDirty = true;
setting.Parent = this;
return(true);
}
return(false);
}
private void SetValueInternal(XElement sectionElement, string key, string value)
{
if (String.IsNullOrEmpty(key))
{
throw new ArgumentException(Resources.Argument_Cannot_Be_Null_Or_Empty, "key");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
var element = FindElementByKey(sectionElement, key, null);
if (element != null)
{
element.SetAttributeValue("value", value);
Save();
}
else
{
XElementUtility.AddIndented(sectionElement, new XElement("add",
new XAttribute("key", key),
new XAttribute("value", value)));
}
}
private static XElement GetOrCreateSection(XElement parentElement, string sectionName)
{
sectionName = XmlConvert.EncodeLocalName(sectionName);
var section = parentElement.Element(sectionName);
if (section == null)
{
section = new XElement(sectionName);
XElementUtility.AddIndented(parentElement, section);
}
return(section);
}
public void UpdateSections(string section, IReadOnlyList <SettingValue> values)
{
// machine wide settings cannot be changed.
if (IsMachineWideSettings)
{
if (_next == null)
{
throw new InvalidOperationException(Resources.Error_NoWritableConfig);
}
_next.UpdateSections(section, values);
return;
}
if (string.IsNullOrEmpty(section))
{
throw new ArgumentException(Resources.Argument_Cannot_Be_Null_Or_Empty, nameof(section));
}
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
var sectionElement = GetSection(ConfigXDocument.Root, section);
if (sectionElement != null)
{
XElementUtility.RemoveIndented(sectionElement);
}
var valuesToWrite = _next == null ? values : values.Where(v => v.Priority < _next._priority);
if (valuesToWrite.Any())
{
sectionElement = GetOrCreateSection(ConfigXDocument.Root, section);
}
foreach (var value in valuesToWrite)
{
var element = new XElement("add");
SetElementValues(element, value.Key, value.Value, value.AdditionalData);
XElementUtility.AddIndented(sectionElement, element);
}
Save();
if (_next != null)
{
_next.UpdateSections(section, values.Where(v => v.Priority >= _next._priority).ToList());
}
}
public void UpdateSections(string section, IReadOnlyList <SettingValue> values)
{
// machine wide settings cannot be changed.
if (IsMachineWideSettings ||
((section == ConfigurationConstants.PackageSources || section == ConfigurationConstants.DisabledPackageSources) && Cleared))
{
if (_next == null)
{
throw new InvalidOperationException(Resources.Error_NoWritableConfig);
}
_next.UpdateSections(section, values);
return;
}
if (string.IsNullOrEmpty(section))
{
throw new ArgumentException(Resources.Argument_Cannot_Be_Null_Or_Empty, nameof(section));
}
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
var valuesToWrite = _next == null ? values : values.Where(v => v.Priority < _next._priority);
var sectionElement = GetSection(ConfigXDocument.Root, section);
if (sectionElement == null && valuesToWrite.Any())
{
sectionElement = GetOrCreateSection(ConfigXDocument.Root, section);
}
// When updating attempt to preserve the clear tag (and any sources that appear prior to it)
// to avoid creating extra diffs in the source.
RemoveElementAfterClearTag(sectionElement);
foreach (var value in valuesToWrite)
{
var element = new XElement("add");
SetElementValues(element, value.Key, value.OriginalValue, value.AdditionalData);
XElementUtility.AddIndented(sectionElement, element);
}
Save();
if (_next != null)
{
_next.UpdateSections(section, values.Where(v => v.Priority >= _next._priority).ToList());
}
}
/// <summary>
/// Convenience method to remove an element from it's origin and convert to abstract
/// </summary>
/// <remarks>Each setting can override this method to remove any descendants from their origin</remarks>
internal virtual void RemoveFromSettings()
{
if (!IsCopy() && !IsAbstract())
{
XElementUtility.RemoveIndented(Node);
Origin.IsDirty = true;
Node = null;
}
Origin = null;
Parent = null;
}
internal static void AddIndented(XContainer container, XContainer content)
{
string oneIndentLevel = ComputeOneLevelOfIndentation(container);
XText leadingText = container.PreviousNode as XText;
string parentIndent = leadingText != null ? leadingText.Value : Environment.NewLine;
XElementUtility.IndentChildrenElements(content, parentIndent + oneIndentLevel, oneIndentLevel);
XElementUtility.AddLeadingIndentation(container, parentIndent, oneIndentLevel);
container.Add(content);
AddTrailingIndentation(container, parentIndent);
}
internal override void Update(SettingItem other)
{
var trustedSigner = other as TrustedSignerItem;
if (!trustedSigner.Certificates.Any())
{
throw new InvalidOperationException(Resources.TrustedSignerMustHaveCertificates);
}
base.Update(other);
var otherCerts = trustedSigner.Certificates.ToDictionary(c => c, c => c);
var immutableCerts = new List <CertificateItem>(Certificates);
foreach (var cert in immutableCerts)
{
if (otherCerts.TryGetValue(cert, out var otherChild))
{
otherCerts.Remove(cert);
}
if (otherChild == null)
{
Certificates.Remove(cert);
cert.RemoveFromSettings();
}
else if (cert is SettingItem item)
{
item.Update(otherChild as SettingItem);
}
}
foreach (var newCert in otherCerts)
{
var certToAdd = newCert.Value;
Certificates.Add(certToAdd);
if (Origin != null)
{
certToAdd.SetOrigin(Origin);
if (Node != null)
{
certToAdd.SetNode(certToAdd.AsXNode());
XElementUtility.AddIndented(Node as XElement, certToAdd.Node);
Origin.IsDirty = true;
}
}
}
}
internal override void Update(SettingItem other)
{
var packageSourceMappingSourceItem = other as PackageSourceMappingSourceItem;
if (!packageSourceMappingSourceItem.Patterns.Any())
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Resources.Error_ItemNeedsAtLeastOnePackagePattern, packageSourceMappingSourceItem.Key));
}
base.Update(other);
Dictionary <PackagePatternItem, PackagePatternItem> otherPatterns = packageSourceMappingSourceItem.Patterns.ToDictionary(c => c, c => c);
var immutablePatterns = new List <PackagePatternItem>(Patterns);
foreach (PackagePatternItem packagePatternItem in immutablePatterns)
{
if (otherPatterns.TryGetValue(packagePatternItem, out PackagePatternItem otherChild))
{
otherPatterns.Remove(packagePatternItem);
}
if (otherChild == null)
{
Patterns.Remove(packagePatternItem);
packagePatternItem.RemoveFromSettings();
}
else if (packagePatternItem is SettingItem item)
{
item.Update(otherChild);
}
}
foreach (var newPackagePatternItem in otherPatterns)
{
var itemToAdd = newPackagePatternItem.Value;
Patterns.Add(itemToAdd);
if (Origin != null)
{
itemToAdd.SetOrigin(Origin);
if (Node != null)
{
itemToAdd.SetNode(itemToAdd.AsXNode());
XElementUtility.AddIndented(Node as XElement, itemToAdd.Node);
Origin.IsDirty = true;
}
}
}
}
private string ElementToValue(XElement element, bool isPath)
{
if (element == null)
{
return(null);
}
// Return the optional value which if not there will be null;
string value = XElementUtility.GetOptionalAttributeValue(element, ConfigurationContants.ValueAttribute);
if (!isPath || String.IsNullOrEmpty(value))
{
return(value);
}
return(Path.Combine(Root, ResolvePath(Path.GetDirectoryName(ConfigFilePath), value)));
}
private static XElement FindElementByKey(XElement sectionElement, string key, XElement curr)
{
XElement result = curr;
foreach (var element in sectionElement.Elements())
{
string elementName = element.Name.LocalName;
if (elementName.Equals("clear", StringComparison.OrdinalIgnoreCase))
{
result = null;
}
else if (elementName.Equals("add", StringComparison.OrdinalIgnoreCase) &&
XElementUtility.GetOptionalAttributeValue(element, ConfigurationContants.KeyAttribute).Equals(key, StringComparison.OrdinalIgnoreCase))
{
result = element;
}
}
return(result);
}
public bool DeleteValue(string section, string key)
{
// machine wide settings cannot be changed.
if (IsMachineWideSettings)
{
if (_next == null)
{
throw new InvalidOperationException(NuGet_Configuration_Resources.Error_NoWritableConfig);
}
return(_next.DeleteValue(section, key));
}
if (String.IsNullOrEmpty(section))
{
throw new ArgumentException(NuGet_Configuration_Resources.Argument_Cannot_Be_Null_Or_Empty, "section");
}
if (String.IsNullOrEmpty(key))
{
throw new ArgumentException(NuGet_Configuration_Resources.Argument_Cannot_Be_Null_Or_Empty, "key");
}
var sectionElement = GetSection(ConfigXDocument.Root, section);
if (sectionElement == null)
{
return(false);
}
var elementToDelete = FindElementByKey(sectionElement, key, null);
if (elementToDelete == null)
{
return(false);
}
XElementUtility.RemoveIndented(elementToDelete);
Save();
return(true);
}
internal bool Add(SettingBase setting)
{
if (setting == null)
{
throw new ArgumentNullException(nameof(setting));
}
if (Origin != null && Origin.IsMachineWide)
{
throw new InvalidOperationException(Resources.CannotUpdateMachineWide);
}
if (!_mutableChildren.ContainsKey(setting) && !setting.IsEmpty())
{
_mutableChildren.Add(setting, setting);
if (Origin != null)
{
setting.SetOrigin(Origin);
if (Node != null)
{
setting.SetNode(setting.AsXNode());
XElementUtility.AddIndented(Node as XElement, setting.Node);
Origin.IsDirty = true;
}
}
setting.Parent = this;
return(true);
}
return(false);
}
