mirror of
https://github.com/sphildreth/roadie
synced 2024-11-10 06:44:12 +00:00
720 lines
No EOL
29 KiB
C#
720 lines
No EOL
29 KiB
C#
using Microsoft.Extensions.Logging;
|
|
using Microsoft.Net.Http.Headers;
|
|
using Roadie.Library;
|
|
using Roadie.Library.Caching;
|
|
using Roadie.Library.Configuration;
|
|
using Roadie.Library.Data.Context;
|
|
using Roadie.Library.Encoding;
|
|
using Roadie.Library.Enums;
|
|
using Roadie.Library.Identity;
|
|
using Roadie.Library.Imaging;
|
|
using Roadie.Library.Models;
|
|
using Roadie.Library.SearchEngines.Imaging;
|
|
using Roadie.Library.Utility;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using data = Roadie.Library.Data;
|
|
|
|
namespace Roadie.Api.Services
|
|
{
|
|
public class ImageService : ServiceBase, IImageService
|
|
{
|
|
public string Referrer { get; set; }
|
|
public string RequestIp { get; set; }
|
|
private IDefaultNotFoundImages DefaultNotFoundImages { get; }
|
|
|
|
private IImageSearchManager ImageSearchManager { get; }
|
|
|
|
public ImageService(IRoadieSettings configuration,
|
|
IHttpEncoder httpEncoder,
|
|
IHttpContext httpContext,
|
|
IRoadieDbContext context,
|
|
ICacheManager cacheManager,
|
|
ILogger<ImageService> logger,
|
|
IDefaultNotFoundImages defaultNotFoundImages,
|
|
IImageSearchManager imageSearchManager)
|
|
: base(configuration, httpEncoder, context, cacheManager, logger, httpContext)
|
|
{
|
|
DefaultNotFoundImages = defaultNotFoundImages;
|
|
ImageSearchManager = imageSearchManager;
|
|
}
|
|
|
|
public ImageService(IRoadieSettings configuration, IRoadieDbContext dbContext, ICacheManager cacheManager,
|
|
ILogger logger, DefaultNotFoundImages defaultNotFoundImages)
|
|
: base(configuration, null, dbContext, cacheManager, logger, null)
|
|
{
|
|
DefaultNotFoundImages = defaultNotFoundImages;
|
|
}
|
|
|
|
public async Task<FileOperationResult<IImage>> ArtistImage(Guid id, int? width, int? height, EntityTagHeaderValue etag = null)
|
|
{
|
|
return await GetImageFileOperation("ArtistImage",
|
|
data.Artist.CacheRegionUrn(id),
|
|
id,
|
|
width,
|
|
height,
|
|
async () => { return await ArtistImageAction(id, etag); },
|
|
etag);
|
|
}
|
|
|
|
public async Task<FileOperationResult<IImage>> ArtistSecondaryImage(Guid id, int imageId, int? width, int? height, EntityTagHeaderValue etag = null)
|
|
{
|
|
return await GetImageFileOperation($"ArtistSecondaryThumbnail.{imageId}",
|
|
data.Artist.CacheRegionUrn(id),
|
|
id,
|
|
width,
|
|
height,
|
|
async () => { return await ArtistSecondaryImageAction(id, imageId, etag); },
|
|
etag);
|
|
}
|
|
|
|
public async Task<FileOperationResult<IImage>> CollectionImage(Guid id, int? width, int? height, EntityTagHeaderValue etag = null)
|
|
{
|
|
return await GetImageFileOperation("CollectionThumbnail",
|
|
data.Collection.CacheRegionUrn(id),
|
|
id,
|
|
width,
|
|
height,
|
|
async () => { return await CollectionImageAction(id, etag); },
|
|
etag);
|
|
}
|
|
|
|
public async Task<FileOperationResult<IImage>> GenreImage(Guid id, int? width, int? height, EntityTagHeaderValue etag = null)
|
|
{
|
|
return await GetImageFileOperation("GenreThumbnail",
|
|
data.Genre.CacheRegionUrn(id),
|
|
id,
|
|
width,
|
|
height,
|
|
async () => await GenreImageAction(id, etag),
|
|
etag);
|
|
}
|
|
|
|
public async Task<FileOperationResult<IImage>> LabelImage(Guid id, int? width, int? height, EntityTagHeaderValue etag = null)
|
|
{
|
|
return await GetImageFileOperation("LabelThumbnail",
|
|
data.Label.CacheRegionUrn(id),
|
|
id,
|
|
width,
|
|
height,
|
|
async () => await LabelImageAction(id, etag),
|
|
etag);
|
|
}
|
|
|
|
public async Task<FileOperationResult<IImage>> PlaylistImage(Guid id, int? width, int? height, EntityTagHeaderValue etag = null)
|
|
{
|
|
return await GetImageFileOperation("PlaylistThumbnail",
|
|
data.Playlist.CacheRegionUrn(id),
|
|
id,
|
|
width,
|
|
height,
|
|
async () => await PlaylistImageAction(id, etag),
|
|
etag);
|
|
}
|
|
|
|
public async Task<FileOperationResult<IImage>> ReleaseImage(Guid id, int? width, int? height, EntityTagHeaderValue etag = null)
|
|
{
|
|
return await GetImageFileOperation("ReleaseThumbnail",
|
|
data.Release.CacheRegionUrn(id),
|
|
id,
|
|
width,
|
|
height,
|
|
async () => await ReleaseImageAction(id, etag),
|
|
etag);
|
|
}
|
|
|
|
public async Task<FileOperationResult<IImage>> ReleaseSecondaryImage(Guid id, int imageId, int? width, int? height, EntityTagHeaderValue etag = null)
|
|
{
|
|
return await GetImageFileOperation($"ReleaseSecondaryThumbnail-{imageId}",
|
|
data.Release.CacheRegionUrn(id),
|
|
id,
|
|
width,
|
|
height,
|
|
async () => { return await ReleaseSecondaryImageAction(id, imageId, etag); },
|
|
etag);
|
|
}
|
|
|
|
public async Task<OperationResult<IEnumerable<ImageSearchResult>>> Search(string query, int resultsCount = 10)
|
|
{
|
|
var sw = new Stopwatch();
|
|
sw.Start();
|
|
var errors = new List<Exception>();
|
|
IEnumerable<ImageSearchResult> searchResults = null;
|
|
try
|
|
{
|
|
searchResults = await ImageSearchManager.ImageSearch(query);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex);
|
|
errors.Add(ex);
|
|
}
|
|
|
|
sw.Stop();
|
|
return new OperationResult<IEnumerable<ImageSearchResult>>
|
|
{
|
|
Data = searchResults,
|
|
IsSuccess = !errors.Any(),
|
|
OperationTime = sw.ElapsedMilliseconds,
|
|
Errors = errors
|
|
};
|
|
}
|
|
|
|
public async Task<FileOperationResult<IImage>> TrackImage(Guid id, int? width, int? height, EntityTagHeaderValue etag = null)
|
|
{
|
|
return await GetImageFileOperation("TrackThumbnail",
|
|
data.Track.CacheRegionUrn(id),
|
|
id,
|
|
width,
|
|
height,
|
|
async () => await TrackImageAction(id, width, height, etag),
|
|
etag);
|
|
}
|
|
|
|
public async Task<FileOperationResult<IImage>> UserImage(Guid id, int? width, int? height, EntityTagHeaderValue etag = null)
|
|
{
|
|
return await GetImageFileOperation("UserById",
|
|
User.CacheRegionUrn(id),
|
|
id,
|
|
width,
|
|
height,
|
|
async () => await UserImageAction(id, etag),
|
|
etag);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get image for an artist, see if the artist has an image in their folder and use that else use Artist.Thumbnail, is also not found use Artist DefaultNotFound image.
|
|
/// </summary>
|
|
private async Task<FileOperationResult<IImage>> ArtistImageAction(Guid id, EntityTagHeaderValue etag = null)
|
|
{
|
|
try
|
|
{
|
|
var artist = await GetArtist(id);
|
|
if (artist == null)
|
|
{
|
|
return new FileOperationResult<IImage>(true, string.Format("Artist Not Found [{0}]", id));
|
|
}
|
|
byte[] imageBytes = null;
|
|
string artistFolder = null;
|
|
try
|
|
{
|
|
// See if artist images exists in artist folder
|
|
artistFolder = artist.ArtistFileFolder(Configuration);
|
|
if (!Directory.Exists(artistFolder))
|
|
{
|
|
Logger.LogWarning($"Artist Folder [{artistFolder}], Not Found For Artist `{artist}`");
|
|
}
|
|
else
|
|
{
|
|
var artistImages = ImageHelper.FindImageTypeInDirectory(new DirectoryInfo(artistFolder), ImageType.Artist);
|
|
if (artistImages.Any())
|
|
{
|
|
imageBytes = File.ReadAllBytes(artistImages.First().FullName);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex, $"Error Reading Folder [{artistFolder}] For Artist [{artist.Id}]");
|
|
}
|
|
|
|
IImage image = new Library.Imaging.Image(id)
|
|
{
|
|
Bytes = imageBytes,
|
|
};
|
|
if (imageBytes == null || !imageBytes.Any())
|
|
{
|
|
image = DefaultNotFoundImages.Artist;
|
|
}
|
|
return GenerateFileOperationResult(id, image, etag);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError($"Error fetching Artist Thumbnail [{id}]", ex);
|
|
}
|
|
|
|
return new FileOperationResult<IImage>(OperationMessages.ErrorOccured);
|
|
}
|
|
|
|
private async Task<FileOperationResult<IImage>> ArtistSecondaryImageAction(Guid id, int imageId, EntityTagHeaderValue etag = null)
|
|
{
|
|
try
|
|
{
|
|
var artist = await GetArtist(id);
|
|
if (artist == null)
|
|
{
|
|
return new FileOperationResult<IImage>(true, string.Format("Release Not Found [{0}]", id));
|
|
}
|
|
byte[] imageBytes = null;
|
|
string artistFolder = null;
|
|
try
|
|
{
|
|
// See if cover art file exists in release folder
|
|
artistFolder = artist.ArtistFileFolder(Configuration);
|
|
if (!Directory.Exists(artistFolder))
|
|
{
|
|
Logger.LogWarning($"Artist Folder [{artistFolder}], Not Found For Artist `{artist}`");
|
|
}
|
|
else
|
|
{
|
|
var artistSecondaryImages = ImageHelper
|
|
.FindImageTypeInDirectory(new DirectoryInfo(artistFolder), ImageType.ArtistSecondary)
|
|
.ToArray();
|
|
if (artistSecondaryImages.Length >= imageId && artistSecondaryImages[imageId] != null)
|
|
imageBytes = File.ReadAllBytes(artistSecondaryImages[imageId].FullName);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex, $"Error Reading Artist Folder [{artistFolder}] For Artist `{artist}`");
|
|
}
|
|
|
|
var image = new Library.Imaging.Image(id)
|
|
{
|
|
Bytes = imageBytes,
|
|
CreatedDate = artist.CreatedDate
|
|
};
|
|
return GenerateFileOperationResult(id, image, etag);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError($"Error fetching Release Thumbnail [{id}]", ex);
|
|
}
|
|
|
|
return new FileOperationResult<IImage>(OperationMessages.ErrorOccured);
|
|
}
|
|
|
|
private async Task<FileOperationResult<IImage>> CollectionImageAction(Guid id, EntityTagHeaderValue etag = null)
|
|
{
|
|
try
|
|
{
|
|
var collection = await GetCollection(id);
|
|
if (collection == null)
|
|
{
|
|
return new FileOperationResult<IImage>(true, string.Format("Collection Not Found [{0}]", id));
|
|
}
|
|
IImage image = new Library.Imaging.Image(id)
|
|
{
|
|
CreatedDate = collection.CreatedDate
|
|
};
|
|
var collectionImageFilename = collection.PathToImage(Configuration);
|
|
try
|
|
{
|
|
if (File.Exists(collectionImageFilename))
|
|
{
|
|
image.Bytes = File.ReadAllBytes(collectionImageFilename);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex, $"Error Reading Image File [{collectionImageFilename}]");
|
|
}
|
|
if (image.Bytes == null || !image.Bytes.Any())
|
|
{
|
|
image = DefaultNotFoundImages.Collection;
|
|
}
|
|
return GenerateFileOperationResult(id, image, etag);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError($"Error fetching Collection Thumbnail [{id}]", ex);
|
|
}
|
|
|
|
return new FileOperationResult<IImage>(OperationMessages.ErrorOccured);
|
|
}
|
|
|
|
private FileOperationResult<IImage> GenerateFileOperationResult(Guid id, IImage image, EntityTagHeaderValue etag = null, string contentType = "image/jpeg")
|
|
{
|
|
var imageEtag = EtagHelper.GenerateETag(HttpEncoder, image.Bytes);
|
|
if (EtagHelper.CompareETag(HttpEncoder, etag, imageEtag))
|
|
{
|
|
return new FileOperationResult<IImage>(OperationMessages.NotModified);
|
|
}
|
|
if (image?.Bytes?.Any() != true)
|
|
{
|
|
return new FileOperationResult<IImage>(string.Format("ImageById Not Set [{0}]", id));
|
|
}
|
|
return new FileOperationResult<IImage>(image?.Bytes?.Any() ?? false
|
|
? OperationMessages.OkMessage
|
|
: OperationMessages.NoImageDataFound)
|
|
{
|
|
IsSuccess = true,
|
|
Data = image,
|
|
ContentType = contentType,
|
|
LastModified = image.CreatedDate,
|
|
ETag = imageEtag
|
|
};
|
|
}
|
|
|
|
private async Task<FileOperationResult<IImage>> GenreImageAction(Guid id, EntityTagHeaderValue etag = null)
|
|
{
|
|
try
|
|
{
|
|
var genre = await GetGenre(id);
|
|
if (genre == null)
|
|
{
|
|
return new FileOperationResult<IImage>(true, string.Format("Genre Not Found [{0}]", id));
|
|
}
|
|
IImage image = new Library.Imaging.Image(id)
|
|
{
|
|
CreatedDate = genre.CreatedDate
|
|
};
|
|
var genreImageFilename = genre.PathToImage(Configuration);
|
|
try
|
|
{
|
|
if (File.Exists(genreImageFilename))
|
|
{
|
|
image.Bytes = File.ReadAllBytes(genreImageFilename);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex, $"Error Reading Image File [{genreImageFilename}]");
|
|
}
|
|
if (image.Bytes == null || !image.Bytes.Any())
|
|
{
|
|
image = DefaultNotFoundImages.Genre;
|
|
}
|
|
return GenerateFileOperationResult(id, image, etag);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError($"Error fetching Label Thumbnail [{id}]", ex);
|
|
}
|
|
|
|
return new FileOperationResult<IImage>(OperationMessages.ErrorOccured);
|
|
}
|
|
|
|
private async Task<FileOperationResult<IImage>> GetImageFileOperation(string type, string regionUrn, Guid id, int? width, int? height, Func<Task<FileOperationResult<IImage>>> action, EntityTagHeaderValue etag = null)
|
|
{
|
|
try
|
|
{
|
|
var sw = Stopwatch.StartNew();
|
|
var sizeHash = (width ?? 0) + (height ?? 0);
|
|
var result = await CacheManager.GetAsync($"urn:{type}_by_id_operation:{id}:{sizeHash}", action, regionUrn);
|
|
if (!result.IsSuccess)
|
|
{
|
|
return new FileOperationResult<IImage>(result.IsNotFoundResult, result.Messages);
|
|
}
|
|
if (result.ETag == etag && etag != null)
|
|
{
|
|
return new FileOperationResult<IImage>(OperationMessages.NotModified);
|
|
}
|
|
var force = width.HasValue || height.HasValue;
|
|
var newWidth = width ?? Configuration.MaximumImageSize.Width;
|
|
var newHeight = height ?? Configuration.MaximumImageSize.Height;
|
|
if (result?.Data?.Bytes != null)
|
|
{
|
|
var resized = ImageHelper.ResizeImage(result?.Data?.Bytes, newWidth, newHeight, force);
|
|
if (resized != null)
|
|
{
|
|
result.Data.Bytes = resized.Item2;
|
|
result.ETag = EtagHelper.GenerateETag(HttpEncoder, result.Data.Bytes);
|
|
result.LastModified = DateTime.UtcNow;
|
|
if (resized.Item1)
|
|
{
|
|
Logger.LogTrace($"{type}: Resized [{id}], Width [{ newWidth}], Height [{ newHeight}], Forced [{ force }]");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logger.LogTrace($"{type}: Image [{id}] Request returned Null Image, Forced [{ force }]");
|
|
}
|
|
}
|
|
|
|
sw.Stop();
|
|
return new FileOperationResult<IImage>(result.Messages)
|
|
{
|
|
Data = result.Data,
|
|
ETag = result.ETag,
|
|
LastModified = result.LastModified,
|
|
ContentType = result.ContentType,
|
|
Errors = result?.Errors,
|
|
IsSuccess = result?.IsSuccess ?? false,
|
|
OperationTime = sw.ElapsedMilliseconds
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex, $"GetImageFileOperation Error, Type [{type}], id [{id}]");
|
|
}
|
|
|
|
return new FileOperationResult<IImage>("System Error");
|
|
}
|
|
|
|
private async Task<FileOperationResult<IImage>> LabelImageAction(Guid id, EntityTagHeaderValue etag = null)
|
|
{
|
|
try
|
|
{
|
|
var label = await GetLabel(id);
|
|
if (label == null)
|
|
{
|
|
return new FileOperationResult<IImage>(true, string.Format("Label Not Found [{0}]", id));
|
|
}
|
|
IImage image = new Library.Imaging.Image(id)
|
|
{
|
|
CreatedDate = label.CreatedDate
|
|
};
|
|
var labelImageFilename = label.PathToImage(Configuration);
|
|
try
|
|
{
|
|
if (File.Exists(labelImageFilename))
|
|
{
|
|
image.Bytes = File.ReadAllBytes(labelImageFilename);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex, $"Error Reading Image File [{labelImageFilename}]");
|
|
}
|
|
if (image.Bytes == null || !image.Bytes.Any())
|
|
{
|
|
image = DefaultNotFoundImages.Label;
|
|
}
|
|
return GenerateFileOperationResult(id, image, etag);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError($"Error fetching Label Thumbnail [{id}]", ex);
|
|
}
|
|
|
|
return new FileOperationResult<IImage>(OperationMessages.ErrorOccured);
|
|
}
|
|
|
|
private async Task<FileOperationResult<IImage>> PlaylistImageAction(Guid id, EntityTagHeaderValue etag = null)
|
|
{
|
|
try
|
|
{
|
|
var playlist = await GetPlaylist(id);
|
|
if (playlist == null)
|
|
{
|
|
return new FileOperationResult<IImage>(true, string.Format("Playlist Not Found [{0}]", id));
|
|
}
|
|
IImage image = new Library.Imaging.Image(id)
|
|
{
|
|
CreatedDate = playlist.CreatedDate
|
|
};
|
|
var playlistImageFilename = playlist.PathToImage(Configuration);
|
|
try
|
|
{
|
|
if (File.Exists(playlistImageFilename))
|
|
{
|
|
image.Bytes = File.ReadAllBytes(playlistImageFilename);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex, $"Error Reading Image File [{playlistImageFilename}]");
|
|
}
|
|
if (image.Bytes == null || !image.Bytes.Any())
|
|
{
|
|
image = DefaultNotFoundImages.Playlist;
|
|
}
|
|
return GenerateFileOperationResult(id, image, etag);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError($"Error fetching Playlist Thumbnail [{id}]", ex);
|
|
}
|
|
|
|
return new FileOperationResult<IImage>(OperationMessages.ErrorOccured);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get image for Release from Release folder, if not exists then use Release.Thumbnail if that is not set then use Release DefaultNotFound image.
|
|
/// </summary>
|
|
private async Task<FileOperationResult<IImage>> ReleaseImageAction(Guid id, EntityTagHeaderValue etag = null)
|
|
{
|
|
try
|
|
{
|
|
var release = await GetRelease(id);
|
|
if (release == null)
|
|
{
|
|
return new FileOperationResult<IImage>(true, string.Format("Release Not Found [{0}]", id));
|
|
}
|
|
byte[] imageBytes = null;
|
|
string artistFolder = null;
|
|
string releaseFolder = null;
|
|
try
|
|
{
|
|
// See if cover art file exists in release folder
|
|
artistFolder = release.Artist.ArtistFileFolder(Configuration);
|
|
if (!Directory.Exists(artistFolder))
|
|
{
|
|
Logger.LogWarning($"Artist Folder [{artistFolder}], Not Found For Artist `{release.Artist}`");
|
|
}
|
|
else
|
|
{
|
|
releaseFolder = release.ReleaseFileFolder(artistFolder);
|
|
if (!Directory.Exists(releaseFolder))
|
|
{
|
|
Logger.LogWarning($"Release Folder [{releaseFolder}], Not Found For Release `{release}`");
|
|
}
|
|
else
|
|
{
|
|
var releaseCoverFiles = ImageHelper.FindImageTypeInDirectory(new DirectoryInfo(releaseFolder), ImageType.Release);
|
|
if (releaseCoverFiles.Any())
|
|
{
|
|
imageBytes = File.ReadAllBytes(releaseCoverFiles.First().FullName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex, $"Error Reading Release Folder [{releaseFolder}] Artist Folder [{artistFolder}] For Artist `{release.Artist.Id}`");
|
|
}
|
|
IImage image = new Library.Imaging.Image(id)
|
|
{
|
|
Bytes = imageBytes,
|
|
CreatedDate = release.CreatedDate
|
|
};
|
|
if (imageBytes?.Any() != true)
|
|
{
|
|
image = DefaultNotFoundImages.Release;
|
|
}
|
|
return GenerateFileOperationResult(id, image, etag);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError($"Error fetching Release Thumbnail [{id}]", ex);
|
|
}
|
|
|
|
return new FileOperationResult<IImage>(OperationMessages.ErrorOccured);
|
|
}
|
|
|
|
private async Task<FileOperationResult<IImage>> ReleaseSecondaryImageAction(Guid id, int imageId, EntityTagHeaderValue etag = null)
|
|
{
|
|
try
|
|
{
|
|
var release = await GetRelease(id);
|
|
if (release == null)
|
|
{
|
|
return new FileOperationResult<IImage>(true, string.Format("Release Not Found [{0}]", id));
|
|
}
|
|
byte[] imageBytes = null;
|
|
string artistFolder = null;
|
|
string releaseFolder = null;
|
|
try
|
|
{
|
|
// See if cover art file exists in release folder
|
|
artistFolder = release.Artist.ArtistFileFolder(Configuration);
|
|
if (!Directory.Exists(artistFolder))
|
|
{
|
|
Logger.LogWarning($"Artist Folder [{artistFolder}], Not Found For Artist `{release.Artist}`");
|
|
}
|
|
else
|
|
{
|
|
releaseFolder = release.ReleaseFileFolder(artistFolder);
|
|
if (!Directory.Exists(releaseFolder))
|
|
{
|
|
Logger.LogWarning($"Release Folder [{releaseFolder}], Not Found For Release `{release}`");
|
|
}
|
|
else
|
|
{
|
|
var releaseSecondaryImages = ImageHelper
|
|
.FindImageTypeInDirectory(new DirectoryInfo(releaseFolder), ImageType.ReleaseSecondary)
|
|
.ToArray();
|
|
if (releaseSecondaryImages.Length >= imageId && releaseSecondaryImages[imageId] != null)
|
|
imageBytes = File.ReadAllBytes(releaseSecondaryImages[imageId].FullName);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex,
|
|
$"Error Reading Release Folder [{releaseFolder}] Artist Folder [{artistFolder}] For Artist `{release.Artist.Id}`");
|
|
}
|
|
|
|
IImage image = new Library.Imaging.Image(id)
|
|
{
|
|
Bytes = imageBytes,
|
|
CreatedDate = release.CreatedDate
|
|
};
|
|
return GenerateFileOperationResult(id, image, etag);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError($"Error fetching Release Thumbnail [{id}]", ex);
|
|
}
|
|
|
|
return new FileOperationResult<IImage>(OperationMessages.ErrorOccured);
|
|
}
|
|
|
|
private async Task<FileOperationResult<IImage>> TrackImageAction(Guid id, int? width, int? height, EntityTagHeaderValue etag = null)
|
|
{
|
|
try
|
|
{
|
|
var track = await GetTrack(id);
|
|
if (track == null)
|
|
{
|
|
return new FileOperationResult<IImage>(true, string.Format("Track Not Found [{0}]", id));
|
|
}
|
|
IImage image = new Library.Imaging.Image(id)
|
|
{
|
|
CreatedDate = track.CreatedDate
|
|
};
|
|
var trackImageFileName = track.PathToTrackThumbnail(Configuration);
|
|
if (File.Exists(trackImageFileName))
|
|
{
|
|
image.Bytes = File.ReadAllBytes(trackImageFileName);
|
|
}
|
|
if (image.Bytes == null || !image.Bytes.Any())
|
|
{
|
|
// If no track image is found then return image for release
|
|
return await ReleaseImage(track.ReleaseMedia.Release.RoadieId, width, height, etag);
|
|
}
|
|
return GenerateFileOperationResult(id, image, etag);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError($"Error fetching Track Thumbnail [{id}]", ex);
|
|
}
|
|
|
|
return new FileOperationResult<IImage>(OperationMessages.ErrorOccured);
|
|
}
|
|
|
|
private async Task<FileOperationResult<IImage>> UserImageAction(Guid id, EntityTagHeaderValue etag = null)
|
|
{
|
|
try
|
|
{
|
|
var user = await GetUser(id);
|
|
if (user == null)
|
|
{
|
|
return new FileOperationResult<IImage>(true, string.Format("User Not Found [{0}]", id));
|
|
}
|
|
IImage image = new Library.Imaging.Image(id)
|
|
{
|
|
CreatedDate = user.CreatedDate.Value
|
|
};
|
|
var userImageFilename = user.PathToImage(Configuration);
|
|
try
|
|
{
|
|
if (File.Exists(userImageFilename))
|
|
{
|
|
image.Bytes = File.ReadAllBytes(userImageFilename);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex, $"Error Reading Image File [{userImageFilename}]");
|
|
}
|
|
if (image.Bytes == null || !image.Bytes.Any())
|
|
{
|
|
image = DefaultNotFoundImages.User;
|
|
}
|
|
return GenerateFileOperationResult(id, image, etag, "image/png");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError($"Error fetching User Thumbnail [{id}]", ex);
|
|
}
|
|
|
|
return new FileOperationResult<IImage>(OperationMessages.ErrorOccured);
|
|
}
|
|
}
|
|
} |