/// <summary>
        ///		Carga las entradas de un nodo
        /// </summary>
        private EntryModelCollection LoadEntries(MLNode rootML)
        {
            EntryModelCollection entries = new EntryModelCollection();

            // Carga las entradas
            foreach (MLNode nodeML in rootML.Nodes)
            {
                if (nodeML.Name == TagConference)
                {
                    EntryModel entry = new EntryModel();

                    // Asigna las propiedades
                    entry.Id          = nodeML.Attributes[TagId].Value;
                    entry.Title       = nodeML.Nodes[TagName].Value;
                    entry.Summary     = nodeML.Nodes[TagDescription].Value;
                    entry.Authors     = nodeML.Nodes[TagAuthors].Value;
                    entry.UrlImage    = nodeML.Nodes[TagThumb].Value;
                    entry.UrlVideo    = nodeML.Nodes[TagVideo].Value;
                    entry.UrlWebSite  = nodeML.Nodes[TagWebSite].Value;
                    entry.UrlSlides   = nodeML.Nodes[TagSlides].Value;
                    entry.PublishedAt = nodeML.Nodes[TagPublishedAt].Value.GetDateTime(DateTime.Now);
                    entry.CreatedAt   = nodeML.Nodes[TagCreatedAt].Value.GetDateTime(DateTime.Now);
                    // Añade la entrada
                    entries.Add(entry);
                }
            }
            // Devuelve la colección
            return(entries);
        }
        /// <summary>
        ///		Carga las entradas de una categoría
        /// </summary>
        internal EntryModelCollection LoadCategoryEntries(string xml)
        {
            EntryModelCollection entries = new EntryModelCollection();
            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 nodeML in rootML.Nodes)
                        {
                            if (nodeML.Name == TagConference)
                            {
                                EntryModel entry = LoadEntry(nodeML);

                                // Añade el artículo a la colección
                                if (!entry.Title.IsEmpty())
                                {
                                    entries.Add(entry);
                                }
                            }
                        }
                    }
                }
            }
            // Devuelve la colección de artículos
            return(entries);
        }
        /// <summary>
        ///		Importa un archivo de entradas
        /// </summary>
        private void ImportEntries()
        {
            string fileName = DevConferencesViewModel.Instance.DialogsController.OpenDialogLoad(null, "Archivos XML (*.xml)|*.xml|Todos los archivos (*.*)|*.*");

            // Importa las entradas
            if (!string.IsNullOrWhiteSpace(fileName) && System.IO.File.Exists(fileName))
            {
                CategoryModel category = (SelectedNode?.Tag as CategoryModel);

                if (category == null)
                {
                    DevConferencesViewModel.Instance.ControllerWindow.ShowMessage("Seleccione una categoría");
                }
                else
                {
                    EntryModelCollection entries = DevConferencesViewModel.Instance.TrackManager.LoadExchangeFileEntries(fileName);

                    // Actualiza el autor con el nombre de la categoría
                    foreach (EntryModel entry in entries)
                    {
                        if (string.IsNullOrWhiteSpace(entry.Authors))
                        {
                            entry.Authors = category.Title;
                        }
                    }
                    // Elimina las entradas que ya estén en la categoría
                    for (int index = entries.Count - 1; index >= 0; index--)
                    {
                        if (category.Entries.SearchByUrlVideo(entries[index].UrlVideo) != null)
                        {
                            entries.RemoveAt(index);
                        }
                    }
                    // Añade las entradas y graba el proyecto
                    if (entries.Count > 0)
                    {
                        category.Entries.AddRange(entries);
                        UpdateTracks();
                    }
                }
            }
        }
        /// <summary>
        ///		Obtiene las últimas entradas de la web
        /// </summary>
        private EntryModelCollection GetLastEntries(TrackModel track)
        {
            EntryModelCollection entries = new EntryModelCollection();

            // Busca las entradas de todas las categorías
            foreach (CategoryModel category in track.Categories)
            {
                foreach (EntryModel entry in category.Entries)
                {
                    entries.Add(entry);
                }
            }
            // Ordena por fecha de creación descendente
            entries.Sort((first, second) => - 1 * first.CreatedAt.CompareTo(second.CreatedAt));
            // Obtiene sólo las primeras n entradas
            while (entries.Count > EntriesRssNumber)
            {
                entries.RemoveAt(entries.Count - 1);
            }
            // Devuelve la colección de entradas
            return(entries);
        }
        /// <summary>
        ///		Procesa el canal
        /// </summary>
        private void ProcessTrack(TrackManagerModel trackManager, TrackModel track)
        {
            EntryModelCollection lastEntries = GetLastEntries(track);
            TrackModel           trackCloned = track.Clone();

            // Crea el directorio de destino
            LibCommonHelper.Files.HelperFiles.MakePath(trackManager.Path);
            // Borra las entradas que no estén entre las últimas
            foreach (CategoryModel category in trackCloned.Categories)
            {
                for (int index = category.Entries.Count - 1; index >= 0; index--)
                {
                    if (lastEntries.FirstOrDefault(item => item.Id.EqualsIgnoreCase(category.Entries[index].Id)) == null)
                    {
                        category.Entries.RemoveAt(index);
                    }
                }
            }
            // Graba las entradas
            LibCommonHelper.Files.HelperFiles.SaveTextFile(System.IO.Path.Combine(trackManager.Path, GetLocalFileName(track)),
                                                           new DevConference.Application.FeedsManager().GetEntriesXml(trackCloned));
        }
