using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Argotic.Common;
using Argotic.Syndication;
using SharpRss.Models;
using ToolQit;
using ToolQit.Logging;
namespace SharpRss.Services
{
///
/// Managing syndication feeds and categories.
///
public class SyndicationService
{
private readonly ILog _log;
public SyndicationService()
{
_log = LogManager.CreateLogger(typeof(SyndicationService));
_log.Information("Constructing SyndicationService...");
Task.Run(async () => await SetupTestCategoriesAndFeedsAsync());
}
public async Task> GetCategoriesAndSyndicationsAsync()
{
HashSet items = new HashSet();
items.UnionWith(await GetCategoriesAsync());
items.UnionWith(await GetUngroupedSyndicationsAsync());
return items;
}
public async Task CreateCategoryAsync(CategoryModel category) =>
await DbAccess.SetCategoryAsync(category);
public async Task> GetCategoriesAsync()
{
HashSet categories = await DbAccess.GetCategoriesAsync();
foreach (CategoryModel catModel in categories)
{
catModel.Syndications = await DbAccess.GetSyndicationsAsync(new[] { catModel.Id });
}
return categories;
}
private async void ForEachCategories(CategoryModel x) => x.Syndications = await DbAccess.GetSyndicationsAsync(new[] { x.Id });
public async Task AddSubscriptionAsync(string url, CategoryModel? category = null)
{
var syndication = SyndicationManager.CreateSyndication(url);
if (!syndication.Fetched)
{
_log.Warning("Failed to fetch syndication feed!");
return false;
}
if (category != null)
syndication.Category = category;
try
{
await DbAccess.SetSyndicationAsync(syndication);
}
catch (Exception e)
{
_log.Error(e,"Error adding syndication: {FeedUrl} to database!", url);
}
return true;
}
public async Task UpdateFeeds()
{
_log.Information("Fetching...");
var feeds = await GetSyndicationsAsync();
}
public async Task> GetSyndicationsAsync(string? categoryId = null) => await DbAccess.GetSyndicationsAsync(categoryId == null ? null : new[]{ categoryId });
public async Task> GetUngroupedSyndicationsAsync() => await DbAccess.GetSyndicationsAsync(new []{""});
public async Task> GetSyndicationItemsAsync(string feedId, string? groupId = null) => await GetSyndicationItemsFromSyndicationsAsync(new[] { feedId }, groupId);
public async Task> GetSyndicationItemsFromSyndicationsAsync(string[] feedIds, string? categoryId = null)
{
/*var items = await DbAccess.GetSyndicationItemsAsync(feedIds);
return items;*/
return new HashSet();
}
/*private static SyndicationModel FromResource(ISyndicationResource resource)
{
SyndicationModel model = new SyndicationModel();
switch (resource.Format)
{
case SyndicationContentFormat.Rss:
RssFeed rssFeed = (RssFeed)resource;
model.SyndicationType = rssFeed.Format.ToString();
model.Title = rssFeed.Channel.Title;
model.Description = rssFeed.Channel.Description;
model.Copyright = rssFeed.Channel.Copyright;
model.EncodedUrl = rssFeed.Channel.SelfLink.ToString();
model.ImageUrl = rssFeed.Channel.Image?.Url.ToString() ?? string.Empty;
model.Language = rssFeed.Channel.Language?.ToString();
break;
case SyndicationContentFormat.Atom:
AtomFeed atomFeed = (AtomFeed)resource;
break;
default:
_log.Information("Syndication implementation missing!");
break;
}
return model;
}*/
private GenericSyndicationFeed? CreateSyndication(string url)
{
Uri feedUri = new Uri(url);
_log.Verbose("Checking syndication: {FeedUrl}", feedUri.ToString());
if (!SyndicationDiscoveryUtility.UriExists(feedUri))
{
_log.Warning("Syndication: {FeedUri} does not exists!", feedUri.ToString());
return null;
}
_log.Verbose("Fetching syndication: {FeedUrl}", feedUri.ToString());
return GenericSyndicationFeed.Create(new Uri(url));
}
private async Task SetupTestCategoriesAndFeedsAsync()
{
_log.Information("Setting up test data...");
try
{
CategoryModel? newsCategory = await CreateCategoryAsync(new CategoryModel() { Name = "News", Icon = "