/// <summary>
/// Obtiene el XML de una colección de canales
/// </summary>
internal string GetXml(TrackModelCollection tracks)
{
MLFile fileML = new MLFile();
MLNode rootML = fileML.Nodes.Add(TagRoot);
// Obtiene los nodos del archivo
foreach (TrackModel track in tracks)
{
MLNode trackML = rootML.Nodes.Add(TagTrack);
// Añade las propiedades
trackML.Nodes.Add(TagName, track.Title);
trackML.Nodes.Add(TagDescription, track.Description);
trackML.Nodes.Add(TagUrl, track.Url);
trackML.Attributes.Add(TagEnabled, track.Enabled);
trackML.Attributes.Add(TagDateLastDownload, track.DateLastDownload);
// trackML.Attributes.Add(TagDateLastError, track.DateLastError);
// Añade los canales
foreach (CategoryModel category in track.Categories)
{
MLNode categoryML = trackML.Nodes.Add(TagCategory);
// Añade las propiedades
categoryML.Attributes.Add(TagId, category.Id);
categoryML.Attributes.Add(TagDeleted, category.IsDeleted);
categoryML.Nodes.Add(TagName, category.Title);
}
}
// Obtiene la cadena XML
return(new LibMarkupLanguage.Services.XML.XMLWriter().ConvertToString(fileML));
}
/// <summary>
/// Carga un archivo de canales
/// </summary>
public TrackModelCollection LoadTracks(string xml)
{
TrackModelCollection tracks = new TrackModelCollection();
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().ParseText(xml);
// Carga el archivo
if (fileML != null)
{
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == TagRoot)
{
foreach (MLNode trackML in rootML.Nodes)
{
if (trackML.Name == TagTrack)
{
TrackModel track = new TrackModel();
// Carga los datos
track.Title = trackML.Nodes[TagName].Value;
track.Description = trackML.Nodes[TagDescription].Value;
track.Url = trackML.Nodes[TagUrl].Value;
// Añade el canal al nodo
if (!track.Url.IsEmpty())
{
tracks.Add(track);
}
}
}
}
}
}
// Devuelve los canales
return(tracks);
}
/// <summary>
/// Carga una serie de canales de una cadena XML
/// </summary>
public TrackModelCollection LoadTracks(string xml)
{
TrackModelCollection tracks = new TrackModelCollection();
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().ParseText(xml);
// Carga los datos
if (fileML != null)
{
foreach (MLNode nodeML in fileML.Nodes)
{
if (nodeML.Name == TagRoot)
{
foreach (MLNode trackML in nodeML.Nodes)
{
if (trackML.Name == TagTrack)
{
TrackModel track = new TrackModel();
// Carga los datos de la carpeta
track.Title = trackML.Nodes[TagName].Value;
track.Description = trackML.Nodes[TagDescription].Value;
track.Url = trackML.Nodes[TagUrl].Value;
track.DateLastDownload = trackML.Attributes[TagDateLastDownload].Value.GetDateTime(DateTime.Now.AddDays(-2));
track.DateLastError = trackML.Attributes[TagDateLastError].Value.GetDateTime();
track.Enabled = trackML.Attributes[TagEnabled].Value.GetBool(true);
track.IsLoaded = false;
// Carga las categorías del canal
foreach (MLNode channelML in trackML.Nodes)
{
if (channelML.Name == TagCategory)
{
CategoryModel category = new CategoryModel(track);
// Carga los datos
category.Id = channelML.Attributes[TagId].Value;
category.IsDeleted = channelML.Attributes[TagDeleted].Value.GetBool();
category.Title = channelML.Nodes[TagName].Value;
// Añade el canal a la categoría
track.Categories.Add(category);
}
}
// Añade las categorías a la colección
if (!track.Url.IsEmpty())
{
tracks.Add(track);
}
}
}
}
}
}
// Devuelve las categorías
return(tracks);
}
/// <summary>
/// Obtiene el XML de un archivo de intercambio de canales
/// </summary>
internal string GetXml(TrackModelCollection tracks)
{
MLFile fileML = new MLFile();
MLNode rootML = fileML.Nodes.Add(TagRoot);
// Convierte los canales
foreach (TrackModel track in tracks)
{
MLNode nodeML = rootML.Nodes.Add(TagTrack);
// Añade los datos al nodo
nodeML.Nodes.Add(TagName, track.Title);
nodeML.Nodes.Add(TagDescription, track.Description);
nodeML.Nodes.Add(TagUrl, track.Url);
}
// Devuelve el XML
return(new LibMarkupLanguage.Services.XML.XMLWriter().ConvertToString(fileML));
}
/// <summary>
/// Obtiene los nodos de canales
/// </summary>
private MLNodesCollection GetTracksNodes(TrackModelCollection tracks)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Añade los canales
foreach (TrackModel track in tracks)
{
MLNode nodeML = nodesML.Add(TagTrack);
// Carga los datos
nodeML.Attributes.Add(TagId, track.Id);
nodeML.Nodes.Add(TagName, track.Title);
nodeML.Nodes.Add(TagUrl, track.Url);
// Añade las categorías
nodeML.Nodes.AddRange(GetCategoriesNodes(track.Categories));
}
// Devuelve la colección de nodos
return(nodesML);
}
/// <summary>
/// Carga los canales de un nodo
/// </summary>
private TrackModelCollection LoadTracks(MLNode rootML)
{
TrackModelCollection tracks = new TrackModelCollection();
// Carga los canales
foreach (MLNode nodeML in rootML.Nodes)
{
if (nodeML.Name == TagTrack)
{
TrackModel track = new TrackModel();
// Carga los datos
track.Id = nodeML.Attributes[TagId].Value;
track.Title = nodeML.Nodes[TagName].Value;
track.Url = nodeML.Nodes[TagUrl].Value;
// Carga las categorías
track.Categories.AddRange(LoadCategories(track, nodeML));
// Añade el canal
tracks.Add(track);
}
}
// Devuelve la colección de canales
return(tracks);
}
/// <summary>
/// Obtiene el XML de un archivo intercambio
/// </summary>
public string GetXmlExchangeFile(TrackModelCollection tracks)
{
return(new Repository.TrackExchangeRepository().GetXml(tracks));
}
/// <summary>
/// Obtiene el XML de una colección de canales
/// </summary>
public string GetTracksXml(TrackModelCollection tracks)
{
return(new Repository.TracksRepository().GetXml(tracks));
}