Esempio n. 6
0
        /// <summary>
        ///		Carga las entradas de un archivo
        /// </summary>
        internal EntryModelCollection Load(string fileName)
        {
            EntryModelCollection entries = new EntryModelCollection();
            MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);

            // Carga las entradas
            if (fileML != null)
            {
                foreach (MLNode rootML in fileML.Nodes)
                {
                    if (rootML.Name == TagRoot)
                    {
                        foreach (MLNode nodeML in rootML.Nodes)
                        {
                            if (nodeML.Name == TagEntry)
                            {
                                EntryModel entry = new EntryModel();

                                // Carga los datos
                                entry.PublishedAt = nodeML.Attributes[TagPublish].Value.GetDateTime(DateTime.Now);
                                entry.Title       = nodeML.Nodes[TagTitle].Value;
                                entry.UrlVideo    = nodeML.Nodes[TagUrl].Value;
                                entry.Summary     = nodeML.Nodes[TagSummary].Value;
                                entry.Authors     = nodeML.Nodes[TagAuthor].Value;
                                // Añade la entrada a la colección
                                if (!string.IsNullOrWhiteSpace(entry.UrlVideo))
                                {
                                    entries.Add(entry);
                                }
                            }
                        }
                    }
                }
            }
            // Devuelve los objetos
            return(entries);
        }
        /// <summary>
        ///		Obtiene los nodos de las entradas
        /// </summary>
        private MLNodesCollection GetEntriesNodes(EntryModelCollection entries)
        {
            MLNodesCollection nodesML = new MLNodesCollection();

            // Crea los nodos
            foreach (EntryModel entry in entries)
            {
                MLNode nodeML = nodesML.Add(TagConference);

                // Asigna las propiedades
                nodeML.Attributes.Add(TagId, entry.Id);
                nodeML.Nodes.Add(TagName, entry.Title);
                nodeML.Nodes.Add(TagDescription, entry.Summary);
                nodeML.Nodes.Add(TagAuthors, entry.Authors);
                nodeML.Nodes.Add(TagThumb, entry.UrlImage);
                nodeML.Nodes.Add(TagVideo, entry.UrlVideo);
                nodeML.Nodes.Add(TagWebSite, entry.UrlWebSite);
                nodeML.Nodes.Add(TagSlides, entry.UrlSlides);
                nodeML.Nodes.Add(TagPublishedAt, entry.PublishedAt);
                nodeML.Nodes.Add(TagCreatedAt, entry.CreatedAt);
            }
            // Devuelve la colección
            return(nodesML);
        }