static void Main(string[] args)
{
DisplayBanner();
if (args.Length < 1)
{
DisplayHelp();
return;
}
IIocContainer iocContainer = InitializeIocContainer();
ReadOnlyControlFile control = new ReadOnlyControlFile(args[0]);
IFinder finder = iocContainer.Resolve <IFinder>();
ICopier copier = iocContainer.Resolve <ICopier>();
IUnwantedFileRemover remover = iocContainer.Resolve <IUnwantedFileRemover>();
IUnwantedFolderRemover folderRemover = iocContainer.Resolve <IUnwantedFolderRemover>();
IFileUtilities fileUtilities = iocContainer.Resolve <IFileUtilities>();
IPathUtilities pathUtilities = iocContainer.Resolve <IPathUtilities>();
IPlaylistFactory playlistFactory = iocContainer.Resolve <IPlaylistFactory>();
Generator generator = new Generator(finder, fileUtilities, pathUtilities, playlistFactory);
generator.StatusUpdate += new EventHandler <StatusUpdateEventArgs>(StatusUpdate);
Synchronizer synchronizer = new Synchronizer(finder, copier, remover, folderRemover);
synchronizer.StatusUpdate += new EventHandler <StatusUpdateEventArgs>(StatusUpdate);
synchronizer.Synchronize(control, false);
if (!string.IsNullOrEmpty(control.GetPlaylistFileName()))
{
generator.GeneratePlaylist(control, true);
}
}
public void AddFactory(IPlaylistFactory factory)
{
factories.Add(factory);
// register factory command node
var playCommand = new PlayCommand(factory.FactoryFor);
CommandNode.AddCommand(factory.SubCommandName, playCommand.Command);
}
public void AddListFactory(IPlaylistFactory factory, CommandManager cmdMgr)
{
listFactories.Add(factory);
// register factory command node
var playCommand = new PlayCommand(factory.FactoryFor, cmdListPrepath + factory.SubCommandName);
cmdMgr.RegisterCommand(playCommand.Command);
}
public PlayListCommand(IPlaylistFactory factory, string cmdPath)
{
this.factory = factory;
var builder = new CommandBuildInfo(
this,
Method,
new CommandAttribute(cmdPath));
Command = new BotCommand(builder);
}
/// <summary>
/// create a playlist generator
/// </summary>
/// <param name="fileFinder">abstract access to the file system to find the files for the playlist</param>
/// <param name="fileUtilities">abstract file utilities</param>
/// <param name="pathUtilities">abstract path utilities</param>
/// <param name="playlistFactory">factpry to generate the correct playlist object depending upon the selected format</param>
public Generator(
IFinder fileFinder,
IFileUtilities fileUtilities,
IPathUtilities pathUtilities,
IPlaylistFactory playlistFactory)
{
FileFinder = fileFinder;
FileUtilities = fileUtilities;
PathUtilities = pathUtilities;
PlaylistFactory = playlistFactory;
}
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 PlaylistServices(IPlaylistRepository playlistRepository, IPlaylistFactory playlistFactory)
{
_playlistRepository = playlistRepository;
_playlistFactory = playlistFactory;
}
