/// <summary>
/// Modifica el estado de las entradas seleccionadas
/// </summary>
private void SetStatusEntries(BlogEntriesCollectionViewModel entries, EntryModel.StatusEntry idNewStatus)
{
BlogsModelCollection blogsUpdated = new BlogsModelCollection();
bool updated = false;
// Marca los elementos seleccionados como leídos
foreach (BlogEntryViewModel entry in entries)
{
if (CanChangeStatus(entry, idNewStatus))
{
// Cambia el estado
entry.Status = idNewStatus;
// Añade el blog
if (!blogsUpdated.Exists(entry.Entry.Blog.GlobalId))
{
blogsUpdated.Add(entry.Entry.Blog);
}
// Indica que se ha modificado
updated = true;
}
}
// Si realmente se ha marcado alguno ...
if (updated)
{
TreatUpdateEntries(blogsUpdated);
}
}
/// <summary>
/// Borra una serie de entradas
/// </summary>
private void DeleteEntries(BlogEntriesCollectionViewModel entriesForDelete)
{
if (entriesForDelete.Count > 0)
{
BlogsModelCollection blogsUpdated = new BlogsModelCollection();
bool deleted = false;
// Borra las entradas
foreach (BlogEntryViewModel entryViewModel in entriesForDelete)
{
// Añade el blog de la entrada
if (!blogsUpdated.Exists(entryViewModel.Entry.Blog.GlobalId))
{
blogsUpdated.Add(entryViewModel.Entry.Blog);
}
// Marca como borrado y añade el ID para borrarlo en la base de datos
entryViewModel.Entry.Status = EntryModel.StatusEntry.Deleted;
// Quita la entrada de la colección
Entries.Remove(entryViewModel);
// Elimina los archivos asociados
if (!string.IsNullOrEmpty(entryViewModel.Entry.DownloadFileName) &&
System.IO.File.Exists(entryViewModel.Entry.DownloadFileName))
{
LibCommonHelper.Files.HelperFiles.KillFile(System.IO.Path.Combine(BlogReaderViewModel.Instance.PathBlogs, entryViewModel.Entry.DownloadFileName));
}
// Indica que algo se ha borrado
deleted = true;
}
// Si realmente hay algo que borrar
if (deleted)
{
TreatUpdateEntries(blogsUpdated);
}
}
}
/// <summary>
/// Elimina los directorios de una serie de blogs
/// </summary>
private void KillPaths(BlogsModelCollection blogs)
{
foreach (BlogModel blog in blogs)
{
LibHelper.Files.HelperFiles.KillPath(System.IO.Path.Combine(MainViewModel.ConfigurationViewModel.PathBlogs, blog.Path));
}
}
/// <summary>
/// Elimina los directorios de una serie de blogs
/// </summary>
private void KillPaths(BlogsModelCollection blogs)
{
foreach (BlogModel blog in blogs)
{
LibCommonHelper.Files.HelperFiles.KillPath(System.IO.Path.Combine(BlogReaderViewModel.Instance.PathBlogs, blog.Path));
}
}
/// <summary>
/// Modifica el número de elementos no leídos
/// </summary>
public void UpdateNumberNotRead(BlogsModelCollection blogs)
{
foreach (BlogModel blog in blogs)
{
UpdateNumberNotRead(blog);
}
}
/// <summary>
/// Descarga los elementos
/// </summary>
private void DownloadItems()
{
if (Tree.SelectedNode is BaseNodeViewModel node && node != null)
{
BlogsModelCollection blogs = node.GetBlogs();
// Descarga los blogs
new Application.Services.Reader.RssDownload(BlogReaderViewModel.Instance.BlogManager).Download(true, blogs);
}
}
/// <summary>
/// Crea el ViewModel
/// </summary>
private BlogSeeNewsViewModel CreateViewModel(BaseNodeViewModel nodeViewModel)
{
BlogsModelCollection blogs = new BlogsModelCollection();
// Obtiene la colección de blogs
if (nodeViewModel != null)
{
blogs = nodeViewModel.GetBlogs();
}
// Devuelve el ViewModel
return(new BlogSeeNewsViewModel(blogs));
}
/// <summary>
/// Obtiene los blogs asociados
/// </summary>
public override BlogsModelCollection GetBlogs()
{
BlogsModelCollection blogs = new BlogsModelCollection();
// Añade el blog a la colección
if (Blog != null)
{
blogs.Add(Blog);
}
// Devuelve la colección de blogs
return(blogs);
}
/// <summary>
/// Obtiene los blogs asociados
/// </summary>
public override BlogsModelCollection GetBlogs()
{
BlogsModelCollection blogs = new BlogsModelCollection();
// Obtiene los blogs de la carpeta
if (Folder != null)
{
blogs = Folder.GetBlogsRecursive();
}
// Devuelve la colección de blogs
return(blogs);
}
/// <summary>
/// Trata la modificación de las entradas las entradas
/// </summary>
private void TreatUpdateEntries(BlogsModelCollection blogsUpdated)
{
// Graba las entradas de los blogs modificados
foreach (BlogModel blog in blogsUpdated)
{
new EntryBussiness().Save(blog, BlogReaderViewModel.Instance.BlogManager.Configuration.PathBlogs);
}
// Modifica el número de elementos no leídos
new BlogBussiness().UpdateNumberNotRead(blogsUpdated);
BlogReaderViewModel.Instance.BlogManager.Save();
// Cambia el estado del comando borrar
DeleteCommand.OnCanExecuteChanged();
// Actualiza el árbol
BlogReaderViewModel.Instance.SendMesageChangeStatus();
}
public BlogSeeNewsViewModel(BlogsModelCollection blogs)
{
// Inicializa la lista de blogs
Blogs = blogs;
// Inicializa las propiedades
PropertyChanged += (sender, args) =>
{
if (args != null && args.PropertyName.EqualsIgnoreCase(nameof(SelectedEntry)))
{
DeleteCommand.OnCanExecuteChanged();
}
IsUpdated = false;
};
// Inicializa el ViewModel
InitViewModel();
}
/// <summary>
/// Borra una carpeta
/// </summary>
private void DeleteFolder(FolderModel folder)
{
if (folder != null && MainViewModel.ViewsController.SystemController.ShowQuestion($"¿Realmente desea eliminar la carpeta '{folder.Name}'?"))
{
BlogsModelCollection blogs = folder.GetBlogsRecursive();
// Borra los directorios de los blogs
KillPaths(blogs);
// Borra la carpeta
MainViewModel.BlogManager.File.Delete(folder);
// Borra la carpeta
MainViewModel.BlogManager.Save();
// Actualiza
Refresh();
}
}
/// <summary>
/// Borra una carpeta
/// </summary>
private void DeleteFolder(FolderModel folder)
{
if (folder != null &&
BlogReaderViewModel.Instance.ControllerWindow.ShowQuestion($"¿Realmente desea eliminar la carpeta '{folder.Name}'?"))
{
BlogsModelCollection blogs = folder.GetBlogsRecursive();
// Borra los directorios de los blogs
KillPaths(blogs);
// Borra la carpeta
Folder.Delete(folder);
// Borra la carpeta
BlogReaderViewModel.Instance.BlogManager.Save();
// Actualiza
Refresh();
}
}
public BlogSeeNewsViewModel(BlogReaderViewModel mainViewModel, BlogsModelCollection blogs) : base(false)
{
// Asigna las propiedades
MainViewModel = mainViewModel;
Blogs = blogs;
// Inicializa el ViewModel
InitViewModel();
// Inicializa los comandos de página
FirstPageCommand = CreateCommandForPage(nameof(FirstPageCommand));
NextPageCommand = CreateCommandForPage(nameof(NextPageCommand));
PreviousPageCommand = CreateCommandForPage(nameof(PreviousPageCommand));
LastPageCommand = CreateCommandForPage(nameof(LastPageCommand));
// Inicializa los comandos del menú
MarkAsReadCommand = new BaseCommand(parameter => ExecuteAction(nameof(MarkAsReadCommand), parameter),
parameter => CanExecuteAction(nameof(MarkAsReadCommand), parameter));
MarkAsNotReadCommand = new BaseCommand(parameter => ExecuteAction(nameof(MarkAsNotReadCommand), parameter),
parameter => CanExecuteAction(nameof(MarkAsNotReadCommand), parameter));
MarkAsInterestingCommand = new BaseCommand(parameter => ExecuteAction(nameof(MarkAsInterestingCommand), parameter),
parameter => CanExecuteAction(nameof(MarkAsInterestingCommand), parameter));
ExportEntriesCommand = new BaseCommand(parameter => ExecuteAction(nameof(ExportEntriesCommand), parameter),
parameter => CanExecuteAction(nameof(ExportEntriesCommand), parameter));
PlayCommand = new BaseCommand(parameter => ExecuteAction(nameof(PlayCommand), parameter),
parameter => CanExecuteAction(nameof(PlayCommand), parameter))
.AddListener(this, nameof(SelectedEntry));
DeleteCommand = new BaseCommand(parameter => ExecuteAction(nameof(DeleteCommand), parameter),
parameter => CanExecuteAction(nameof(DeleteCommand), parameter))
.AddListener(this, nameof(SelectedEntry));
// Inicializa las propiedades
PropertyChanged += (sender, args) =>
{
if (args != null && args.PropertyName.EqualsIgnoreCase(nameof(SelectedEntry)))
{
DeleteCommand.OnCanExecuteChanged();
}
IsUpdated = false;
};
}
/// <summary>
/// Descarg los blogs
/// </summary>
private async System.Threading.Tasks.Task DownloadProcessAsync(bool includeDisabled, BlogsModelCollection blogs = null)
{
Procesor processor = new Procesor();
EntriesModelCollection entriesForDownload = new EntriesModelCollection();
// Lanza el evento de inicio
RaiseEvent(EventArguments.DownloadEventArgs.ActionType.StartDownload, "Comienzo del proceso de descarga");
// Crea la colección de blogs si estaba vacía
if (blogs == null)
{
blogs = _blogManager.File.GetBlogsRecursive();
}
// Descarga los blogs
foreach (BlogModel blog in blogs)
{
if (blog.Enabled || (includeDisabled && !blog.Enabled))
{
AtomChannel atom;
// Lanza el evento
RaiseEvent(EventArguments.DownloadEventArgs.ActionType.StartDownloadBlog, $"Comienzo de descarga de {blog.Name}");
// Descarga el archivo
try
{
// Descarga el archivo Atom / Rss
atom = await processor.DownloadAsync(blog.URL);
// Añade los mensajes
if (atom != null)
{
EntriesModelCollection downloaded = AddMessages(blog, atom);
if (downloaded.Count > 0 && blog.DownloadPodcast)
{
entriesForDownload.AddRange(downloaded);
}
}
// Modifica la fecha de última descarga
blog.DateLastDownload = DateTime.Now;
// Indica que en las entradas del blog se han hecho modificaciones (para el recálculo de elementos leídos)
blog.IsDirty = true;
// Lanza el evento
RaiseEvent(EventArguments.DownloadEventArgs.ActionType.EndDownloadBlog, $"Fin de descarga de {blog.Name}");
}
catch (Exception exception)
{
RaiseEvent(EventArguments.DownloadEventArgs.ActionType.ErrorDonwloadBlog, $"Error al descargar {blog.Name}. {exception.Message}");
}
}
}
// Graba los blogs
_blogManager.Save();
// Descarga los adjuntos
if (entriesForDownload.Count > 0)
{
await DownloadAttachmentsAsync(entriesForDownload);
}
// Lanza el evento de fin
RaiseEvent(EventArguments.DownloadEventArgs.ActionType.EndDownload, "Fin del proceso de descarga");
}
/// <summary>
/// Descarga los blogs
/// </summary>
public void Download(bool includeDisabled, BlogsModelCollection blogs = null)
{
System.Threading.Tasks.Task.Run(async() => await DownloadProcessAsync(includeDisabled, blogs));
}
