public static bool ParseUri(string uri, string last_modified, out IFeedParser parser)
{
// if no last_modified, put ""
try {
Request request = new Request(uri, last_modified);
if ( request.Status != HttpStatusCode.NotFound ) {
parser = Sniff(request);
try {
parser.Request = request;
} catch ( NullReferenceException e ) {
Globals.Exception(e);
return false;
}
} else {
parser = null;
return false;
}
return true;
} catch ( Exceptions.NotFound e ) {
Globals.Exception(e);
parser = null;
return false;
} catch ( Exceptions.NotUpdated e ) {
Globals.Exception(e);
parser = null;
return false;
}
}
public RefreshRssFeed(ILogger <RefreshRssFeed> logger, IHttpClientFactory clientFactory, IFeedParser feedParser,
IArticleRepository articleRepository)
{
_logger = logger;
_clientFactory = clientFactory;
_feedParser = feedParser;
_articleRepository = articleRepository;
}
public Feed(string name, string url, IFeedTransport feedTransport, IFeedParser feedParser, IChannel channel, FeedTypes feedType)
{
Chanel = channel;
ChanelId = channel.Id;
Name = name;
Url = url;
FeedType = feedType;
Init();
}
private IFeed CreateFeed(string url, string name, IFeedParser feedParser, FeedTypes rSS)
{
IList <Parameter> parameters = new List <Parameter>()
{
new NamedParameter("name", name),
new NamedParameter("chanel", this),
new NamedParameter("url", url),
new NamedParameter("feedTransport", _feedTransport),
new NamedParameter("feedParser", feedParser),
new NamedParameter("feedType", FeedTypes.RSS)
};
return(DIService.Container.Resolve <IFeed>(parameters));
}
public void Init()
{
_saveCommand = DIService.Container.Resolve <IFeedSaveCommand>();
_deleteCommand = DIService.Container.Resolve <IFeedDeleteCommand>();
if (FeedType == FeedTypes.ATOM)
{
_feedParser = DIService.Container.Resolve <IFeedAtomParser>();
}
else
{
_feedParser = DIService.Container.Resolve <IFeedRssParser>();
}
_feedTransport = DIService.Container.Resolve <IFeedTransport>();;
}
public FeedController(ILogger <FeedController> logger,
IRssFeedRepository rssFeedRepository,
IRefreshRssFeed refreshRssFeed,
IFeedParser feedParser,
IHttpClientFactory clientFactory,
SqliteDataContext context)
{
_logger = logger;
_rssFeedRepository = rssFeedRepository;
_refreshRssFeed = refreshRssFeed;
_feedParser = feedParser;
_clientFactory = clientFactory;
_context = context;
}
public FeedReader(IFeedParser feedParser, IWebPageDownloader webPageDownloader)
{
_feedParser = feedParser;
_webPageDownloader = webPageDownloader;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="feedParser">Feed parser</param>
/// <param name="storage"> Storage instance</param>
public FeedProvider(IFeedParser feedParser, DataStorage storage)
{
_parser = feedParser;
_storage = storage;
_client = new HttpClient();
}
public LoggedFeedParser(IFeedParser feedParser, ILog log)
{
_feedParser = feedParser;
_log = log;
}
public BaseProvider(IRSSFeed rSSFeed,
IFeedParser feedParser)
{
RSSFeed = rSSFeed;
Parser = feedParser;
}
public HeartSeekerWebServices(IFeedParser parser)
{
feedParser = parser;
}
public PodcastGeneratorFactory(IFeedGetter feedGetter, IFeedParser feedParser, IFeedGenerator feedGenerator)
{
_feedGetter = feedGetter;
_feedGenerator = feedGenerator;
_feedParser = feedParser;
}
public NewsFeedParseService()
{
feedSources = new List<FeedSource>();
defaultParser = new DefaultFeedParser();
}
public GetFeedCommand(IFeedParser feedParser, HttpMessageHandler httpMessageHandler)
{
_feedParser = feedParser;
_httpMessageHandler = httpMessageHandler;
}
private AmazonProvider(IRSSFeed rSSFeed,
IFeedParser feedParser)
: base(rSSFeed, feedParser)
{
}
public PodcastViewModel(IScreen hostScreen,
IPlayerModel player,
IEventAggregator eventAggregator,
IDialogService dialogService,
IFeedParser feedParser,
IChannelStore channelStore,
IPlaylistStore playlistStore)
: base(eventAggregator)
{
HostScreen = hostScreen;
Player = player;
DialogService = dialogService;
FeedParser = feedParser;
this.channelStore = channelStore;
this.playlistStore = playlistStore;
GetChannelsCommand = ReactiveCommand.CreateFromTask(async _ => await GetChannels());
GetChannelsCommand.IsExecuting.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => OnChannelsBusy(GetChannelsCommand.GetHashCode(), _));
PlayItemCommand = ReactiveCommand.CreateFromTask <IPlayable>(async _ => await OnPlayEpisode(_ as Episode));
// open url
OpenUrlDialogCommand = ReactiveCommand.CreateFromTask(async _ => await OpenUrlDialog());
OpenUrlDialogCommand.ThrownExceptions.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => LogAndNotify(NotificationType.Error, Messages.ERR_CHANNEL_LOAD));
// channels busy indicator
this.WhenAnyObservable(_ => _.ChannelsBusyList.CountChanged).DistinctUntilChanged()
.Subscribe(_ => IsChannelsBusy = _ > 0);
// episodes busy indicator
this.WhenAnyObservable(_ => _.EpisodesBusyList.CountChanged).DistinctUntilChanged()
.Subscribe(_ => IsEpisodesBusy = _ > 0);
OpenUrlCommand = ReactiveCommand.CreateFromTask <string>(async _ => await OnOpenUrl(_));
OpenUrlCommand.ThrownExceptions.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => LogAndNotify(NotificationType.Error, Messages.ERR_CHANNEL_LOAD));
// load channel
LoadChannelFromUrlCommand = ReactiveCommand.CreateFromTask <string>(LoadChannelFromUrlAsync);
OpenUrlCommand.IsExecuting.ObserveOn(RxApp.MainThreadScheduler).Subscribe(_ =>
{
OnChannelsBusy(OpenUrlCommand.GetHashCode(), _);
OnEpisodesBusy(OpenUrlCommand.GetHashCode(), _);
});
LoadChannelFromUrlCommand.ThrownExceptions.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => LogAndNotify(NotificationType.Error, Messages.ERR_CHANNEL_LOAD));
// delete channel
ConfirmDeleteChannelCommand = ReactiveCommand.CreateFromTask <Channel>(async _ => await ConfirmDelete(_));
DeleteChannelCommand = ReactiveCommand.CreateFromTask <Channel>(async _ => await DeleteChannel(_));
DeleteChannelCommand.ThrownExceptions.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => LogAndNotify(NotificationType.Error, Messages.ERR_CHANNEL_DELETE));
DeleteChannelCommand.IsExecuting.Subscribe(_ =>
{
OnChannelsBusy(DeleteChannelCommand.GetHashCode(), _);
OnEpisodesBusy(DeleteChannelCommand.GetHashCode(), _);
});
var existsSelectedChannel = this.WhenAny(vm => vm.SelectedChannel, _ => SelectedChannel != null);
this.WhenAnyValue(vm => vm.SelectedChannel).Select(_ => _ == null ? 0 : SelectedChannel.Id)
.ToProperty(this, _ => _.SelectedChannelId, out selectedChannelId);
RemoveFilterCommand = ReactiveCommand.Create <Unit>(_ => SelectedChannel = null, existsSelectedChannel);
MarkAllPlayedCommand = ReactiveCommand.CreateFromTask <Channel>(async _ => await MarkChannelPlayed(_));
CopyUrlCommand = ReactiveCommand.Create <Channel>(_ => Clipboard.SetText(_.Link));
var episodeSet = this.WhenAnyValue(_ => _.SelectedEpisode);
// detail
this.WhenAnyValue(vm => vm.SelectedChannel).NotNull().Cast <IDetailEntity>()
.Merge(episodeSet.Cast <IDetailEntity>())
.ToProperty(this, _ => _.CurrentDetailEntity, out currentDetailEntity);
this.WhenAnyValue(vm => vm.Player.LocateCurrent).NotNull()
.Subscribe(c => c.Subscribe(_ => LocatePageForCurrent()));
// episode list is loading
this.WhenAnyValue(_ => _.EpisodeList.IsLoading).SubscribeOn(RxApp.MainThreadScheduler)
.Subscribe(_ => OnEpisodesBusy(EpisodeList.GetHashCode(), _));
ScrollIntoView = ReactiveCommand.Create <int, int>(_ => _);
// playlist
AddToPlaylist = ReactiveCommand.CreateFromTask <Playlist>(async _ => await AddEpisodeToPlaylist(_));
// sort order
this.WhenAnyValue(_ => _.SelectedEpisodeSortOrder)
.Subscribe(_ => EpisodeOrderBy.OnNext(GetEpisodeSortOrder(_)));
ToggleSortDirectionCommand =
ReactiveCommand.Create(
() => EpisodeOrderBy.OnNext(GetEpisodeSortOrder(SelectedEpisodeSortOrder, false)));
// on channels changed
this.WhenAnyValue(_ => _.Channels).NotNull().Subscribe(_ => OnChannelsChanged());
// update channels
var canUpdate = new BehaviorSubject <bool>(false);
UpdateChannelsCommand = ReactiveCommand.CreateFromTask(async _ => await UpdateChannelsAsync(),
canUpdate.DistinctUntilChanged());
UpdateChannelsCommand.IsExecuting.CombineLatest(this.WhenAnyValue(_ => _.Channels.IsEmpty),
(exec, empty) => !exec && !empty && IsUpdateEnabled).DistinctUntilChanged()
.Subscribe(_ => canUpdate.OnNext(_));
UpdateChannelsCommand.IsExecuting.ObserveOn(RxApp.MainThreadScheduler).Subscribe(_ => IsUpdating = _);
UpdateChannelsCommand.ThrownExceptions.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => LogAndNotify(NotificationType.Error, Messages.ERR_CHANNEL_UPDATE));
// init episodes
EpisodeList = InitEpisodeList();
EpisodeList.Changed.Subscribe(_ => InitActivePlaylist());
// detail
ToggleShowDetailCommand = ReactiveCommand.Create <bool, bool>(_ => _);
DeactivateCommand = ReactiveCommand.Create(() => { });
}
