public void Add(Member item)
{
//Tranforma un objeto a formato XML
XmlSerializer serializer = new XmlSerializer(item.GetType());
var memoryStream = new MemoryStream();
var strWriter = new StringWriterUtf8();
serializer.Serialize(strWriter, item);
var strXML = strWriter.ToString();
strWriter.Close();
try
{
MemoryStream ms = new MemoryStream(
System.Text.Encoding.UTF8.GetBytes(strXML));
//conexión a la base de datos
Session session = new Session("localhost", 1984, "admin", "admin");
//abre base de datos
session.Execute("check biblioteca");
//Agrega un miembro a la biblioteca
session.Add("members", ms);
session.Close();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
protected override async Task <string> CreateStructureAsync(IEnumerable <Sentence> sentences)
{
var header = new XDeclaration(version: "1.0", encoding: "utf-8", standalone: "yes");
var doc = new XDocument( // xml -> xsd, xmlsoap -> wsdl, xslt (transformata)
new XElement("text",
from sentence in sentences
select new XElement("sentence",
from word in sentence.Words
select new XElement("word", word)//SecurityElement.Escape(word).Replace("\'", "'"))
)));
var text = doc.ToString()
.Replace("&", "&amp;")
.Replace("<", "&lt;")
.Replace(">", "&gt;")
.Replace("\'", "&apos;")
.Replace("\"", "&quot;");
var xml = new StringWriterUtf8();
await xml.WriteAsync(header.ToString() + "\r\n" + text);
var ooo = xml.ToString();
return(await Task.FromResult(ooo));
}
public string Generate()
{
XNamespace ns = "http://www.sitemaps.org/schemas/sitemap/0.9";
XDocument doc = new XDocument(
new XDeclaration("1.0", "utf-8", null),
new XElement(ns + "sitemapindex", new XAttribute("xmlns", ns.NamespaceName))
);
foreach (var item in list)
{
var sm = new XElement(ns + "sitemap");
sm.Add(new XElement(ns + "loc", item.Url));
if (item.LastModified.HasValue)
{
sm.Add(new XElement(ns + "lastmod", item.LastModified.ToString()));
}
doc.Root.Add(sm);
}
StringBuilder builder = new StringBuilder();
using (TextWriter writer = new StringWriterUtf8(builder))
{
doc.Save(writer);
}
return(builder.ToString());
}
/// <summary>
/// Convertir Modelo Comprobante a string XML
/// </summary>
/// <param name="comprobante">Modelo Comprobante</param>
/// <returns>Cadena XML</returns>
private string ConvertirComprobanteString(Comprobante comprobante)
{
try
{
var xmlNameSpace = new XmlSerializerNamespaces();
xmlNameSpace.Add("cfdi", "http://www.sat.gob.mx/cfd/3");
xmlNameSpace.Add("tfd", "http://www.sat.gob.mx/TimbreFiscalDigital");
xmlNameSpace.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance");
if (comprobante.TipoDeComprobante == "P")
{
xmlNameSpace.Add("pago10", "http://www.sat.gob.mx/Pagos");
}
XmlSerializer oXmlSerializar = new XmlSerializer(typeof(Comprobante));
string sXml = string.Empty;
using (var sww = new StringWriterUtf8())
{
using (XmlWriter writter = XmlWriter.Create(sww))
{
oXmlSerializar.Serialize(writter, comprobante, xmlNameSpace);
sXml = sww.ToString();
}
}
return(!string.IsNullOrWhiteSpace(sXml) ? sXml : string.Empty);
}
catch (Exception ex)
{
return(string.Empty);
}
}
internal XmlDocument ToXmlDocument(object invoice)
{
Assembly assembly = Assembly.GetExecutingAssembly();
FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(assembly.Location);
string fversion = fvi.FileVersion;
IInvoiceBase invBase = (IInvoiceBase)invoice;
string genSystem = invBase.InvoiceSubtype.DocTypeNew + GetTfsString();// String.Format("DotNetApi für ebInterface V{0}", fversion);
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
// ns.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance");
foreach (var ebISchema in invBase.CurrentSchemas)
{
ns.Add(ebISchema.Prefix, ebISchema.Url);
}
XmlDocument xDoc = new XmlDocument();
// XmlSerializer serializer = new XmlSerializer(this.GetType(), null, Type.EmptyTypes, new XmlRootAttribute("InvoiceType"), "http://schemas.microsoft.com/2003/10/serialization/");
XmlSerializer serializer = new XmlSerializer(invoice.GetType());
using (StringWriterUtf8 stringWriter = new StringWriterUtf8())
{
XmlWriterSettings settings = new XmlWriterSettings
{
Encoding = Encoding.UTF8,
Indent = true,
IndentChars = "\t",
NewLineChars = Environment.NewLine,
//ConformanceLevel = ConformanceLevel.Document
};
using (XmlWriter writer = XmlWriter.Create(stringWriter, settings))
{
serializer.Serialize(writer, invoice, ns);
string xmlString = stringWriter.ToString();
xDoc.LoadXml(xmlString);
}
}
var nspUriSel = from si in invBase.CurrentSchemas where si.CacheName.EndsWith("Invoice.xsd") select si;
string NspUri = nspUriSel.FirstOrDefault().Url;
string prefix = nspUriSel.FirstOrDefault().Prefix;
XmlAttributeCollection attrColl = xDoc.DocumentElement.Attributes;
string genSysTag = (string.IsNullOrEmpty(prefix) ? "" : $"{prefix}:") + "GeneratingSystem";
if (attrColl.GetNamedItem("GeneratingSystem") != null)
{
attrColl.Remove(attrColl[genSysTag]);
}
XmlAttribute genSys = xDoc.CreateAttribute(prefix, "GeneratingSystem", NspUri);
genSys.Value = genSystem;
xDoc.DocumentElement.Attributes.Append(genSys);
return(RemoveEmptyNodes(xDoc));
}
public static string Convert(XDocument xmlDocument)
{
var builder = new StringBuilder();
using (TextWriter writer = new StringWriterUtf8(builder))
{
xmlDocument.Save(writer, SaveOptions.DisableFormatting);
return(builder.ToString());
}
}
public static string SerializeObject <T>(this T toSerialize)
{
var xmlSerializer = new XmlSerializer(toSerialize.GetType());
using (var textWriter = new StringWriterUtf8())
{
xmlSerializer.Serialize(textWriter, toSerialize);
return(textWriter.ToString());
}
}
public string Serialize <T>(T ObjectToSerialize)
{
XmlSerializer xmlSerializer = new XmlSerializer(ObjectToSerialize.GetType());
using (StringWriterUtf8 stringWriter = new StringWriterUtf8())
{
xmlSerializer.Serialize(stringWriter, ObjectToSerialize);
return(stringWriter.ToString());
}
}
public string GetXmlSitemap()
{
var activeLanguages = _languageRepository.GetActiveLanguages();
_isMultilingual = activeLanguages != null && activeLanguages.Count > 0;
_enabledLanguages = _isMultilingual ? activeLanguages.Select(al => al.CultureCode).ToList() : null;
var isSecureConnection = _httpContextAccessor.HttpContext.Request.IsHttps;
_requestHost = _httpContextAccessor.HttpContext.Request.Host.Host;
var scheme = isSecureConnection ? "https://" : "http://";
_protocolHost = scheme + _requestHost;
var publicPages = _navigation.GetPublicPages();
List <SitemapUrl> sitemapUrls = new List <SitemapUrl>();
if (publicPages != null && publicPages.Count > 0)
{
foreach (var page in publicPages)
{
sitemapUrls.Add(GetSitemapUrl(page));
}
}
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.Encoding = Encoding.UTF8;
using (var stringWriter = new StringWriterUtf8())
{
using (var writer = XmlWriter.Create(stringWriter, settings))
{
// build header
writer.WriteStartElement("urlset", "http://www.sitemaps.org/schemas/sitemap/" + SITEMAP_VERSION);
writer.WriteAttributeString("xmlns", "xsi", null, "http://www.w3.org/2001/XMLSchema-instance");
writer.WriteAttributeString("xmlns", "xhtml", null, "http://www.w3.org/1999/xhtml");
var schemaLocation = "http://www.sitemaps.org/schemas/sitemap/" + SITEMAP_VERSION;
writer.WriteAttributeString("xsi", "schemaLocation", null, string.Format("{0} {0}/sitemap.xsd", schemaLocation));
// write urls to output
foreach (SitemapUrl url in sitemapUrls)
{
AddURL(url, writer);
}
writer.WriteEndElement();
writer.Close();
}
return(stringWriter.ToString());
}
}
/// <inheritdoc />
public BaseMessage Serialize(T message)
{
var result = new TextMessage();
var writer = new StringWriterUtf8();
new XmlSerializer(typeof(T)).Serialize(writer, message);
var xml = writer.ToString();
ValidateXml(xml);
result.Body = xml;
return(result);
}
public static string Serialize <T>(T value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
var serializer = new System.Xml.Serialization.XmlSerializer(typeof(T));
using var stringWriter = new StringWriterUtf8();
serializer.Serialize(stringWriter, value, new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty }));
return(stringWriter.ToString());
}
private string SerializeToString(ParamsList list, bool includeReferenceNumber)
{
using (TextWriter writer = new StringWriterUtf8())
using (XmlWriter xmlWriter = XmlWriter.Create(writer, new XmlWriterSettings {
Indent = true, Encoding = Encoding.UTF8
}))
{
(includeReferenceNumber ? _serializerWithReferenceNumber : _serializer).Serialize(xmlWriter, list);
string xml = writer.ToString();
return(xml);
}
}
private static string GetSerializedAssembly(SerializableAssembly assembly)
{
var serializer = new XmlSerializer(typeof(SerializableAssembly));
var xmlns = new XmlSerializerNamespaces();
xmlns.Add("gml", "http://www.opengis.net/gml/3.2");
xmlns.Add("asm", "http://localhost/standaarden/assemblage");
var writer = new StringWriterUtf8();
serializer.Serialize(writer, assembly, xmlns);
return(writer.ToString());
}
public string SerializeData(T data)
{
XmlSerializer employeeSerializer = new XmlSerializer(typeof(T));
StringWriterUtf8 swWriter = new StringWriterUtf8(sbData);
// swWriter = new StringWriter(sbData);
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance");
ns.Add("sh", "urn:sfti:documents:StandardBusinessDocumentHeader");
employeeSerializer.Serialize(swWriter, data, ns);
return(sbData.ToString());
}
protected void SaveLevelButton_Click(object sender, EventArgs e)
{
int ySize = Convert.ToInt32(LevelYSizeTextBox.Text);
XMLToCSharp.Level level = new XMLToCSharp.Level();
level.Name = LevelNameTextBox.Text;
level.Blocks = new List<XMLToCSharp.Block>();
string[] lines = LevelDataTextBox.Text.Split(',');
for (int row = 0; row < lines.Length; row++)
{
for (var col = 0; col < lines[row].Length; col++)
{
int realY = ySize - row - 1;
switch (lines[row][col])
{
case '8':
level.Exit = new XMLToCSharp.Exit() { X = col, Y = realY };
break;
case '4':
level.Player = new XMLToCSharp.Player() { X = col, Y = realY };
break;
case '2':
level.Blocks.Add(new XMLToCSharp.Block() { Type = "Gem", X = col, Y = realY });
break;
case '1':
level.Blocks.Add(new XMLToCSharp.Block() { Type = "Ground", X = col, Y = realY });
break;
}
}
}
string resultingFile;
XmlSerializer serializer = new XmlSerializer(typeof(XMLToCSharp.Level));
using (StringWriterUtf8 textWriter = new StringWriterUtf8())
{
serializer.Serialize(textWriter, level);
resultingFile = textWriter.ToString();
}
SimplePlatformerEntities ents = new SimplePlatformerEntities();
ents.levels.Add(new levels() { name = level.Name, level = resultingFile });
ents.SaveChanges();
Response.Redirect("~/Default.aspx");
}
private string WriteXML(XmlDocument xdoc)
{
var xwsetting = new XmlWriterSettings
{
Indent = true,
NewLineChars = Environment.NewLine,
Encoding = Encoding.UTF8
};
StringWriterUtf8 sWrt = new StringWriterUtf8();
XmlWriter myXMLWriter = XmlWriter.Create(sWrt, xwsetting);
xdoc.Save(myXMLWriter);
myXMLWriter.Close();
// myXMLWriter.Flush();
string xmlStr = sWrt.ToString();
return(xmlStr);
}
/// <summary>
/// Settings to XML.
/// </summary>
///
/// <returns>
/// A String.
/// </returns>
public String SettingsToXml()
{
XmlSerializer ser = new XmlSerializer(Settings.GetType());
using (StringWriterUtf8 textWriter = new StringWriterUtf8())
{
//! Use DataContractSerializer or DataContractJsonSerializer?
// See https://msdn.microsoft.com/en-us/library/bb412170(v=vs.100).aspx
// See https://msdn.microsoft.com/en-us/library/bb924435(v=vs.110).aspx
// See https://msdn.microsoft.com/en-us/library/aa347875(v=vs.110).aspx
//
ser.Serialize(textWriter, Settings);
textWriter.Flush();
return(textWriter.ToString());
}
}
public static string ToStringUniform(this XmlDocument doc, Encoding encoding, bool indentation)
{
var sb = new StringBuilder();
using (var sw = new StringWriterUtf8(sb, encoding))
{
if (!indentation)
{
doc.Save(sw);
}
else
{
using (var xtw = new XmlTextWriter(sw)
{
Indentation = 4
})
{
doc.Save(xtw);
}
}
}
return(sb.ToString());
}
public override void Run()
{
HttpWebRequest request = null;
if (type == RequestTarget.Storage)
{
request = CreateRESTRequest(httpVerb, url, body, new SortedList<string, string>(headers));
}
else
{
request = CreateRequest();
}
if (request != null)
{
request.Timeout = 500000; // 500 seconds timeout in case of slow connections
}
HttpWebResponse response = null;
for (int retry = 0; retry < MaxRetries; retry++)
{
try
{
response = (HttpWebResponse)request.GetResponse();
break;
}
catch (WebException ex)
{
if (retry < (MaxRetries - 1)) // do not continue with the loop if will not be executed anyway. this will avoid the NPE
{
if (ShouldRetry(ex))
{
Thread.Sleep(1000);
continue;
}
}
response = (HttpWebResponse)ex.Response;
if (response == null)
{
Console.Error.Write(ex.Status.ToString());
return;
}
}
}
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
string result = reader.ReadToEnd();
XElement element = null;
if (!string.IsNullOrEmpty(result))
element = XElement.Parse(result);
XDocument document = CreateResponse(response, element);
document.Declaration = new XDeclaration("1.0", "utf-8", null);
StringBuilder output = new StringBuilder();
using (StringWriterUtf8 writer = new StringWriterUtf8(output))
{
document.Save(writer, SaveOptions.None);
}
Console.Write(output.ToString());
}
}
public static string GetAuthenticationCookie(string IdProviderUrl, string RP_Uri, string RP_Realm, string UserName, string Password, string Domain)
{
//-----------------------------------------------------------------------------
// Pass the Windows auth credential to the endpoint of the Identity Provider (ADFS)
//-----------------------------------------------------------------------------
var binding = new WS2007HttpBinding(SecurityMode.TransportWithMessageCredential);
binding.Security.Message.EstablishSecurityContext = false;
var endpoint = new EndpointAddress(IdProviderUrl + "/adfs/services/trust/13/windowsmixed");
RequestSecurityTokenResponse rstr;
using (var factory = new Microsoft.IdentityModel.Protocols.WSTrust.WSTrustChannelFactory(binding, endpoint))
{
factory.Credentials.Windows.ClientCredential =
new NetworkCredential(UserName, Password, Domain);
factory.TrustVersion = System.ServiceModel.Security.TrustVersion.WSTrust13;
var rst = new RequestSecurityToken();
rst.AppliesTo = new EndpointAddress(RP_Realm);
rst.KeyType = WSTrust13Constants.KeyTypes.Bearer;
rst.RequestType = WSTrust13Constants.RequestTypes.Issue;
var channel = (Microsoft.IdentityModel.Protocols.WSTrust.WSTrustChannel)factory.CreateChannel();
channel.Issue(rst, out rstr);
}
//-----------------------------------------------------------------------------
// Send the security token acquired from the Identity Provider (ADFS)
// to Replying Party (SharePoint)
// And acquire authorization cookie from SharePoint Server.
//-----------------------------------------------------------------------------
using (var output = new StringWriterUtf8(new StringBuilder()))
{
using (var xmlwr = XmlWriter.Create(output))
{
WSTrust13ResponseSerializer rs = new WSTrust13ResponseSerializer();
rs.WriteXml(rstr, xmlwr, new WSTrustSerializationContext());
}
var str = string.Format("wa=wsignin1.0&wctx={0}&wresult={1}",
HttpUtility.UrlEncode(RP_Uri + "/_layouts/15/Authenticate.aspx?Source=%2F"),
HttpUtility.UrlEncode(output.ToString()));
var req = (HttpWebRequest)HttpWebRequest.Create(RP_Uri + "/_trust/");
req.Method = "POST";
req.ContentType = "application/x-www-form-urlencoded";
req.CookieContainer = new CookieContainer();
req.AllowAutoRedirect = false;
using (var res = req.GetRequestStream())
{
byte[] postData = Encoding.UTF8.GetBytes(str);
res.Write(postData, 0, postData.Length);
}
using (var res = (HttpWebResponse)req.GetResponse())
{
return(res.Cookies["FedAuth"].Value);
}
}
}
/// <summary>
/// Odeslani SMS zpravy
/// </summary>
public static SendSmsResult SendSms(OutgoingSms sms, LoginInfo loginInfo)
{
if (sms == null)
{
throw new ArgumentNullException("message");
}
if (loginInfo == null)
{
throw new ArgumentNullException("loginInfo");
}
#region pozadavek
var doc = new XDocument();
var rootEl = new XElement("outgoing_message");
doc.Add(rootEl);
if (sms.RequireDeliveryReport.HasValue)
{
if (sms.RequireDeliveryReport == true)
{
rootEl.Add(new XElement("dr_request", "20"));
}
else
{
rootEl.Add(new XElement("dr_request", "0"));
}
}
rootEl.Add(new XElement("text", new XCData(sms.Text)));
rootEl.Add(new XElement("recipient", sms.Recipient));
if (sms.SendAt.HasValue)
{
rootEl.Add(new XElement("send_at", sms.SendAt.Value.ToString("yyyyMMddHHmmss")));
}
var sb = new StringBuilder();
using (var sw = new StringWriterUtf8(sb))
{
doc.Save(sw);
}
#endregion
string url = ApiXml20RecieverUrl
.Replace("[login]", HttpUtility.UrlEncodeUnicode(loginInfo.Login))
.Replace("[password]", HttpUtility.UrlEncodeUnicode(loginInfo.Password))
.Replace("[affiliate]", loginInfo.Affiliate);
// odeslani
string resultString = Communicator.CallUrl(url, sb.ToString(), "POST", "text/xml");
#region zpracovani odpovedi
var result = new SendSmsResult()
{
Status = SendSmsResultStatus.OK, StatusDescription = "OK"
};
result.Message = sms;
doc = XDocument.Parse(resultString);
// chyba
if (string.Equals(doc.Root.Name.LocalName, "messages", StringComparison.OrdinalIgnoreCase))
{
var messageEl = doc.Root.Elements("message").First();
result.Message.OutgoingSmsID = messageEl.Elements("id").FirstOrDefault().Value;
result.Message.Text = messageEl.Elements("text").FirstOrDefault().Value;
result.Message.SendAt = DateTime.ParseExact(messageEl.Elements("send_at").FirstOrDefault().Value, "yyyyMMddHHmmss", CultureInfo.InvariantCulture);
result.Message.Recipient = messageEl.Elements("recipient").FirstOrDefault().Value;
result.Parts = int.Parse(messageEl.Elements("parts").FirstOrDefault().Value);
result.Price = decimal.Parse(messageEl.Elements("price").FirstOrDefault().Value, CultureInfo.GetCultureInfo(2057));
result.Credit = decimal.Parse(doc.Root.Elements("credit").First().Value, CultureInfo.GetCultureInfo(2057));
}
else
{
result.StatusDescription = doc.Root.Elements("message").First().Value;
switch (doc.Root.Elements("id").First().Value)
{
case "400;1":
result.Status = SendSmsResultStatus.InvalidMsisdn;
break;
case "400;2":
result.Status = SendSmsResultStatus.InvalidText;
break;
case "400":
result.Status = SendSmsResultStatus.InvalidAction;
break;
case "401":
result.Status = SendSmsResultStatus.InvalidLogin;
break;
case "402":
result.Status = SendSmsResultStatus.LowCredit;
break;
case "500":
result.Status = SendSmsResultStatus.GatewayError;
break;
default:
break;
}
}
#endregion
return(result);
}
/// <summary>
/// Convertir Modelo Comprobante a XML Reader
/// </summary>
/// <param name="comprobante">Modelo Comprobante</param>
/// <returns>Objeto XmlReader</returns>
private async Task <string> GenerarComprobanteXmlTemp(Comprobante comprobante)
{
string sXml;
string rutaXmlTemp;
try
{
var xmlNameSpace = new XmlSerializerNamespaces();
xmlNameSpace.Add("cfdi", "http://www.sat.gob.mx/cfd/3");
xmlNameSpace.Add("tfd", "http://www.sat.gob.mx/TimbreFiscalDigital");
xmlNameSpace.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance");
if (comprobante.TipoDeComprobante == "P")
{
xmlNameSpace.Add("pago10", "http://www.sat.gob.mx/Pagos");
}
var oXmlSerializar = new XmlSerializer(typeof(Comprobante));
using (var sww = new StringWriterUtf8())
{
using (XmlWriter writter = XmlWriter.Create(sww))
{
oXmlSerializar.Serialize(writter, comprobante, xmlNameSpace);
sXml = sww.ToString();
}
}
var carpeta = $@"Temp\";
var directorio = $@"{_facturaRutaTimbrado}\{carpeta}";
var archivo = $@"{_facturaRutaTimbrado}\{carpeta}{comprobante.Emisor.Rfc}_{comprobante.TipoDeComprobante}_{comprobante.Serie}_{comprobante.Folio}.xml";
if (!string.IsNullOrEmpty(sXml))
{
rutaXmlTemp = archivo;
}
else
{
return(string.Empty);
}
if (!Directory.Exists(directorio))
{
DirectoryInfo di = Directory.CreateDirectory(directorio);
}
using (StreamWriter outputFile = new StreamWriter(archivo, false, Encoding.UTF8))
{
await outputFile.WriteAsync(sXml);
}
if (File.Exists(archivo))
{
return(archivo);
}
else
{
return(string.Empty);
}
}
catch (Exception ex)
{
return(string.Empty);
}
}
private void fehlerBehandelnToolStripMenuItem_Click(object sender, EventArgs e)
{
// convert into opus XML and manage conversion errors
var mapping = GetDefaultMapping();
var html = File.ReadAllText(htmlFileName, Encoding.Default);
try {
AddTextToProtocol("Make XHTML");
// Make XHTML
var xhtmlDocument = new Texxtoor.BaseLibrary.Core.HtmlAgility.Pack.HtmlDocument();
xhtmlDocument.OptionOutputAsXhtml = true;
xhtmlDocument.OptionFixNestedTags = true;
xhtmlDocument.OptionOutputAsXml = true;
xhtmlDocument.LoadHtml(html);
var ms = new MemoryStream();
var tw = new XmlTextWriter(ms, Encoding.Default);
xhtmlDocument.Save(tw);
// change encoding, as our xslt module needs utf-8
var enc = Encoding.GetEncoding("iso-8859-1");
var text = enc.GetString(ms.ToArray());
var xhtml = Encoding.UTF8.GetString(Encoding.UTF8.GetBytes(text));
// convert to UTF-8 for XSLT parsing
var doc = System.Xml.Linq.XDocument.Parse(xhtml);
doc.Declaration.Encoding = "UTF-8";
var sb = new StringBuilder();
var targetDocWriter = new StringWriterUtf8(sb);
// replace entites with regular spaces, double call for weird &nbsp;'s
var leaves = from elm in doc.Descendants()
where !elm.Elements().Any()
select elm;
foreach (var leaf in leaves)
{
var v = HttpUtility.HtmlDecode(leaf.Value);
v = HttpUtility.HtmlDecode(v);
if (v.Contains(((char)133).ToString()))
{
v = v.Replace(((char)133).ToString(), "...");
}
leaf.Value = v;
}
doc.Save(targetDocWriter);
xhtml = sb.ToString();
// transform
var xml = Html2XmlUtil.HtmlToOpusXsltParser(xhtml, mapping);
// TODO: check XML here
using (var xmlStream = new MemoryStream(Encoding.UTF8.GetBytes(xml))) {
using (var xmlReader = new XmlTextReader(xmlStream)) {
doc = XDocument.Load(xmlReader);
}
}
AddTextToProtocol("Fix XML");
// 1. Fix headers: <Element type="section" Name="1 Name">1 Name</Element> ===> Remove "1 "
var headers = doc.Descendants("Element").Where(elm => elm.Attribute("Type") != null && elm.Attribute("Type").Value == "Section");
foreach (var header in headers)
{
if (header.FirstNode.NodeType == XmlNodeType.Text)
{
var value = ((XText)header.FirstNode).Value.Trim();
var match = Regex.Match(value, @"^\d{1,3}(?:\.\d{1,3}){0,5}\s+(.*)");
if (match.Success)
{
((XText)header.FirstNode).Value = match.Groups[1].Value;
}
}
}
// 2. Fix bullet points <li>. Text</li> ===> Remove ". "
var bullets = doc.Descendants("li");
foreach (var bullet in bullets)
{
var match = Regex.Match(bullet.Value, @"[·]\s+(.*)");
if (match.Success)
{
bullet.Value = match.Groups[1].Value;
}
}
AddTextToProtocol("Embed Images");
// 3. Embed images (Element Type="Image")
var images = doc.Descendants("Element").Where(elm => elm.Attribute("Type") != null && elm.Attribute("Type").Value == "Image");
foreach (var image in images)
{
// try reading file
if (image.Attribute("Path") == null)
{
continue;
}
// we take PNG only, hence a conversion is appropriate
var path = Path.Combine(imgFolder, Path.GetFileName(image.Attribute("Path").Value));
if (!File.Exists(path))
{
continue;
}
var img = Image.FromFile(path);
using (var imgMs = new MemoryStream()) {
img.Save(imgMs, ImageFormat.Png);
var base64 = Convert.ToBase64String(imgMs.ToArray());
// apply as embedded base64
image.Add(new XAttribute("Method", "Base64"));
image.Value = base64;
}
}
sb.Clear();
targetDocWriter = new StringWriterUtf8(sb);
doc.Save(targetDocWriter);
xml = sb.ToString();
// TODO: if XML is okay store on disc for further processing
var xmlFileName = Path.Combine(Path.GetDirectoryName(htmlFileName) ?? String.Empty, String.Format("{0}.xml", Path.GetFileNameWithoutExtension(htmlFileName)));
if (File.Exists(xmlFileName))
{
AddTextToProtocol("XML exists, deleting ");
File.Delete(xmlFileName);
AddTextToProtocol("XML deleted ");
}
AddTextToProtocol("Attempt to write XML");
File.WriteAllText(xmlFileName, xml, Encoding.UTF8);
AddTextToProtocol("XML written to disc at {0}", xmlFileName);
} catch (Exception ex) {
AddTextToProtocol("** Fehler beim Konvertieren in Texxtoor-XML: {0}", ex.Message);
}
}
