public IUrlFormatter Assemble(IBuilderContext context, UrlFormatterData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache) { var data = (StringReplaceUrlFormatterData)objectConfiguration; string rulesFile = data.RulesFile; if (!rulesFile.IsNullOrEmpty()) { string fullPath = HostingEnvironment.MapPath(rulesFile); Verify.That(C1File.Exists(fullPath), "Cannot find file '{0}'", rulesFile); try { XDocument xDoc = XDocumentUtils.Load(fullPath); return(new StringReplaceUrlFormatter( xDoc.Root.Elements() .Select(e => new Pair <string, string>(GetAttributeNotNull(e, "oldValue"), GetAttributeNotNull(e, "newValue"))).ToList())); } catch (Exception e) { throw new ConfigurationErrorsException("Failed to process file '{0}'".FormatWith(rulesFile), e); } } var replacements = data.Replace.Cast <ReplacementRuleConfigurationElement>(); return(new StringReplaceUrlFormatter(replacements.Select(r => new Pair <string, string>(r.OldValue, r.NewValue)).ToList())); }
/// <exclude /> protected override void OnInitialize() { if ((this.OwnerNode is DataElementsTreeNode) == false) { AddValidationError("TreeValidationError.GenericEditDataAction.OwnerIsNotDataNode"); } if (string.IsNullOrEmpty(this.CustomFormMarkupPath) == false) { try { string path = PathUtil.Resolve(this.CustomFormMarkupPath); if (C1File.Exists(path) == false) { AddValidationError("TreeValidationError.GenericEditDataAction.MissingMarkupFile", path); } XDocument document = XDocumentUtils.Load(path); this.CustomFormMarkupPath = path; } catch { AddValidationError("TreeValidationError.GenericEditDataAction.BadMarkupPath", this.CustomFormMarkupPath); } } }
protected void Page_Load(object sender, EventArgs e) { var xsdFiles = C1Directory.GetFiles(this.MapPath(""), "*.xsd"); XElement xsdFilesTable = new XElement("table", new XElement("tr", new XElement("td", "Namespace"), new XElement("td", "Last generated"))); foreach (string xsdFile in xsdFiles) { DateTime lastWrite = C1File.GetLastWriteTime(xsdFile); XDocument schemaDocument = XDocumentUtils.Load(xsdFile); string targetNamespace = schemaDocument.Root.Attribute("targetNamespace").Value; xsdFilesTable.Add( new XElement("tr", new XElement("td", new XElement("a", new XAttribute("href", Path.GetFileName(xsdFile)), targetNamespace)), new XElement("td", lastWrite))); } XsdTable.Controls.Add(new LiteralControl(xsdFilesTable.ToString())); GenerateButton.Click += new EventHandler(GenerateButton_Click); }
private static void LoadC1ConsoleAccessConfig() { // defaults - keeping these if config file is missing or f****d up somehow _forceHttps = false; _allowFallbackToHttp = true; _customHttpsPortNumber = null; string c1ConsoleAccessConfigPath = HostingEnvironment.MapPath(c1ConsoleAccessRelativeConfigPath); if (C1File.Exists(c1ConsoleAccessConfigPath)) { try { XDocument accessDoc = XDocumentUtils.Load(c1ConsoleAccessConfigPath); _allowC1ConsoleRequests = _allowC1ConsoleRequests && (bool)accessDoc.Root.Attribute("enabled"); XElement protocolElement = accessDoc.Root.Element("ClientProtocol"); _forceHttps = (bool)protocolElement.Attribute("forceHttps"); _allowFallbackToHttp = (bool)protocolElement.Attribute("allowFallbackToHttp"); var customHttpsPortNumberAttrib = protocolElement.Attribute("customHttpsPortNumber"); if (customHttpsPortNumberAttrib != null && customHttpsPortNumberAttrib.Value.Length > 0) { _customHttpsPortNumber = (int)customHttpsPortNumberAttrib; } } catch (Exception ex) { Log.LogError("Authorization", "Problem parsing '{0}'. Will use defaults and allow normal access. Error was '{1}'", c1ConsoleAccessRelativeConfigPath, ex.Message); } } }
private static void LoadAllowedPaths() { _allAllowedPaths.Clear(); string webauthorizationConfigPath = HostingEnvironment.MapPath(webauthorizationRelativeConfigPath); if (!C1File.Exists(webauthorizationConfigPath)) { Log.LogInformation("AdministrativeAuthorizationHttpModule ", "File '{0}' not found - all access to the ~/Composite folder will be blocked", webauthorizationConfigPath); return; } XDocument webauthorizationConfigDocument = XDocumentUtils.Load(webauthorizationConfigPath); XAttribute loginPagePathAttribute = Verify.ResultNotNull(webauthorizationConfigDocument.Root.Attribute("loginPagePath"), "Missing '{0}' attribute on '{1}' root element", loginPagePathAttributeName, webauthorizationRelativeConfigPath); string relativeLoginPagePath = Verify.StringNotIsNullOrWhiteSpace(loginPagePathAttribute.Value, "Unexpected empty '{0}' attribute on '{1}' root element", loginPagePathAttributeName, webauthorizationRelativeConfigPath); _loginPagePath = UrlUtils.ResolveAdminUrl(relativeLoginPagePath); foreach (XElement allowElement in webauthorizationConfigDocument.Root.Elements(allowElementName)) { XAttribute relativePathAttribute = Verify.ResultNotNull(allowElement.Attribute(allow_pathAttributeName), "Missing '{0}' attribute on '{1}' element in '{2}'.", allow_pathAttributeName, allowElement, webauthorizationRelativeConfigPath); string relativePath = Verify.StringNotIsNullOrWhiteSpace(relativePathAttribute.Value, "Empty '{0}' attribute on '{1}' element in '{2}'.", allow_pathAttributeName, allowElement, webauthorizationRelativeConfigPath); string fullPath = UrlUtils.ResolveAdminUrl(relativePath).ToLowerInvariant(); _allAllowedPaths.Add(fullPath); } }
public override void Uninstall() { foreach (var kvp in _packageToRestore.Reverse()) { if (this.InstalledPackages.ContainsKey(kvp.Key)) { XDocument doc = XDocumentUtils.Load(this.InstalledPackages[kvp.Key]); XElement element = doc.Root; if (element == null) { continue; } XAttribute attribute = element.Attribute(PackageSystemSettings.VersionAttributeName); if (attribute == null) { continue; } attribute.Value = kvp.Value; doc.SaveToFile(this.InstalledPackages[kvp.Key]); } } }
internal TagManager() { var doc = XDocumentUtils.Load(PathUtil.Resolve(TagConfigurationsRelativePath)); _tagToTitleMap = (from element in doc.Root?.Elements() select new { Name = element.GetAttributeValue("name"), Value = element.GetAttributeValue("title") }) .ToDictionary(o => o.Name, o => o.Value); }
public static DateTime GetFirstTimeStart() { Verify.That(File.Exists(FirstTimeStartFilePath), "File '{0}' is missing", FirstTimeStartFilePath); var doc = XDocumentUtils.Load(FirstTimeStartFilePath); return((DateTime)doc.Element("Root").Attribute("time")); }
/// <summary> /// Used for processing xml/sql data providers configuration build by C1 vesrion older than 3.0 /// </summary> internal static Dictionary <string, Guid> GetTypeManagerTypeNameToTypeIdMap() { string metaDataFolderPath = PathUtil.Resolve(GlobalSettingsFacade.DataMetaDataDirectory); List <string> filepaths = C1Directory.GetFiles(metaDataFolderPath, "*.xml").ToList(); var result = new Dictionary <string, Guid>(); foreach (string filepath in filepaths) { try { XDocument doc = XDocumentUtils.Load(filepath); XAttribute dataTypeIdAttr = doc.Root.Attribute("dataTypeId"); XAttribute typeManagerTypeNameAttr = doc.Root.Attribute("typeManagerTypeName"); if (dataTypeIdAttr == null || typeManagerTypeNameAttr == null) { continue; } string typeManagerTypeName = typeManagerTypeNameAttr.Value; Guid dataTypeId = new Guid(dataTypeIdAttr.Value); const string redundantSuffix = ",Composite.Generated"; if (typeManagerTypeName.EndsWith(redundantSuffix, StringComparison.OrdinalIgnoreCase)) { typeManagerTypeName = typeManagerTypeName.Substring(0, typeManagerTypeName.Length - redundantSuffix.Length); } if (!result.ContainsKey(typeManagerTypeName)) { result.Add(typeManagerTypeName, dataTypeId); } if (!typeManagerTypeName.Contains(",") && !typeManagerTypeName.StartsWith("DynamicType:")) { string fixedTypeManagerTypeName = "DynamicType:" + typeManagerTypeName; if (!result.ContainsKey(fixedTypeManagerTypeName)) { result.Add(fixedTypeManagerTypeName, dataTypeId); } } } catch (Exception ex) { Log.LogWarning(LogTitle, "Error while parsing meta data file '{0}'".FormatWith(filepath)); Log.LogWarning(LogTitle, ex); } } // Backward compatibility for configuraiton files. (Breaking change C1 3.2 -> C1 4.0) result["Composite.Data.Types.IPageTemplate,Composite"] = new Guid("7b54d7d2-6be6-48a6-9ae1-2e0373073d1d"); return(result); }
private static bool ValidateMarkup(Tree tree, XDocument document) { try { if (document.Root == null) { tree.AddValidationError("", "TreeValidationError.Markup.NoRootElement"); return(false); } bool schemaValidationResult = true; Action <object, ValidationEventArgs> onValidationError = (obj, args) => { tree.AddValidationError("", "TreeValidationError.Markup.SchemaError", args.Message, args.Exception.LineNumber, args.Exception.LinePosition); schemaValidationResult = false; }; XDocument schemaDocument = XDocumentUtils.Load(Path.Combine(PathUtil.Resolve("~/Composite/schemas/Trees"), "Tree.xsd")); IEnumerable <XElement> elements = schemaDocument.Descendants((XNamespace)"http://www.w3.org/2001/XMLSchema" + "import").ToList(); foreach (XElement element in elements) { element.Remove(); } XmlReaderSettings xmlReaderSettings = new XmlReaderSettings(); xmlReaderSettings.ValidationType = ValidationType.Schema; using (XmlReader schemaReader = schemaDocument.CreateReader()) { xmlReaderSettings.Schemas.Add(null, schemaReader); } xmlReaderSettings.Schemas.AddFromPath(null, Path.Combine(PathUtil.Resolve("~/Composite/schemas/Functions"), "Function.xsd")); //xmlReaderSettings.Schemas.AddFromPath(null, Path.Combine(PathUtil.Resolve("~/Composite/schemas/Trees"), "Tree.xsd")); xmlReaderSettings.ValidationEventHandler += new ValidationEventHandler(onValidationError); xmlReaderSettings.ValidationFlags = XmlSchemaValidationFlags.ProcessSchemaLocation | XmlSchemaValidationFlags.ReportValidationWarnings; XmlReader xmlReader = XmlReader.Create(new StringReader(document.ToString()), xmlReaderSettings); while (xmlReader.Read()) { ; } if (schemaValidationResult == false) { return(false); } } catch (Exception ex) { tree.AddValidationError("", "TreeValidationError.Common.UnknownException", ex.Message); return(false); } return(true); }
private static XDocument TryLoad(string uri) { try { return(XDocumentUtils.Load(uri)); } catch { /* silent */ return(null); } }
public static UrlMappings GetMappingsFromXml() { var result = new UrlMappings { RawLinks = new Dictionary <string, string>(), RelativeLinks = new Dictionary <string, string>(), RelativeLinksPerHostname = new Dictionary <string, Dictionary <string, string> >() }; if (C1File.Exists(XmlFileName)) { var doc = XDocumentUtils.Load(XmlFileName).Descendants("Mapping"); foreach (var m in doc) { var oldPath = m.Attribute("OldPath").Value; var newPath = m.Attribute("NewPath").Value; if (!result.RawLinks.ContainsKey(oldPath)) { result.RawLinks.Add(oldPath, newPath); } if (oldPath.StartsWith("http://") || oldPath.StartsWith("https://") || oldPath.StartsWith("//")) { int hostnameOffset = oldPath.IndexOf("//") + 2; int hostnameEndOffset = oldPath.IndexOf('/', hostnameOffset); if (hostnameEndOffset > 0) { string hostname = oldPath.Substring(hostnameOffset, hostnameEndOffset - hostnameOffset); string relativeUrl = oldPath.Substring(hostnameEndOffset); Dictionary <string, string> linksPerHostname; if (!result.RelativeLinksPerHostname.TryGetValue(hostname, out linksPerHostname)) { result.RelativeLinksPerHostname.Add(hostname, linksPerHostname = new Dictionary <string, string>()); } if (!linksPerHostname.ContainsKey(relativeUrl)) { linksPerHostname.Add(relativeUrl, newPath); } } } else { result.RelativeLinks.Add(oldPath, newPath); } } } return(result); }
public ElementInformationExtractor(string configurationFilePath) { this.configurationFilePath = configurationFilePath; configDoc = XDocumentUtils.Load(configurationFilePath); //Quick code for nameSpaces UiContolNs = (from c in GetUiControlDescriptors() group c by c.NamespaceName into g select g.Key).ToList(); FunctionNs = (from c in GetFunctionDescriptors() group c by c.NamespaceName into g select g.Key).ToList(); }
/// <summary> /// Returns custom form markup. /// </summary> /// <param name="dataTypeDescriptor">A data type descriptor</param> /// <returns></returns> public static XDocument GetCustomFormMarkup(DataTypeDescriptor dataTypeDescriptor) { var file = GetCustomFormMarkupFile(dataTypeDescriptor.Namespace, dataTypeDescriptor.Name); if (file == null) { return(null); } var markupFilePath = (file as FileSystemFile).SystemPath; return(XDocumentUtils.Load(markupFilePath, LoadOptions.SetBaseUri | LoadOptions.SetLineInfo)); }
private static DataTypeDescriptor LoadFromFile(string filePath) { XDocument doc; try { doc = XDocumentUtils.Load(filePath, LoadOptions.SetBaseUri | LoadOptions.SetLineInfo); } catch (XmlException e) { throw new ConfigurationErrorsException("Error loading meta data file '{0}': {1}".FormatWith(filePath, e.Message), e, filePath, e.LineNumber); } return(DataTypeDescriptor.FromXml(doc.Root)); }
static InstallationInformationFacade() { string filepath = Path.Combine(PathUtil.Resolve(GlobalSettingsFacade.ConfigurationDirectory), "InstallationInformation.xml"); if (C1File.Exists(filepath)) { XDocument doc = XDocumentUtils.Load(filepath); XAttribute idAttribute = doc.Root.Attribute("installationId"); _installationId = (Guid)idAttribute; } else { InitializeNewFile(filepath); } }
/// <summary> /// Loads a Page Template Feature based on name. /// </summary> /// <param name="featureName">Name of the Page Template Feature to load.</param> /// <returns></returns> private static XhtmlDocument LoadPageTemplateFeature(string featureName) { string featurePath = Path.Combine(PathUtil.Resolve(GlobalSettingsFacade.PageTemplateFeaturesDirectory), featureName + ".xml"); if (!C1File.Exists(featurePath)) { featurePath = Path.Combine(PathUtil.Resolve(GlobalSettingsFacade.PageTemplateFeaturesDirectory), featureName + ".html"); } if (!C1File.Exists(featurePath)) { throw new InvalidOperationException("Unknown feature '" + featureName + "'"); } var doc = XDocumentUtils.Load(featurePath); return(new XhtmlDocument(doc)); }
internal static void CreateStore(string providerName, DataScopeConfigurationElement scopeElement) { string filename = ResolvePath(scopeElement.Filename, providerName); string directoryPath = Path.GetDirectoryName(filename); if (!C1Directory.Exists(directoryPath)) { C1Directory.CreateDirectory(directoryPath); } bool keepExistingFile = false; string rootLocalName = XmlDataProviderDocumentWriter.GetRootElementName(scopeElement.ElementName); string obsoleteRootElementName = scopeElement.ElementName + "s"; if (C1File.Exists(filename)) { try { XDocument existingDocument = XDocumentUtils.Load(filename); if (existingDocument.Root.Name.LocalName == rootLocalName || existingDocument.Root.Name.LocalName == obsoleteRootElementName) { keepExistingFile = true; } } catch (Exception) { keepExistingFile = false; } if (!keepExistingFile) { C1File.Delete(filename); } } if (!keepExistingFile) { var document = new XDocument(); document.Add(new XElement(rootLocalName)); XDocumentUtils.Save(document, filename); } }
private static Dictionary <string, string> AntonymContainerClassLoader() { XDocument document = null; try { document = XDocumentUtils.Load(PathUtil.Resolve(AntonymClassConfigurationsRelativePath)); } catch (XmlException exception) { Log.LogWarning(nameof(AntonymContainerClassManager), $"error in parsing config file: {exception}"); return(new Dictionary <string, string>()); } return((from element in document.Root?.Elements() select new { Name = element.GetAttributeValue("name"), Value = element.GetAttributeValue("antonym") }) .ToDictionary(o => o.Name, o => o.Value)); }
private Tree LoadTreeFromFile(string treeId) { string filename = Path.Combine(TreeDefinitionsFolder, treeId); for (int i = 0; i < 10; i++) { try { XDocument document = XDocumentUtils.Load(filename); return(LoadTreeFromDom(treeId, document)); } catch (IOException) { Thread.Sleep(100); } } throw new InvalidOperationException("Could not load tree " + treeId); }
/// <exclude /> public override IEnumerable <XElement> Install() { Verify.IsNotNull(_xmlFileMerges, "XmlFileMergePackageFragmentInstaller has not been validated"); foreach (XmlFileMerge xmlFileMerge in _xmlFileMerges) { string targetXmlFile = PathUtil.Resolve(xmlFileMerge.TargetPath); using (Stream stream = this.InstallerContext.ZipFileSystem.GetFileStream(xmlFileMerge.ChangeFilePath)) { XElement source = XElement.Load(stream); XDocument target = XDocumentUtils.Load(targetXmlFile); target.Root.ImportSubtree(source); target.SaveToFile(targetXmlFile); } } return(new[] { this.Configuration.FirstOrDefault() }); }
private static IEnumerable <string> GetStrings(string type, string mode, string folderPath) { string filename = Path.Combine(folderPath, _compileScriptsFilename); XDocument doc = XDocumentUtils.Load(filename); if (mode == "compile") { mode = "develop"; } XName name = "name"; XElement topElement = doc.Root.Elements().Single(f => f.Attribute(name).Value == type); XElement modeElement = topElement.Elements().Single(f => f.Attribute(name).Value == mode); return (from e in modeElement.Elements() select e.Attribute("filename").Value); }
/// <exclude /> public override void Uninstall() { if (_xmlFileMerges == null) { throw new InvalidOperationException("XmlFileMergePackageFragmentUninstaller has not been validated"); } foreach (XmlFileMerge xmlFileMerge in _xmlFileMerges) { string targetXml = PathUtil.Resolve(xmlFileMerge.TargetPath); using (Stream stream = this.UninstallerContext.ZipFileSystem.GetFileStream(xmlFileMerge.ChangeFilePath)) { XElement source = XElement.Load(stream); XDocument target = XDocumentUtils.Load(targetXml); target.Root.RemoveMatches(source); target.SaveToFile(targetXml); } } }
/// <exclude /> public override IEnumerable <XElement> Install() { Verify.IsNotNull(_packagesToBumb, this.GetType().Name + " has not been validated"); var installedElements = new List <XElement>(); foreach (var kvp in _packagesToBumb) { if (this.InstalledPackages.ContainsKey(kvp.Key)) { XDocument doc = XDocumentUtils.Load(this.InstalledPackages[kvp.Key]); XElement element = doc.Root; if (element == null) { continue; } XAttribute attribute = element.Attribute(PackageSystemSettings.VersionAttributeName); if (attribute == null) { continue; } installedElements.Add( new XElement("PackageVersion", new XAttribute("packageId", kvp.Key), new XAttribute("oldVersion", attribute.Value)) ); attribute.Value = kvp.Value; doc.SaveToFile(this.InstalledPackages[kvp.Key]); } } yield return(new XElement("PackageVersions", installedElements)); }
private void TryLoadPersistedFormData(string filename) { string guidString = Path.GetFileNameWithoutExtension(filename); Guid id; if (!Guid.TryParse(guidString ?? "", out id)) { return; } try { var doc = XDocumentUtils.Load(filename); var formData = FormData.Deserialize(doc.Root); if (!_resourceLocker.Resources.FormData.ContainsKey(id)) { _resourceLocker.Resources.FormData.TryAdd(id, formData); FormsWorkflowBindingCache.Bindings.TryAdd(id, formData.Bindings); } } catch (DataSerilizationException ex) { Log.LogWarning(LogTitle, $"The workflow {id} contained one or more bindings where data was deleted or data type changed"); Log.LogWarning(LogTitle, ex); //AbortWorkflow(id); } catch (Exception ex) { Log.LogCritical(LogTitle, $"Could not deserialize form data for the workflow {id}"); Log.LogCritical(LogTitle, ex); AbortWorkflow(id); } }
/// <exclude /> public static void TransformConfiguration(Func <XDocument, bool> transformer) { using (GlobalInitializerFacade.CoreLockScope) { lock (_lock) { XDocument document = XDocumentUtils.Load(ConfigurationServices.FileConfigurationSourcePath); if (transformer(document)) { ValidateConfigurationFile(document); // Kill monitoring of file changes: // FileConfigurationSource.ResetImplementation(ConfigurationServices.FileConfigurationSourcePath, false); document.SaveToFile(ConfigurationServices.FileConfigurationSourcePath); _configurationSource = new FileConfigurationSource(ConfigurationServices.FileConfigurationSourcePath); // Kill monitoring of file changes: // FileConfigurationSource.ResetImplementation(ConfigurationServices.FileConfigurationSourcePath, false); GlobalEventSystemFacade.ShutDownTheSystem(); } } } }
private static PackageLicenseDefinition TryLoadLicenseFile(string filePath) { XDocument doc = XDocumentUtils.Load(filePath); var licenseDefinition = new PackageLicenseDefinition { ProductName = doc.Descendants("Name").Single().Value, InstallationId = (Guid)doc.Descendants("InstallationId").Single(), ProductId = (Guid)doc.Descendants("ProductId").Single(), Permanent = (bool)doc.Descendants("Permanent").Single(), Expires = (DateTime?)doc.Descendants("Expires").SingleOrDefault() ?? DateTime.MaxValue, LicenseKey = doc.Descendants("LicenseKey").Single().Value, PurchaseUrl = doc.Descendants("PurchaseUrl").SingleOrDefault()?.Value ?? "", LicenseFileName = filePath }; if (licenseDefinition.InstallationId != InstallationInformationFacade.InstallationId) { Log.LogError(LogTitle, $"The license for the product '{licenseDefinition.ProductId}' ({licenseDefinition.ProductName}) does not match the current installation"); return(null); } return(licenseDefinition); }
private static void CopyData(string providerName, DataTypeChangeDescriptor dataTypeChangeDescriptor, DataScopeConfigurationElement oldDataScopeConfigurationElement, DataScopeConfigurationElement newDataScopeConfigurationElement, Dictionary <string, object> newFieldValues, bool deleteOldFile = true) { string oldFilename = ResolvePath(oldDataScopeConfigurationElement.Filename, providerName); string newFilename = ResolvePath(newDataScopeConfigurationElement.Filename, providerName); XDocument oldDocument = XDocumentUtils.Load(PathUtil.Resolve(oldFilename)); List <XElement> newElements = new List <XElement>(); bool addingVersionId = dataTypeChangeDescriptor.AddedFields.Any(f => f.Name == nameof(IVersioned.VersionId)) && dataTypeChangeDescriptor.AlteredType.SuperInterfaces.Any(s => s == typeof(IVersioned)); string versionIdSourceFieldName = null; if (addingVersionId) { if (dataTypeChangeDescriptor.AlteredType.DataTypeId == typeof(IPage).GetImmutableTypeId()) { versionIdSourceFieldName = nameof(IPage.Id); } else { versionIdSourceFieldName = dataTypeChangeDescriptor.AlteredType.Fields .Where(f => f.InstanceType == typeof(Guid) && (f.ForeignKeyReferenceTypeName?.Contains(typeof(IPage).FullName) ?? false)) .OrderByDescending(f => f.Name == nameof(IPageData.PageId)) .Select(f => f.Name) .FirstOrDefault(); } } foreach (XElement oldElement in oldDocument.Root.Elements()) { List <XAttribute> newChildAttributes = new List <XAttribute>(); foreach (XAttribute oldChildAttribute in oldElement.Attributes()) { var existingFieldInfo = GetExistingFieldInfo(dataTypeChangeDescriptor, oldChildAttribute.Name.LocalName); if (existingFieldInfo != null) { if (existingFieldInfo.OriginalField.Name != existingFieldInfo.AlteredField.Name) { XAttribute newChildAttribute = new XAttribute(existingFieldInfo.AlteredField.Name, oldChildAttribute.Value); newChildAttributes.Add(newChildAttribute); } else { newChildAttributes.Add(oldChildAttribute); } } // It may happen that some data were added before data descriptors are updated, in the case of using // [AutoUpdateable] attribute. else if (dataTypeChangeDescriptor.AddedFields.Any(addedField => addedField.Name == oldChildAttribute.Name)) { newChildAttributes.Add(oldChildAttribute); } } // Adding default value for fields that are NULL and become required foreach (var existingFieldInfo in dataTypeChangeDescriptor.ExistingFields) { bool fieldBecomeRequired = existingFieldInfo.OriginalField.IsNullable && !existingFieldInfo.AlteredField.IsNullable; string fieldName = existingFieldInfo.AlteredField.Name; if (fieldBecomeRequired && !newChildAttributes.Any(attr => attr.Name.LocalName == fieldName)) { newChildAttributes.Add(new XAttribute(fieldName, GetDefaultValue(existingFieldInfo.AlteredField))); } } foreach (DataFieldDescriptor fieldDescriptor in dataTypeChangeDescriptor.AddedFields) { if (addingVersionId && fieldDescriptor.Name == nameof(IVersioned.VersionId) && versionIdSourceFieldName != null) { var existingField = (Guid)oldElement.Attribute(versionIdSourceFieldName); if (existingField != null) { newChildAttributes.Add(new XAttribute(fieldDescriptor.Name, existingField)); continue; } } if (!fieldDescriptor.IsNullable && !newChildAttributes.Any(attr => attr.Name == fieldDescriptor.Name)) { object value; if (!newFieldValues.TryGetValue(fieldDescriptor.Name, out value)) { value = GetDefaultValue(fieldDescriptor); } newChildAttributes.Add(new XAttribute(fieldDescriptor.Name, value)); } else if (newFieldValues.ContainsKey(fieldDescriptor.Name)) { XAttribute attribute = newChildAttributes.SingleOrDefault(attr => attr.Name == fieldDescriptor.Name); attribute?.SetValue(newFieldValues[fieldDescriptor.Name]); } } XElement newElement = new XElement(newDataScopeConfigurationElement.ElementName, newChildAttributes); newElements.Add(newElement); } if (deleteOldFile) { C1File.Delete(oldFilename); } XElement newRoot = new XElement(XmlDataProviderDocumentWriter.GetRootElementName(newDataScopeConfigurationElement.ElementName)); newRoot.Add(newElements); XDocument newDocument = new XDocument(); newDocument.Add(newRoot); XDocumentUtils.Save(newDocument, newFilename); }
private XElement LoadXml() { XDocument doc = XDocumentUtils.Load(this.UninstallFilename); return(doc.Root); }
private void LoadXml() { _packageDescriptions = new Dictionary <string, List <KeyValuePair <PackageDescription, ExtraInfo> > >(); _eulaTexts = new Dictionary <string, Dictionary <Guid, string> >(); XDocument doc = XDocumentUtils.Load(_configFilePath); foreach (XElement element in doc.Root.Elements("Source")) { XAttribute urlAttribute = element.Attribute("url"); List <KeyValuePair <PackageDescription, ExtraInfo> > packageDescriptions = new List <KeyValuePair <PackageDescription, ExtraInfo> >(); foreach (XElement packageElement in element.Elements("PackageDescription")) { PackageDescription packageDescription = new PackageDescription(); packageDescription.PackageVersion = packageElement.Attribute("packageVersion").Value; packageDescription.PackageFileDownloadUrl = packageElement.Attribute("packageFileDownloadUrl").Value; packageDescription.Description = packageElement.Attribute("description").Value; packageDescription.EulaId = (Guid)packageElement.Attribute("eulaId"); packageDescription.GroupName = packageElement.Attribute("groupName").Value; packageDescription.Id = (Guid)packageElement.Attribute("id"); packageDescription.InstallationRequireLicenseFileUpdate = (bool)packageElement.Attribute("installationRequireLicenseFileUpdate"); packageDescription.IsFree = (bool)packageElement.Attribute("isFree"); packageDescription.IsTrial = (bool)packageElement.Attribute("isTrial"); packageDescription.LicenseRuleId = (Guid)packageElement.Attribute("licenseRuleId"); packageDescription.MaxCompositeVersionSupported = packageElement.Attribute("maxCompositeVersionSupported").Value; packageDescription.MinCompositeVersionSupported = packageElement.Attribute("minCompositeVersionSupported").Value; packageDescription.Name = packageElement.Attribute("name").Value; packageDescription.PriceAmmount = (decimal)packageElement.Attribute("priceAmmount"); packageDescription.PriceCurrency = packageElement.Attribute("priceCurrency").Value; packageDescription.ReadMoreUrl = packageElement.Attribute("readMoreUrl").Value; packageDescription.TechicalDetails = packageElement.Attribute("techicalDetails").Value; packageDescription.TrialPeriodDays = (int)packageElement.Attribute("trialPeriodDays"); packageDescription.UpgradeAgreementMandatory = (bool)packageElement.Attribute("upgradeAgreementMandatory"); packageDescription.Vendor = packageElement.Attribute("vendor").Value; ExtraInfo extraInfo = new ExtraInfo(); if (packageElement.Attribute("canBeUninstalled") != null) { extraInfo.CanBeUninstalled = (bool)packageElement.Attribute("canBeUninstalled"); } if (packageElement.Attribute("flushOnCompletion") != null) { extraInfo.FlushOnCompletion = (bool)packageElement.Attribute("flushOnCompletion"); } if (packageElement.Attribute("reloadConsoleOnCompletion") != null) { extraInfo.ReloadConsoleOnCompletion = (bool)packageElement.Attribute("reloadConsoleOnCompletion"); } if (packageElement.Attribute("systemLocking") != null) { SystemLockingType systemLockingType; packageElement.Attribute("systemLocking").TryDeserialize(out systemLockingType); extraInfo.SystemLockingType = systemLockingType; } packageDescriptions.Add(new KeyValuePair <PackageDescription, ExtraInfo>(packageDescription, extraInfo)); } _packageDescriptions.Add(element.Attribute("url").Value.ToLowerInvariant(), packageDescriptions); Dictionary <Guid, string> eulaTexts = new Dictionary <Guid, string>(); foreach (XElement eulaTextElement in element.Elements("EulaText")) { eulaTexts.Add( (Guid)eulaTextElement.Attribute("id"), eulaTextElement.Value ); } _eulaTexts.Add(element.Attribute("url").Value.ToLowerInvariant(), eulaTexts); } }