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;
}
