public static ViewModels.GenreViewModel GetGenreViewModel(string name)
{
var genre = new ViewModels.GenreViewModel();
using (var db = new SQLiteConnection(Tables.DBPath))
{
Genre _album;
try
{
_album = (db.Table <Genre>().Where(
c => c.Name == name)).Single();
}
catch (Exception e)
{
return(null);
}
genre.Name = _album.Name;
genre.Duration = _album.Duration;
genre.Image = _album.Image;
genre.LastPlay = _album.LastPlayed;
genre.Listens = _album.Listens;
genre.SongCount = _album.SongCount;
genre.Meta = _album.Meta;
genre.Rate = _album.Rate;
//9
}
return(genre);
}
void dpt_Tick(object sender, System.EventArgs e)
{
ticks++;
if (incremented | Player.Instance.NetStreamingConfigsLoaded)
{
return;
}
if (Player.Instance.Wave != null && ticks > Player.Instance.Wave.Duration / 2
| ticks > 4000)
{
incremented = true;
EventHandler handler = IncrementListens;
if (handler != null)
{
handler(this, EventArgs.Empty);
}
//track update
Track existingTrack = TrackQuery.GetTrack(CoreMain.CurrentTrack.Path);
if (existingTrack != null)
{
existingTrack.Listens++;
TrackQuery.SaveTrack(existingTrack);
}
//artistUpdate
ArtistViewModel existingArtist = ArtistQuery.GetArtistViewModel(CoreMain.CurrentTrack.Artist);
if (existingArtist != null)
{
existingArtist.Listens++;
existingArtist.SaveArtist();
}
//albumUpdate
AlbumViewModel existingAlbum = AlbumQuery.GetAlbumViewModel(CoreMain.CurrentTrack.Album);
if (existingAlbum != null)
{
existingAlbum.Listens++;
existingAlbum.SaveAlbum();
}
//a;bumUpdate
ViewModels.GenreViewModel existingGenre = GenreQuery.GetGenreViewModel(CoreMain.CurrentTrack.Genre);
if (existingGenre != null)
{
existingGenre.Listens++;
existingGenre.SaveGenre();
}
//scrobble
LastFm.ScrobbleTrack(LastFm.CurrentTrack);
}
}
public static bool ValidGenre(SearchPackage searchPackage, ViewModels.GenreViewModel gen)
{
bool valid = false;
searchPackage.Data = (searchPackage.Data == null) ? "" : searchPackage.Data;
if (gen.Name.ToLower().Contains(searchPackage.Data))
{
valid = true;
}
return(valid); //valid;
}
private static void Start(object o)
{
var ob = o as object[];
var search = (SearchPackage)ob[0];
var dp = (Dispatcher)ob[1];
TableQuery <Genre> query = null;
IEnumerable <ViewModels.GenreViewModel> nq;
LockManager lm = new LockManager(); lm.PrepareForWrite();
int i = 0;
if (Results.Genres == null)
{
Results.Genres = new ObservableCollection <ViewModels.GenreViewModel>();
}
dp.BeginInvoke(new Action(() => Results.Genres.Clear()));
if (!Adder.LibraryAdder.DB_InUse)
{
using (var db = new SQLiteConnection(Tables.DBPath))
{
query =
db.Table <Genre>()
.OrderByDescending(c => c.Listens)
.Where(
c => (c.Name.Contains(search.Data))
);
if (query != null)
{
foreach (Genre _album in query)
{
var genre = new ViewModels.GenreViewModel()
{
Name = _album.Name,
Duration = _album.Duration,
Image = _album.Image,
LastPlay = _album.LastPlayed,
Listens = _album.Listens,
SongCount = _album.SongCount,
Meta = _album.Meta,
Rate = _album.Rate
};
try
{
if (i++ > Results.previewCount)
{
Results.displayFreeze = true;
dp.BeginInvoke(new Action(() => Results.Genres.Add(genre)));
}
else if (i == Results.previewCount)
{
Thread.Sleep(250);
}
else
{
dp.BeginInvoke(new Action(() => Results.Genres.Add(genre)));
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
}
}
else
{
nq =
Adder.LibraryAdder.Genres
.OrderByDescending(c => c.Listens)
.Where(
c => (c.Name.ToLower().Contains(search.Data.ToLower()))
);
foreach (var genre in nq)
{
try
{
if (i++ > Results.previewCount)
{
Results.displayFreeze = true;
dp.BeginInvoke(new Action(() => Results.Genres.Add(genre)));
}
else if (i == Results.previewCount)
{
Thread.Sleep(250);
}
else
{
dp.BeginInvoke(new Action(() => Results.Genres.Add(genre)));
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
//dp.BeginInvoke(new Action(() =>
//{
Results.displayFreeze = false;
// dp.BeginInvoke(new Action(() => Results.Genres.Add(null)));
lm.RemoveLock();
}
public static TrackViewModel AddFile(string file)
{
try
{
var d = new TrackViewModel();
//Build tags
TrackViewModel track = TaglibCore.BuildTrack(file);
try
{
//Save Track
track.SaveTrack();
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
//==============
//Artists
//==============
//Do the operations for artists
ArtistViewModel art = ArtistQuery.GetArtistViewModel(track.Artist);
art = art ?? new ArtistViewModel();
art.Name = track.Artist;
art.Duration += track.Duration;
art.SongCount++;
art.SaveArtist();
//==============
//Genre
//==============
ViewModels.GenreViewModel gens = GenreQuery.GetGenreViewModel(track.Genre);
gens = gens ?? new ViewModels.GenreViewModel();
gens.Name = track.Genre;
gens.Duration += track.Duration;
gens.SongCount++;
gens.SaveGenre();
//==============
//Albums
//==============
AlbumViewModel albs = AlbumQuery.GetAlbumViewModel(track.Album);
albs = albs ?? new AlbumViewModel();
albs.Name = track.Album;
albs.Artist = track.Artist;
albs.Duration += track.Duration;
albs.SongCount++;
albs.ID = track.Album;
albs.SaveAlbum();
if (track.Album.ToLower() != "unknown album")
{
//Global.SaveAlbumArt(album + " - " + Artists, tgl.getArtStream());
//opt.SaveThumb("My Library\\AlbumArt\\" + album + " - " + Artists + ".jpg.thumb");
}
Tracks.Add(track);
Artists.Add(art);
Albums.Add(albs);
Genres.Add(gens);
App.Current.Dispatcher.Invoke(new Action(() =>
{
var mw = App.Current.MainWindow as MainWindow;
if (mw != null)
{
if (mw.hLibrary.grdDD.Visibility == Visibility.Visible)
{
mw.hLibrary.grdDD.FadeOut();
}
}
if (SOFilter.ValidGenre(Results.TrackSearch, gens))
{
Results.Genres.Add(gens);
}
if (SOFilter.ValidArtist(Results.TrackSearch, art))
{
Results.Artists.Add(art);
}
if (SOFilter.ValidAlbum(Results.TrackSearch, albs))
{
Results.Albums.Add(albs);
}
if (SOFilter.ValidTrack(Results.TrackSearch, track))
{
Results.Tracks.Add(track);
}
}));
return(track);
}
catch
{
}
return(null);
}
private void InitializeLists()
{
using (var db = new SQLiteConnection(Tables.DBPath))
{
TableQuery <Track> query = db.Table <Track>().OrderBy(c => c.Title);
foreach (Track track in query)
{
var etrack = new TrackViewModel
{
Path = track.Path,
Title = track.Title,
Artist = track.Artist,
Album = track.Album,
Bitrate = track.Bitrate,
Composer = track.Composer,
Duration = track.Duration,
FileType = track.FileType,
Channels = track.Channels,
Genre = track.Genre,
LastPlay = track.LastPlay,
Listens = track.Listens,
Lyrics = track.Lyrics,
Meta = track.Meta,
Rate = track.Rate,
TrackPosition = track.TrackPosition,
Year = track.Year,
};
Tracks.Add(etrack);
}
}
using (var db = new SQLiteConnection(Tables.DBPath))
{
TableQuery <Artist> query = db.Table <Artist>().OrderBy(c => c.Name);
foreach (Artist track in query)
{
var etrack = new ArtistViewModel()
{
Duration = track.Duration,
Name = track.Name,
Image = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) +
@"\Safire\ArtistData\" + track.Name + ".jpg.thumb",
AlbumCount = track.AlbumCount,
SongCount = track.SongCount,
Listens = track.Listens,
Meta = track.Meta,
Rate = track.Rate,
LastPlay = track.LastPlayed
};
Artists.Add(etrack);
}
}
using (var db = new SQLiteConnection(Tables.DBPath))
{
TableQuery <Album> query = db.Table <Album>().OrderBy(c => c.Name);
foreach (Album track in query)
{
var etrack = new AlbumViewModel()
{
Duration = track.Duration,
Name = track.Name,
Image = track.Image,
SongCount = track.SongCount,
Listens = track.Listens,
Meta = track.Meta,
Rate = track.Rate,
LastPlay = track.LastPlayed,
Artist = track.Artist,
ID = track.ID
};
Albums.Add(etrack);
}
}
using (var db = new SQLiteConnection(Tables.DBPath))
{
TableQuery <Genre> query = db.Table <Genre>().OrderBy(c => c.Name);
foreach (Genre track in query)
{
var etrack = new ViewModels.GenreViewModel()
{
Duration = track.Duration,
Name = track.Name,
Image = track.Image,
SongCount = track.SongCount,
Listens = track.Listens,
Meta = track.Meta,
Rate = track.Rate,
LastPlay = track.LastPlayed,
};
Genres.Add(etrack);
}
}
}
/// <summary>
/// Workers load
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void worker_load(object sender, DoWorkEventArgs e)
{
//Load lists
//InitializeLists();
if (Results.Tracks == null)
{
Results.Tracks = new ObservableCollection <TrackViewModel>();
}
if (Results.Artists == null)
{
Results.Artists = new ObservableCollection <ArtistViewModel>();
}
if (Results.Albums == null)
{
Results.Albums = new ObservableCollection <AlbumViewModel>();
}
if (Results.Genres == null)
{
Results.Genres = new ObservableCollection <ViewModels.GenreViewModel>();
}
DB_InUse = true;
try
{
NotifyPropertyChanged("Initialized");
App.Current.Dispatcher.BeginInvoke(new Action(() =>
{
if (ListenToChanges != null)
{
ListenToChanges(new TrackViewModel()
{
Title = "Searching"
}, SearchGuid);
}
}));
files =
Search(@path, "*.*")
.Where(
s =>
s.ToLower().EndsWith(".mp3") || s.ToLower().EndsWith(".wma") ||
s.ToLower().EndsWith(".flac") || s.ToLower().EndsWith(".ogg") ||
s.ToLower().EndsWith(".wav") || s.ToLower().EndsWith(".mp2") ||
s.ToLower().EndsWith(".mp1") || s.ToLower().EndsWith(".m4a"));
;
max = files.Count();
NotifyPropertyChanged("New Count");
}
catch
{
}
//NotifyPropertyChanged("New Count");
//tag data holding variables
int mval = 0;
if (files == null)
// if there is nothin in files, return
{
//Settings.Default.LibSearchPath = "";
//Settings.Default.LibSearchCompleted = true;
Settings.Default.Save();
return;
}
var artists = new Dictionary <string, ArtistViewModel>();
var albums = new Dictionary <string, AlbumViewModel>();
var genres = new Dictionary <string, ViewModels.GenreViewModel>();
Parallel.ForEach(files, new ParallelOptions {
MaxDegreeOfParallelism = 1
}, file =>
{
if (GlobalSearchCancel)
{
return;
}
try
{
var d = new TrackViewModel();
//Build tags
TrackViewModel track = TaglibCore.BuildTrack(file);
try
{
//Save Track
if (!string.IsNullOrEmpty(track.Title) && track.SaveTrack() == "success")
{
App.Current.Dispatcher.BeginInvoke(new Action(() =>
{
if (SOFilter.ValidTrack(Results.TrackSearch, track))
{
if (!Results.Tracks.Contains(track))
{
Results.Tracks.Add(track);
}
}
}));
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
//==============
//Artists
//==============
//Add the artist to dictionary from DB if the dictionary doesnt have already
if (!artists.ContainsKey(track.Artist))
{
ArtistViewModel arts = ArtistQuery.GetArtistViewModel(track.Artist);
if (arts != null)
{
artists.Add(track.Artist, arts);
}
else
{
artists.Add(track.Artist, new ArtistViewModel());
}
}
//Do the operations for artists
ArtistViewModel art = artists[track.Artist];
art.Name = track.Artist;
art.Duration += track.Duration;
art.SongCount++;
art.SaveArtist();
App.Current.Dispatcher.BeginInvoke(new Action(() =>
{
if (SOFilter.ValidArtist(Results.TrackSearch, art))
{
ArtistViewModel exar;
try
{
exar = Results.Artists.Single(c => c.Name == art.Name);
}
catch (Exception exception)
{
exar = null;
}
if (exar == null)
{
Results.Artists.Add(art);
}
else
{
exar.Listens = art.Listens;
exar.Duration = art.Duration;
exar.SongCount = art.SongCount;
exar.Name = art.Name;
}
}
}));
//==============
//Genre
//==============
//Add the album to dictionary from DB if the dictionary doesnt have already
if (!genres.ContainsKey(track.Genre))
{
ViewModels.GenreViewModel al = GenreQuery.GetGenreViewModel(track.Genre);
if (al != null)
{
genres.Add(track.Genre, al);
}
else
{
genres.Add(track.Genre, new ViewModels.GenreViewModel());
}
}
ViewModels.GenreViewModel gens = genres[track.Genre];
gens.Name = track.Genre;
gens.Duration += track.Duration;
gens.SongCount++;
gens.SaveGenre();
App.Current.Dispatcher.BeginInvoke(new Action(() =>
{
if (SOFilter.ValidGenre(Results.TrackSearch, gens))
{
ViewModels.GenreViewModel exar;
try
{
exar = Results.Genres.Single(c => c.Name == gens.Name);
}
catch (Exception exception)
{
exar = null;
}
if (exar == null)
{
Results.Genres.Add(gens);
}
else
{
exar.Listens = art.Listens;
exar.Duration = art.Duration;
exar.SongCount = art.SongCount;
exar.Name = art.Name;
}
}
}));
//==============
//Albums
//==============
//Add the genre to dictionary from DB if the dictionary doesnt have already
if (!albums.ContainsKey(track.Album))
{
AlbumViewModel al = AlbumQuery.GetAlbumViewModel(track.Album);
if (al != null)
{
albums.Add(track.Album, al);
}
else
{
albums.Add(track.Album, new AlbumViewModel());
}
}
AlbumViewModel albs = albums[track.Album];
albs.Name = track.Album;
albs.Artist = track.Artist;
albs.Duration += track.Duration;
albs.SongCount++;
albs.ID = track.Album;
albs.SaveAlbum();
App.Current.Dispatcher.BeginInvoke(new Action(() =>
{
if (SOFilter.ValidAlbum(Results.TrackSearch, albs))
{
AlbumViewModel exar;
try
{
exar = Results.Albums.Single(c => c.ID == albs.ID);
}
catch (Exception exception)
{
exar = null;
}
if (exar == null)
{
Results.Albums.Add(albs);
}
else
{
exar.Listens = art.Listens;
exar.Duration = art.Duration;
exar.SongCount = art.SongCount;
exar.Name = art.Name;
}
}
}));
if (track.Album.ToLower() != "unknown album")
{
//Global.SaveAlbumArt(album + " - " + Artists, tgl.getArtStream());
//opt.SaveThumb("My Library\\AlbumArt\\" + album + " - " + Artists + ".jpg.thumb");
}
if (!Tracks.Any(c => c.Path == track.Path))
{
Tracks.Add(track);
}
if (!Artists.Any(c => c.Name == art.Name))
{
Artists.Add(art);
}
if (!Albums.Any(c => c.Name == albs.Name))
{
Albums.Add(albs);
}
if (!Genres.Any(c => c.Name == gens.Name))
{
Genres.Add(gens);
}
//Playlist callbacks
triggerCallback(track, SearchGuid);
ListenToChanges(track, SearchGuid);
}
catch
{
}
mval += 1;
cworker.ReportProgress(mval);
});
}
