/// <summary>
/// Interpreta los nodos de un elemento
/// </summary>
private RDFEntry ParseEntry(MLNode objMLEntry, RDFChannel channel)
{
RDFEntry entry = new RDFEntry();
// Interpreta los nodos
foreach (MLNode node in objMLEntry.Nodes)
{
switch (node.Name)
{
case RDFConstTags.cnstStrItemTitle:
entry.Title = node.Value;
break;
case RDFConstTags.cnstStrItemLink:
entry.Link = node.Value;
break;
case RDFConstTags.cnstStrItemDescription:
entry.Content = node.Value;
break;
case RDFConstTags.cnstStrItemDate:
entry.DateCreated = LibMarkupLanguage.Tools.DateTimeHelper.ParseRfc(node.Value, DateTime.Now);
break;
default:
entry.Extensions.Parse(node, entry, channel.Dictionary);
break;
}
}
// Devuelve la entrada
return(entry);
}
/// <summary>
/// Convierte un archivo RDF en un archivo Atom
/// </summary>
public AtomChannel Convert(RDFChannel rdf)
{
AtomChannel channel = new AtomChannel();
// Convierte los datos del canal
channel.ID = new Guid().ToString();
channel.Title = ConvertText(rdf.Title);
channel.Info = ConvertText(rdf.Description);
channel.Subtitle = ConvertText("");
channel.Links.Add(ConvertLink(rdf.Link, AtomLink.AtomLinkType.Self));
// Añade las extensiones
ConvertExtension(rdf.Extensions, channel.Extensions);
// Añade las entradas
ConvertEntries(rdf, channel);
// Devuelve el objeto Atom
return(channel);
}
/// <summary>
/// Obtiene el builder XML de un objeto RDF
/// </summary>
private MLFile GetFile(RDFChannel rdf)
{
MLFile file = new MLFile();
MLNode node = file.Nodes.Add(RDFConstTags.cnstStrRoot);
// Añade los atributos de la cabecera
node.NameSpaces.AddRange(rdf.Extensions.GetNameSpaces(rdf));
// Añade los datos del canal
node = node.Nodes.Add(RDFConstTags.cnstStrChannel);
// Obtiene el XML de los datos del canal
node.Nodes.Add(RDFConstTags.cnstStrChannelTitle, rdf.Title);
node.Nodes.Add(RDFConstTags.cnstStrChannelLink, rdf.Link);
node.Nodes.Add(RDFConstTags.cnstStrChannelDescription, rdf.Description);
// Obtiene el XML de las extensiones
rdf.Extensions.AddNodesExtension(node);
// Obtiene el XML de los elementos
AddItems(node, rdf.Entries);
// Devuelve los datos
return(file);
}
/// <summary>
/// Convierte las entradas RDF en entradas Atom
/// </summary>
private void ConvertEntries(RDFChannel rdf, AtomChannel channel)
{
foreach (RDFEntry rdfEntry in rdf.Entries)
{
AtomEntry channelEntry = new AtomEntry();
// Convierte los datos de la entrada
channelEntry.ID = rdfEntry.ID;
channelEntry.Title = ConvertText(rdfEntry.Title);
channelEntry.Content = ConvertText(rdfEntry.Content);
channelEntry.DateIssued = rdfEntry.DateCreated;
channelEntry.DateCreated = rdfEntry.DateCreated;
channelEntry.DateModified = rdfEntry.DateCreated;
channelEntry.DateUpdated = rdfEntry.DateCreated;
channelEntry.DatePublished = rdfEntry.DateCreated;
// Vínculos
channelEntry.Links.Add(ConvertLink(rdfEntry.Link, AtomLink.AtomLinkType.Self));
// Convierte las extensiones
ConvertExtension(rdfEntry.Extensions, channelEntry.Extensions);
// Añade la entrada al objeto Atom
channel.Entries.Add(channelEntry);
}
}
/// <summary>
/// Interpreta un archivo XML
/// </summary>
public RDFChannel Parse(MLFile fileML)
{
RDFChannel rdf = null;
// Carga los datos del archivo
if (fileML != null)
{
MLNode node = fileML.Nodes[RDFConstTags.cnstStrRoot];
// Carga los datos del canal
if (node != null && node.Name == RDFConstTags.cnstStrRoot)
{
// Crea el objeto
rdf = new RDFChannel();
// Lee los espacios de nombres de las extensiones
rdf.Dictionary.LoadNameSpaces(node);
// Lee los datos del canal
foreach (MLNode channel in node.Nodes)
{
if (channel.Name.Equals(RDFConstTags.cnstStrChannel))
{
ParseChannel(channel, rdf);
}
}
// Lee los elementos
foreach (MLNode item in node.Nodes)
{
if (item.Name.Equals(RDFConstTags.cnstStrItem))
{
rdf.Entries.Add(ParseEntry(item, rdf));
}
}
}
}
// Devuelve el objeto RDF
return(rdf);
}
/// <summary>
/// Interpreta los datos del canal
/// </summary>
private void ParseChannel(MLNode channel, RDFChannel rdf)
{
foreach (MLNode node in channel.Nodes)
{
switch (node.Name)
{
case RDFConstTags.cnstStrChannelTitle:
rdf.Title = node.Value;
break;
case RDFConstTags.cnstStrChannelDescription:
rdf.Description = node.Value;
break;
case RDFConstTags.cnstStrChannelLink:
rdf.Link = node.Value;
break;
default:
rdf.Extensions.Parse(node, rdf, rdf.Dictionary);
break;
}
}
}
/// <summary>
/// Graba los datos de un objeto RDF en un archivo XML
/// </summary>
public void Save(RDFChannel rdf, string fileName)
{
new XMLWriter().Save(fileName, GetFile(rdf));
}
/// <summary>
/// Obtiene el XML de un canal RDF
/// </summary>
public string GetXML(RDFChannel rdf)
{
return(GetFile(rdf).ToString());
}
