public CDAlbumDescriptorCreatorViewModel(AmbigueousCDInformationArgs cadi, IMusicSession session)
{
_CADI = cadi;
_Session = session;
_CDInfos.AddCollection(_CADI.CDInfos);
_Authours = new ObservableCollection<IArtist>();
_Authours.CollectionChanged += _Authours_CollectionChanged;
if (CDInfos.Count == 0)
{
Created = Default.GetEditable();
}
else if (CDInfos.Count == 1)
{
Created = CDInfos[0].FindItem.GetEditable();
}
_ArtistSearchableFactory = new ArtistSearchableFactory(_Session);
GenreFactory = FactoryBuilder.Instanciate((n) => _Session.GetGenreFactory().Create(n));
CommitCommand = RelayCommand.Instanciate(() => OnCommintCommand());
InternetFind = RelayCommand.InstanciateAsync(() => FindAdditionalInfoFromWebAsync());
iTunesFind = RelayCommand.InstanciateAsync(() => FindAdditionalInfoFromiTunesAsync());
}
public void TD()
{
Init();
var tr2 = TimeTracer.TimeTrack("Session Building");
using (tr2)
{
_MS = MusicSessionImpl.GetSession(_SK.Builder);
GC.Collect();
GC.WaitForFullGCComplete();
}
Assert.That(_MS.AllAlbums.Count, Is.EqualTo(0));
Assert.That(_MS.AllGenres.Count, Is.EqualTo(0));
Assert.That(_MS.AllArtists.Count, Is.EqualTo(0));
var tr = TimeTracer.TimeTrack("Load");
using (tr)
{
IMusicImporter imi = _MS.GetDBImporter();
Assert.That(imi, Is.Not.Null);
imi.Load();
}
GC.Collect();
GC.WaitForFullGCComplete();
}
public WebAlbumSelectorViewModel(IMusicSession ims, IModifiableAlbum imad, int iMaxResult=5)
{
_IModifiableAlbum = imad;
_IMS = ims;
_IsLoading = true;
_FoundSomething = true;
_MergeStategy = MergeStategy.OnlyCover;
var lookfor = imad.GetAlbumDescriptor();
IWebQuery wb = ims.WebQueryFactory.FromAlbumDescriptor(lookfor);
wb.NeedCoverArt = true;
wb.MaxResult = iMaxResult;
_OriginalAlbumName = lookfor.ToString();
_IInternetFinder = ims.GetInternetFinder(wb);
SelectCover = Register(RelayCommand.InstanciateAsync(()=>DoSelect(), () => SelectedInfos.Count>0));
Cancel = Register(RelayCommand.Instanciate(DoCancel, ()=>IsLoading));
Close = RelayCommand.Instanciate(DoClose);
//LoadResult().DoNotWaitSafe();
}
public void SetUp()
{
_wpfTester = new WPFTester();
_window = new Window();
_wpfTester.ShowWindow(_window);
Init();
_ISession = MusicSessionImpl.GetSession(_SK.Builder, new WPFHwndProvider(_window));
_Session = _ISession as MusicSessionImpl;
IMusicImporter imi = _ISession.GetDBImporter();
imi.Load();
IDirectoryImporterBuilder imib = _ISession.GetImporterBuilder(MusicImportType.Directory) as IDirectoryImporterBuilder;
Assert.That(imib, Is.Not.Null);
imib.Directory = DirectoryIn;
imib.DefaultAlbumMaturity = AlbumMaturity.Discover;
Assert.That(imib.IsValid, Is.True);
imi = imib.BuildImporter();
Assert.That(imi, Is.Not.Null);
imi.Load();
}
public MoveAlbumFileWindowViewModel(IMusicSession ims, IEnumerable<IAlbum> al)
{
_IMusicSession = ims;
AllAlbums = al;
Directory = _IMusicSession.Setting.MusicImporterExporter.PathMove;
_SelectedAlbums = new WrappedObservableCollection<IAlbum>();
_SelectedAlbums.CollectionChanged += inc_CollectionChanged;
Move = this.Register( RelayCommand.Instanciate(() => DoMove(), ()=>IsValid));
}
private MusicEntitiesEditorViewModel(IMusicSession session)
{
_IMS = session;
ArtistSearchableFactory = new ArtistSearchableFactory(session);
Genres = Register( _IMS.AllGenres.LiveOrderBy(global => global.FullName));
Commit = RelayCommand.Instanciate(DoCommit);
GenreFactory = FactoryBuilder.Instanciate((n) => session.GetGenreFactory().Create(n));
YearFactory = FactoryBuilder.Instanciate((n) => { int res = 0; int.TryParse(n, out res); return res; });
NameFactory = FactoryBuilder.Instanciate((n) => n);
}
internal SingleTrackUpdater(Track track, IMusicSession iContext):base(track.SingleItemCollection(), iContext)
{
_Tr = track;
if (_Tr == null)
throw new Exception("Track can not be null");
this._Artist = _Tr.Artist;
this._Name= _Tr.Name;
this._TN= _Tr.TrackNumber;
this._DiscNumber = _Tr.DiscNumber;
}
public Exporter(IMusicSession iSession, IEnumerable<IAlbum> iAlbums)
{
Session = iSession;
_session = Session.Setting.MusicImporterExporter;
Option = _session.LastExportType;
Directory = _session.OutputPath;
iPodExport = _session.SynchronizeBrokeniTunes;
_Albums = iAlbums.ToList();
_SelectedAlbums = new WrappedObservableCollection<IAlbum>();
_SelectedAlbums.CollectionChanged += SelectedAlbums_CollectionChanged;
OK = this.Register(RelayCommand.Instanciate(() => DoOK(), () => IsValid));
Cancel = RelayCommand.Instanciate(() => Window.Close());
}
public ImporterViewModel(IMusicSession iSession)
{
Continue = false;
_Session = iSession;
_IMusicSettings = _Session.Setting;
Option = _IMusicSettings.MusicImporterExporter.LastImportType;
UpdateBuilder();
OK = Register(RelayCommand.Instanciate(
Commit,
() => (Builder != null) && (Builder.IsValid)
));
}
public AlbumEditorViewModel(IMusicSession iMusicSession, IModifiableAlbum iModifiableAlbum)
{
_IModifiableAlbum = iModifiableAlbum;
_Session = iMusicSession;
ArtistSearchableFactory = new ArtistSearchableFactory(iMusicSession);
GenreFactory = FactoryBuilder.Instanciate((n) => iMusicSession.GetGenreFactory().Create(n));
Images = _IModifiableAlbum.Images;
SelectedImages = new WrappedObservableCollection<IAlbumPicture>();
if (Images.Count > 0)
SelectedImage = Images[0];
Images.CollectionChanged += Images_CollectionChanged;
SelectedTracks = new WrappedObservableCollection<IModifiableTrack>();
Authours = _IModifiableAlbum.Artists;
_Genre = iMusicSession.GetGenreFactory().Get(_IModifiableAlbum.Genre);
Genres = Register(iMusicSession.AllGenres.LiveOrderBy(global => global.FullName));
Tracks = new WrappedObservableCollection<IModifiableTrack>(_IModifiableAlbum.Tracks.
OrderBy(t => t.DiscNumber).ThenBy(t => t.TrackNumber).ThenBy(t => t.Name));
SetFrontCover = Register(RelayCommand.Instanciate<IAlbumPicture>(SetToFront, ial => (ial != null) && Images.IndexOf(ial) > 0));
ToLast = Register(RelayCommand.Instanciate<IAlbumPicture>(SetToLast, ial => (ial != null) && Images.IndexOf(ial) != Images.Count - 1));
SplitImage = Register(RelayCommand.Instanciate<IAlbumPicture>(DoSplitImage, ial => ial != null));
RotateImageRight = Register(RelayCommand.Instanciate<IAlbumPicture>((al)=>DoRotateImage(al,true), ial => ial != null));
RotateImageLeft = Register(RelayCommand.Instanciate<IAlbumPicture>((al) => DoRotateImage(al, false), ial => ial != null));
DeleteImage = Register(RelayCommand.Instanciate<IAlbumPicture>(DoDeleteImage, ial => ial != null));
ImageFromFile = RelayCommand.Instanciate(DoImageFromFile);
PasteImage = RelayCommand.InstanciateStatic(DoPasteImage, CanExecuteImage);
DeleteTrack = Register(RelayCommand.Instanciate<IModifiableTrack>(DoDeleteTrack, ial => ial != null));
WindowOpenTrack = Register(RelayCommand.Instanciate<IModifiableTrack>(DoWindowOpenTrack, ial => ial != null));
UpdateFromFileName = Register(RelayCommand.Instanciate<IModifiableTrack>(DoUpdateFromFileName, ial => ial != null));
RemoveTrackNumber= Register(RelayCommand.Instanciate<IModifiableTrack>(DoRemoveTrackNumber, ial => ial != null));
PreFixByArtistName = Register(RelayCommand.Instanciate<IModifiableTrack>(DoPreFixByArtistName, ial => ial != null));
ChangeDiscNumber = Register(RelayCommand.Instanciate<IModifiableTrack>(DoChangeDiscNumber, ial => ial != null));
FindFromDB = RelayCommand.Instanciate(DoFindFromInternet);
BrowseInternet = RelayCommand.Instanciate(FindOnInternet);
OK = RelayCommand.Instanciate(DoCommit);
}
protected void baseSetUp()
{
_IMusicSession = MusicSessionImpl.GetSession(_SK.Builder);
_IMusicSession.AllAlbums.Should().BeEmpty();
_IMusicSession.AllGenres.Should().BeEmpty();
_IMusicSession.AllArtists.Should().BeEmpty();
IMusicImporter imi = _IMusicSession.GetDBImporter();
_IMusicSession.Should().NotBeNull();
imi.Load();
Console.WriteLine("Importing Music Folder");
PostOpen(_IMusicSession);
}
public CenteredAlbumViewModel(IList<IAlbum> iAlbums, IMusicSession isession)
{
Albums = iAlbums;
AlbumDistanceComparerFactory adcf = new AlbumDistanceComparerFactory(isession);
_OrderByAfinity = new AfinityCollection<IAlbum>(this.Albums, al => adcf.GetComparer(al), 50);
AffinityOrderedCollection = _OrderByAfinity.Collection;
//CenterAlbum = Albums.MaxBy(isession.AlbumSorter.Sorter);
_OrderByAfinity.Reference = Albums.MaxBy(isession.AlbumSorter.Sorter);
ChangeArtist = RelayCommand.Instanciate(DoChangeArtist);
ChangeGenre = RelayCommand.Instanciate(DoChangeGenre);
Random = RelayCommand.Instanciate(DoRandom);
ChangeAlbum = RelayCommand.Instanciate(DoChangeAlbum);
Center = RelayCommand.Instanciate<IAlbum>(al => CenterAlbum = al);
}
internal static ViewModelBase FromEntities(IEnumerable<IObjectAttribute> entities, IMusicSession ims)
{
int count = entities.Count();
if (count == 0)
return null;
IObjectAttribute ent = entities.First();
if (count == 1)
{
IAlbum al = ent as IAlbum;
if (al != null)
{
IModifiableAlbum IAM = al.GetModifiableAlbum();
if (IAM != null)
{
return new AlbumEditorViewModel(ims, IAM);
}
return BusyMV();
}
}
if (ent is IAlbum)
{
var all = entities.Cast<IAlbum>();
if (!CheckAlbums(all))
return BusyMV();
return new MusicEntitiesEditorViewModel(ims, all);
}
if (ent is ITrack)
{
var trcs = entities.Cast<ITrack>();
if (!CheckAlbums(trcs.Select(t=>t.Album).Distinct()))
return BusyMV();
return new MusicEntitiesEditorViewModel(ims, trcs);
}
return null;
}
public void SetUp()
{
Init();
_ISession = MusicSessionImpl.GetSession(_SK.Builder);
_Session = _ISession as MusicSessionImpl;
IMusicImporter imi = _ISession.GetDBImporter();
imi.Load();
IDirectoryImporterBuilder imib = _ISession.GetImporterBuilder(MusicImportType.Directory) as IDirectoryImporterBuilder;
Assert.That(imib, Is.Not.Null);
imib.Directory = DirectoryIn;
imib.DefaultAlbumMaturity = AlbumMaturity.Discover;
Assert.That(imib.IsValid, Is.True);
imi = imib.BuildImporter();
Assert.That(imi, Is.Not.Null);
imi.Load();
}
protected override void PostOpen(IMusicSession ims)
{
ims.AllAlbums.Should().BeEmpty();
ims.AllGenres.Count.Should().Be(25);
ims.AllArtists.Should().BeEmpty();
IDirectoryImporterBuilder imib = ims.GetImporterBuilder(MusicImportType.Directory) as IDirectoryImporterBuilder;
imib.Should().NotBeNull();
imib.Directory = DirectoryIn;
imib.DefaultAlbumMaturity = AlbumMaturity.Discover;
imib.IsValid.Should().BeTrue();
IMusicImporter imi = imib.BuildImporter();
imi.Should().NotBeNull();
imi.Load();
ims.ShouldHaveAlbumsLike(Albums[0], AlbumDescriptorCompareMode.AlbumandTrackMD);
}
public AplicationViewModel(IMusicSession iIMusicSession)
{
_IMusicSession = iIMusicSession;
Player = new PlayerViewModel(_IMusicSession.MusicPlayer, _IMusicSession.PlayListFactory);
Player.PlayingAlbums.CollectionChanged += PlayingAlbums_CollectionChanged;
ShowSettings = RelayCommand.Instanciate(DoShowSettings);
Import = RelayCommand.InstanciateAsync(() => DoImport(), false);
iPodSync = RelayCommand.InstanciateAsync(() => DoiPodSynchro());
Move = RelayCommand.Instanciate<IAlbum>(DoMove, al => NotBroken(al));
Export = RelayCommand.InstanciateAsync<IAlbum>(DoExport, al => NotBroken(al), false);
Edit = RelayCommand.InstanciateAsync<object>((ims) => DoEdit(ims));
Delete = RelayCommand.InstanciateAsync<object>((ims) => DoDelete(ims));
Play = RelayCommand.InstanciateAsync<object>((o) => DoPlay(o), false);
GoToArtist = RelayCommand.InstanciateAsync<IArtist>(ar => DoGoToArtist(ar));
GoToGenre = RelayCommand.Instanciate<IGenre>( g => DoGoToGenre(g));
Settings = _IMusicSession.Setting;
AlbumSorter = _IMusicSession.AlbumSorter;
AlbumSorter.OnChanged += AlbumSorter_OnChanged;
RemoveTrackNumber = RelayCommand.Instanciate<TrackView>(DoRemoveTrackNumber);
PrefixArtistName = RelayCommand.Instanciate<TrackView>(DoPrefixArtistName);
AllAlbums = _IMusicSession.AllAlbums;
AllTracks = _IMusicSession.AllTracks.SelectLive(t => TrackView.GetTrackView(t));
Tracks = AllTracks;
Albums = AllAlbums;
GoToPlay = Register(RelayCommand.Instanciate(() => Show(MainDisplay.Play), () => Player.ShoulBePlayed && (MainDisplay == MainDisplay.Browse)));
GoToBrowse = Register(RelayCommand.Instanciate(() => Show(MainDisplay.Browse), () => Player.ShoulBePlayed && (MainDisplay == MainDisplay.Play)));
FocusOnPlay = RelayCommand.Instanciate(DoFocusOnPlay);
_PresenterMode = _IMusicSession.Setting.AparencyUserSettings.PresenterMode;
Finder = new FindItemsControlViewModel(_IMusicSession.EntityFinder, this);
_SelectedTracks.CollectionChanged += SelectedTracks_CollectionChanged;
}
public void SetUp()
{
base.Init();
_AddDirectory = Path.Combine(this.DirectoryIn, "Greg Kelley And Co");
Directory.CreateDirectory(_AddDirectory);
string copysong = Path.Combine(_AddDirectory, "02 One To Grow On.mp3");
string mysong = Path.Combine(this.DirectoryIn, "02 One To Grow On.mp3");
FileInfo fi = new FileInfo(mysong);
fi.MoveTo(copysong);
_MainDirectory = Path.Combine(this.DirectoryIn, "Main");
Directory.CreateDirectory(_MainDirectory);
DirectoryInfo di = new DirectoryInfo(this.DirectoryIn);
foreach (FileInfo fif in di.GetFiles())
{
if (Path.GetExtension(fif.Name) != ".xml")
{
string Des = Path.Combine(_MainDirectory, fif.Name);
fif.MoveTo(Des);
}
}
_MS = MusicSessionImpl.GetSession(_SK.Builder);
_msi = _MS as MusicSessionImpl;
IMusicImporter imi = _MS.GetDBImporter();
Assert.That(imi, Is.Not.Null);
imi.Load();
Assert.That(_msi.AllAlbums.Count, Is.EqualTo(0));
Assert.That(_msi.AllArtists.Count, Is.EqualTo(0));
Assert.That(_msi.AllGenres.Count, Is.EqualTo(25));
}
//internal static IWindow GetWindowFromImporterror(ImportExportErrorEventArgs Ev, IMusicSession ims)
//{
// CorruptedRarOrMissingPasswordArgs cmp = Ev as CorruptedRarOrMissingPasswordArgs;
// if (cmp != null)
// {
// return new RarPasswordWindow(cmp);
// }
// AmbigueousCDInformationArgs acdia = Ev as AmbigueousCDInformationArgs;
// if (acdia != null)
// {
// var cdinfos = new CDAlbumDescriptorCreatorViewModel(acdia,ims);
// return new CDImportInfoEditor() { ModelView = cdinfos };
// }
// CDCoverInformationArgs cdia = Ev as CDCoverInformationArgs;
// if (cdia != null)
// {
// WebAlbumFoundSelectorViewModel waw = new WebAlbumFoundSelectorViewModel(cdia, ims.Strategy);
// return new InternetResultWindow() { ModelView = waw };
// }
// return new CustoMessageBox(Ev);
//}
internal static ViewModelBase GetViewModelBaseFromImporterror(ImportExportError Ev, IMusicSession ims)
{
CorruptedRarOrMissingPasswordArgs cmp = Ev as CorruptedRarOrMissingPasswordArgs;
if (cmp != null)
{
return new RarPasswordViewModel(cmp);
}
AmbigueousCDInformationArgs acdia = Ev as AmbigueousCDInformationArgs;
if (acdia != null)
{
return new CDAlbumDescriptorCreatorViewModel(acdia, ims);
}
CDCoverInformationArgs cdia = Ev as CDCoverInformationArgs;
if (cdia != null)
{
return new WebAlbumFoundSelectorViewModel(cdia, ims.Strategy);
}
return new ImportExportErrorEventArgsViewModel(Ev);
}
private void PerfRun(IMusicSession ms, List<IExtendedObservableCollection<IObservableGrouping<IArtist, IAlbum>>> l)
{
for (int i = 0; i < _MaxCount; i++)
{
l.Add(ms.AllAlbums.LiveSelectManyTuple(a => a.Artists).LiveToLookUp((t) => t.Item2, (t) => t.Item1).LiveOrderBy((a) => a.Key.Name));
}
}
public WindowsPhoneExporter(IInternalMusicSession ims)
{
_Ims = ims;
_IIC = ims.GetNewSessionContext();
}
public void TD()
{
Init();
ThreadProperties TP = new ThreadProperties( ThreadPriority.Highest,ProcessPriorityClass.High);
TP.SetCurrentThread();
//Thread.CurrentThread.Priority = ThreadPriority.Highest;
//Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.High;
var tr2 = TimeTracer.TimeTrack("Session Building");
using (tr2)
{
_MS = MusicSessionImpl.GetSession(_SK.Builder);
_msi = _MS as MusicSessionImpl;
GC.Collect();
GC.WaitForFullGCComplete();
}
_BuildSessionTime = (TimeSpan)tr2.EllapsedTimeSpent;
Assert.That(_MS.AllAlbums.Count, Is.EqualTo(0));
Assert.That(_MS.AllGenres.Count, Is.EqualTo(0));
Assert.That(_MS.AllArtists.Count, Is.EqualTo(0));
var tr = TimeTracer.TimeTrack("Load before vacuum");
using (tr)
{
IMusicImporter imi = _MS.GetDBImporter();
Assert.That(imi, Is.Not.Null);
imi.Load();
}
_OpenTime = (TimeSpan)tr.EllapsedTimeSpent;
Assert.That(_MS.AllAlbums.Count, Is.EqualTo(_AlbumNumber));
Assert.That(_MS.AllArtists.Count, Is.EqualTo(_ArtistNumber));
GC.Collect();
GC.WaitForFullGCComplete();
}
public MusicEntitiesEditorViewModel(IMusicSession iims, IEnumerable<IAlbum> albums):this(albums.First().Session)
{
_MYMod = iims.GetAlbumEditor(albums);
}
public MusicEntitiesEditorViewModel(IMusicSession iims, IEnumerable<ITrack> tracks):this(tracks.First().Album.Session)
{
_MYMod = iims.GetTrackEditor(tracks);
}
public ExportKeyViewModel(IMusicSession imusicsession) :
this(imusicsession.Setting.WebUserSettings.GetDiscogsAutentificator(), imusicsession.Dependencies)
{
}
public AlbumDistanceComparerFactory(IMusicSession iSession)
{
_Session = iSession;
}
private static void OnException(UnhandledExceptionEventArgs e, IMusicSession Ims)
{
if (_EventDone)
return;
ExceptionManager em = new ExceptionManager(Ims, e.ExceptionObject);
SilentException se = e.ExceptionObject as SilentException;
bool sendemail = (se!=null) ? se.SendEmail : (MessageBox.Show(
string.Format("Music Collection encountered a fatal error and needs to close.{0}Click Ok to allow music collection to communicate details about the error to administator.{0}This will help improving Music collection quality. {0}", Environment.NewLine)
, "Fatal Error Detected", MessageBoxButton.OKCancel) == MessageBoxResult.OK);
em.Deal(sendemail);
_EventDone = true;
}
private static void Execute(string[] args)
{
MusicCollectionWPF.App app = new MusicCollectionWPF.App();
using (_IS = MusicSession.GetSession(new WPFHwndProvider()))
{
AppDomain.CurrentDomain.UnhandledException += (o, e) => OnException(e, _IS);
_SplashScreen = new MusicCollectionWPF.Windows.SplashScreen(new SplashScreenViewModel(_IS.SplashScreen));
_SplashScreen.Loaded += slaphscreen_Loaded;
app.Run(_SplashScreen);
if (_MusicImporterService != null)
{
_MusicImporterService.Dispose();
_MusicImporterService = null;
}
}
}
public ArtistGrain(IAccountsSession session, IMusicSession musicSession)
: base(session)
{
_musicSession = musicSession;
}
protected virtual void PostOpen(IMusicSession ims)
{
}
internal AlbumInfoEditor(IEnumerable<Track> tracks, IMusicSession iContext)
{
Tracks = tracks.ToList();
var ab = Tracks.Select(t => t.RawAlbum).Distinct();
AlbumMaturity DefaultAlbumMaturity = ab.Any(a => a.Maturity == AlbumMaturity.Discover) ? AlbumMaturity.Discover : AlbumMaturity.Collection;
Context = (iContext as IInternalMusicSession).GetNewSessionContext(DefaultAlbumMaturity);
//AutorOption = new OptionChooserArtist(ab.Select(alb => alb.Author).Distinct(), Context.Session);
ArtistOption = new OptionArtistChooser(ab.Select(alb => alb.Artists), Context.Session);
GenreOption = new OptionChooser<string>(ab.Select(alb => alb.Genre).Distinct());
YearOption = new OptionChooser<int?>(ab.Select(alb => (int?)alb.Year).Distinct());
NameOption = new OptionChooser<string>(ab.Select(alb => alb.Name).Distinct());
}
public DiscEditor(IModifiableAlbum Al, IMusicSession Session)
{
DataContext = Al;
InitializeComponent();
(Editor as ISessionAcessor).Session = Session;
}
