public async Task <IActionResult> LyricInfo(int?id, string title = null, string artist = null, string picurl = null)
{
if (id == null)
{
return(HttpBadRequest());
}
//编码
SongResponseById detailedSong = new SongResponseById();
WebSong song = new WebSong();
await Task.Run(() =>
{
var task = HttpReqProxy.GetSongByIdAsync(id.Value.ToString());
detailedSong = task.GetAwaiter().GetResult();
if (detailedSong.showapi_res_code == -1)
{
throw new HttpRequestException(detailedSong.showapi_res_error);
}
});
SongFileManager.SetSongById(song, detailedSong.showapi_res_body);
song.Title = title;
song.Artist = artist;
song.Albumpic_big = picurl;
return(View(song));
}
public async Task <WebSong> FindMp3For(string title, string artist)
{
title.CleanUpAsync();
artist.ToCleanQuery();
int currentProvider = 0;
WebSong song = new WebSong();
while (currentProvider < _providers.Length)
{
try
{
song = await GetMatch(_providers[currentProvider], title, artist).ConfigureAwait(false);
}
catch
{
// ignored
}
if (song != null)
{
break;
}
currentProvider++;
}
return(song);
}
private WebSong CreateSong(XboxTrack xboxTrack)
{
var song = new WebSong(GetType())
{
Title = xboxTrack.Name + (string.IsNullOrEmpty(xboxTrack.Subtitle) ? "" : $" ({xboxTrack.Subtitle})"),
Token = xboxTrack.Id,
TrackNumber = (uint?)xboxTrack.TrackNumber ?? 1,
DiskNumber = 1
};
if (xboxTrack.Artists != null)
{
song.Artists = xboxTrack.Artists.Select(p => CreateArtist(p.Artist)).ToList();
}
else
{
song.IsPartial = true;
}
if (xboxTrack.Album != null)
{
song.Album = CreateAlbum(xboxTrack.Album);
}
else
{
song.IsPartial = true;
}
return(song);
}
private static async Task SaveViezTrackFindAlbum(WebSong song)
{
try
{
var track = await App.Locator.ScrobblerService.GetDetailTrack(song.Name, song.Artist).ConfigureAwait(false);;
if (track == null)
{
song.Album = "Unknown Album";
}
else
{
if (track.AlbumName != null)
{
song.Album = track.AlbumName;
}
else
{
song.Album = "Unknown Album";
}
}
}
catch (Exception)
{
song.Album = "Unknown Album";
}
}
private WebSong CreateSong(ChartItem item)
{
var track = item.Track;
var song = new WebSong(GetType())
{
Title = track.Name,
Token = track.Id,
IsPartial = true,
Artists = new List <WebArtist>
{
new WebArtist(GetType())
{
Name = track.Artist.Name,
IsPartial = true,
Token = track.Artist.Id
}
},
Album = new WebAlbum(GetType())
{
Title = track.Album.Name,
IsPartial = true,
Token = track.Album.Id,
Artwork = new Uri(track.Album.Images.Select(i => i.Url).FirstOrDefault())
}
};
return(song);
}
private static async Task <bool> IsUrlOnlineAsync(WebSong song)
{
try
{
song.OnlyDownload = false;
using (var response = await song.AudioUrl.ToUri().HeadAsync())
{
if (response == null || !response.IsSuccessStatusCode)
{
return(false);
}
var type = response.Content.Headers.ContentType?.MediaType ??
response.Content.Headers.GetValues("Content-Type")?.FirstOrDefault() ?? "";
if (!type.Contains("audio") && !type.Contains("octet-stream"))
{
return(false);
}
var size = response.Content.Headers.ContentLength;
if (size != null)
{
song.ByteSize = (long)size;
}
return(song.ByteSize > 0);
}
}
catch
{
return(false);
}
}
public static Artist ToViezArtist(this WebSong ViezArtist)
{
return(new Artist
{
ProviderId = string.Format("Viez." + ViezArtist.Id),
Name = ViezArtist.Artist.Trim().Replace(" ", " ")
});
}
public IActionResult DeleteConfirmed(int id)
{
WebSong webSong = _context.WebSong.Single(m => m.Id == id);
_context.WebSong.Remove(webSong);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <Track> SaveAsync(WebSong song)
{
var track = await _webSongConverter.ConvertAsync(song);
await SaveAsync(track);
return(track);
}
public static Album ToViezAlbum(this WebSong ViezAlbum)
{
var album = new Album
{
ProviderId = string.Format("Viez." + ViezAlbum.Id),
Name = ViezAlbum.Album.Trim().Replace(" ", " ")
};
return(album);
}
public IActionResult Edit(WebSong webSong)
{
if (ModelState.IsValid)
{
_context.Update(webSong);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(webSong));
}
public static Song ToViezSong(this WebSong ViezTrack)
{
var song = new Song
{
ProviderId = string.Format("Viez." + ViezTrack.Id),
Name = ViezTrack.Name.Trim().Replace(" ", " "),
AudioUrl = ViezTrack.Id
};
return(song);
}
private static async Task <SaveResults> SaveViezTrackLevel4(WebSong track)
{
try
{
bool isDeezerTrack = track.IsDeezerTrack;
if (track == null)
{
return new SaveResults()
{
Error = SavingError.Unknown
}
}
;
var preparedSong = track.ToViezSong();
preparedSong.Album = track.ToViezAlbum();
preparedSong.Artist = track.ToViezArtist();
preparedSong.Album.PrimaryArtist = preparedSong.Artist;
if (App.Locator.CollectionService.ViezSongAlreadyExists(track.Name, track.Album, track.Artist))
{
return(new SaveResults()
{
Error = SavingError.AlreadyExists
});
}
if (isDeezerTrack)
{
await App.Locator.CollectionService.AddSongAsync(preparedSong, isDeezerTrack : true).ConfigureAwait(false);
CollectionHelper.MatchSong(preparedSong);
}
else
{
await App.Locator.CollectionService.AddSongAsync(preparedSong).ConfigureAwait(false);
CollectionHelper.MatchSong(preparedSong);
//CollectionHelper.MatchViezTrack(preparedSong);
}
return(new SaveResults()
{
Error = SavingError.None, Song = preparedSong
});
}
catch
{
return(new SaveResults()
{
Error = SavingError.Unknown
});
}
}
private static bool CheckUp(WebSong track)
{
if (!string.IsNullOrEmpty(track.Name) && !string.IsNullOrEmpty(track.Artist) &&
!string.IsNullOrEmpty(track.Album))
{
return(true);
}
else
{
return(false);
}
}
private async Task <Track> ConvertToTrackAsync(WebSong webSong)
{
var track = webSong.PreviousConversion as Track;
if (track == null)
{
using (var blocker = new UiBlocker())
{
blocker.UpdateProgress("Getting data...");
track = await _webSongConverter.ConvertAsync(webSong);
}
}
return(track);
}
private static async Task <SavingError> SaveViezTrackLevel3(WebSong track)
{
if (track == null)
{
return(SavingError.Unknown);
}
while (!App.Locator.CollectionService.IsLibraryLoaded)
{
}
var startTransaction = !App.Locator.SqlService.DbConnection.IsInTransaction;
if (startTransaction)
{
App.Locator.SqlService.BeginTransaction();
}
var result = await SaveViezTrackLevel4(track);
if (startTransaction)
{
App.Locator.SqlService.Commit();
}
ShowResults(result.Error, track.Name);
if (result.Song != null)
{
if (track != null && track.ArtworkImage != null)
{
await DownloadArtworks.SaveArtworkByUrl(track.ArtworkImage, result.Song.Album.Name);
}
else
{
await DownloadArtworks.DownloadAlbumsArtworkAsync();
}
if (App.Locator.Setting.SpotifyArtworkSync)
{
await DownloadArtworks.DownloadArtistsArtworkAsyncFromSpotify(false, result.Song.Artist.Name);
}
else
{
await DownloadArtworks.DownloadArtistsArtworkAsync(false, result.Song.Artist.Name);
}
}
return(result.Error);
}
// GET: WebSongs/Edit/5
public IActionResult Edit(int?id)
{
if (id == null)
{
return(HttpNotFound());
}
WebSong webSong = _context.WebSong.Single(m => m.Id == id);
if (webSong == null)
{
return(HttpNotFound());
}
return(View(webSong));
}
private WebSong CreateSong(SimpleTrack track)
{
var song = new WebSong(GetType())
{
Title = track.Name,
Token = track.Id,
IsPartial = true,
TrackNumber = (uint)track.TrackNumber,
DiskNumber = (uint)track.DiscNumber
};
var full = track as FullTrack;
if (full != null)
{
song.IsPartial = false;
if (full.Artists != null)
{
song.Artists = full.Artists.Select(CreateArtist).ToList();
}
else
{
song.IsPartial = true;
}
if (full.Album != null)
{
song.Album = CreateAlbum(full.Album);
}
else
{
song.IsPartial = true;
}
}
else
{
if (track.Artist != null)
{
song.Artists = new List <WebArtist> {
CreateArtist(track.Artist)
}
}
;
}
return(song);
}
public static async Task <SavingError> SaveViezTrackLevel1(WebSong track)
{
if (!string.IsNullOrEmpty(track.Id) && track.Provider != Data.Mp3Provider.YouTube)
{
track.Album = await GetAlbumName(track.Id);
}
else if (track.Album.ToLower().Contains("unknown") ||
track.Album.ToLower().Contains("various") ||
track.Album.ToLower().Contains("random"))
{
await SaveViezTrackFindAlbum(track);
}
//clean track only english letters
track.Name = SongSavingHelper.ToCleanQuery(track.Name);
track.Artist = SongSavingHelper.ToCleanQuery(track.Artist);
track.Album = SongSavingHelper.ToCleanQuery(track.Album);
//check if it is track properties are noll or not;
if (!CheckUp(track))
{
ShowResults(SavingError.Unknown, track.Name);
return(SavingError.Unknown);
}
if (App.Locator.CollectionService.ViezSongAlreadyExists(track.Name, track.Album, track.Artist))
{
ShowResults(SavingError.AlreadyExists, track.Name);
return(SavingError.AlreadyExists);
}
if (App.Locator.Network.IsActive)
{
var result = await SaveViezTrackLevel2(track);
return(result);
}
ShowResults(SavingError.Network, track.Name);
return(SavingError.Network);
}
public static WebSong CreateSong(SimpleTrack track)
{
var song = new WebSong()
{
Name = track.Name,
Id = track.Id,
};
if (track.Artist != null)
{
song.Artist = !string.IsNullOrEmpty(track.Artist.Name) ? track.Artist.Name : "Unknown Artist";
}
else
{
song.Artist = "Unknown Artist";
}
return(song);
}
public static async Task SaveViezTrackLevel1(WebSong track)
{
if (!App.Locator.Setting.IsLoggedIn)
{
if (_warningCount > 0)
{
ToastManager.ShowError("Login required.");
return;
}
await MessageHelpers.LoginRequired();
_warningCount += 1;
}
var fTrack = track;
App.Locator.PBar.IsEnable = true;
try
{
track.Name = track.Name.GetSongNameFromMain();
track.Artist = track.Artist.GetArtistName();
if (track.Name == "Unknown Track")
{
track.Name = fTrack.Name;
}
if (track.Artist == "Unknown Artist" && fTrack.Artist != "Unknown Artist")
{
track.Artist = fTrack.Artist;
}
await ViezTrackSavingHelper.SaveViezTrackLevel1(track);
}
catch
{
await ViezTrackSavingHelper.SaveViezTrackLevel1(track);
}
App.Locator.PBar.IsEnable = false;
}
public static WebSong CreateSong(LastTrack track)
{
var song = new WebSong()
{
Name = track.Name,
Id = track.Id != null ? track.Id : track.Mbid,
Artist = !string.IsNullOrEmpty(track.ArtistName) ? track.ArtistName : "Unknown Artist",
Album = !string.IsNullOrEmpty(track.AlbumName) ? track.AlbumName : "Unknown Album",
};
if (track.Images != null)
{
var image = GetImage(track.Images);
if (image != null)
{
song.ArtworkImage = image;
}
}
return(song);
}
public async Task <WebSong> FindMp3ByProvider(string title, string artist, int id)
{
WebSong song = new WebSong();
try
{
song = await GetMatch(_providers[id - 1], title, artist).ConfigureAwait(false);
}
catch
{
// ignored
}
if (song != null)
{
return(song);
}
else
{
return(await FindMp3For(title, artist));
}
}
private WebSong CreateSong(DeezerSong deezerSong)
{
var song = new WebSong()
{
Name = deezerSong.Title,
Id = deezerSong.Id,
Artist = deezerSong.Artist != null ? deezerSong.Artist.Name : "Unknown Artist",
Album = deezerSong.Album != null ? deezerSong.Album.Title : "Unknown Album"
};
if (deezerSong.Album != null)
{
var image = deezerSong.Album.CoverBig;
if (image != null)
{
song.ArtworkImage = new Uri(image);
}
}
return(song);
}
private WebSong CreateSong(DeezerSong deezerSong)
{
var song = new WebSong(GetType())
{
Title = deezerSong.Title,
Token = deezerSong.Id,
Artists = new List <WebArtist> {
CreateArtist(deezerSong.Artist)
},
Album = deezerSong.Album != null?CreateAlbum(deezerSong.Album) : null
};
if (deezerSong.TrackPosition != null)
{
song.TrackNumber = (uint)deezerSong.TrackPosition.Value;
}
else
{
song.IsPartial = true;
}
if (deezerSong.DiskNumber != null)
{
song.DiskNumber = (uint)deezerSong.DiskNumber.Value;
}
else
{
song.IsPartial = true;
}
if (deezerSong.Contributors != null)
{
song.Artists = deezerSong.Contributors.Where(p => p.Role == "Main").Select(CreateArtist).ToList();
}
else
{
song.IsPartial = true;
}
return(song);
}
private async Task <bool> IsUrlOnlineAsync(WebSong song)
{
try
{
using (var client = new HttpClient())
{
client.Timeout = TimeSpan.FromSeconds(10);
using (var resp =
await
client.SendAsync(
new HttpRequestMessage(HttpMethod.Head, new Uri(song.AudioUrl)),
HttpCompletionOption.ResponseHeadersRead))
{
if (!resp.IsSuccessStatusCode)
{
return(false);
}
if (!resp.Content.Headers.ContentType.MediaType.Contains("audio") &&
!resp.Content.Headers.ContentType.MediaType.Contains("octet-stream"))
{
return(false);
}
var size = resp.Content.Headers.ContentLength;
if (size != null)
{
song.ByteSize = (long)size;
}
return(song.ByteSize > 0);
}
}
}
catch
{
return(false);
}
}
private WebSong CreateSong(LastTrack track)
{
var song = new WebSong(GetType())
{
MetadataProvider = GetType(),
Title = track.Name,
Token = new[] { track.Name, track.ArtistName }.Tokenize(),
// TODO: TrackNumber =
Artists = new List <WebArtist>
{
new WebArtist(GetType())
{
Name = track.ArtistName,
Token = track.ArtistName,
IsPartial = true
}
}
};
if (!string.IsNullOrEmpty(track.AlbumName))
{
song.Album =
new WebAlbum(GetType())
{
Title = track.AlbumName,
Token = new[] { track.AlbumName, track.ArtistName }.Tokenize(),
Artwork = track.Images?.Largest,
IsPartial = true
};
}
else
{
song.IsPartial = true;
}
return(song);
}
public static WebSong CreateDeezerSong(DeezerSong track)
{
var song = new WebSong()
{
Name = track.title,
Id = track.id + "",
};
if (track.album != null)
{
song.Album = !string.IsNullOrEmpty(track.album.title) ? track.album.title : "Unknown Album";
if (track.album.cover != null)
{
var image = track.album.cover;
if (image != null)
{
song.ArtworkImage = new Uri(image, UriKind.RelativeOrAbsolute);
}
}
}
else
{
song.Album = "Unknown Album";
}
if (track.artist != null)
{
song.Artist = !string.IsNullOrEmpty(track.artist?.name) ? track.artist.name : "Unknown Artist";
}
else
{
song.Artist = "Unknown Artist";
}
return(song);
}
public static WebSong CreateSong(FullTrack track)
{
var song = new WebSong()
{
Name = track.Name,
Id = track.Id,
};
if (track.Album != null)
{
song.Album = !string.IsNullOrEmpty(track.Album.Name) ? track.Album.Name : "Unknown Album";
if (track.Album.Images != null)
{
var image = track.Album.Images[0];
if (image != null)
{
song.ArtworkImage = new Uri(image.Url, UriKind.RelativeOrAbsolute);
}
}
}
else
{
song.Album = "Unknown Album";
}
if (track.Artist != null)
{
song.Artist = !string.IsNullOrEmpty(track.Artist?.Name) ? track.Artist.Name : "Unknown Artist";
}
else
{
song.Artist = "Unknown Artist";
}
return(song);
}
public static void SetNameAndArtistFromTitle(this WebSong song, string title, bool artistOnLeft,
char seperator = '-')
{
var titleSplit = title.Split(seperator).Select(p => p.Trim()).ToArray();
if (titleSplit.Length < 1)
{
return;
}
var left = titleSplit[0];
var right = string.Join($" {seperator} ", titleSplit.Skip(1));
if (artistOnLeft)
{
song.Artist = left;
song.Name = right;
}
else
{
song.Artist = right;
song.Name = left;
}
}
private WebSong CreateSong(XboxTrack xboxTrack)
{
var song = new WebSong(GetType())
{
Title = xboxTrack.Name + (string.IsNullOrEmpty(xboxTrack.Subtitle) ? "" : $" ({xboxTrack.Subtitle})"),
Token = xboxTrack.Id,
TrackNumber = (uint?)xboxTrack.TrackNumber ?? 1,
DiskNumber = 1
};
if (xboxTrack.Artists != null)
song.Artists = xboxTrack.Artists.Select(p => CreateArtist(p.Artist)).ToList();
else
song.IsPartial = true;
if (xboxTrack.Album != null)
song.Album = CreateAlbum(xboxTrack.Album);
else
song.IsPartial = true;
return song;
}
public Task<QueueTrack> AddAsync(WebSong webSong, int position = -1)
{
throw new NotImplementedException();
}
private async Task<Track> ConvertToTrackAsync(WebSong webSong)
{
var track = webSong.PreviousConversion as Track;
if (track == null)
using (var blocker = new UiBlocker())
{
blocker.UpdateProgress("Getting data...");
track = await _webSongConverter.ConvertAsync(webSong);
}
return track;
}
public Task<QueueTrack> AddUpNextAsync(WebSong webSong)
{
throw new NotImplementedException();
}
public async Task<QueueTrack> AddAsync(WebSong webSong, int position = -1)
{
var track = await ConvertToTrackAsync(webSong);
return await AddAsync(track, position);
}
public async Task<Track> SaveAsync(WebSong song)
{
var track = await _webSongConverter.ConvertAsync(song);
await SaveAsync(track);
return track;
}
public async Task<QueueTrack> AddUpNextAsync(WebSong webSong)
{
var track = await ConvertToTrackAsync(webSong);
return await AddUpNextAsync(track);
}
