public Function3Worker(
ILoger <Function3Worker> logger,
IStreamBlobReader reader,
IFeedReader feedReader,
IQueue <ChannelUpdate> queue,
IBlobPathGenerator pathGenerator,
IBlobContainer blobContainer,
ISerializer serializer,
INewsWriter newsWriter,
IHashSum hasher)
{
Ensure.NotNull(logger, nameof(logger));
Ensure.NotNull(reader, nameof(reader));
Ensure.NotNull(feedReader, nameof(feedReader));
Ensure.NotNull(queue, nameof(queue));
Ensure.NotNull(pathGenerator, nameof(pathGenerator));
Ensure.NotNull(blobContainer, nameof(blobContainer));
Ensure.NotNull(serializer, nameof(serializer));
Ensure.NotNull(newsWriter, nameof(newsWriter));
this.logger = logger;
this.reader = reader;
this.feedReader = feedReader;
this.queue = queue;
this.pathGenerator = pathGenerator;
this.blobContainer = blobContainer;
this.serializer = serializer;
this.newsWriter = newsWriter;
this.hasher = hasher;
}
public RssDownloaderTests()
{
_feedReader = Substitute.For <IFeedReader>();
_articleReader = Substitute.For <IArticleReader>();
_repository = Substitute.For <ISyndicationItemRepository>();
_downloader = new RssDownloader(_feedReader, _articleReader, _repository);
}
public ResourceDownloader(newsaggregatorresourceContext databasecontext, IFeedReader reader, IEventBus eventBus, ILogger <ResourceDownloader> logger)
{
_databasecontext = databasecontext;
_reader = reader;
_eventHub = eventBus;
_logger = logger;
}
public FeedReaderService(IFeedReader reader, IFeedConverter converter, IFeedStore store, ILogger <FeedReaderService> logger)
{
_reader = reader;
_converter = converter;
_store = store;
_logger = logger;
}
/// <summary>
/// Gets the social media feed.
/// </summary>
/// <param name="feedFor">The feed for.</param>
/// <returns></returns>
public static IFeedReader GetSocialMediaFeed(FeedFor feedFor)
{
IFeedReader feedReader = null;
try
{
switch (feedFor)
{
case FeedFor.Facebook:
feedReader = new FacebookFeedReader();
break;
case FeedFor.Twitter:
feedReader = new TwitterFeedReader();
break;
case FeedFor.Pinterest:
feedReader = new PinterestFeedReader();
break;
case FeedFor.Instagram:
feedReader = new InstagramFeedReader();
break;
default:
break;
}
}
catch (Exception ex)
{
ex.ExceptionValueTracker(feedFor);
}
return(feedReader);
}
public FeedCrawlingJob(IRepository <FeedItem> feedItems, IUnitOfWork unitOfWork, IFeedReader feedReader,
IHtmlConverter htmlConverter, IRepository <Feed> feeds, ILanguageIdentifier languageIdentifier)
{
_feedItems = feedItems;
_unitOfWork = unitOfWork;
_feedReader = feedReader;
_htmlConverter = htmlConverter;
_feeds = feeds;
_languageIdentifier = languageIdentifier;
}
private async Task <SpotlightViewModel> InitializeAsync_(string url, IFeedReader <SpotlightItemRoot> reader)
{
if (reader == null)
{
reader = await SpotlightFeedReaderFactory.CreateSpotlightFeedReader(url);
}
m_reader = reader;
return(this);
}
public FeedCollection(IFeedReader xmlFeedReader)
{
XDocument xmlDocument = xmlFeedReader.GetFeed();
var channelElement = xmlDocument.Root.Element("channel");
var feedParser = new FeedParser();
foreach (var feed in channelElement.Descendants("item"))
{
this.Add(feedParser.Parse(feed));
}
}
public SynchronizeMediaFeedsCommandHandler(
IRepository repository,
IFeedReader feedReader,
ArticleFactory articleFactory,
ISynchronizationFinder synchronizationFinder,
ILogger logger)
{
_repository = repository;
_feedReader = feedReader;
_articleFactory = articleFactory;
_synchronizationFinder = synchronizationFinder;
_logger = logger;
}
public TestsBase(bool clearCache = false)
{
this.Container = DependencyInjection.Instance().Initialize();
this.AirportRepository = this.Container.Resolve <IAirportRepository>();
this.CountryRepository = this.Container.Resolve <ICountryRepository>();
this.CacheHandler = this.Container.Resolve <ICacheHandler>();
this.CacheStorage = this.Container.Resolve <ICacheStorage>();
this.FeedReader = this.Container.Resolve <IFeedReader>();
if (clearCache)
{
this.CacheStorage.ClearData();
}
}
public ScheduleTask(
IServiceScopeFactory serviceScopeFactory,
IMemoryCache memoryCache,
IScraperService scraperService,
ILogger <ScheduleTask> logger,
IOptions <FeedUrls> feedConfiguration,
IFeedReader feedReader,
ILogger <ScheduledProcessor> baseLogger) : base(serviceScopeFactory, baseLogger)
{
_cache = memoryCache;
_scraperService = scraperService;
_logger = logger;
_feedConfiguration = feedConfiguration;
_feedReader = feedReader;
_baseLogger = baseLogger;
}
public void CancelledImmediate()
{
var cts = new CancellationTokenSource();
cts.Cancel();
IFeedReader reader = GetDefaultReader();
int maxSongs = 60;
var settings = new BeastSaberFeedSettings((int)BeastSaberFeedName.Following)
{
MaxSongs = maxSongs
};
var result = reader.GetSongsFromFeed(settings, cts.Token);
Assert.IsFalse(result.Successful);
Assert.AreEqual(FeedResultError.Cancelled, result.ErrorCode);
cts.Dispose();
}
public async Task <Dictionary <string, ScrapedSong> > ReadFeed(IFeedReader reader, IFeedSettings settings, Playlist feedPlaylist, PlaylistStyle playlistStyle)
{
//Logger.log?.Info($"Getting songs from {feedName} feed.");
var songs = await reader.GetSongsFromFeedAsync(settings).ConfigureAwait(false) ?? new Dictionary <string, ScrapedSong>();
if (songs.Count > 0 && playlistStyle == PlaylistStyle.Replace)
{
feedPlaylist.Clear();
}
var addDate = DateTime.Now;
var decrement = new TimeSpan(1);
foreach (var scrapedSong in songs)
{
if (HistoryManager.TryGetValue(scrapedSong.Value.Hash, out var historyEntry) &&
(historyEntry.Flag == HistoryFlag.NotFound ||
historyEntry.Flag == HistoryFlag.Deleted))
{
continue;
}
//if (string.IsNullOrEmpty(scrapedSong.Value.SongKey))
//{
// try
// {
// //Logger.log?.Info($"Grabbing key from BeatSaver: {scrapedSong.Value.SongName} by {scrapedSong.Value.MapperName}");
// // ScrapedSong doesn't have a Beat Saver key associated with it, probably scraped from ScoreSaber
// scrapedSong.Value.UpdateFrom(await BeatSaverReader.GetSongByHashAsync(scrapedSong.Key), false);
// }
// catch (ArgumentNullException)
// {
// Logger.log?.Warn($"Unable to find {scrapedSong.Value?.SongName} by {scrapedSong.Value?.MapperName} on Beat Saver ({scrapedSong.Key})");
// }
//}
var song = scrapedSong.Value.ToPlaylistSong();
song.DateAdded = addDate;
feedPlaylist?.TryAdd(song);
addDate = addDate - decrement;
}
feedPlaylist?.TryWriteFile();
return(songs);
}
public FeedService(IJobRepository repository, IFeedReader feedReader)
{
_repository = repository;
_feedReader = feedReader;
}
public void Init(IFeedReader feedReader = null)
{
this.FileFeedReader = feedReader != null ? feedReader : DependencyInjection.Instance().Container.Resolve <IFeedReader>("LocalFileFeedReader");
}
/// <summary>
/// Create an instance of this object with a url and reader provided,
/// and initialize it asynchronously.
/// </summary>
/// <param name="url"></param>
/// <param name="reader"></param>
/// <returns></returns>
public static Task <SpotlightViewModel> CreateAsync(string url, IFeedReader <SpotlightItemRoot> reader)
{
var vm = new SpotlightViewModel();
return(vm.InitializeAsync_(url, reader));
}
public RssDownloader(IFeedReader feedReader, IArticleReader articleReader, ISyndicationItemRepository itemRepository)
{
_feedReader = feedReader;
_articleReader = articleReader;
_itemRepository = itemRepository;
}
public AirportRepository(IFeedReader feedReader)
{
this.FeedReader = feedReader;
}
public ContentOperations()
{
ninjectKernel = new StandardKernel(new BLLNinjectConfig());
this.uow = ninjectKernel.Get <IUnitOfWork>();
this.fReader = ninjectKernel.Get <IFeedReader>();
}
public ReadController(IFeedReader reader, ISyndFeedStore syncStore, ILogger <ReadController> logger)
{
_reader = reader;
_syncStore = syncStore;
_logger = logger;
}
public FeedAnalizer(IFeedReader feedReader, IActionManipulation <Feed, T> action)
{
_feedReader = feedReader;
_action = action;
}
/// <summary>
/// Overload for creating a SpotlightViewModel with a specific url and dependency
/// injected reader. Mostly for unit testing purposes.
/// </summary>
/// <param name="url"></param>
/// <returns></returns>
public static async Task <SpotlightViewModel> CreateSpotlightViewModel(string url, IFeedReader <SpotlightItemRoot> reader)
{
return(await SpotlightViewModel.CreateAsync(url, reader));
}
public GetResourcePropertiesHandler(IFeedReader networkClient)
{
_networkClient = networkClient;
}
