public async Task <JObject> HitUnofficialApi(string method, JObject data, int retries = 3)
{
string queryString = await DeezerHelpers.BuildDeezerApiQueryString(_apiToken, method);
string url = $"{ApiUrl}?{queryString}";
string bodyData = JsonConvert.SerializeObject(data);
var body = new StringContent(bodyData, Encoding.UTF8, "application/json");
var attempts = 1;
while (attempts <= retries)
{
try
{
using (HttpResponseMessage apiResponse = await _httpClient.PostAsync(url, body))
{
if (apiResponse.IsSuccessStatusCode)
{
string bodyContent = await apiResponse.Content.ReadAsStringAsync();
if (!string.IsNullOrWhiteSpace(bodyContent))
{
try
{
return(JObject.Parse(bodyContent));
}
catch (JsonReaderException ex)
{
Console.WriteLine(ex.Message);
}
}
}
}
}
catch (HttpRequestException ex)
{
Console.WriteLine(ex.Message);
}
attempts++;
Helpers.RedMessage("Request failed, waiting 5s...");
await Task.Delay(5000);
}
return(null);
}
// the way this works is that if the wanted quality was not found, the next best will be tried and so on
// until it wraps around to the start and tries the lower quality options, starting at highest lower quality
// I.E. 320 -> FLAC -> 256 -> 128 -> null
private AudioQuality FindAvailableAudioQuality(TrackInfo trackInfo)
{
var enumIds = new List <int> {
1, 5, 3, 9
};
int startIndex = enumIds.IndexOf((int)_audioQuality);
if (_audioQuality == AudioQuality.Flac)
{
enumIds.Reverse();
startIndex = 0;
}
AudioQuality newQuality = ValidAudioQualityFound(startIndex, enumIds.Count);
if (newQuality != AudioQuality.None)
{
return(newQuality);
}
if (_audioQuality != AudioQuality.Flac)
{
enumIds.RemoveRange(startIndex, 4 - startIndex);
enumIds.Reverse();
}
return(ValidAudioQualityFound(0, startIndex));
AudioQuality ValidAudioQualityFound(int startingIndex, int endIndex)
{
for (int index = startingIndex; index < endIndex; index++)
{
int enumId = enumIds[index];
var quality = (AudioQuality)enumId;
bool qualityIsAvailable = DeezerHelpers.CheckIfQualityIsAvailable(quality, trackInfo);
if (qualityIsAvailable)
{
return(quality);
}
}
return(AudioQuality.None);
}
}
public async Task <bool> GetApiToken()
{
Console.WriteLine("Grabbing API token...");
using (FormUrlEncodedContent formContent = DeezerHelpers.BuildDeezerApiContent("", "deezer.getUserData"))
{
using (HttpResponseMessage apiRequest = await _httpClient.PostAsync(ApiUrl, formContent))
{
if (!apiRequest.IsSuccessStatusCode)
{
Helpers.RedMessage("Failed to contact initial API");
return(false);
}
string apiRequestBody = await apiRequest.Content.ReadAsStringAsync();
JObject apiRequestJson = JObject.Parse(apiRequestBody);
if (apiRequestJson == null)
{
Helpers.RedMessage("Failed to parse API token request JSON");
return(false);
}
apiRequestJson.DisplayDeezerErrors("API Token");
if (apiRequestJson["results"]?["USER"]?["USER_ID"].Value <int>() == 0)
{
Helpers.RedMessage("Invalid credentials");
return(false);
}
if (apiRequestJson["results"]?["checkForm"] != null)
{
_apiToken = apiRequestJson["results"]["checkForm"].Value <string>();
return(true);
}
Helpers.RedMessage("Unable to get checkform");
return(false);
}
}
}
public async Task <bool> ProcessTrack(string id, AlbumInfo albumInfo = null, TrackInfo trackInfo = null)
{
var trackProgress = new ProgressBar(100, 100);
if (trackInfo == null)
{
trackInfo = await GetTrackInfo(id);
if (trackInfo == null)
{
trackProgress.Refresh(0, $"{id} | Failed to get track info");
return(false);
}
}
if (albumInfo == null)
{
string albumId = trackInfo.TrackTags.AlbumId;
albumInfo = await GetAlbumInfo(albumId) ?? new AlbumInfo
{
AlbumTags = new AlbumTags
{
Artists = new [] { new Artists {
Name = "Unknown Artist"
} },
Type = "Unknown",
Title = albumId ?? "Unknown Collection " + Helpers.GetRandomChars(5),
NumberOfDiscs = "0",
NumberOfTracks = "0"
}
};
}
AudioQuality qualityToUse = FindAvailableAudioQuality(trackInfo);
if (qualityToUse == AudioQuality.None)
{
Helpers.RedMessage("Failed to find any available audio quality");
return(false);
}
string trackProgressTitle =
$"\nDownloading {albumInfo.AlbumTags.Artists[0].Name} - {trackInfo.TrackTags.Title} | Quality: {DeezerHelpers.AudioQualityToOutputString[qualityToUse]}";
trackProgress.Next($"{trackProgressTitle} | Getting save location");
string saveLocation = DeezerHelpers.BuildSaveLocation(trackInfo, albumInfo, qualityToUse);
string saveLocationDirectory = Path.GetDirectoryName(saveLocation);
string tempTrackPath = DeezerHelpers.GetTempTrackPath(saveLocationDirectory, trackInfo.TrackTags.Id);
if (File.Exists(saveLocation))
{
trackProgress.Refresh(100, $"{trackProgressTitle} | file already exists");
return(true);
}
byte[] decryptedBytes = await GetDecryptedBytes(trackInfo, qualityToUse, trackProgress, trackProgressTitle);
trackProgress.Next($"{trackProgressTitle} | Writing to disk");
if (!DeezerHelpers.WriteTrackBytes(decryptedBytes, tempTrackPath))
{
trackProgress.Refresh(0, $"{trackProgressTitle} | Failed to write file to disk");
return(false);
}
byte[] albumCover = await GetAndSaveAlbumArt(albumInfo.AlbumTags.PictureId, saveLocationDirectory);
trackProgress.Next($"{trackProgressTitle} | Writing metadata");
var metadataWriter = new MetadataWriter(trackInfo, albumInfo, tempTrackPath, albumCover);
if (!metadataWriter.WriteMetaData(qualityToUse == AudioQuality.Flac))
{
trackProgress.Refresh(0, $"{trackProgressTitle} | Failed to write tags");
}
DeezerHelpers.RenameFiles(tempTrackPath, saveLocation, saveLocationDirectory);
trackProgress.Next($"{trackProgressTitle} | Complete");
return(true);
}
