public async Task <UploadResult> UploadAsset(AlbumCoverData artworkData)
{
Debug.WriteLine($"Get key for asset string: {artworkData}...", "DiscordBee");
if (!artworkData.HasCover)
{
return(null);
}
Debug.WriteLine($" --> Uploading asset {artworkData} ...", "DiscordBee");
if (_uploadInProgress.ContainsKey(artworkData.Hash))
{
Debug.WriteLine($"Skipping upload for asset {artworkData} because its already being uploaded", "DiscordBee");
return(null);
}
_uploadInProgress.TryAdd(artworkData.Hash, "");
try
{
var result = await _assetUploader.UploadAsset(artworkData);
Debug.WriteLine($" <-- Uploading asset {artworkData} ... finished", "DiscordBee");
return(result);
}
catch (Exception e)
{
Debug.WriteLine($" <-- Uploading asset {artworkData} ... FAILED with {e.Message}", "DiscordBee");
return(null);
}
finally
{
_uploadInProgress.TryRemove(artworkData.Hash, out _);
}
}
public override Task <UploadResult> UploadAsset(AlbumCoverData assetData)
{
// As this uploader changes the Hash of the image for all following uploaders, we need to restore the original hash on completion
// because otherwise the caller would receive an upload result for a seemingly different image
return(base.UploadAsset(GetNormalizeAlbumData(assetData)).ContinueWith(
t => new UploadResult {
Hash = assetData.Hash, Link = t.Result.Link
},
TaskContinuationOptions.OnlyOnRanToCompletion
));
}
public async Task <UploadResult> UploadAsset(AlbumCoverData assetData)
{
if (_album == null)
{
return(new UploadResult {
Hash = assetData.Hash, Link = null
});
}
var uploaded = await _client.UploadImage(assetData.Hash, assetData.ImageB64, _album.DeleteHash);
return(new UploadResult {
Hash = assetData.Hash, Link = uploaded.Link
});
}
private AlbumCoverData GetNormalizeAlbumData(AlbumCoverData assetData)
{
Image input = Base64ToImage(assetData.ImageB64);
string imageData = ImageToBase64(ResizeImage(input, 1024, 1024), ImageFormat.Png);
if (string.IsNullOrEmpty(imageData))
{
imageData = ImageToBase64(input, ImageFormat.Png);
}
input.Dispose();
return(new AlbumCoverData(assetData.AlbumName, assetData.ArtistName, imageData));
}
public virtual Task <UploadResult> UploadAsset(AlbumCoverData assetData)
{
if (_innerUploader?.IsHealthy() == true)
{
return(_innerUploader?.UploadAsset(assetData) ?? Task.FromResult <UploadResult>(new UploadResult {
Hash = assetData.Hash, Link = null
}));
}
else
{
return(Task.FromResult(new UploadResult {
Hash = assetData.Hash, Link = null
}));
}
}
public bool IsAssetCached(AlbumCoverData artworkData)
{
if (!artworkData.HasCover)
{
Debug.WriteLine("Artwork is empty -> using default", "DiscordBee");
return(false);
}
if (_assetUploader.IsAssetCached(artworkData))
{
Debug.WriteLine($"Key for asset {artworkData} returned from cache", "DiscordBee");
return(true);
}
return(false);
}
public override Task <UploadResult> UploadAsset(AlbumCoverData assetData)
{
if (_cache.ContainsKey(assetData.Hash))
{
Debug.WriteLine($"Returning link from cache for {assetData}");
_cache.TryGetValue(assetData.Hash, out string ret);
return(Task.FromResult(new UploadResult {
Hash = assetData.Hash, Link = ret
}));
}
Debug.WriteLine($"Not found in cache -> uploading {assetData}");
return(base.UploadAsset(assetData).ContinueWith(res =>
{
if (res.Result.Success)
{
_cache.TryAdd(assetData.Hash, res.Result.Link);
}
return res.Result;
}, TaskContinuationOptions.OnlyOnRanToCompletion));
}
public IEnumerable <AlbumCoverData> GetAlbumCoverData()
{
_log.Debug("Retrieving album cover data...");
SqlCommand command = _dbObj.GetNewCommand("Library.GetAlbumCoverData", CommandType.StoredProcedure, false);
_dbObj.AddErrorHandlingParamsToSqlCommand(command);
SqlDataReader reader = command.ExecuteReader();
try
{
int ordId = reader.GetOrdinal("Id");
int ordDirectory = reader.GetOrdinal("Directory");
int ordWmCollectionId = reader.GetOrdinal("WmCollectionId");
int ordTitle = reader.GetOrdinal("Title");
while (reader.Read())
{
AlbumCoverData albumCoverRecord = new AlbumCoverData()
{
Id = reader[ordId].ToString(),
Directory = reader.GetString(ordDirectory),
WmCollectionId = reader[ordWmCollectionId].ToString(),
Title = reader[ordTitle].ToString()
};
yield return(albumCoverRecord);
}
}
finally
{
reader.Close();
//Since it's only a select, we don't care about committing the transaction even if we
_dbObj.FreeCommand(command);
}
}
public virtual bool IsAssetCached(AlbumCoverData assetData)
{
return(_innerUploader?.IsAssetCached(assetData) == true);
}
public virtual Task <bool> DeleteAsset(AlbumCoverData assetData)
{
return((_innerUploader?.DeleteAsset(assetData)) ?? Task.FromResult(false));
}
public override bool IsAssetCached(AlbumCoverData assetData)
{
return(_cache.ContainsKey(assetData.Hash) || base.IsAssetCached(assetData));
}
public override Task <bool> DeleteAsset(AlbumCoverData assetData)
{
_cache.TryRemove(assetData.Hash, out _);
return(base.DeleteAsset(assetData));
}
public Task <bool> DeleteAsset(AlbumCoverData assetData)
{
throw new System.NotImplementedException();
}
public bool IsAssetCached(AlbumCoverData assetData)
{
return(false);
}
public override bool IsAssetCached(AlbumCoverData assetData)
{
return(base.IsAssetCached(GetNormalizeAlbumData(assetData)));
}
