public static void SaveConfigurationToXMLFile(string fullFileName, string directory, bool changeMarker, string fromNet, string toNet, bool changeKeyFiles, string keyFilesFolder)
{
if (File.Exists(fullFileName))
{
File.Delete(fullFileName);
}
XDocument document = new XDocument(new XElement("NOBuildTools.VersionUpdater"));
XElement root = document.FirstNode as XElement;
root.Add(new XElement("TargetFolder", XmlConvert.EncodeName(directory)));
root.Add(new XElement("ChangeMarker", XmlConvert.EncodeName(changeMarker.ToString())));
root.Add(new XElement("From", XmlConvert.EncodeName(fromNet)));
root.Add(new XElement("To", XmlConvert.EncodeName(fromNet)));
root.Add(new XElement("ChangeKeyFiles", XmlConvert.EncodeName(changeKeyFiles.ToString())));
root.Add(new XElement("KeyFilesFolder", XmlConvert.EncodeName(keyFilesFolder)));
document.Save(fullFileName);
}
/// <summary>
/// Gets the array element.
/// </summary>
/// <param name="propertyName">The property name.</param>
/// <param name="input">The input object.</param>
/// <returns>Returns an XElement with the array collection as child elements.</returns>
internal XElement GetArrayElement(string propertyName, Array input)
{
var name = XmlConvert.EncodeName(propertyName);
XElement rootElement = new XElement(name);
var arrayCount = input.GetLength(0);
for (int i = 0; i < arrayCount; i++)
{
var val = input.GetValue(i);
XElement childElement = val.GetType().IsSimpleType() ? new XElement(name + "Child", val) : new XElement(name, SerializeComplexType(val));
rootElement.Add(childElement);
}
return(rootElement);
}
protected string GetName(string name, string defaultName, params string[] exclusive)
{
if (exclusive.Any(e => !String.IsNullOrEmpty(e)))
{
if (!String.IsNullOrEmpty(name))
{
throw new Exception("Multiple exclusive properties specified.");
}
return(null);
}
if (String.IsNullOrEmpty(name))
{
return(String.IsNullOrEmpty(defaultName)
? null : XmlConvert.EncodeName(defaultName));
}
XmlConvert.VerifyName(name);
return(name);
}
private void WriteHashTable(XmlWriter w, Hashtable value)
{
try
{
foreach (DictionaryEntry item in value)
{
string key = XmlConvert.EncodeName(item.Key.ToString());
w.WriteStartElement(key);
object o = item.Value;
w.WriteString(this.ConvertToString(o));
w.WriteEndElement();
}
}
catch (Exception x)
{
Console.WriteLine(x.Message);
}
}
private static XElement GetArrayElement(PropertyInfo info, Array input, XNamespace xmlNamespace = null)
{
var name = XmlConvert.EncodeName(info.Name) ?? "Object";
XElement rootElement = CreateElement(xmlNamespace, name);
var arrayCount = input?.GetLength(0) ?? 0;
for (int i = 0; i < arrayCount; i += 1)
{
var val = input?.GetValue(i);
var typeName = GetTypeName(val.GetType());
XElement childElement = val.GetType().IsSimpleType()
? CreateElement(xmlNamespace, $"{typeName}", val)
: val.ToXml(typeName, xmlNamespace);
rootElement.Add(childElement);
}
return(rootElement);
}
internal static XmlNode ListAsXmlNode <T>(this List <T> items, XmlDocument _doc, string ElementName)
{
XmlNode nod = _doc.CreateElement(XmlConvert.EncodeName(ElementName));
foreach (var item in items)
{
IXmlRenderable itemToRender = item as IXmlRenderable;
if (itemToRender != null)
{
nod.AppendChild(itemToRender.AsXmlNode(_doc, item.GetType().Name));
}
else
{
nod.AppendChild(item.AsXmlNode(_doc, "item"));
}
}
return(nod);
}
SignDigitally(
X509Certificate certificate,
bool embedCertificate,
XpsDigSigPartAlteringRestrictions restrictions,
Guid id,
bool testIsSignable
)
{
CheckDisposed();
return(SignDigitally(
certificate,
embedCertificate,
restrictions,
XmlConvert.EncodeName(id.ToString()),
testIsSignable
));
}
public FileInfo File(string path)
{
var result = new FileInfo();
logger.LogDebug("loading file " + path);
using (var image = new MagickImage(path))
{
result.Filename = path;
result.Width = image.Width;
result.Height = image.Height;
result.Hashsum = XmlConvert.EncodeName(Encoding.ASCII.GetString(MD5.Create().ComputeHash(image.ToByteArray())));
}
logger.LogDebug("loading file succeeded");
return(result);
}
/// <summary>
/// Gets the array element.
/// </summary>
/// <param name="info">The property info.</param>
/// <param name="input">The input object.</param>
/// <returns>Returns an XElement with the array collection as child elements.</returns>
private static XElement GetArrayElement(PropertyInfo info, Array input)
{
var name = XmlConvert.EncodeName(info.Name);
XElement rootElement = new XElement(name);
var arrayCount = input.GetLength(0);
for (int i = 0; i < arrayCount; i++)
{
var val = input.GetValue(i);
XElement childElement = val.GetType().IsSimpleType() ? new XElement(name + "Child", val) : val.ToXml();
rootElement.Add(childElement);
}
return(rootElement);
}
static string GetValidVariableName(ISharepointFieldTo mapping)
{
var fixedName = mapping.Name.Replace(" ", "").Replace(".", "").Replace(":", "").Replace(",", "");
fixedName = XmlConvert.EncodeName(fixedName);
var startIndexOfEncoding = fixedName.IndexOf("_", StringComparison.OrdinalIgnoreCase);
var endIndexOfEncoding = fixedName.LastIndexOf("_", StringComparison.OrdinalIgnoreCase);
if (startIndexOfEncoding > 0 && endIndexOfEncoding > 0)
{
fixedName = fixedName.Remove(startIndexOfEncoding - 1, endIndexOfEncoding - startIndexOfEncoding);
}
if (fixedName[0] == 'f' || fixedName[0] == '_' || Char.IsNumber(fixedName[0]))
{
fixedName = fixedName.Remove(0, 1);
}
return(fixedName);
}
private static string ValidateXml(string supposedlyXml)
{
try
{
XmlReaderSettings xmlReaderSettings = new XmlReaderSettings();
xmlReaderSettings.ConformanceLevel = ConformanceLevel.Fragment;
XmlReader xmlReader = XmlReader.Create(new StringReader(supposedlyXml), xmlReaderSettings);
while (xmlReader.Read())
{
}
xmlReader.Close();
return(supposedlyXml);
}
catch (XmlException)
{
return(XmlConvert.EncodeName(supposedlyXml));
}
}
public void Add(XmlNode componentsNode)
{
foreach (XmlNode componentNode in componentsNode.ChildNodes)
{
string text = componentNode.Attributes["Description"].InnerText;
string fileName = componentNode.Attributes["ContainingFile"].InnerText;
foreach (ToolStripItem item in _toolstrip.DropDownItems)
{
if (item.Text == text)
{
return;
}
}
if (_toolstrip.DropDownItems.Count < 7)
{
ToolStripItem item = _toolstrip.DropDownItems.Add(text);
_toolstrip.DropDownItems.Insert(2, item);
item.Tag = fileName;
item.Click += _recentClickHandler;
XmlNode newNode = _document.CreateElement(System.Xml.XmlConvert.EncodeName(text));
newNode.InnerText = fileName;
_document.FirstChild.AppendChild(newNode);
}
else
{
string encodedNodeName = XmlConvert.EncodeName(_toolstrip.DropDownItems[5].Text);
XmlNode deleteNode = _document.SelectSingleNode("/TypeLibraries/" + encodedNodeName);
_document.FirstChild.RemoveChild(deleteNode);
_toolstrip.DropDownItems.Remove(_toolstrip.DropDownItems[6]);
ToolStripItem item = _toolstrip.DropDownItems.Add(text);
_toolstrip.DropDownItems.Insert(2, item);
item.Text = text;
item.Tag = fileName;
XmlNode newNode = _document.CreateElement(System.Xml.XmlConvert.EncodeName(text));
newNode.InnerText = fileName;
_document.FirstChild.AppendChild(newNode);
}
}
}
public static string TransformTokenTextToXslScript(DataSet udtDataset, string listView, string detailView,
string headerView, bool pagingEnabled, bool sortingEnabled,
bool searchEnabled, bool showDetailView,
string currentListType)
{
headerView = Regex.Replace(headerView, "\\[((?:\\w|\\s)+)\\]",
sortingEnabled
? "<xsl:apply-templates select =\"udt:Fields[udt:FieldTitle=\'$1\']\"/>"
: "$1");
string template = LoadXslScriptTemplate(listView, detailView, headerView, pagingEnabled, sortingEnabled,
searchEnabled, showDetailView, currentListType);
template =
(template.Replace("[ ]", SpacePlaceholder).Replace(HardSpace, SpacePlaceholder).Replace(" ",
SpacePlaceholder));
const string attributeRegexPattern = "(?<==\\s*[\'\"][^\'\"<>]*)(\\[{0}\\])(?=[^\'\"<>]*[\"\'])";
foreach (DataColumn col in udtDataset.Tables[DataSetTableName.Data].Columns)
{
template = Regex.Replace(template, string.Format(attributeRegexPattern, col.ColumnName),
string.Format("{{udt:{0}}}", XmlConvert.EncodeName(col.ColumnName)));
template = template.Replace(string.Format("[{0}]", col.ColumnName),
string.Format(
"<xsl:value-of select=\"udt:{0}\" disable-output-escaping=\"yes\"/>",
XmlConvert.EncodeName(col.ColumnName)));
}
foreach (var contextString in Enum.GetNames(typeof(ContextValues)))
{
template = Regex.Replace(template, string.Format(attributeRegexPattern, "Context:" + contextString),
string.Format("{{/udt:UserDefinedTable/udt:Context/udt:{0}}}", contextString));
template = template.Replace(string.Format("[Context:{0}]", contextString),
string.Format(
"<xsl:value-of select=\"/udt:UserDefinedTable/udt:Context/udt:{0}\" disable-output-escaping=\"yes\"/>",
contextString));
}
template = template.Replace("[UDT:EditLink]", "<xsl:call-template name =\"EditLink\"/>");
template = template.Replace("[UDT:DetailView]", "<xsl:call-template name =\"DetailView\"/>");
template = template.Replace("[UDT:ListView]", "<xsl:call-template name =\"ListView\"/>");
return(PrettyPrint(template).Replace(SpacePlaceholder, HardSpace));
}
public override void RenderValuesToHtmlInsideDataSet(DataSet ds, int moduleId, bool noScript)
{
var fields = new ArrayList();
//List of columns that contains URLs
foreach (DataRow row in ds.Tables[DataSetTableName.Fields].Rows)
{
if (row[FieldsTableColumn.Type].ToString() == Name)
{
var fieldId = (int)row[FieldsTableColumn.Id];
var field = new FieldSetting
{
Title = row[FieldsTableColumn.Title].ToString(),
FormatString = row[FieldsTableColumn.OutputSettings].AsString("t")
};
fields.Add(field);
var renderedValueColumnName = field.Title + DataTableColumn.Appendix_LocalizedValue;
ds.Tables[DataSetTableName.Data].Columns.Add(renderedValueColumnName, typeof(string));
ds.Tables[DataSetTableName.Data].Columns.Add(field.Title + DataTableColumn.Appendix_Ticks,
typeof(long));
row[FieldsTableColumn.ValueColumn] = XmlConvert.EncodeName(renderedValueColumnName);
}
}
if (HttpContext.Current != null)
{
var serverTimeZone = PortalController.GetCurrentPortalSettings().TimeZone;
var userTimeZone = UserController.GetCurrentUserInfo().Profile.PreferredTimeZone;
foreach (DataRow row in ds.Tables[DataSetTableName.Data].Rows)
{
foreach (FieldSetting field in fields)
{
if (Information.IsDate(row[field.Title]))
{
var d = Convert.ToDateTime(row[field.Title]);
var format = "<!--{0:000000000000}-->{1:" + field.FormatString + "}";
row[field.Title + DataTableColumn.Appendix_LocalizedValue] = string.Format(format, d.Ticks / 10000000, d);
row[field.Title + DataTableColumn.Appendix_Ticks] = d.Ticks;
}
}
}
}
}
protected override XElement MainElement(EmoticonPack emoticonPack)
{
if (FileOutputOptions.IsLocalizedText)
{
AddLocalizedGameString(emoticonPack);
}
return(new XElement(
XmlConvert.EncodeName(emoticonPack.Id),
string.IsNullOrEmpty(emoticonPack.Name) || FileOutputOptions.IsLocalizedText ? null ! : new XAttribute("name", emoticonPack.Name),
string.IsNullOrEmpty(emoticonPack.HyperlinkId) ? null ! : new XAttribute("hyperlinkId", emoticonPack.HyperlinkId),
new XAttribute("rarity", emoticonPack.Rarity),
string.IsNullOrEmpty(emoticonPack.CollectionCategory) ? null ! : new XAttribute("category", emoticonPack.CollectionCategory),
string.IsNullOrEmpty(emoticonPack.EventName) ? null ! : new XAttribute("event", emoticonPack.EventName),
emoticonPack.ReleaseDate.HasValue ? new XAttribute("releaseDate", emoticonPack.ReleaseDate.Value.ToString("yyyy-MM-dd")) : null !,
string.IsNullOrEmpty(emoticonPack.SortName) || FileOutputOptions.IsLocalizedText ? null ! : new XElement("SortName", emoticonPack.SortName),
string.IsNullOrEmpty(emoticonPack.Description?.RawDescription) || FileOutputOptions.IsLocalizedText ? null ! : new XElement("Description", GetTooltip(emoticonPack.Description, FileOutputOptions.DescriptionType)),
emoticonPack.EmoticonIds != null && emoticonPack.EmoticonIds.Any() ? new XElement("Emoticons", emoticonPack.EmoticonIds.Select(x => new XElement("Emoticon", x))) : null !));
}
public XmlDocument ToXml()
{
XmlDocument doc = new XmlDocument();
doc.AppendChild(doc.CreateElement(XmlConvert.EncodeName(info.Name)));
//if lastFilledNode is null no one state has been validated by the workflow and then the "product" of the workflow is empty
if (lastFilledNode != null)
{
Node nextNode = initialNode;
while (nextNode != lastFilledNode)
{
doc.FirstChild.AppendChild(doc.ImportNode(nextNode.ToXml(), true));
nextNode = nextNode.Next;
}
doc.FirstChild.AppendChild(doc.ImportNode(lastFilledNode.ToXml(), true));
}
return(doc);
}
private static XElement ToXml(object input, string name)
{
var type = input.GetType();
var properties = type.GetProperties();
var root = new XElement(XmlConvert.EncodeName(name));
var elements = from p in properties
let n = XmlConvert.EncodeName(p.Name)
let v = p.GetValue(input, null)
let val = p.PropertyType.IsAllowedType()
? new XElement(p.Name, p.GetValue(input))
: ToXml(p.GetValue(input), p.Name)
where val != null
select val;
root.Add(elements);
return(root);
}
protected override XElement MainElement(Banner banner)
{
if (FileOutputOptions.IsLocalizedText)
{
AddLocalizedGameString(banner);
}
return(new XElement(
XmlConvert.EncodeName(banner.Id),
string.IsNullOrEmpty(banner.Name) || FileOutputOptions.IsLocalizedText ? null ! : new XAttribute("name", banner.Name),
string.IsNullOrEmpty(banner.HyperlinkId) ? null ! : new XAttribute("hyperlinkId", banner.HyperlinkId),
string.IsNullOrEmpty(banner.AttributeId) ? null ! : new XAttribute("attributeId", banner.AttributeId),
new XAttribute("rarity", banner.Rarity),
new XAttribute("category", banner.CollectionCategory !),
string.IsNullOrEmpty(banner.EventName) ? null ! : new XAttribute("event", banner.EventName),
banner.ReleaseDate.HasValue ? new XAttribute("releaseDate", banner.ReleaseDate.Value.ToString("yyyy-MM-dd")) : null !,
string.IsNullOrEmpty(banner.SortName) || FileOutputOptions.IsLocalizedText ? null ! : new XElement("SortName", banner.SortName),
string.IsNullOrEmpty(banner.Description?.RawDescription) || FileOutputOptions.IsLocalizedText ? null ! : new XElement("Description", GetTooltip(banner.Description, FileOutputOptions.DescriptionType))));
}
private void CreateElement(
JsonReader reader,
IXmlDocument document,
IXmlNode currentNode,
string elementName,
XmlNamespaceManager manager,
string elementPrefix,
Dictionary <string, string> attributeNameValues)
{
IXmlElement element = this.CreateElement(elementName, document, elementPrefix, manager);
currentNode.AppendChild((IXmlNode)element);
foreach (KeyValuePair <string, string> attributeNameValue in attributeNameValues)
{
string str = XmlConvert.EncodeName(attributeNameValue.Key);
string prefix = MiscellaneousUtils.GetPrefix(attributeNameValue.Key);
IXmlNode attribute = !string.IsNullOrEmpty(prefix) ? document.CreateAttribute(str, manager.LookupNamespace(prefix) ?? string.Empty, attributeNameValue.Value) : document.CreateAttribute(str, attributeNameValue.Value);
element.SetAttributeNode(attribute);
}
if (reader.TokenType == JsonToken.String || reader.TokenType == JsonToken.Integer || (reader.TokenType == JsonToken.Float || reader.TokenType == JsonToken.Boolean) || reader.TokenType == JsonToken.Date)
{
string xmlValue = this.ConvertTokenToXmlValue(reader);
if (xmlValue == null)
{
return;
}
element.AppendChild(document.CreateTextNode(xmlValue));
}
else
{
if (reader.TokenType == JsonToken.Null)
{
return;
}
if (reader.TokenType != JsonToken.EndObject)
{
manager.PushScope();
this.DeserializeNode(reader, document, manager, (IXmlNode)element);
manager.PopScope();
}
manager.RemoveNamespace(string.Empty, manager.DefaultNamespace);
}
}
protected override XElement MainElement(HeroSkin heroSkin)
{
if (FileOutputOptions.IsLocalizedText)
{
AddLocalizedGameString(heroSkin);
}
return(new XElement(
XmlConvert.EncodeName(heroSkin.Id),
string.IsNullOrEmpty(heroSkin.Name) || FileOutputOptions.IsLocalizedText ? null : new XAttribute("name", heroSkin.Name),
new XAttribute("hyperlinkId", heroSkin.HyperlinkId),
new XAttribute("attributeId", heroSkin.AttributeId),
new XAttribute("rarity", heroSkin.AttributeId),
heroSkin.ReleaseDate.HasValue ? new XAttribute("releaseDate", heroSkin.ReleaseDate.Value.ToString("yyyy-MM-dd")) : null,
string.IsNullOrEmpty(heroSkin.SortName) || FileOutputOptions.IsLocalizedText ? null : new XElement("SortName", heroSkin.SortName),
string.IsNullOrEmpty(heroSkin.SearchText) || FileOutputOptions.IsLocalizedText ? null : new XElement("SearchText", heroSkin.SearchText),
string.IsNullOrEmpty(heroSkin.Description?.RawDescription) || FileOutputOptions.IsLocalizedText ? null : new XElement("Description", GetTooltip(heroSkin.Description, FileOutputOptions.DescriptionType)),
heroSkin.Features.Any() ? new XElement("Features", heroSkin.Features.Select(f => new XElement("Feature", f))) : null));
}
internal static XmlNode DictionaryAsXmlNode <T>(this Dictionary <string, T> items, XmlDocument _doc, string ElementName)
{
XmlNode nod = _doc.CreateElement(XmlConvert.EncodeName(ElementName));
foreach (var itemKV in items)
{
IXmlRenderable valToRender = itemKV.Value as IXmlRenderable;
if (valToRender != null)
{
var newNode = nod.AppendChild(((IXmlRenderableInternal)valToRender).AsXml(_doc));
((XmlElement)newNode).SetAttribute("key", itemKV.Key);
}
else
{
nod.AppendChild(itemKV.Value.AsXmlNode(_doc, itemKV.Value.GetType().Name, itemKV.Key));
}
}
return(nod);
}
public static void WriteNode(XmlWriter xmlWriter, ConfigurationNode node)
{
string xmlElementName;
string xmlAttributeValue;
if (node.HasName)
{
var nodeName = node.Name;
var encodedName = XmlConvert.EncodeName(nodeName);
if (nodeName == encodedName)
{
xmlElementName = nodeName;
xmlAttributeValue = null;
}
else
{
xmlElementName = ConfigurationElementName.Node;
xmlAttributeValue = nodeName;
}
}
else
{
xmlElementName = ConfigurationElementName.Node;
xmlAttributeValue = null;
}
using (xmlWriter.WriteElement(xmlElementName))
{
if (xmlAttributeValue != null)
{
xmlWriter.WriteAttributeString("name", xmlAttributeValue);
}
Write(xmlWriter, node.Attributes);
foreach (var childNode in node.ChildNodes)
{
WriteNode(xmlWriter, childNode);
}
}
}
public List <ColumnSchema> GetDataSchema(SqlConnection connection)
{
List <ColumnSchema> schemas = new List <ColumnSchema>();
string sqlQuery = string.Format("Select * From {0} where 1 = 0", this.tableName);
DataTable dataTable = new DataTable(this.tableName);
using (SqlDataAdapter adapter = new SqlDataAdapter(sqlQuery, connection))
{
adapter.FillSchema(dataTable, SchemaType.Source);
}
foreach (DataColumn column in dataTable.Columns)
{
schemas.Add(new ColumnSchema(column.ColumnName, XmlConvert.EncodeName(column.ColumnName), column.DataType, Type.GetTypeCode(column.DataType).ToString(), column.AllowDBNull, column.MaxLength));
}
return(schemas);
}
protected override XElement MainElement(RewardPortrait rewardPortrait)
{
if (FileOutputOptions.IsLocalizedText)
{
AddLocalizedGameString(rewardPortrait);
}
return(new XElement(
XmlConvert.EncodeName(rewardPortrait.Id),
string.IsNullOrEmpty(rewardPortrait.Name) || FileOutputOptions.IsLocalizedText ? null ! : new XAttribute("name", rewardPortrait.Name),
string.IsNullOrEmpty(rewardPortrait.HyperlinkId) ? null ! : new XAttribute("hyperlinkId", rewardPortrait.HyperlinkId),
new XAttribute("rarity", rewardPortrait.Rarity),
string.IsNullOrEmpty(rewardPortrait.HeroId) ? null ! : new XAttribute("heroId", rewardPortrait.HeroId),
new XAttribute("iconSlot", rewardPortrait.IconSlot),
string.IsNullOrEmpty(rewardPortrait.PortraitPackId) ? null ! : new XAttribute("PortraitPackId", rewardPortrait.PortraitPackId),
string.IsNullOrEmpty(rewardPortrait.CollectionCategory) ? null ! : new XAttribute("category", rewardPortrait.CollectionCategory),
string.IsNullOrEmpty(rewardPortrait.Description?.RawDescription) || FileOutputOptions.IsLocalizedText ? null ! : new XElement("Description", GetTooltip(rewardPortrait.Description, FileOutputOptions.DescriptionType)),
string.IsNullOrEmpty(rewardPortrait.DescriptionUnearned?.RawDescription) || FileOutputOptions.IsLocalizedText ? null ! : new XElement("DescriptionUnearned", GetTooltip(rewardPortrait.DescriptionUnearned, FileOutputOptions.DescriptionType)),
GetImageObject(rewardPortrait)));
}
internal static void SaveCredentials(SessionOptions credentials)
{
ValidateStorage(credentials.HostName);
var xml = new XmlDocument();
using (var writer = XmlWriter.Create(GetFilePath(credentials.HostName), new XmlWriterSettings()
{
Indent = true
}))
{
writer.WriteStartDocument();
writer.WriteStartElement(XmlConvert.EncodeName(credentials.HostName));
writer.WriteElementString("fingerprint", XmlConvert.EncodeName(credentials.SshHostKeyFingerprint));
writer.WriteEndElement();
writer.WriteEndDocument();
xml.Save(writer);
}
}
protected override void Exporting(OEmbedPart part, ContentManagement.Handlers.ExportContentContext context)
{
var partName = XmlConvert.EncodeName(typeof(OEmbedPart).Name);
var infosetPart = part.As <InfosetPart>();
if (infosetPart != null)
{
// OEmbedPart is not versionable thats why using Infoset.Element instead of VersionInfoset.Element
var element = infosetPart.Infoset.Element;
var partElement = element.Element(partName);
if (partElement == null)
{
return;
}
context.Element(partName).Add(partElement.Elements());
}
}
private async Task ExportPromoAsync(XmlWriter xml, Product product, String URL)
{
var promos = await _abcPromoService.GetActivePromosByProductIdAsync(product.Id);
if (!promos.Any())
{
return;
}
xml.WriteStartElement(_promosTag);
foreach (var promo in promos)
{
xml.WriteStartElement(_promoTag);
xml.WriteAttributeString("name", XmlConvert.EncodeName(promo.Description));
xml.WriteValue(XmlSanitize(URL + promo.GetPdfPath()));
xml.WriteEndElement();
}
xml.WriteEndElement();
}
private static XElement _ToXml(object input, string element, int?arrayIndex = null, string arrayName = null)
{
if (input == null)
{
return(null);
}
if (String.IsNullOrEmpty(element))
{
var name = input.GetType().Name;
element = name.Contains("AnonymousType")
? "Object"
: arrayIndex != null
? arrayName + "_" + arrayIndex
: name;
}
element = XmlConvert.EncodeName(element);
var ret = new XElement(element);
var type = input.GetType();
var props = type.GetProperties();
var elements = props.Select(p =>
{
var pType = Nullable.GetUnderlyingType(p.PropertyType) ?? p.PropertyType;
var name = XmlConvert.EncodeName(p.Name);
var val = pType.IsArray ? "array" : p.GetValue(input, null);
var value = pType.IsEnumerable()
? GetEnumerableElements(p, (IEnumerable)p.GetValue(input, null))
: pType.IsSimpleType2() || pType.IsEnum
? new XElement(name, val)
: val.ToXml2(name);
return(value);
})
.Where(v => v != null);
ret.Add(elements);
return(ret);
}
/// <summary>
/// Converts an anonymous type to an XElement.
/// </summary>
/// <param name="input">The input.</param>
/// <param name="element">The element name.</param>
/// <returns>Returns the object as it's XML representation in an XElement.</returns>
public static XElement ToXml(this object input, string element)
{
try
{
if (input == null)
{
return(null);
}
if (String.IsNullOrWhiteSpace(element))
{
element = "object";
}
element = XmlConvert.EncodeName(element);
var ret = new XElement(element);
if (input != null)
{
var type = input.GetType();
var props = type.GetProperties();
//.Where(p => p.GetIndexParameters().Length == 0);
var elements = from prop in props
let name = XmlConvert.EncodeName(prop.Name)
let val = prop.PropertyType.IsArray ? "array" : prop.GetValue(input, null)
let value = prop.PropertyType.IsArray ? GetArrayElement(prop, (Array)prop.GetValue(input, null)) : (prop.PropertyType.IsSimpleType() ? new XElement(name, val) : val.ToXml(name))
where value != null
select value;
ret.Add(elements);
}
return(ret);
}
catch (Exception ex)
{
throw ex;
}
}
public string AddImage(string filePath, string imageId)
{
if (this.PartType != XmlParts.RibbonX12 && this.PartType != XmlParts.RibbonX14)
{
return(null);
}
if (filePath == null)
{
throw new ArgumentNullException(nameof(filePath));
}
if (filePath.Length == 0)
{
return(null);
}
var fileName = Path.GetFileNameWithoutExtension(filePath);
if (imageId == null)
{
imageId = XmlConvert.EncodeName(fileName);
}
if (imageId == null)
{
throw new ArgumentNullException(nameof(imageId));
}
if (imageId.Length == 0)
{
throw new ArgumentException(StringsResource.idsNonEmptyId);
}
if (this.Part.RelationshipExists(imageId))
{
imageId = "rId";
}
return(this.AddImageHelper(filePath, imageId));
}
