mirror of
https://github.com/sphildreth/roadie
synced 2024-09-20 06:32:02 +00:00
1405 lines
No EOL
68 KiB
C#
1405 lines
No EOL
68 KiB
C#
using Mapster;
|
|
using Microsoft.AspNetCore.Http;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.Logging;
|
|
using Newtonsoft.Json;
|
|
using Roadie.Library;
|
|
using Roadie.Library.Caching;
|
|
using Roadie.Library.Configuration;
|
|
using Roadie.Library.Encoding;
|
|
using Roadie.Library.Engines;
|
|
using Roadie.Library.Enums;
|
|
using Roadie.Library.Extensions;
|
|
using Roadie.Library.Identity;
|
|
using Roadie.Library.Imaging;
|
|
using Roadie.Library.MetaData.Audio;
|
|
using Roadie.Library.MetaData.FileName;
|
|
using Roadie.Library.MetaData.ID3Tags;
|
|
using Roadie.Library.MetaData.LastFm;
|
|
using Roadie.Library.Models;
|
|
using Roadie.Library.Models.Pagination;
|
|
using Roadie.Library.Models.Releases;
|
|
using Roadie.Library.Models.Statistics;
|
|
using Roadie.Library.Models.Users;
|
|
using Roadie.Library.Processors;
|
|
using Roadie.Library.Utility;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Linq.Dynamic.Core;
|
|
using System.Threading.Tasks;
|
|
using data = Roadie.Library.Data;
|
|
using mb = Roadie.Library.MetaData.MusicBrainz;
|
|
|
|
namespace Roadie.Api.Services
|
|
{
|
|
public class ArtistService : ServiceBase, IArtistService
|
|
{
|
|
private IArtistLookupEngine ArtistLookupEngine { get; }
|
|
|
|
private IAudioMetaDataHelper AudioMetaDataHelper { get; }
|
|
|
|
private IBookmarkService BookmarkService { get; }
|
|
|
|
private ICollectionService CollectionService { get; }
|
|
|
|
private IFileNameHelper FileNameHelper { get; }
|
|
|
|
private IID3TagsHelper ID3TagsHelper { get; }
|
|
|
|
private ILabelLookupEngine LabelLookupEngine { get; }
|
|
|
|
private ILastFmHelper LastFmHelper { get; }
|
|
|
|
private mb.IMusicBrainzProvider MusicBrainzProvider { get; }
|
|
|
|
private IPlaylistService PlaylistService { get; }
|
|
|
|
private IReleaseLookupEngine ReleaseLookupEngine { get; }
|
|
|
|
private IReleaseService ReleaseService { get; }
|
|
|
|
private IFileDirectoryProcessorService FileDirectoryProcessorService { get; }
|
|
|
|
public ArtistService(IRoadieSettings configuration,
|
|
IHttpEncoder httpEncoder,
|
|
IHttpContext httpContext,
|
|
data.IRoadieDbContext dbContext,
|
|
ICacheManager cacheManager,
|
|
ILogger<ArtistService> logger,
|
|
ICollectionService collectionService,
|
|
IPlaylistService playlistService,
|
|
IBookmarkService bookmarkService,
|
|
IReleaseService releaseService,
|
|
IArtistLookupEngine artistLookupEngine,
|
|
mb.IMusicBrainzProvider musicBrainzProvider,
|
|
ILastFmHelper lastFmHelper,
|
|
IFileNameHelper fileNameHelper,
|
|
IID3TagsHelper id3tagsHelper,
|
|
IAudioMetaDataHelper audioMetaDataHelper,
|
|
IReleaseLookupEngine releaseLookupEngine,
|
|
ILabelLookupEngine labelLookupEngine,
|
|
IFileDirectoryProcessorService fileDirectoryProcessorService
|
|
)
|
|
: base(configuration, httpEncoder, dbContext, cacheManager, logger, httpContext)
|
|
{
|
|
CollectionService = collectionService;
|
|
PlaylistService = playlistService;
|
|
BookmarkService = bookmarkService;
|
|
|
|
MusicBrainzProvider = musicBrainzProvider;
|
|
LastFmHelper = lastFmHelper;
|
|
FileNameHelper = fileNameHelper;
|
|
ID3TagsHelper = id3tagsHelper;
|
|
|
|
ArtistLookupEngine = artistLookupEngine;
|
|
LabelLookupEngine = labelLookupEngine;
|
|
ReleaseLookupEngine = releaseLookupEngine;
|
|
|
|
AudioMetaDataHelper = audioMetaDataHelper;
|
|
|
|
ReleaseService = releaseService;
|
|
FileDirectoryProcessorService = fileDirectoryProcessorService;
|
|
}
|
|
|
|
public async Task<OperationResult<Artist>> ById(User roadieUser, Guid id, IEnumerable<string> includes)
|
|
{
|
|
var timings = new Dictionary<string, long>();
|
|
var tsw = new Stopwatch();
|
|
|
|
var sw = Stopwatch.StartNew();
|
|
sw.Start();
|
|
var cacheKey = $"urn:artist_by_id_operation:{id}:{(includes == null ? "0" : string.Join("|", includes))}";
|
|
var result = await CacheManager.GetAsync(cacheKey, async () =>
|
|
{
|
|
tsw.Restart();
|
|
var rr = await ArtistByIdAction(id, includes);
|
|
tsw.Stop();
|
|
timings.Add("ArtistByIdAction", tsw.ElapsedMilliseconds);
|
|
return rr;
|
|
}, data.Artist.CacheRegionUrn(id));
|
|
if (result?.Data != null && roadieUser != null)
|
|
{
|
|
tsw.Restart();
|
|
var artist = GetArtist(id);
|
|
tsw.Stop();
|
|
timings.Add("GetArtist", tsw.ElapsedMilliseconds);
|
|
tsw.Restart();
|
|
var userBookmarkResult =
|
|
await BookmarkService.List(roadieUser, new PagedRequest(), false, BookmarkType.Artist);
|
|
if (userBookmarkResult.IsSuccess)
|
|
result.Data.UserBookmarked =
|
|
userBookmarkResult?.Rows?.FirstOrDefault(x => x.Bookmark.Value == artist.RoadieId.ToString()) !=
|
|
null;
|
|
tsw.Stop();
|
|
timings.Add("userBookmarkResult", tsw.ElapsedMilliseconds);
|
|
tsw.Restart();
|
|
var userArtist =
|
|
DbContext.UserArtists.FirstOrDefault(x => x.ArtistId == artist.Id && x.UserId == roadieUser.Id);
|
|
if (userArtist != null)
|
|
result.Data.UserRating = new UserArtist
|
|
{
|
|
IsDisliked = userArtist.IsDisliked ?? false,
|
|
IsFavorite = userArtist.IsFavorite ?? false,
|
|
Rating = userArtist.Rating
|
|
};
|
|
tsw.Stop();
|
|
timings.Add("userArtist", tsw.ElapsedMilliseconds);
|
|
|
|
if (result.Data.Comments.Any())
|
|
{
|
|
tsw.Restart();
|
|
var commentIds = result.Data.Comments.Select(x => x.DatabaseId).ToArray();
|
|
var userCommentReactions = (from cr in DbContext.CommentReactions
|
|
where commentIds.Contains(cr.CommentId)
|
|
where cr.UserId == roadieUser.Id
|
|
select cr).ToArray();
|
|
foreach (var comment in result.Data.Comments)
|
|
{
|
|
var userCommentReaction =
|
|
userCommentReactions.FirstOrDefault(x => x.CommentId == comment.DatabaseId);
|
|
comment.IsDisliked = userCommentReaction?.ReactionValue == CommentReaction.Dislike;
|
|
comment.IsLiked = userCommentReaction?.ReactionValue == CommentReaction.Like;
|
|
}
|
|
|
|
tsw.Stop();
|
|
timings.Add("commentReactions", tsw.ElapsedMilliseconds);
|
|
}
|
|
}
|
|
|
|
sw.Stop();
|
|
timings.Add("operation", sw.ElapsedMilliseconds);
|
|
Logger.LogDebug("ById Timings: id [{0}], includes [{1}], timings [{3}]", id, includes,
|
|
JsonConvert.SerializeObject(timings));
|
|
return new OperationResult<Artist>(result.Messages)
|
|
{
|
|
Data = result?.Data,
|
|
Errors = result?.Errors,
|
|
IsNotFoundResult = result?.IsNotFoundResult ?? false,
|
|
IsSuccess = result?.IsSuccess ?? false,
|
|
OperationTime = sw.ElapsedMilliseconds
|
|
};
|
|
}
|
|
|
|
public async Task<OperationResult<bool>> Delete(ApplicationUser user, data.Artist Artist)
|
|
{
|
|
var isSuccess = false;
|
|
try
|
|
{
|
|
if (Artist != null)
|
|
{
|
|
DbContext.Artists.Remove(Artist);
|
|
await DbContext.SaveChangesAsync();
|
|
CacheManager.ClearRegion(Artist.CacheRegion);
|
|
Logger.LogInformation(string.Format("x DeleteArtist [{0}]", Artist.Id));
|
|
isSuccess = true;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex, ex.Serialize());
|
|
return new OperationResult<bool>
|
|
{
|
|
Errors = new Exception[1] { ex }
|
|
};
|
|
}
|
|
|
|
return new OperationResult<bool>
|
|
{
|
|
IsSuccess = isSuccess,
|
|
Data = isSuccess
|
|
};
|
|
}
|
|
|
|
private OperationResult<data.Artist> GetByExternalIds(string musicBrainzId = null, string iTunesId = null, string amgId = null, string spotifyId = null)
|
|
{
|
|
var sw = new Stopwatch();
|
|
sw.Start();
|
|
var artist = (from a in DbContext.Artists
|
|
where a.MusicBrainzId != null && musicBrainzId != null && a.MusicBrainzId == musicBrainzId ||
|
|
a.ITunesId != null || iTunesId != null && a.ITunesId == iTunesId || a.AmgId != null ||
|
|
amgId != null && a.AmgId == amgId || a.SpotifyId != null ||
|
|
spotifyId != null && a.SpotifyId == spotifyId
|
|
select a).FirstOrDefault();
|
|
sw.Stop();
|
|
if (artist == null || !artist.IsValid)
|
|
Logger.LogTrace(
|
|
"ArtistFactory: Artist Not Found By External Ids: MusicbrainzId [{0}], iTunesIs [{1}], AmgId [{2}], SpotifyId [{3}]",
|
|
musicBrainzId, iTunesId, amgId, spotifyId);
|
|
return new OperationResult<data.Artist>
|
|
{
|
|
IsSuccess = artist != null,
|
|
OperationTime = sw.ElapsedMilliseconds,
|
|
Data = artist
|
|
};
|
|
}
|
|
|
|
public async Task<Library.Models.Pagination.PagedResult<ArtistList>> List(User roadieUser, PagedRequest request,
|
|
bool? doRandomize = false, bool? onlyIncludeWithReleases = true)
|
|
{
|
|
var sw = new Stopwatch();
|
|
sw.Start();
|
|
|
|
IQueryable<int> favoriteArtistIds = null;
|
|
if (request.FilterFavoriteOnly)
|
|
favoriteArtistIds = from a in DbContext.Artists
|
|
join ua in DbContext.UserArtists on a.Id equals ua.ArtistId
|
|
where ua.IsFavorite ?? false
|
|
where roadieUser == null || ua.UserId == roadieUser.Id
|
|
select a.Id;
|
|
IQueryable<int> labelArtistIds = null;
|
|
if (request.FilterToLabelId.HasValue)
|
|
labelArtistIds = (from l in DbContext.Labels
|
|
join rl in DbContext.ReleaseLabels on l.Id equals rl.LabelId
|
|
join r in DbContext.Releases on rl.ReleaseId equals r.Id
|
|
where l.RoadieId == request.FilterToLabelId
|
|
select r.ArtistId)
|
|
.Distinct();
|
|
IQueryable<int> genreArtistIds = null;
|
|
var isFilteredToGenre = false;
|
|
if (!string.IsNullOrEmpty(request.Filter) &&
|
|
request.Filter.StartsWith(":genre", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
var genreFilter = request.Filter.Replace(":genre ", "");
|
|
genreArtistIds = (from ag in DbContext.ArtistGenres
|
|
join g in DbContext.Genres on ag.GenreId equals g.Id
|
|
where g.Name.Contains(genreFilter)
|
|
select ag.ArtistId)
|
|
.Distinct();
|
|
isFilteredToGenre = true;
|
|
request.Filter = null;
|
|
}
|
|
|
|
var onlyWithReleases = onlyIncludeWithReleases ?? true;
|
|
var isEqualFilter = false;
|
|
if (!string.IsNullOrEmpty(request.FilterValue))
|
|
{
|
|
var filter = request.FilterValue;
|
|
// if filter string is wrapped in quotes then is an exact not like search, e.g. "Diana Ross" should not return "Diana Ross & The Supremes"
|
|
if (filter.StartsWith('"') && filter.EndsWith('"'))
|
|
{
|
|
isEqualFilter = true;
|
|
request.Filter = filter.Substring(1, filter.Length - 2);
|
|
}
|
|
}
|
|
|
|
var normalizedFilterValue = !string.IsNullOrEmpty(request.FilterValue)
|
|
? request.FilterValue.ToAlphanumericName()
|
|
: null;
|
|
var result = (from a in DbContext.Artists
|
|
where !onlyWithReleases || a.ReleaseCount > 0
|
|
where request.FilterToArtistId == null || a.RoadieId == request.FilterToArtistId
|
|
where request.FilterMinimumRating == null || a.Rating >= request.FilterMinimumRating.Value
|
|
where request.FilterValue == "" || a.Name.Contains(request.FilterValue) ||
|
|
a.SortName.Contains(request.FilterValue) || a.AlternateNames.Contains(request.FilterValue) ||
|
|
a.AlternateNames.Contains(normalizedFilterValue)
|
|
where !isEqualFilter || a.Name.Equals(request.FilterValue) || a.SortName.Equals(request.FilterValue) ||
|
|
a.AlternateNames.Equals(request.FilterValue) || a.AlternateNames.Equals(normalizedFilterValue)
|
|
where !request.FilterFavoriteOnly || favoriteArtistIds.Contains(a.Id)
|
|
where request.FilterToLabelId == null || labelArtistIds.Contains(a.Id)
|
|
where !isFilteredToGenre || genreArtistIds.Contains(a.Id)
|
|
select new ArtistList
|
|
{
|
|
DatabaseId = a.Id,
|
|
Id = a.RoadieId,
|
|
Artist = new DataToken
|
|
{
|
|
Text = a.Name,
|
|
Value = a.RoadieId.ToString()
|
|
},
|
|
Thumbnail = MakeArtistThumbnailImage(a.RoadieId),
|
|
Rating = a.Rating,
|
|
Rank = a.Rank,
|
|
CreatedDate = a.CreatedDate,
|
|
LastUpdated = a.LastUpdated,
|
|
LastPlayed = a.LastPlayed,
|
|
PlayedCount = a.PlayedCount,
|
|
ReleaseCount = a.ReleaseCount,
|
|
TrackCount = a.TrackCount,
|
|
SortName = a.SortName
|
|
}).Distinct();
|
|
|
|
ArtistList[] rows;
|
|
var rowCount = result.Count();
|
|
if (doRandomize ?? false)
|
|
{
|
|
var randomLimit = roadieUser?.RandomReleaseLimit ?? 100;
|
|
request.Limit = request.LimitValue > randomLimit ? randomLimit : request.LimitValue;
|
|
rows = result.OrderBy(x => x.RandomSortId).Skip(request.SkipValue).Take(request.LimitValue).ToArray();
|
|
}
|
|
else
|
|
{
|
|
string sortBy;
|
|
if (request.ActionValue == User.ActionKeyUserRated)
|
|
sortBy = string.IsNullOrEmpty(request.Sort)
|
|
? request.OrderValue(
|
|
new Dictionary<string, string> { { "Rating", "DESC" }, { "Artist.Text", "ASC" } })
|
|
: request.OrderValue();
|
|
else
|
|
sortBy = request.OrderValue(new Dictionary<string, string>
|
|
{{"SortName", "ASC"}, {"Artist.Text", "ASC"}});
|
|
rows = result.OrderBy(sortBy).Skip(request.SkipValue).Take(request.LimitValue).ToArray();
|
|
}
|
|
|
|
if (rows.Any() && roadieUser != null)
|
|
{
|
|
var rowIds = rows.Select(x => x.DatabaseId).ToArray();
|
|
var userArtistRatings = (from ua in DbContext.UserArtists
|
|
where ua.UserId == roadieUser.Id
|
|
where rowIds.Contains(ua.ArtistId)
|
|
select ua).ToArray();
|
|
|
|
foreach (var userArtistRating in userArtistRatings.Where(x =>
|
|
rows.Select(r => r.DatabaseId).Contains(x.ArtistId)))
|
|
{
|
|
var row = rows.FirstOrDefault(x => x.DatabaseId == userArtistRating.ArtistId);
|
|
if (row != null)
|
|
row.UserRating = new UserArtist
|
|
{
|
|
IsDisliked = userArtistRating.IsDisliked ?? false,
|
|
IsFavorite = userArtistRating.IsFavorite ?? false,
|
|
Rating = userArtistRating.Rating,
|
|
RatedDate = userArtistRating.LastUpdated ?? userArtistRating.CreatedDate
|
|
};
|
|
}
|
|
}
|
|
|
|
sw.Stop();
|
|
if (!string.IsNullOrEmpty(request.Filter) && rowCount == 0)
|
|
if (Configuration.RecordNoResultSearches)
|
|
{
|
|
// Create request for no artist found
|
|
var req = new data.Request
|
|
{
|
|
UserId = roadieUser?.Id,
|
|
Description = request.Filter
|
|
};
|
|
DbContext.Requests.Add(req);
|
|
await DbContext.SaveChangesAsync();
|
|
}
|
|
|
|
return new Library.Models.Pagination.PagedResult<ArtistList>
|
|
{
|
|
TotalCount = rowCount,
|
|
CurrentPage = request.PageValue,
|
|
TotalPages = (int)Math.Ceiling((double)rowCount / request.LimitValue),
|
|
OperationTime = sw.ElapsedMilliseconds,
|
|
Rows = rows
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Merge one Artist into another one
|
|
/// </summary>
|
|
/// <param name="artistToMerge">The Artist to be merged</param>
|
|
/// <param name="artistToMergeInto">The Artist to merge into</param>
|
|
/// <returns></returns>
|
|
public async Task<OperationResult<bool>> MergeArtists(ApplicationUser user, Guid artistToMergeId, Guid artistToMergeIntoId)
|
|
{
|
|
var sw = new Stopwatch();
|
|
sw.Start();
|
|
|
|
var errors = new List<Exception>();
|
|
var artistToMerge = DbContext.Artists
|
|
.Include(x => x.Genres)
|
|
.Include("Genres.Genre")
|
|
.FirstOrDefault(x => x.RoadieId == artistToMergeId);
|
|
if (artistToMerge == null)
|
|
{
|
|
Logger.LogWarning("MergeArtists Unknown Artist [{0}]", artistToMergeId);
|
|
return new OperationResult<bool>(true, $"Artist Not Found [{artistToMergeId}]");
|
|
}
|
|
|
|
var mergeIntoArtist = DbContext.Artists
|
|
.Include(x => x.Genres)
|
|
.Include("Genres.Genre")
|
|
.FirstOrDefault(x => x.RoadieId == artistToMergeIntoId);
|
|
if (mergeIntoArtist == null)
|
|
{
|
|
Logger.LogWarning("MergeArtists Unknown Artist [{0}]", artistToMergeIntoId);
|
|
return new OperationResult<bool>(true, $"Artist Not Found [{artistToMergeIntoId}]");
|
|
}
|
|
|
|
try
|
|
{
|
|
var result = await MergeArtists(user, artistToMerge, mergeIntoArtist);
|
|
if (!result.IsSuccess)
|
|
{
|
|
CacheManager.ClearRegion(artistToMerge.CacheRegion);
|
|
CacheManager.ClearRegion(mergeIntoArtist.CacheRegion);
|
|
Logger.LogInformation("MergeArtists `{0}` => `{1}`, By User `{2}`", artistToMerge, mergeIntoArtist,
|
|
user);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex);
|
|
errors.Add(ex);
|
|
}
|
|
|
|
sw.Stop();
|
|
|
|
return new OperationResult<bool>
|
|
{
|
|
IsSuccess = !errors.Any(),
|
|
Data = !errors.Any(),
|
|
OperationTime = sw.ElapsedMilliseconds,
|
|
Errors = errors
|
|
};
|
|
}
|
|
|
|
|
|
async Task<OperationResult<data.Artist>> MergeArtists(ApplicationUser user, data.Artist artistToMerge, data.Artist artistToMergeInto)
|
|
{
|
|
SimpleContract.Requires<ArgumentNullException>(artistToMerge != null, "Invalid Artist");
|
|
SimpleContract.Requires<ArgumentNullException>(artistToMergeInto != null, "Invalid Artist");
|
|
|
|
var result = false;
|
|
var now = DateTime.UtcNow;
|
|
|
|
var sw = new Stopwatch();
|
|
sw.Start();
|
|
|
|
artistToMergeInto.RealName = artistToMerge.RealName ?? artistToMergeInto.RealName;
|
|
artistToMergeInto.MusicBrainzId = artistToMerge.MusicBrainzId ?? artistToMergeInto.MusicBrainzId;
|
|
artistToMergeInto.ITunesId = artistToMerge.ITunesId ?? artistToMergeInto.ITunesId;
|
|
artistToMergeInto.AmgId = artistToMerge.AmgId ?? artistToMergeInto.AmgId;
|
|
artistToMergeInto.SpotifyId = artistToMerge.SpotifyId ?? artistToMergeInto.SpotifyId;
|
|
artistToMergeInto.Thumbnail = artistToMerge.Thumbnail ?? artistToMergeInto.Thumbnail;
|
|
artistToMergeInto.Profile = artistToMerge.Profile ?? artistToMergeInto.Profile;
|
|
artistToMergeInto.BirthDate = artistToMerge.BirthDate ?? artistToMergeInto.BirthDate;
|
|
artistToMergeInto.BeginDate = artistToMerge.BeginDate ?? artistToMergeInto.BeginDate;
|
|
artistToMergeInto.EndDate = artistToMerge.EndDate ?? artistToMergeInto.EndDate;
|
|
if (!string.IsNullOrEmpty(artistToMerge.ArtistType) && !artistToMerge.ArtistType.Equals("Other", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
artistToMergeInto.ArtistType = artistToMerge.ArtistType;
|
|
}
|
|
artistToMergeInto.BioContext = artistToMerge.BioContext ?? artistToMergeInto.BioContext;
|
|
artistToMergeInto.DiscogsId = artistToMerge.DiscogsId ?? artistToMergeInto.DiscogsId;
|
|
artistToMergeInto.Tags = artistToMergeInto.Tags.AddToDelimitedList(artistToMerge.Tags.ToListFromDelimited());
|
|
var altNames = artistToMerge.AlternateNames.ToListFromDelimited().ToList();
|
|
altNames.Add(artistToMerge.Name);
|
|
altNames.Add(artistToMerge.SortName);
|
|
artistToMergeInto.AlternateNames = artistToMergeInto.AlternateNames.AddToDelimitedList(altNames);
|
|
artistToMergeInto.URLs = artistToMergeInto.URLs.AddToDelimitedList(artistToMerge.URLs.ToListFromDelimited());
|
|
artistToMergeInto.ISNI = artistToMergeInto.ISNI.AddToDelimitedList(artistToMerge.ISNI.ToListFromDelimited());
|
|
artistToMergeInto.LastUpdated = now;
|
|
|
|
try
|
|
{
|
|
var artistGenres = DbContext.ArtistGenres.Where(x => x.ArtistId == artistToMerge.Id).ToArray();
|
|
if (artistGenres != null)
|
|
{
|
|
foreach (var artistGenre in artistGenres)
|
|
{
|
|
artistGenre.ArtistId = artistToMergeInto.Id;
|
|
}
|
|
}
|
|
var artistImages = DbContext.Images.Where(x => x.ArtistId == artistToMerge.Id).ToArray();
|
|
if (artistImages != null)
|
|
{
|
|
foreach (var artistImage in artistImages)
|
|
{
|
|
artistImage.ArtistId = artistToMergeInto.Id;
|
|
}
|
|
}
|
|
var userArtists = DbContext.UserArtists.Where(x => x.ArtistId == artistToMerge.Id).ToArray();
|
|
if (artistImages != null)
|
|
{
|
|
foreach (var userArtist in userArtists)
|
|
{
|
|
userArtist.ArtistId = artistToMergeInto.Id;
|
|
}
|
|
}
|
|
var artistTracks = DbContext.Tracks.Where(x => x.ArtistId == artistToMerge.Id).ToArray();
|
|
if (artistTracks != null)
|
|
{
|
|
foreach (var artistTrack in artistTracks)
|
|
{
|
|
artistTrack.ArtistId = artistToMergeInto.Id;
|
|
}
|
|
}
|
|
var artistReleases = DbContext.Releases.Where(x => x.ArtistId == artistToMerge.Id).ToArray();
|
|
if (artistReleases != null)
|
|
{
|
|
foreach (var artistRelease in artistReleases)
|
|
{
|
|
// See if there is already a release by the same name for the artist to merge into, if so then merge releases
|
|
var artistToMergeHasRelease = DbContext.Releases.FirstOrDefault(x => x.ArtistId == artistToMerge.Id && x.Title == artistRelease.Title);
|
|
if (artistToMergeHasRelease != null)
|
|
{
|
|
await ReleaseService.MergeReleases(user, artistRelease, artistToMergeHasRelease, false);
|
|
}
|
|
else
|
|
{
|
|
artistRelease.ArtistId = artistToMerge.Id;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogWarning(ex.ToString());
|
|
}
|
|
|
|
var artistFolder = artistToMerge.ArtistFileFolder(Configuration);
|
|
foreach (var release in DbContext.Releases.Include("Artist").Where(x => x.ArtistId == artistToMerge.Id).ToArray())
|
|
{
|
|
var originalReleaseFolder = release.ReleaseFileFolder(artistFolder);
|
|
await ReleaseService.UpdateRelease(user, release.Adapt<Release>(), originalReleaseFolder);
|
|
}
|
|
await Delete(user, artistToMerge);
|
|
|
|
|
|
result = true;
|
|
|
|
sw.Stop();
|
|
return new OperationResult<data.Artist>
|
|
{
|
|
Data = artistToMergeInto,
|
|
IsSuccess = result,
|
|
OperationTime = sw.ElapsedMilliseconds
|
|
};
|
|
}
|
|
|
|
public async Task<OperationResult<bool>> RefreshArtistMetadata(ApplicationUser user, Guid artistId)
|
|
{
|
|
SimpleContract.Requires<ArgumentOutOfRangeException>(artistId != Guid.Empty, "Invalid ArtistId");
|
|
|
|
var result = true;
|
|
var resultErrors = new List<Exception>();
|
|
var sw = new Stopwatch();
|
|
sw.Start();
|
|
try
|
|
{
|
|
var artist = DbContext.Artists.FirstOrDefault(x => x.RoadieId == artistId);
|
|
if (artist == null)
|
|
{
|
|
Logger.LogWarning("Unable To Find Artist [{0}]", artistId);
|
|
return new OperationResult<bool>();
|
|
}
|
|
|
|
OperationResult<data.Artist> artistSearch = null;
|
|
try
|
|
{
|
|
artistSearch = await ArtistLookupEngine.PerformMetaDataProvidersArtistSearch(new AudioMetaData
|
|
{
|
|
Artist = artist.Name
|
|
});
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex, ex.Serialize());
|
|
}
|
|
|
|
if (artistSearch.IsSuccess)
|
|
{
|
|
// Do metadata search for Artist like if new Artist then set some overides and merge
|
|
var mergeResult = await MergeArtists(user, artistSearch.Data, artist);
|
|
if (mergeResult.IsSuccess)
|
|
{
|
|
artist = mergeResult.Data;
|
|
await DbContext.SaveChangesAsync();
|
|
sw.Stop();
|
|
CacheManager.ClearRegion(artist.CacheRegion);
|
|
Logger.LogInformation("Scanned RefreshArtistMetadata [{0}], OperationTime [{1}]",
|
|
artist.ToString(), sw.ElapsedMilliseconds);
|
|
}
|
|
else
|
|
{
|
|
sw.Stop();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex, ex.Serialize());
|
|
resultErrors.Add(ex);
|
|
}
|
|
|
|
return new OperationResult<bool>
|
|
{
|
|
Data = result,
|
|
IsSuccess = result,
|
|
Errors = resultErrors,
|
|
OperationTime = sw.ElapsedMilliseconds
|
|
};
|
|
}
|
|
|
|
public async Task<OperationResult<Image>> SetReleaseImageByUrl(ApplicationUser user, Guid id, string imageUrl)
|
|
{
|
|
return await SaveImageBytes(user, id, WebHelper.BytesForImageUrl(imageUrl));
|
|
}
|
|
|
|
public async Task<OperationResult<bool>> UpdateArtist(ApplicationUser user, Artist model)
|
|
{
|
|
var didRenameArtist = false;
|
|
var didChangeThumbnail = false;
|
|
var sw = new Stopwatch();
|
|
sw.Start();
|
|
var errors = new List<Exception>();
|
|
var artist = DbContext.Artists
|
|
.Include(x => x.Genres)
|
|
.Include("Genres.Genre")
|
|
.FirstOrDefault(x => x.RoadieId == model.Id);
|
|
if (artist == null)
|
|
return new OperationResult<bool>(true, $"Artist Not Found [{model.Id}]");
|
|
try
|
|
{
|
|
var now = DateTime.UtcNow;
|
|
var originalArtistFolder = artist.ArtistFileFolder(Configuration);
|
|
var specialArtistName = model.Name.ToAlphanumericName();
|
|
var alt = new List<string>(model.AlternateNamesList);
|
|
if (!model.AlternateNamesList.Contains(specialArtistName, StringComparer.OrdinalIgnoreCase))
|
|
alt.Add(specialArtistName);
|
|
artist.AlternateNames = alt.ToDelimitedList();
|
|
artist.ArtistType = model.ArtistType;
|
|
artist.AmgId = model.AmgId;
|
|
artist.BeginDate = model.BeginDate;
|
|
artist.BioContext = model.BioContext;
|
|
artist.BirthDate = model.BirthDate;
|
|
artist.DiscogsId = model.DiscogsId;
|
|
artist.EndDate = model.EndDate;
|
|
artist.IsLocked = model.IsLocked;
|
|
artist.ISNI = model.ISNIList.ToDelimitedList();
|
|
artist.ITunesId = model.ITunesId;
|
|
artist.MusicBrainzId = model.MusicBrainzId;
|
|
artist.Name = model.Name;
|
|
artist.Profile = model.Profile;
|
|
artist.Rating = model.Rating;
|
|
artist.RealName = model.RealName;
|
|
artist.SortName = model.SortName;
|
|
artist.SpotifyId = model.SpotifyId;
|
|
artist.Status = SafeParser.ToEnum<Statuses>(model.Status);
|
|
artist.Tags = model.TagsList.ToDelimitedList();
|
|
artist.URLs = model.URLsList.ToDelimitedList();
|
|
|
|
var newArtistFolder = artist.ArtistFileFolder(Configuration);
|
|
if (!newArtistFolder.Equals(originalArtistFolder, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
didRenameArtist = true;
|
|
|
|
// Rename artist folder to reflect new artist name
|
|
Logger.LogTrace("Moving Artist From Folder [{0}] To [{1}]", originalArtistFolder, newArtistFolder);
|
|
Directory.Move(originalArtistFolder, newArtistFolder);
|
|
}
|
|
|
|
var artistImage = ImageHelper.ImageDataFromUrl(model.NewThumbnailData);
|
|
if (artistImage != null)
|
|
{
|
|
// Ensure is jpeg first
|
|
artist.Thumbnail = ImageHelper.ConvertToJpegFormat(artistImage);
|
|
|
|
// Save unaltered image to cover file
|
|
var artistImageName = Path.Combine(newArtistFolder, ImageHelper.ArtistImageFilename);
|
|
File.WriteAllBytes(artistImageName, artist.Thumbnail);
|
|
|
|
// Resize to store in database as thumbnail
|
|
artist.Thumbnail = ImageHelper.ResizeImage(artist.Thumbnail, Configuration.MediumImageSize.Width, Configuration.MediumImageSize.Height);
|
|
didChangeThumbnail = true;
|
|
}
|
|
|
|
if (model.NewSecondaryImagesData != null && model.NewSecondaryImagesData.Any())
|
|
{
|
|
// Additional images to add to artist
|
|
var looper = 0;
|
|
foreach (var newSecondaryImageData in model.NewSecondaryImagesData)
|
|
{
|
|
var artistSecondaryImage = ImageHelper.ImageDataFromUrl(newSecondaryImageData);
|
|
if (artistSecondaryImage != null)
|
|
{
|
|
// Ensure is jpeg first
|
|
artistSecondaryImage = ImageHelper.ConvertToJpegFormat(artistSecondaryImage);
|
|
|
|
var artistImageFilename = Path.Combine(newArtistFolder,string.Format(ImageHelper.ArtistSecondaryImageFilename, looper.ToString("00")));
|
|
while (File.Exists(artistImageFilename))
|
|
{
|
|
looper++;
|
|
artistImageFilename = Path.Combine(newArtistFolder,string.Format(ImageHelper.ArtistSecondaryImageFilename, looper.ToString("00")));
|
|
}
|
|
|
|
File.WriteAllBytes(artistImageFilename, artistSecondaryImage);
|
|
}
|
|
|
|
looper++;
|
|
}
|
|
}
|
|
|
|
if (model.Genres != null && model.Genres.Any())
|
|
{
|
|
// Remove existing Genres not in model list
|
|
foreach (var genre in artist.Genres.ToList())
|
|
{
|
|
var doesExistInModel = model.Genres.Any(x => SafeParser.ToGuid(x.Value) == genre.Genre.RoadieId);
|
|
if (!doesExistInModel) artist.Genres.Remove(genre);
|
|
}
|
|
|
|
// Add new Genres in model not in data
|
|
foreach (var genre in model.Genres)
|
|
{
|
|
var genreId = SafeParser.ToGuid(genre.Value);
|
|
var doesExistInData = artist.Genres.Any(x => x.Genre.RoadieId == genreId);
|
|
if (!doesExistInData)
|
|
{
|
|
var g = DbContext.Genres.FirstOrDefault(x => x.RoadieId == genreId);
|
|
if (g != null)
|
|
artist.Genres.Add(new data.ArtistGenre
|
|
{
|
|
ArtistId = artist.Id,
|
|
GenreId = g.Id,
|
|
Genre = g
|
|
});
|
|
}
|
|
}
|
|
}
|
|
else if (model.Genres == null || !model.Genres.Any())
|
|
{
|
|
artist.Genres.Clear();
|
|
}
|
|
|
|
if (model.AssociatedArtistsTokens != null && model.AssociatedArtistsTokens.Any())
|
|
{
|
|
var associatedArtists = DbContext.ArtistAssociations.Include(x => x.AssociatedArtist)
|
|
.Where(x => x.ArtistId == artist.Id).ToList();
|
|
|
|
// Remove existing AssociatedArtists not in model list
|
|
foreach (var associatedArtist in associatedArtists)
|
|
{
|
|
var doesExistInModel = model.AssociatedArtistsTokens.Any(x =>
|
|
SafeParser.ToGuid(x.Value) == associatedArtist.AssociatedArtist.RoadieId);
|
|
if (!doesExistInModel) DbContext.ArtistAssociations.Remove(associatedArtist);
|
|
}
|
|
|
|
// Add new AssociatedArtists in model not in data
|
|
foreach (var associatedArtist in model.AssociatedArtistsTokens)
|
|
{
|
|
var associatedArtistId = SafeParser.ToGuid(associatedArtist.Value);
|
|
var doesExistInData =
|
|
associatedArtists.Any(x => x.AssociatedArtist.RoadieId == associatedArtistId);
|
|
if (!doesExistInData)
|
|
{
|
|
var a = DbContext.Artists.FirstOrDefault(x => x.RoadieId == associatedArtistId);
|
|
if (a != null)
|
|
DbContext.ArtistAssociations.Add(new data.ArtistAssociation
|
|
{
|
|
ArtistId = artist.Id,
|
|
AssociatedArtistId = a.Id
|
|
});
|
|
}
|
|
}
|
|
}
|
|
else if (model.AssociatedArtistsTokens == null || !model.AssociatedArtistsTokens.Any())
|
|
{
|
|
var associatedArtists = DbContext.ArtistAssociations.Include(x => x.AssociatedArtist).Where(x => x.ArtistId == artist.Id || x.AssociatedArtistId == artist.Id).ToList();
|
|
DbContext.ArtistAssociations.RemoveRange(associatedArtists);
|
|
}
|
|
|
|
if (model.SimilarArtistsTokens != null && model.SimilarArtistsTokens.Any())
|
|
{
|
|
var similarArtists = DbContext.ArtistSimilar.Include(x => x.SimilarArtist)
|
|
.Where(x => x.ArtistId == artist.Id).ToList();
|
|
|
|
// Remove existing AssociatedArtists not in model list
|
|
foreach (var similarArtist in similarArtists)
|
|
{
|
|
var doesExistInModel = model.SimilarArtistsTokens.Any(x =>
|
|
SafeParser.ToGuid(x.Value) == similarArtist.SimilarArtist.RoadieId);
|
|
if (!doesExistInModel) DbContext.ArtistSimilar.Remove(similarArtist);
|
|
}
|
|
|
|
// Add new SimilarArtists in model not in data
|
|
foreach (var similarArtist in model.SimilarArtistsTokens)
|
|
{
|
|
var similarArtistId = SafeParser.ToGuid(similarArtist.Value);
|
|
var doesExistInData = similarArtists.Any(x => x.SimilarArtist.RoadieId == similarArtistId);
|
|
if (!doesExistInData)
|
|
{
|
|
var a = DbContext.Artists.FirstOrDefault(x => x.RoadieId == similarArtistId);
|
|
if (a != null)
|
|
DbContext.ArtistSimilar.Add(new data.ArtistSimilar
|
|
{
|
|
ArtistId = artist.Id,
|
|
SimilarArtistId = a.Id
|
|
});
|
|
}
|
|
}
|
|
}
|
|
else if (model.SimilarArtistsTokens == null || !model.SimilarArtistsTokens.Any())
|
|
{
|
|
var similarArtists = DbContext.ArtistSimilar.Include(x => x.SimilarArtist).Where(x => x.ArtistId == artist.Id || x.SimilarArtistId == artist.Id).ToList();
|
|
DbContext.ArtistSimilar.RemoveRange(similarArtists);
|
|
}
|
|
|
|
if (model.Images != null && model.Images.Any())
|
|
{
|
|
// TODO
|
|
}
|
|
|
|
artist.LastUpdated = now;
|
|
await DbContext.SaveChangesAsync();
|
|
if (didRenameArtist)
|
|
{
|
|
// Update artist tracks to have new artist name in ID3 metadata
|
|
foreach (var mp3 in Directory.GetFiles(newArtistFolder, "*.mp3", SearchOption.AllDirectories))
|
|
{
|
|
var trackFileInfo = new FileInfo(mp3);
|
|
var audioMetaData = await AudioMetaDataHelper.GetInfo(trackFileInfo);
|
|
if (audioMetaData != null)
|
|
{
|
|
audioMetaData.Artist = artist.Name;
|
|
AudioMetaDataHelper.WriteTags(audioMetaData, trackFileInfo);
|
|
}
|
|
}
|
|
|
|
await ScanArtistReleasesFolders(user, artist.RoadieId, Configuration.LibraryFolder, false);
|
|
}
|
|
|
|
CacheManager.ClearRegion(artist.CacheRegion);
|
|
Logger.LogInformation(
|
|
$"UpdateArtist `{artist}` By User `{user}`: Renamed Artist [{didRenameArtist}], Uploaded new image [{didChangeThumbnail}]");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex);
|
|
errors.Add(ex);
|
|
}
|
|
|
|
sw.Stop();
|
|
|
|
return new OperationResult<bool>
|
|
{
|
|
IsSuccess = !errors.Any(),
|
|
Data = !errors.Any(),
|
|
OperationTime = sw.ElapsedMilliseconds,
|
|
Errors = errors
|
|
};
|
|
}
|
|
|
|
public async Task<OperationResult<Image>> UploadArtistImage(ApplicationUser user, Guid id, IFormFile file)
|
|
{
|
|
var bytes = new byte[0];
|
|
using (var ms = new MemoryStream())
|
|
{
|
|
file.CopyTo(ms);
|
|
bytes = ms.ToArray();
|
|
}
|
|
|
|
return await SaveImageBytes(user, id, bytes);
|
|
}
|
|
|
|
private async Task<OperationResult<Artist>> ArtistByIdAction(Guid id, IEnumerable<string> includes)
|
|
{
|
|
var timings = new Dictionary<string, long>();
|
|
var tsw = new Stopwatch();
|
|
|
|
var sw = Stopwatch.StartNew();
|
|
sw.Start();
|
|
|
|
tsw.Restart();
|
|
var artist = GetArtist(id);
|
|
tsw.Stop();
|
|
timings.Add("getArtist", tsw.ElapsedMilliseconds);
|
|
|
|
if (artist == null) return new OperationResult<Artist>(true, $"Artist Not Found [{id}]");
|
|
tsw.Restart();
|
|
var result = artist.Adapt<Artist>();
|
|
result.BandStatus = result.BandStatus ?? BandStatus.Unknown.ToString();
|
|
result.BeginDate = result.BeginDate == null || result.BeginDate == DateTime.MinValue
|
|
? null
|
|
: result.BeginDate;
|
|
result.EndDate = result.EndDate == null || result.EndDate == DateTime.MinValue ? null : result.EndDate;
|
|
result.BirthDate = result.BirthDate == null || result.BirthDate == DateTime.MinValue
|
|
? null
|
|
: result.BirthDate;
|
|
result.RankPosition = result.Rank > 0
|
|
? SafeParser.ToNumber<int?>(DbContext.Artists.Count(x => x.Rank > result.Rank) + 1)
|
|
: null;
|
|
tsw.Stop();
|
|
timings.Add("adaptArtist", tsw.ElapsedMilliseconds);
|
|
result.Thumbnail = MakeArtistThumbnailImage(id);
|
|
result.MediumThumbnail = MakeThumbnailImage(id, "artist", Configuration.MediumImageSize.Width,
|
|
Configuration.MediumImageSize.Height);
|
|
tsw.Restart();
|
|
result.Genres = artist.Genres.Select(x => new DataToken
|
|
{ Text = x.Genre.Name, Value = x.Genre.RoadieId.ToString() });
|
|
tsw.Stop();
|
|
timings.Add("genres", tsw.ElapsedMilliseconds);
|
|
|
|
if (includes != null && includes.Any())
|
|
{
|
|
if (includes.Contains("releases"))
|
|
{
|
|
var dtoReleases = new List<ReleaseList>();
|
|
foreach (var release in DbContext.Releases.Include("Medias").Include("Medias.Tracks")
|
|
.Include("Medias.Tracks").Where(x => x.ArtistId == artist.Id).ToArray())
|
|
{
|
|
var releaseList = release.Adapt<ReleaseList>();
|
|
releaseList.Thumbnail = MakeReleaseThumbnailImage(release.RoadieId);
|
|
var dtoReleaseMedia = new List<ReleaseMediaList>();
|
|
if (includes.Contains("tracks"))
|
|
foreach (var releasemedia in release.Medias.OrderBy(x => x.MediaNumber).ToArray())
|
|
{
|
|
var dtoMedia = releasemedia.Adapt<ReleaseMediaList>();
|
|
var tracks = new List<TrackList>();
|
|
foreach (var t in DbContext.Tracks.Where(x => x.ReleaseMediaId == releasemedia.Id)
|
|
.OrderBy(x => x.TrackNumber).ToArray())
|
|
{
|
|
var track = t.Adapt<TrackList>();
|
|
ArtistList trackArtist = null;
|
|
if (t.ArtistId.HasValue)
|
|
{
|
|
var ta = DbContext.Artists.FirstOrDefault(x => x.Id == t.ArtistId.Value);
|
|
if (ta != null)
|
|
trackArtist = ArtistList.FromDataArtist(ta,
|
|
MakeArtistThumbnailImage(ta.RoadieId));
|
|
}
|
|
|
|
track.TrackArtist = trackArtist;
|
|
tracks.Add(track);
|
|
}
|
|
|
|
dtoMedia.Tracks = tracks;
|
|
dtoReleaseMedia.Add(dtoMedia);
|
|
}
|
|
|
|
releaseList.Media = dtoReleaseMedia;
|
|
dtoReleases.Add(releaseList);
|
|
}
|
|
|
|
result.Releases = dtoReleases;
|
|
}
|
|
|
|
if (includes.Contains("stats"))
|
|
try
|
|
{
|
|
tsw.Restart();
|
|
var artistTracks = from r in DbContext.Releases
|
|
join rm in DbContext.ReleaseMedias on r.Id equals rm.ReleaseId
|
|
join t in DbContext.Tracks on rm.Id equals t.ReleaseMediaId
|
|
where r.ArtistId == artist.Id || t.ArtistId == artist.Id
|
|
select new
|
|
{
|
|
t.Id,
|
|
size = t.FileSize,
|
|
time = t.Duration,
|
|
isMissing = t.Hash == null
|
|
};
|
|
var validCartistTracks = artistTracks.Where(x => !x.isMissing);
|
|
var trackTime = validCartistTracks.Sum(x => (long?)x.time);
|
|
result.Statistics = new CollectionStatistics
|
|
{
|
|
FileSize = artistTracks.Sum(x => (long?)x.size).ToFileSize(),
|
|
MissingTrackCount = artistTracks.Count(x => x.isMissing),
|
|
ReleaseCount = artist.ReleaseCount,
|
|
ReleaseMediaCount = (from r in DbContext.Releases
|
|
join rm in DbContext.ReleaseMedias on r.Id equals rm.ReleaseId
|
|
where r.ArtistId == artist.Id
|
|
select rm.Id).Count(),
|
|
TrackTime = validCartistTracks.Any()
|
|
? new TimeInfo((decimal)trackTime).ToFullFormattedString()
|
|
: "--:--",
|
|
TrackCount = validCartistTracks.Count(),
|
|
TrackPlayedCount = artist.PlayedCount
|
|
};
|
|
tsw.Stop();
|
|
timings.Add("stats", tsw.ElapsedMilliseconds);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex, $"Error Getting Statistics for Artist `{artist}`");
|
|
}
|
|
|
|
if (includes.Contains("images"))
|
|
{
|
|
tsw.Restart();
|
|
result.Images = DbContext.Images.Where(x => x.ArtistId == artist.Id)
|
|
.Select(x => MakeFullsizeImage(x.RoadieId, x.Caption)).ToArray();
|
|
|
|
var artistFolder = artist.ArtistFileFolder(Configuration);
|
|
var artistImagesInFolder = ImageHelper.FindImageTypeInDirectory(new DirectoryInfo(artistFolder),
|
|
ImageType.ArtistSecondary, SearchOption.TopDirectoryOnly);
|
|
if (artistImagesInFolder.Any())
|
|
result.Images = result.Images.Concat(artistImagesInFolder.Select((x, i) =>
|
|
MakeFullsizeSecondaryImage(id, ImageType.ArtistSecondary, i)));
|
|
|
|
tsw.Stop();
|
|
timings.Add("images", tsw.ElapsedMilliseconds);
|
|
}
|
|
|
|
if (includes.Contains("associatedartists"))
|
|
{
|
|
tsw.Restart();
|
|
var associatedWithArtists = (from aa in DbContext.ArtistAssociations
|
|
join a in DbContext.Artists on aa.AssociatedArtistId equals a.Id
|
|
where aa.ArtistId == artist.Id
|
|
select new ArtistList
|
|
{
|
|
DatabaseId = a.Id,
|
|
Id = a.RoadieId,
|
|
Artist = new DataToken
|
|
{
|
|
Text = a.Name,
|
|
Value = a.RoadieId.ToString()
|
|
},
|
|
Thumbnail = MakeArtistThumbnailImage(a.RoadieId),
|
|
Rating = a.Rating,
|
|
Rank = a.Rank,
|
|
CreatedDate = a.CreatedDate,
|
|
LastUpdated = a.LastUpdated,
|
|
LastPlayed = a.LastPlayed,
|
|
PlayedCount = a.PlayedCount,
|
|
ReleaseCount = a.ReleaseCount,
|
|
TrackCount = a.TrackCount,
|
|
SortName = a.SortName
|
|
}).ToArray();
|
|
|
|
var associatedArtists = (from aa in DbContext.ArtistAssociations
|
|
join a in DbContext.Artists on aa.ArtistId equals a.Id
|
|
where aa.AssociatedArtistId == artist.Id
|
|
select new ArtistList
|
|
{
|
|
DatabaseId = a.Id,
|
|
Id = a.RoadieId,
|
|
Artist = new DataToken
|
|
{
|
|
Text = a.Name,
|
|
Value = a.RoadieId.ToString()
|
|
},
|
|
Thumbnail = MakeArtistThumbnailImage(a.RoadieId),
|
|
Rating = a.Rating,
|
|
Rank = a.Rank,
|
|
CreatedDate = a.CreatedDate,
|
|
LastUpdated = a.LastUpdated,
|
|
LastPlayed = a.LastPlayed,
|
|
PlayedCount = a.PlayedCount,
|
|
ReleaseCount = a.ReleaseCount,
|
|
TrackCount = a.TrackCount,
|
|
SortName = a.SortName
|
|
}).ToArray();
|
|
result.AssociatedArtists = associatedArtists.Union(associatedWithArtists, new ArtistListComparer())
|
|
.OrderBy(x => x.SortName);
|
|
result.AssociatedArtistsTokens = result.AssociatedArtists.Select(x => x.Artist).ToArray();
|
|
tsw.Stop();
|
|
timings.Add("associatedartists", tsw.ElapsedMilliseconds);
|
|
}
|
|
|
|
if (includes.Contains("similarartists"))
|
|
{
|
|
tsw.Restart();
|
|
var similarWithArtists = (from aa in DbContext.ArtistSimilar
|
|
join a in DbContext.Artists on aa.SimilarArtistId equals a.Id
|
|
where aa.ArtistId == artist.Id
|
|
select new ArtistList
|
|
{
|
|
DatabaseId = a.Id,
|
|
Id = a.RoadieId,
|
|
Artist = new DataToken
|
|
{
|
|
Text = a.Name,
|
|
Value = a.RoadieId.ToString()
|
|
},
|
|
Thumbnail = MakeArtistThumbnailImage(a.RoadieId),
|
|
Rating = a.Rating,
|
|
Rank = a.Rank,
|
|
CreatedDate = a.CreatedDate,
|
|
LastUpdated = a.LastUpdated,
|
|
LastPlayed = a.LastPlayed,
|
|
PlayedCount = a.PlayedCount,
|
|
ReleaseCount = a.ReleaseCount,
|
|
TrackCount = a.TrackCount,
|
|
SortName = a.SortName
|
|
}).ToArray();
|
|
|
|
var similarArtists = (from aa in DbContext.ArtistSimilar
|
|
join a in DbContext.Artists on aa.ArtistId equals a.Id
|
|
where aa.SimilarArtistId == artist.Id
|
|
select new ArtistList
|
|
{
|
|
DatabaseId = a.Id,
|
|
Id = a.RoadieId,
|
|
Artist = new DataToken
|
|
{
|
|
Text = a.Name,
|
|
Value = a.RoadieId.ToString()
|
|
},
|
|
Thumbnail = MakeArtistThumbnailImage(a.RoadieId),
|
|
Rating = a.Rating,
|
|
Rank = a.Rank,
|
|
CreatedDate = a.CreatedDate,
|
|
LastUpdated = a.LastUpdated,
|
|
LastPlayed = a.LastPlayed,
|
|
PlayedCount = a.PlayedCount,
|
|
ReleaseCount = a.ReleaseCount,
|
|
TrackCount = a.TrackCount,
|
|
SortName = a.SortName
|
|
}).ToArray();
|
|
result.SimilarArtists = similarWithArtists.Union(similarArtists, new ArtistListComparer())
|
|
.OrderBy(x => x.SortName);
|
|
result.SimilarArtistsTokens = result.SimilarArtists.Select(x => x.Artist).ToArray();
|
|
tsw.Stop();
|
|
timings.Add("similarartists", tsw.ElapsedMilliseconds);
|
|
}
|
|
|
|
if (includes.Contains("collections"))
|
|
{
|
|
tsw.Restart();
|
|
var collectionPagedRequest = new PagedRequest
|
|
{
|
|
Limit = 100
|
|
};
|
|
var r = await CollectionService.List(null,
|
|
collectionPagedRequest, artistId: artist.RoadieId);
|
|
if (r.IsSuccess) result.CollectionsWithArtistReleases = r.Rows.ToArray();
|
|
tsw.Stop();
|
|
timings.Add("collections", tsw.ElapsedMilliseconds);
|
|
}
|
|
|
|
if (includes.Contains("comments"))
|
|
{
|
|
tsw.Restart();
|
|
var artistComments = DbContext.Comments.Include(x => x.User).Where(x => x.ArtistId == artist.Id)
|
|
.OrderByDescending(x => x.CreatedDate).ToArray();
|
|
if (artistComments.Any())
|
|
{
|
|
var comments = new List<Comment>();
|
|
var commentIds = artistComments.Select(x => x.Id).ToArray();
|
|
var userCommentReactions = (from cr in DbContext.CommentReactions
|
|
where commentIds.Contains(cr.CommentId)
|
|
select cr).ToArray();
|
|
foreach (var artistComment in artistComments)
|
|
{
|
|
var comment = artistComment.Adapt<Comment>();
|
|
comment.DatabaseId = artistComment.Id;
|
|
comment.User = UserList.FromDataUser(artistComment.User,
|
|
MakeUserThumbnailImage(artistComment.User.RoadieId));
|
|
comment.DislikedCount = userCommentReactions.Count(x =>
|
|
x.CommentId == artistComment.Id && x.ReactionValue == CommentReaction.Dislike);
|
|
comment.LikedCount = userCommentReactions.Count(x =>
|
|
x.CommentId == artistComment.Id && x.ReactionValue == CommentReaction.Like);
|
|
comments.Add(comment);
|
|
}
|
|
|
|
result.Comments = comments;
|
|
}
|
|
|
|
tsw.Stop();
|
|
timings.Add("comments", tsw.ElapsedMilliseconds);
|
|
}
|
|
|
|
if (includes.Contains("playlists"))
|
|
{
|
|
tsw.Restart();
|
|
var pg = new PagedRequest
|
|
{
|
|
FilterToArtistId = artist.RoadieId
|
|
};
|
|
var r = await PlaylistService.List(pg);
|
|
if (r.IsSuccess) result.PlaylistsWithArtistReleases = r.Rows.ToArray();
|
|
tsw.Stop();
|
|
timings.Add("playlists", tsw.ElapsedMilliseconds);
|
|
}
|
|
|
|
if (includes.Contains("contributions"))
|
|
{
|
|
tsw.Restart();
|
|
result.ArtistContributionReleases = (from t in DbContext.Tracks
|
|
join rm in DbContext.ReleaseMedias on t.ReleaseMediaId equals rm.Id
|
|
join r in DbContext.Releases.Include(x => x.Artist) on rm.ReleaseId equals r.Id
|
|
where t.ArtistId == artist.Id
|
|
group r by r.Id
|
|
into rr
|
|
select rr)
|
|
.ToArray()
|
|
.Select(rr => rr.First())
|
|
.Select(r => ReleaseList.FromDataRelease(r, r.Artist, HttpContext.BaseUrl,
|
|
MakeArtistThumbnailImage(r.Artist.RoadieId), MakeReleaseThumbnailImage(r.RoadieId)))
|
|
.ToArray().OrderBy(x => x.Release.Text).ToArray();
|
|
result.ArtistContributionReleases = result.ArtistContributionReleases.Any()
|
|
? result.ArtistContributionReleases
|
|
: null;
|
|
tsw.Stop();
|
|
timings.Add("contributions", tsw.ElapsedMilliseconds);
|
|
}
|
|
|
|
if (includes.Contains("labels"))
|
|
{
|
|
tsw.Restart();
|
|
result.ArtistLabels = (from l in DbContext.Labels
|
|
join rl in DbContext.ReleaseLabels on l.Id equals rl.LabelId
|
|
join r in DbContext.Releases on rl.ReleaseId equals r.Id
|
|
where r.ArtistId == artist.Id
|
|
orderby l.SortName
|
|
select LabelList.FromDataLabel(l, MakeLabelThumbnailImage(l.RoadieId)))
|
|
.ToArray()
|
|
.GroupBy(x => x.Label.Value).Select(x => x.First()).OrderBy(x => x.SortName)
|
|
.ThenBy(x => x.Label.Text).ToArray();
|
|
result.ArtistLabels = result.ArtistLabels.Any() ? result.ArtistLabels : null;
|
|
tsw.Stop();
|
|
timings.Add("labels", tsw.ElapsedMilliseconds);
|
|
}
|
|
}
|
|
|
|
sw.Stop();
|
|
timings.Add("operation", sw.ElapsedMilliseconds);
|
|
Logger.LogDebug("ArtistByIdAction Timings: id [{0}], includes [{1}], timings [{3}]", id, includes,
|
|
JsonConvert.SerializeObject(timings));
|
|
|
|
return new OperationResult<Artist>
|
|
{
|
|
Data = result,
|
|
IsSuccess = result != null,
|
|
OperationTime = sw.ElapsedMilliseconds
|
|
};
|
|
}
|
|
|
|
private async Task<OperationResult<Image>> SaveImageBytes(ApplicationUser user, Guid id, byte[] imageBytes)
|
|
{
|
|
var sw = new Stopwatch();
|
|
sw.Start();
|
|
var errors = new List<Exception>();
|
|
var artist = DbContext.Artists.FirstOrDefault(x => x.RoadieId == id);
|
|
if (artist == null) return new OperationResult<Image>(true, $"Artist Not Found [{id}]");
|
|
try
|
|
{
|
|
var now = DateTime.UtcNow;
|
|
artist.Thumbnail = imageBytes;
|
|
if (artist.Thumbnail != null)
|
|
{
|
|
// Ensure is jpeg first
|
|
artist.Thumbnail = ImageHelper.ConvertToJpegFormat(artist.Thumbnail);
|
|
|
|
// Ensure artist folder exists
|
|
var artistFolder = artist.ArtistFileFolder(Configuration);
|
|
if (!Directory.Exists(artistFolder))
|
|
{
|
|
Directory.CreateDirectory(artistFolder);
|
|
Logger.LogInformation("Created Artist Folder [0] for `artist`", artistFolder, artist);
|
|
}
|
|
|
|
// Save unaltered image to artist file
|
|
var artistImage = Path.Combine(artistFolder, ImageHelper.ArtistImageFilename);
|
|
File.WriteAllBytes(artistImage, artist.Thumbnail);
|
|
|
|
// Resize to store in database as thumbnail
|
|
artist.Thumbnail = ImageHelper.ResizeImage(artist.Thumbnail, Configuration.MediumImageSize.Width,
|
|
Configuration.MediumImageSize.Height);
|
|
}
|
|
|
|
artist.LastUpdated = now;
|
|
await DbContext.SaveChangesAsync();
|
|
CacheManager.ClearRegion(artist.CacheRegion);
|
|
Logger.LogInformation($"SaveImageBytes `{artist}` By User `{user}`");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex);
|
|
errors.Add(ex);
|
|
}
|
|
|
|
sw.Stop();
|
|
|
|
return new OperationResult<Image>
|
|
{
|
|
IsSuccess = !errors.Any(),
|
|
Data = MakeThumbnailImage(id, "artist", Configuration.MediumImageSize.Width,
|
|
Configuration.MediumImageSize.Height, true),
|
|
OperationTime = sw.ElapsedMilliseconds,
|
|
Errors = errors
|
|
};
|
|
}
|
|
|
|
public async Task<OperationResult<bool>> ScanArtistReleasesFolders(ApplicationUser user, Guid artistId, string destinationFolder, bool doJustInfo)
|
|
{
|
|
SimpleContract.Requires<ArgumentOutOfRangeException>(artistId != Guid.Empty, "Invalid ArtistId");
|
|
|
|
var result = true;
|
|
var resultErrors = new List<Exception>();
|
|
var sw = new Stopwatch();
|
|
sw.Start();
|
|
try
|
|
{
|
|
var artist = DbContext.Artists
|
|
.Include("Releases")
|
|
.Include("Releases.Labels")
|
|
.FirstOrDefault(x => x.RoadieId == artistId);
|
|
if (artist == null)
|
|
{
|
|
Logger.LogWarning("Unable To Find Artist [{0}]", artistId);
|
|
return new OperationResult<bool>();
|
|
}
|
|
|
|
var releaseScannedCount = 0;
|
|
var artistFolder = artist.ArtistFileFolder(Configuration);
|
|
var scannedArtistFolders = new List<string>();
|
|
// Scan known releases for changes
|
|
if (artist.Releases != null)
|
|
foreach (var release in artist.Releases)
|
|
try
|
|
{
|
|
result = result && (await ReleaseService.ScanReleaseFolder(user, Guid.Empty, doJustInfo, release)).Data;
|
|
releaseScannedCount++;
|
|
scannedArtistFolders.Add(release.ReleaseFileFolder(artistFolder));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex, ex.Serialize());
|
|
}
|
|
|
|
// Any folder found in Artist folder not already scanned scan
|
|
var nonReleaseFolders = from d in Directory.EnumerateDirectories(artistFolder)
|
|
where !(from r in scannedArtistFolders select r).Contains(d)
|
|
orderby d
|
|
select d;
|
|
foreach (var folder in nonReleaseFolders)
|
|
{
|
|
await FileDirectoryProcessorService.Process(user, new DirectoryInfo(folder), doJustInfo);
|
|
}
|
|
if (!doJustInfo)
|
|
{
|
|
Services.FileDirectoryProcessorService.DeleteEmptyFolders(new DirectoryInfo(artistFolder), Logger);
|
|
}
|
|
// Always update artist image if artist image is found on an artist rescan
|
|
var imageFiles = ImageHelper.ImageFilesInFolder(artistFolder, SearchOption.AllDirectories);
|
|
if (imageFiles != null && imageFiles.Any())
|
|
{
|
|
var imageFile = imageFiles.First();
|
|
var i = new FileInfo(imageFile);
|
|
var iName = i.Name.ToLower().Trim();
|
|
var isArtistImage = iName.Contains("artist");
|
|
if (isArtistImage)
|
|
{
|
|
// Read image and convert to jpeg
|
|
artist.Thumbnail = File.ReadAllBytes(i.FullName);
|
|
artist.Thumbnail = ImageHelper.ResizeImage(artist.Thumbnail,
|
|
Configuration.MediumImageSize.Width, Configuration.MediumImageSize.Height);
|
|
artist.Thumbnail = ImageHelper.ConvertToJpegFormat(artist.Thumbnail);
|
|
artist.LastUpdated = DateTime.UtcNow;
|
|
await DbContext.SaveChangesAsync();
|
|
CacheManager.ClearRegion(artist.CacheRegion);
|
|
Logger.LogInformation("Update Thumbnail using Artist File [{0}]", iName);
|
|
}
|
|
}
|
|
|
|
sw.Stop();
|
|
CacheManager.ClearRegion(artist.CacheRegion);
|
|
Logger.LogInformation("Scanned Artist [{0}], Releases Scanned [{1}], OperationTime [{2}]",
|
|
artist.ToString(), releaseScannedCount, sw.ElapsedMilliseconds);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError(ex, ex.Serialize());
|
|
resultErrors.Add(ex);
|
|
}
|
|
|
|
return new OperationResult<bool>
|
|
{
|
|
Data = result,
|
|
IsSuccess = result,
|
|
Errors = resultErrors,
|
|
OperationTime = sw.ElapsedMilliseconds
|
|
};
|
|
}
|
|
}
|
|
} |