public SimplePlaylist( uint id, uint?parentId, string name, ITracksRepository tracksRepository, IEnumerable <uint> ids = null) : base(id, parentId, name) { this.Name = name?.Trim() ?? throw new ArgumentNullException(nameof(name)); this._tracksRepository = tracksRepository ?? throw new ArgumentNullException(nameof(tracksRepository)); this.ParentId = parentId; this._trackIdsSourceCache = new SourceCache <uint, uint>(x => x).DisposeWith(this._disposables); if (ids != null) { this._trackIdsSourceCache.Edit(updater => updater.AddOrUpdate(ids)); } this.TrackIds = this._trackIdsSourceCache.Connect(); //this._tracksRepository.TracksRemoved.Subscribe( // removedTracks => // { // this._trackIdsSourceCache.Edit( // updater => // { // updater.RemoveKeys(removedTracks.Select(track => track.Id)); // }); // }) // .DisposeWith(this._disposables); }
public PlaylistBase ToFolderPlaylist( Func <uint> newPlaylistIdGenerator, uint?parentPlaylistId, ITracksRepository tracksRepository, IEnumerable <iTunesPlaylist> iTunesPlaylists, IReadOnlyDictionary <uint, Track> tracksMapper) { PlaylistBase playlist = null; try { var playlistId = newPlaylistIdGenerator.Invoke(); var playlists = iTunesPlaylists == null ? ImmutableList <PlaylistBase> .Empty : iTunesPlaylists .Where(x => x.Parent_Persistent_ID == this.Playlist_Persistent_ID) .Select(x => x.ToPlaylist(newPlaylistIdGenerator, playlistId, tracksRepository, iTunesPlaylists, tracksMapper)) .RemoveNulls() .ToImmutableList(); playlist = new FolderPlaylist( playlistId, // library entry parentPlaylistId, this.Name, playlists); } catch //(Exception ex) { playlist = null; } return(playlist); }
public TracksUpdater(ITracksRepository tracksRepository, ITracksProvider tracksProvider, IBackgroundTracksLoadingList backgroundTracksLoadingList, ILogger <TracksUpdater> logger) { _tracksRepository = tracksRepository; _tracksProvider = tracksProvider; _backgroundTracksLoadingList = backgroundTracksLoadingList; _logger = logger; }
public TracksService( ITracksRepository tracksRepository, CoreUnitOfWork unitOfWork) { this.tracksRepository = tracksRepository; this.unitOfWork = unitOfWork; }
// TODO: handle AC/DC splitting //private readonly Hashtable<IReadOnlyList<string>, string> public PlaylistBase ToSimplePlaylist( Func <uint> newPlaylistIdGenerator, uint?parentPlaylistId, ITracksRepository tracksRepository, IReadOnlyDictionary <uint, Track> tracksMapper) { PlaylistBase playlist = null; try { playlist = new SimplePlaylist( newPlaylistIdGenerator.Invoke(), // library entry parentPlaylistId, this.Name, tracksRepository, tracksMapper == null || this.Playlist_Items == null ? ImmutableList <uint> .Empty : this.Playlist_Items.Select(x => tracksMapper[x].Id).ToImmutableList()); } catch //(Exception ex) { playlist = null; } return(playlist); }
public FakePlaylistsRepository(ITracksRepository tracksRepository) { this._tracksRepository = tracksRepository ?? throw new ArgumentNullException(nameof(tracksRepository)); this._playlistsCache = new ConcurrentDictionary <uint, PlaylistBase>( new PlaylistBase[] { } .ToDictionary(t => t.Id, t => t)); }
public LocalLibraryService( ITracksRepository tracksRepository, ITrackFactory trackFactory, IPlaylistsRepository playlistsRepository, IPlaylistFactory playlistFactory) { this._tracksRepository = tracksRepository ?? throw new ArgumentNullException(nameof(tracksRepository)); this._trackFactory = trackFactory ?? throw new ArgumentNullException(nameof(trackFactory)); this._playlistsRepository = playlistsRepository ?? throw new ArgumentNullException(nameof(playlistsRepository)); this._playlistFactory = playlistFactory ?? throw new ArgumentNullException(nameof(playlistFactory)); this._playlistBaseChangesSubscription = new SerialDisposable().DisposeWith(this._disposables); this._tracksChangesSubscription = new SerialDisposable().DisposeWith(this._disposables); this.TracksChanges = ObservableChangeSet.Create <Track, uint>( async cache => { var items = await this._tracksRepository.GetAllAsync(); cache.AddOrUpdate(items); //return new CompositeDisposable( // //this._tracksRepository.TracksAddeded.Subscribe(addedItems => cache.Edit(cacheUpdater => cacheUpdater.AddOrUpdate(addedItems))), // //this._tracksRepository.TracksRemoved.Subscribe(addedItems => cache.Edit(cacheUpdater => cacheUpdater.Remove(addedItems))), // //this._tracksRepository.TracksUpdated.Subscribe(addedItems => cache.Edit(cacheUpdater => cacheUpdater.AddOrUpdate(addedItems))) // ); }, x => x.Id) // TODO: add synchronization to handle multiple subscriptions? .RefCount() //.Multicast(new ReplaySubject<IChangeSet<Track, uint>>()) //.AutoConnect(1, subscription => this._tracksChangesSubscription.Disposable = subscription) ; this.PlaylistsChanges = ObservableChangeSet.Create <PlaylistBase, uint>( async cache => { var items = await this._playlistsRepository.GetAllPlaylistsAsync(); cache.AddOrUpdate(items); //return new CompositeDisposable( //// this._playlistsRepository.Addeded.Subscribe(addedItems => cache.Edit(cacheUpdater => cacheUpdater.AddOrUpdate(addedItems))), //// this._playlistsRepository.Removed.Subscribe(addedItems => cache.Edit(cacheUpdater => cacheUpdater.Remove(addedItems))), //// this._playlistsRepository.Updated.Subscribe(addedItems => cache.Edit(cacheUpdater => cacheUpdater.AddOrUpdate(addedItems))) //); }, x => x.Id) .RefCount() //.Multicast(new ReplaySubject<IChangeSet<PlaylistBase, uint>>()) //.AutoConnect(1, subscription => this._playlistBaseChangesSubscription.Disposable = subscription) ; }
public LocalLibraryService( ITracksRepository tracksRepository, ITrackFactory trackFactory, IPlaylistsRepository playlistsRepository, IPlaylistFactory playlistFactory) { this._tracksRepository = tracksRepository ?? throw new ArgumentNullException(nameof(tracksRepository)); this._trackFactory = trackFactory ?? throw new ArgumentNullException(nameof(trackFactory)); this._playlistsRepository = playlistsRepository ?? throw new ArgumentNullException(nameof(playlistsRepository)); this._playlistFactory = playlistFactory ?? throw new ArgumentNullException(nameof(playlistFactory)); this.TracksChanges = ObservableChangeSet.Create <Track, uint>( async cache => { var items = await this.GetTracksAsync( //TimeSpan.FromSeconds(3) ); GC.Collect(); cache.AddOrUpdate(items); GC.Collect(); //return new CompositeDisposable( // this._tracksRepository.Addeded.Subscribe(addedItems => cache.Edit(cacheUpdater => cacheUpdater.AddOrUpdate(addedItems))), // this._tracksRepository.Removed.Subscribe(addedItems => cache.Edit(cacheUpdater => cacheUpdater.Remove(addedItems))), // this._tracksRepository.Updated.Subscribe(addedItems => cache.Edit(cacheUpdater => cacheUpdater.AddOrUpdate(addedItems)))); }, x => x.Id) // TODO: add synchronization to handle multiple subscriptions? .RefCount(); this.PlaylistsChanges = ObservableChangeSet.Create <PlaylistBase, uint>( async cache => { var items = await this._playlistsRepository.GetAllPlaylistsAsync(); cache.AddOrUpdate(items); //return new CompositeDisposable( // this._playlistsRepository.Addeded.Subscribe(addedItems => cache.Edit(cacheUpdater => cacheUpdater.AddOrUpdate(addedItems))), // this._playlistsRepository.Removed.Subscribe(addedItems => cache.Edit(cacheUpdater => cacheUpdater.Remove(addedItems))), // this._playlistsRepository.Updated.Subscribe(addedItems => cache.Edit(cacheUpdater => cacheUpdater.AddOrUpdate(addedItems)))); }, x => x.Id) .RefCount(); }
public PlaylistBase ToPlaylist( Func <uint> newPlaylistIdGenerator, uint?parentPlaylistId, ITracksRepository tracksRepository, IEnumerable <iTunesPlaylist> iTunesPlaylists, IReadOnlyDictionary <uint, Track> tracksMapper) { if (this.Folder) { return(this.ToFolderPlaylist(newPlaylistIdGenerator, parentPlaylistId, tracksRepository, iTunesPlaylists, tracksMapper)); } else //if (this.Smart_Criteria == null && this.Smart_Info == null) { return(this.ToSimplePlaylist(newPlaylistIdGenerator, parentPlaylistId, tracksRepository, tracksMapper)); } //return null; //else // throw new NotSupportedException(); }
public Playlist(ITracksRepository <T> tracksRepository) { _tracksRepository = tracksRepository; }
public HomeController(ITracksRepository tracks, IGlobalRacesRepository races) { Tracks = tracks; Races = races; }
public TracksController(ITracksRepository tracksRepository, IDistributedCache cache) { _tracksRepository = tracksRepository; _cache = cache; }
public CalendarController(ITracksRepository tracks) { _tracks = tracks; }
public TracksService(ITracksRepository tracksRepository) { _tracksRepository = tracksRepository; }
public TrackController(ITracksRepository tracksRepository) { _tracksRepository = tracksRepository; //tracksRepository = new TracksRepository(WebConfigurationManager.ConnectionStrings["TrackStoreEntities"].ConnectionString); }
public TracksProvider(ITracksSourcesRepository tracksSourceRepository, ITracksRepository tracksRepository, ICommonTracksGrabber grabber) { _tracksSourceRepository = tracksSourceRepository; _tracksRepository = tracksRepository; _grabber = grabber; }