public void AddArtist(ArtistItem artistItem)
{
try
{
if (string.IsNullOrEmpty(artistItem.Name))
{
return;
}
string lsSQL = string.Format("select distinct ARTIST_ID,ARTIST_IMG from ARTISTS WHERE ARTIST_NAME like '{0}'", artistItem.Name);
SQLiteResultSet loResultSet = m_db.Execute(lsSQL);
if (loResultSet.Rows.Count > 0)
{
Save(artistItem);
return;
}
lsSQL =
string.Format(
"insert into ARTISTS (ARTIST_ID,ARTIST_NAME ,ARTIST_IMG, ARTIST_USER, ARTIST_TAG, ARTIST_BIO) VALUES ('{0}','{1}','{2}','{3}','{4}','{5}')",
artistItem.Id,
DatabaseUtility.RemoveInvalidChars(artistItem.Name), artistItem.Img_url, artistItem.User,
DatabaseUtility.RemoveInvalidChars(artistItem.Tags), DatabaseUtility.RemoveInvalidChars(artistItem.Bio));
m_db.Execute(lsSQL);
artistItem.Db_id = m_db.LastInsertID();
}
catch (Exception exception)
{
}
}
async Task InsertIntoGroupArtist(ArtistItem artist)
{
try
{
var supposedFirstChar = Strings.HumanizedArtistFirstLetter(artist.Name);
var firstChar = GroupedArtists.FirstOrDefault(x => (string)x.Key == supposedFirstChar);
if (firstChar == null)
{
var newChar = new GroupItemList <ArtistItem>(artist)
{
Key = supposedFirstChar
};
if (GroupedArtists == null)
{
return;
}
int i = GroupedArtists.IndexOf(GroupedArtists.LastOrDefault(x => string.Compare((string)x.Key, (string)newChar.Key) < 0));
i++;
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () => GroupedArtists.Insert(i, newChar));
}
else
{
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () => firstChar.Add(artist));
}
}
catch { }
}
public bool GetDetails(ArtistItem artistItem)
{
if (string.IsNullOrEmpty(artistItem.Name))
{
return(false);
}
string strArtistHTML;
string strAlbumHTML;
string strArtistURL;
string artist = artistItem.Name;
if (GetArtistHTML(artist, out strArtistHTML, out strArtistURL))
{
var artistInfo = new MusicArtistInfo();
if (artistInfo.Parse(strArtistHTML))
{
artistInfo.Artist = artist;
artistItem.Bio = artistInfo.AMGBiography;
if (!string.IsNullOrEmpty(artistInfo.ImageURL))
{
artistItem.Img_url = artistInfo.ImageURL;
}
//setMusicVideoArtist(ref mv1, artistInfo, strArtistHTML);
//GetArtistArt((DBArtistInfo)mv);
return(true);
}
}
return(false);
}
public void Update(ArtistItem artist)
{
using (connection.Lock())
{
connection.Update(artist);
}
}
public void Add(ArtistItem artist)
{
using (connection.Lock())
{
connection.Insert(artist);
}
}
private void UpdateArtistsTreeView(Task<Indexes> task)
{
switch (task.Status)
{
case TaskStatus.RanToCompletion:
Dispatcher.Invoke(() =>
{
ArtistItems.Clear();
if (task.Result == null || task.Result.Index == null)
return;
foreach (Index index in task.Result.Index)
{
var artistItem = new ArtistItem { Name = index.Name };
foreach (Artist artist in index.Artist)
artistItem.Children.Add(new ArtistItem { Name = artist.Name, Artist = artist });
ArtistItems.Add(artistItem);
}
});
break;
}
}
public void Remove(ArtistItem artist)
{
using (connection.Lock())
{
connection.Delete(artist);
}
}
public ArtistItem GetArtist(YouTubeEntry entry)
{
ArtistItem artistItem = new ArtistItem();
string lsSQL = string.Format("select distinct ARTIST_ID from VIDEOS WHERE VIDEO_ID=\"{0}\" ", Youtube2MP.GetVideoId(entry));
SQLiteResultSet loResultSet = m_db.Execute(lsSQL);
for (int iRow = 0; iRow < loResultSet.Rows.Count; iRow++)
{
artistItem = ArtistManager.Instance.GetArtistsById(DatabaseUtility.Get(loResultSet, iRow, "ARTIST_ID"));
break;
}
if (string.IsNullOrEmpty(artistItem.Name))
{
artistItem.Name = ArtistManager.Instance.GetArtistName(entry.Title.Text);
}
ArtistItem artistItemLocal = GetArtistsByName(artistItem.Name);
if (artistItemLocal != null)
{
artistItem.Bio = artistItemLocal.Bio;
artistItem.Id = string.IsNullOrEmpty(artistItem.Id) ? artistItemLocal.Id : artistItem.Id;
artistItem.Img_url = !string.IsNullOrEmpty(artistItemLocal.Img_url) ? artistItemLocal.Img_url : artistItem.Img_url;
artistItem.Name = string.IsNullOrEmpty(artistItem.Name) ? artistItemLocal.Name : artistItem.Name;
artistItem.Tags = string.IsNullOrEmpty(artistItem.Tags) ? artistItemLocal.Tags : artistItem.Tags;
artistItem.User = string.IsNullOrEmpty(artistItem.User) ? artistItemLocal.User : artistItem.User;
}
return(artistItem);
}
private void FindIndex(ArtistItem item)
{
bool find = false;
int i = 0;
foreach (var a in Artists)
{
foreach (var b in a)
{
if (b.Artist == item.Artist)
{
find = true;
index = i;
break;
}
i++;
}
if (find)
{
break;
}
}
if (!find)
{
index = 0;
}
}
public async void AddArtistToNowPlayingAsync(ArtistItem item)
{
var g = await DatabaseManager.GetSongItemsFromArtistAsync(item.Artist);
g.OrderBy(s => s.Album).ThenBy(t => t.TrackNumber);
Library.Current.AddToNowPlaying(g);
}
public async void Pin(ArtistItem artist)
{
int id = ApplicationSettingsHelper.ReadTileIdValue() + 1;
string tileId = AppConstants.TileId + id.ToString();
ApplicationSettingsHelper.SaveTileIdValue(id);
string displayName = "Next Player";
string tileActivationArguments = ParamConvert.ToString(new string[] { "artist", artist.ArtistParam });
Uri square150x150Logo = new Uri("ms-appx:///Assets/AppImages/Logo/Logo.png");
SecondaryTile secondaryTile = new SecondaryTile(tileId,
displayName,
tileActivationArguments,
square150x150Logo,
TileSize.Wide310x150);
secondaryTile.VisualElements.Wide310x150Logo = new Uri("ms-appx:///Assets/AppImages/WideLogo/WideLogo.png");
secondaryTile.VisualElements.Square71x71Logo = new Uri("ms-appx:///Assets/AppImages/Square71x71Logo/Square71x71LogoTr.png");
ApplicationSettingsHelper.SaveSettingsValue(AppConstants.TileId, tileId);
ApplicationSettingsHelper.SaveSettingsValue(AppConstants.TileName, artist.Artist);
ResourceLoader loader = new ResourceLoader();
ApplicationSettingsHelper.SaveSettingsValue(AppConstants.TileType, loader.GetString("Artist"));
App.OnNewTilePinned = UpdateNewSecondaryTile;
await secondaryTile.RequestCreateAsync();
}
public void AddArtist(ArtistItem artistItem)
{
try
{
if(string.IsNullOrEmpty(artistItem.Id))
return;
string lsSQL = string.Format("select distinct ARTIST_ID,ARTIST_IMG from ARTISTS WHERE ARTIST_ID=\"{0}\"", artistItem.Id);
SQLiteResultSet loResultSet = m_db.Execute(lsSQL);
if (loResultSet.Rows.Count > 0)
{
for (int iRow = 0; iRow < loResultSet.Rows.Count; iRow++)
{
artistItem.Img_url = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_IMG");
artistItem.Tags = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_TAG");
}
return;
}
lsSQL =
string.Format(
"insert into ARTISTS (ARTIST_ID,ARTIST_NAME,ARTIST_IMG, ARTIST_USER, ARTIST_TAG) VALUES ('{0}','{1}','{2}','{3}','{4}')",
artistItem.Id,
DatabaseUtility.RemoveInvalidChars(artistItem.Name), artistItem.Img_url, artistItem.User,
DatabaseUtility.RemoveInvalidChars(artistItem.Tags));
m_db.Execute(lsSQL);
artistItem.Db_id = m_db.LastInsertID();
}
catch (Exception)
{
}
}
public async Task PopulateAlbumsWithTracks(ArtistItem artist)
{
try
{
var albums = musicDatabase.LoadAlbumsFromIdWithTracks(artist.Id).ToObservable();
var groupedAlbums = new ObservableCollection <GroupItemList <TrackItem> >();
var groupQuery = from album in albums
orderby album.Name
group album.Tracks by album into a
select new { GroupName = a.Key, Items = a };
foreach (var g in groupQuery)
{
GroupItemList <TrackItem> tracks = new GroupItemList <TrackItem>();
tracks.Key = g.GroupName;
foreach (var track in g.Items)
{
tracks.AddRange(track);
}
groupedAlbums.Add(tracks);
}
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
artist.Albums = albums;
artist.AlbumsGrouped = groupedAlbums;
});
}
catch { }
}
public void AddArtist(ArtistItem artistItem)
{
try
{
if (string.IsNullOrEmpty(artistItem.Name))
return;
string lsSQL = string.Format("select distinct ARTIST_ID,ARTIST_IMG from ARTISTS WHERE ARTIST_NAME like '{0}'", artistItem.Name);
SQLiteResultSet loResultSet = m_db.Execute(lsSQL);
if (loResultSet.Rows.Count > 0)
{
Save(artistItem);
return;
}
lsSQL =
string.Format(
"insert into ARTISTS (ARTIST_ID,ARTIST_NAME ,ARTIST_IMG, ARTIST_USER, ARTIST_TAG, ARTIST_BIO) VALUES ('{0}','{1}','{2}','{3}','{4}','{5}')",
artistItem.Id,
DatabaseUtility.RemoveInvalidChars(artistItem.Name), artistItem.Img_url, artistItem.User,
DatabaseUtility.RemoveInvalidChars(artistItem.Tags), DatabaseUtility.RemoveInvalidChars(artistItem.Bio));
m_db.Execute(lsSQL);
artistItem.Db_id = m_db.LastInsertID();
}
catch (Exception exception)
{
}
}
protected ArtistItem GetArtist(YouTubeEntry entry)
{
ArtistItem artistItem = DatabaseProvider.InstanInstance.GetArtist(entry);
if (artistItem != null)
{
return(artistItem);
}
string vidId = Youtube2MP.GetVideoId(entry);
artistItem = ArtistManager.Instance.SitesCache.GetByVideoId(vidId) != null
? ArtistManager.Instance.Grabber.GetFromVideoSite(
ArtistManager.Instance.SitesCache.GetByVideoId(vidId).SIte)
: ArtistManager.Instance.Grabber.GetFromVideoId(vidId);
if (string.IsNullOrEmpty(artistItem.Id) && entry.Title.Text.Contains("-"))
{
artistItem =
ArtistManager.Instance.GetArtistsByName(entry.Title.Text.Split('-')[0].TrimEnd());
}
if (!string.IsNullOrEmpty(artistItem.Id))
{
ArtistManager.Instance.Save(artistItem);
DatabaseProvider.InstanInstance.Save(entry, artistItem);
}
return(artistItem);
}
public static async Task PopulateAlbums(this ArtistItem artist)
{
var albums = await Locator.MusicLibraryVM._albumDatabase.LoadAlbumsFromId(artist.Id).ToObservableAsync();
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
artist.Albums = albums;
});
}
/// <inheritdoc/>
public async Task <ArtistItem> RemoveArtistAsync(ArtistItem artist)
{
artist = await this.Artists.Include(n => n.Albums).Include(n => n.Tracks).FirstAsync(n => n.Id == artist.Id).ConfigureAwait(false);
this.Artists.Remove(artist);
var rows = await this.SaveChangesAsync().ConfigureAwait(false);
return(artist);
}
public async Task Remove(ArtistItem artist)
{
await MusicDatabase.DatabaseOperation.WaitAsync();
var connection = new SQLiteAsyncConnection(DbPath);
await connection.DeleteAsync(artist);
MusicDatabase.DatabaseOperation.Release();
}
public static void AddAlbum(AlbumItem album, ArtistItem artist)
{
artist?.Albums.Add(album);
if (Locator.NavigationService.CurrentPage == VLCPage.MainPageMusic && Locator.MusicLibraryVM.MusicView == MusicView.Albums)
{
Task.Run(() => InsertIntoGroupAlbum(album));
}
Locator.MusicLibraryVM.Albums.Add(album);
}
private async Task <ArtistItem> GetFollowingArtist(ArtistItem currentArtist)
{
// similarity
var t = await GetFollowingArtistViaSimilarity(currentArtist);
// music genre
//var artistItems = await GetFollowingArtistViaGenre(currentArtist);
// years, decades
return(null);
}
public static async Task PopulateTracksByAlbum(this ArtistItem artist)
{
var t = new Tuple <string, string>("", "");
var tracks = await Locator.MusicLibraryVM._trackDatabase.LoadTracksByArtistId(artist.Id);
var groupedTracks = tracks.GroupBy(x => new Tuple <string, string>(x.AlbumName, x.Thumbnail));
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
artist.TracksGroupedByAlbum = groupedTracks;
});
}
public void OnDownloadTimedEvent()
{
if (!Client.IsBusy && downloaQueue.Count > 0)
{
curentDownlodingFile = (DownloadFileObject)downloaQueue.Dequeue();
try
{
if (curentDownlodingFile.ListItem != null)
{
SiteItemEntry siteItemEntry = curentDownlodingFile.ListItem.MusicTag as SiteItemEntry;
if (siteItemEntry != null && !string.IsNullOrEmpty(siteItemEntry.GetValue("id")))
{
ArtistItem artistItem = ArtistManager.Instance.GetArtistsById(siteItemEntry.GetValue("id"));
if (string.IsNullOrEmpty(curentDownlodingFile.Url) || curentDownlodingFile.Url.Contains("@") ||
curentDownlodingFile.Url.Contains("ytimg.com"))
{
try
{
Artist artist = new Artist(artistItem.Name, Youtube2MP.LastFmProfile.Session);
artistItem.Img_url = artist.GetImageURL(ImageSize.Huge);
ArtistManager.Instance.Save(artistItem);
curentDownlodingFile.Url = artistItem.Img_url;
curentDownlodingFile.FileName = Youtube2MP.GetLocalImageFileName(curentDownlodingFile.Url);
}
catch
{
}
}
}
}
if (!string.IsNullOrEmpty(curentDownlodingFile.FileName) && !File.Exists(curentDownlodingFile.FileName))
{
try
{
Client.DownloadFileAsync(new Uri(curentDownlodingFile.Url), Path.GetTempPath() + @"\station.png");
}
catch
{
downloaQueue.Enqueue(curentDownlodingFile);
}
}
else
{
OnDownloadTimedEvent(null, null);
}
}
catch (Exception ex)
{
Log.Error(ex);
}
}
}
public async Task <bool> SaveArtistImageAsync(ArtistItem artist, byte[] img)
{
if (await SaveImage(artist.Id, "artistPic", img))
{
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => artist.IsPictureLoaded = true);
await artist.ResetArtistHeader();
return(true);
}
return(false);
}
private async Task <List <ArtistItem> > GetFollowingArtistViaSimilarity(ArtistItem currentArtist)
{
await App.MusicMetaService.GetSimilarArtists(currentArtist);
if (currentArtist.OnlineRelatedArtists == null || !currentArtist.OnlineRelatedArtists.Any())
{
return(null); // no more similar artists
}
var artistsInCollection = InCollection(currentArtist.OnlineRelatedArtists.Select(x => x.Name).ToList());
return(artistsInCollection);
}
/// <inheritdoc/>
public async Task <ArtistItem> AddArtistAsync(ArtistItem artist)
{
if (artist.Id > 0)
{
throw new ArgumentException($"{nameof(artist)} has id greater than 0");
}
await this.Artists.AddAsync(artist).ConfigureAwait(false);
await this.SaveChangesAsync().ConfigureAwait(false);
return(artist);
}
public static async Task FetchArtistPicOrWaitAsync(ArtistItem artistItem)
{
await ArtistPicFetcherSemaphoreSlim.WaitAsync();
try
{
await artistItem.LoadPicture();
}
finally
{
ArtistPicFetcherSemaphoreSlim.Release();
}
}
private async Task <List <ArtistItem> > GetFollowingArtistViaGenre(ArtistItem currentArtist)
{
// if (currentArtist.Genre == null)
//#if DEBUG
// currentArtist.Genre = "Rock";
//#else
return(null);
//#endif
// var artists = await Locator.MusicMetaService.GetTopArtistGenre(currentArtist.Genre);
// if (artists == null || !artists.Any()) return null;
// var artistsInCollection = InCollection(artists.Select(x => x.Name).ToList());
// return artistsInCollection;
}
public async Task GetArtistBiography(ArtistItem artist)
{
var bio = await musicMdFetcher.GetArtistBiography(artist.Name);
if (bio == null)
{
return;
}
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
artist.Biography = bio;
});
}
public async Task GetArtistEvents(ArtistItem artist)
{
var shows = await musicMdFetcher.GetArtistEvents(artist.Name);
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
artist.IsUpcomingShowsLoading = false;
if (shows == null)
{
return;
}
artist.UpcomingShows = shows;
});
}
public void Save(YouTubeEntry entry, ArtistItem artistItem)
{
try
{
Save(entry);
string lsSQL = string.Format("UPDATE VIDEOS SET ARTIST_ID =\"{1}\" WHERE VIDEO_ID=\"{0}\" ", Youtube2MP.GetVideoId(entry),
artistItem.Id);
m_db.Execute(lsSQL);
}
catch (Exception exception)
{
Log.Error(exception);
}
}
public async Task GetSimilarArtists(ArtistItem artist)
{
var artists = await musicMdFetcher.GetArtistSimilarsArtist(artist.Name);
if (artists == null)
{
return;
}
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
artist.IsOnlineRelatedArtistsLoaded = true;
artist.OnlineRelatedArtists = artists;
});
}
public async Task GetPopularAlbums(ArtistItem artist)
{
var albums = await musicMdFetcher.GetArtistTopAlbums(artist.Name);
if (albums == null)
{
return;
}
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
artist.IsOnlinePopularAlbumItemsLoaded = true;
artist.OnlinePopularAlbumItems = albums;
});
}
protected override void OnClicked(int controlId, GUIControl control, Action.ActionType actionType)
{
if (control == listControl && actionType == Action.ActionType.ACTION_SELECT_ITEM && listControl.SelectedListItem != null)
{
DoPlay(listControl.SelectedListItem.MusicTag as YouTubeEntry, true, listControl);
}
else if (control == listsimilar && actionType == Action.ActionType.ACTION_SELECT_ITEM && listsimilar.SelectedListItem != null)
{
ArtistItem artistItem = listsimilar.SelectedListItem.MusicTag as ArtistItem;
MessageGUI.Item = artistItem;
GUIWindowManager.ActivateWindow(29050);
}
base.OnClicked(controlId, control, actionType);
}
public ArtistItem GetArtist(YouTubeEntry entry)
{
ArtistItem artistItem = new ArtistItem();
string lsSQL = string.Format("select distinct ARTIST_ID from VIDEOS WHERE VIDEO_ID=\"{0}\" ", Youtube2MP.GetVideoId(entry));
SQLiteResultSet loResultSet = m_db.Execute(lsSQL);
for (int iRow = 0; iRow < loResultSet.Rows.Count; iRow++)
{
artistItem= ArtistManager.Instance.GetArtistsById(DatabaseUtility.Get(loResultSet, iRow, "ARTIST_ID"));
break;
}
if (string.IsNullOrEmpty(artistItem.Name))
artistItem.Name = ArtistManager.Instance.GetArtistName(entry.Title.Text);
ArtistItem artistItemLocal = GetArtistsByName(artistItem.Name);
if (artistItemLocal != null)
{
artistItem.Bio = artistItemLocal.Bio;
artistItem.Id = string.IsNullOrEmpty(artistItem.Id) ? artistItemLocal.Id : artistItem.Id;
artistItem.Img_url = !string.IsNullOrEmpty(artistItemLocal.Img_url) ? artistItemLocal.Img_url : artistItem.Img_url;
artistItem.Name = string.IsNullOrEmpty(artistItem.Name) ? artistItemLocal.Name : artistItem.Name;
artistItem.Tags = string.IsNullOrEmpty(artistItem.Tags) ? artistItemLocal.Tags : artistItem.Tags;
artistItem.User = string.IsNullOrEmpty(artistItem.User) ? artistItemLocal.User : artistItem.User;
}
return artistItem;
}
public void SaveTag(ArtistItem artistItem, string tag)
{
try
{
if (string.IsNullOrEmpty(artistItem.Id) || string.IsNullOrEmpty(tag))
return;
string lsSQL =
string.Format(
"insert into TAGS (ARTIST_ID, ARTIST_TAG) VALUES ('{0}','{1}')",
artistItem.Id, DatabaseUtility.RemoveInvalidChars(tag));
m_db.Execute(lsSQL);
}
catch (Exception exception)
{
}
}
public bool GetDetails(ArtistItem artistItem)
{
if (string.IsNullOrEmpty(artistItem.Name))
return false;
string strArtistHTML;
string strAlbumHTML;
string strArtistURL;
string artist = artistItem.Name;
if (GetArtistHTML(artist, out strArtistHTML, out strArtistURL))
{
var artistInfo = new MusicArtistInfo();
if (artistInfo.Parse(strArtistHTML))
{
artistInfo.Artist = artist;
artistItem.Bio = artistInfo.AMGBiography;
if (!string.IsNullOrEmpty(artistInfo.ImageURL))
artistItem.Img_url = artistInfo.ImageURL;
//setMusicVideoArtist(ref mv1, artistInfo, strArtistHTML);
//GetArtistArt((DBArtistInfo)mv);
return true;
}
}
return false;
}
public ArtistItem GetArtistsByName(string name)
{
if (string.IsNullOrEmpty(name))
return null;
ArtistItem res = new ArtistItem();
string lsSQL = string.Format("select * from ARTISTS WHERE ARTIST_NAME like \"{0}\" order by ARTIST_NAME",
DatabaseUtility.RemoveInvalidChars(name.Replace('"', '`')));
SQLiteResultSet loResultSet = m_db.Execute(lsSQL);
for (int iRow = 0; iRow < loResultSet.Rows.Count; iRow++)
{
res.Id = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_ID");
res.Name = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_NAME").Replace("''", "'");
res.Img_url = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_IMG");
res.User = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_USER");
res.Tags = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_TAG");
res.Bio = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_BIO");
return res;
}
return null;
}
public async Task Initialize(StorageFolderQueryResult albumQueryResult, ArtistItem artist)
{
await LoadAlbums(albumQueryResult, artist.Id);
}
private async Task StartIndexing()
{
// TODO: Rewrite function.
_artistDataRepository = new ArtistDataRepository();
var musicFolder = await
KnownVLCLocation.MusicLibrary.GetFoldersAsync(CommonFolderQuery.GroupByArtist);
TimeSpan period = TimeSpan.FromSeconds(10);
_periodicTimer = ThreadPoolTimer.CreatePeriodicTimer(async (source) =>
{
if (Locator.MusicLibraryVM.Track.Count > _numberOfTracks)
{
await DispatchHelper.InvokeAsync(() => Locator.MusicLibraryVM._numberOfTracks = Track.Count);
}
else
{
_periodicTimer.Cancel();
await DispatchHelper.InvokeAsync(() =>
{
IsLoaded = true;
IsBusy = false;
});
}
}, period);
using (await _artistLock.LockAsync())
foreach (var artistItem in musicFolder)
{
IsMusicLibraryEmpty = false;
MusicProperties artistProperties = null;
try
{
artistProperties = await artistItem.Properties.GetMusicPropertiesAsync();
}
catch
{
Debug.WriteLine("Could not get artist item properties.");
}
// If we could not get the artist information, skip it and continue.
if (artistProperties == null || artistProperties.Artist == string.Empty)
{
continue;
}
StorageFolderQueryResult albumQuery =
artistItem.CreateFolderQuery(CommonFolderQuery.GroupByAlbum);
// Check if artist is in the database. If so, use it.
ArtistItem artist = await _artistDataRepository.LoadViaArtistName(artistProperties.Artist);
if (artist == null)
{
artist = new ArtistItem { Name = artistProperties.Artist };
Artist.Add(artist);
await _artistDataRepository.Add(artist);
}
await artist.Initialize(albumQuery, artist);
OnPropertyChanged("Track");
OnPropertyChanged("Artist");
}
OnPropertyChanged("Artist");
}
public void Save(YouTubeEntry entry, ArtistItem artistItem)
{
try
{
Save(entry);
string lsSQL = string.Format("UPDATE VIDEOS SET ARTIST_ID =\"{1}\" WHERE VIDEO_ID=\"{0}\" ", Youtube2MP.GetVideoId(entry),
artistItem.Id);
m_db.Execute(lsSQL);
}
catch (Exception exception)
{
Log.Error(exception);
}
}
public ArtistItem GetFromVideoSite(string site)
{
ArtistItem res=new ArtistItem();
try
{
Regex regexObj = new Regex(@"<a href=""/artist/(?<id>.*?)\?.*?Artist: <span class=.link-like.>(?<name>.*?)</span>", RegexOptions.Singleline);
Match matchResult = regexObj.Match(site);
while (matchResult.Success)
{
res.Id = matchResult.Groups["id"].Value;
res.Name = HttpUtility.HtmlDecode(matchResult.Groups["name"].Value);
//res.Img_url = HttpUtility.HtmlDecode(matchResult.Groups["img_url"].Value);
matchResult = matchResult.NextMatch();
}
GetArtistUser(res.Id);
}
catch (ArgumentException ex)
{
// Syntax error in the regular expression
}
return res;
}
public List<ArtistItem> GetSimilarArtistsSite(string site)
{
List<ArtistItem> res = new List<ArtistItem>();
try
{
Regex regexObj =
new Regex("<h3 class=\"channel-summary-title\">.*?<a href=\"/artist/(?<id>.*?)\" class=\"yt-uix-tile-link\">YouTube - (?<name>.*?)</a>",
RegexOptions.Singleline);
Match matchResult = regexObj.Match(site);
while (matchResult.Success)
{
ArtistItem item = new ArtistItem() { Id = matchResult.Groups["id"].Value, Name = HttpUtility.HtmlDecode(matchResult.Groups["name"].Value) };
ArtistManager.Instance.AddArtist(item);
res.Add(item);
matchResult = matchResult.NextMatch();
}
}
catch (ArgumentException ex)
{
// Syntax error in the regular expression
}
return res;
}
public ArtistItem GetArtistsById(string id)
{
ArtistItem res = new ArtistItem();
string lsSQL = string.Format("select * from ARTISTS WHERE ARTIST_ID = '{0}' order by ARTIST_NAME", id);
SQLiteResultSet loResultSet = m_db.Execute(lsSQL);
for (int iRow = 0; iRow < loResultSet.Rows.Count; iRow++)
{
res.Id = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_ID");
res.Name = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_NAME");
res.Img_url = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_IMG");
res.User = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_USER");
res.Tags = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_TAG");
};
return res;
}
public ArtistItem GetArtistsByName(string name)
{
ArtistItem res = new ArtistItem();
res = DatabaseProvider.InstanInstance.GetArtistsByName(name);
if (res != null)
return res;
res = new ArtistItem();
string lsSQL = string.Format("select * from ARTISTS WHERE ARTIST_NAME like '{0}' order by ARTIST_NAME",
DatabaseUtility.RemoveInvalidChars(name));
SQLiteResultSet loResultSet = m_db.Execute(lsSQL);
for (int iRow = 0; iRow < loResultSet.Rows.Count; iRow++)
{
res.Id = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_ID");
res.Name = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_NAME");
res.Img_url = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_IMG");
res.User = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_USER");
res.Tags = DatabaseUtility.Get(loResultSet, iRow, "ARTIST_TAG");
break;
}
return res;
}
public void Save(ArtistItem artistItem)
{
//if (string.IsNullOrEmpty(artistItem.Id))
// return;
//if (Youtube2MP.LastFmProfile.Session != null)
//{
// Lastfm.Services.Artist artist = new Lastfm.Services.Artist(artistItem.Name, Youtube2MP.LastFmProfile.Session);
// artistItem.Img_url = artist.GetImageURL(ImageSize.Large);
//}
string lsSQL =
string.Format(
"UPDATE ARTISTS SET ARTIST_NAME ='{1}' ,ARTIST_IMG='{2}', ARTIST_USER='******', ARTIST_TAG='{4}', ARTIST_BIO='{5}' WHERE ARTIST_NAME like '{0}' ",
DatabaseUtility.RemoveInvalidChars(artistItem.Name), DatabaseUtility.RemoveInvalidChars(artistItem.Name),
artistItem.Img_url, artistItem.User, DatabaseUtility.RemoveInvalidChars(artistItem.Tags), DatabaseUtility.RemoveInvalidChars(artistItem.Bio));
m_db.Execute(lsSQL);
}
public bool SetSkinProperties(YouTubeEntry youTubeEntry, string prefix, bool grab, bool download)
{
if (youTubeEntry == null)
return true;
ArtistItem artistItem = DatabaseProvider.InstanInstance.GetArtist(youTubeEntry);
if (artistItem == null && grab)
{
string vidId = Youtube2MP.GetVideoId(youTubeEntry);
artistItem = SitesCache.GetByVideoId(vidId) != null
? Grabber.GetFromVideoSite(SitesCache.GetByVideoId(vidId).SIte)
: Grabber.GetFromVideoId(vidId);
}
if (artistItem == null)
{
string art = GetArtistName(youTubeEntry.Title.Text);
artistItem = GetArtistsByName(art);
}
if ((artistItem == null || string.IsNullOrEmpty(artistItem.Bio) || string.IsNullOrEmpty(artistItem.Img_url)) && grab)
{
if (artistItem == null || string.IsNullOrEmpty((artistItem.Name)))
artistItem = new ArtistItem() {Name = GetArtistName(youTubeEntry.Title.Text)};
try
{
Lastfm.Services.Artist artist = new Lastfm.Services.Artist(artistItem.Name, Youtube2MP.LastFmProfile.Session);
if (string.IsNullOrEmpty(artistItem.Img_url))
{
artistItem.Img_url = artist.GetImageURL(ImageSize.Huge);
}
if (string.IsNullOrEmpty(artistItem.Bio))
{
ArtistBio artistBio = artist.Bio;
artistBio.Lang = GUILocalizeStrings.GetCultureName(GUILocalizeStrings.CurrentLanguage());
string contents = Regex.Replace(HttpUtility.HtmlDecode(artistBio.getContent()), "<.*?>",
string.Empty);
if (string.IsNullOrEmpty(contents))
{
artistBio.Lang = string.Empty;
contents = Regex.Replace(HttpUtility.HtmlDecode(artistBio.getContent()), "<.*?>",
string.Empty);
}
artistItem.Bio = contents;
}
if (string.IsNullOrEmpty(artistItem.Tags))
{
int i = 0;
string tags = "";
TopTag[] topTags = artist.GetTopTags();
foreach (TopTag tag in topTags)
{
tags += tag.Item.Name + "|";
if (i < 5)
{
if (!string.IsNullOrEmpty(artistItem.Id))
SaveTag(artistItem, tag.Item.Name);
}
i++;
}
artistItem.Tags = tags;
}
DatabaseProvider.InstanInstance.AddArtist(artistItem);
}
catch (Exception exception)
{
Log.Debug(exception.Message);
}
}
if (artistItem != null)
{
if (download && !File.Exists(artistItem.LocalImage))
{
Youtube2MP.DownloadFile(artistItem.Img_url, artistItem.LocalImage);
}
SetSkinProperties(artistItem, prefix);
}
return false;
}
public void SetSkinProperties(ArtistItem artistItem,string prefix)
{
GUIPropertyManager.SetProperty("#Youtube.fm." + prefix + ".Artist.Image", " ");
GUIPropertyManager.SetProperty("#Youtube.fm." + prefix + ".Artist.Name", Property(artistItem.Name));
GUIPropertyManager.SetProperty("#Youtube.fm." + prefix + ".Artist.Bio", Property(artistItem.Bio));
GUIPropertyManager.SetProperty("#Youtube.fm." + prefix + ".Artist.Tags", Property(artistItem.Tags));
GUIPropertyManager.SetProperty("#Youtube.fm." + prefix + ".Artist.Image",
Property(artistItem.LocalImage));
}
