roadie/Roadie.Api.Services/LabelService.cs

using Mapster;
using Microsoft.AspNetCore.Http;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Roadie.Library;
using Roadie.Library.Caching;
using Roadie.Library.Configuration;
using Roadie.Library.Encoding;
using Roadie.Library.Enums;
using Roadie.Library.Extensions;
using Roadie.Library.Imaging;
using Roadie.Library.Models;
using Roadie.Library.Models.Pagination;
using Roadie.Library.Models.Statistics;
using Roadie.Library.Models.Users;
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;

namespace Roadie.Api.Services
{
    public class LabelService : ServiceBase, ILabelService
    {
        private IBookmarkService BookmarkService { get; }

        public LabelService(IRoadieSettings configuration,
                    IHttpEncoder httpEncoder,
            IHttpContext httpContext,
            data.IRoadieDbContext context,
            ICacheManager cacheManager,
            ILogger<LabelService> logger,
            ICollectionService collectionService,
            IPlaylistService playlistService,
            IBookmarkService bookmarkService)
            : base(configuration, httpEncoder, context, cacheManager, logger, httpContext)
        {
            BookmarkService = bookmarkService;
        }

        public async Task<OperationResult<Label>> ById(User roadieUser, Guid id, IEnumerable<string> includes = null)
        {
            var sw = Stopwatch.StartNew();
            sw.Start();
            var cacheKey = string.Format("urn:label_by_id_operation:{0}:{1}", id,
                includes == null ? "0" : string.Join("|", includes));
            var result = await CacheManager.GetAsync(cacheKey,
                async () => { return await LabelByIdAction(id, includes); }, data.Artist.CacheRegionUrn(id));
            sw.Stop();
            if (result?.Data != null && roadieUser != null)
            {
                var userBookmarkResult =
                    await BookmarkService.List(roadieUser, new PagedRequest(), false, BookmarkType.Label);
                if (userBookmarkResult.IsSuccess)
                    result.Data.UserBookmarked =
                        userBookmarkResult?.Rows?.FirstOrDefault(x => x.Bookmark.Text == result.Data.Id.ToString()) !=
                        null;
                if (result.Data.Comments.Any())
                {
                    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;
                    }
                }
            }

            return new OperationResult<Label>(result.Messages)
            {
                Data = result?.Data,
                IsNotFoundResult = result?.IsNotFoundResult ?? false,
                Errors = result?.Errors,
                IsSuccess = result?.IsSuccess ?? false,
                OperationTime = sw.ElapsedMilliseconds
            };
        }

        public Task<Library.Models.Pagination.PagedResult<LabelList>> List(User roadieUser, PagedRequest request,
            bool? doRandomize = false)
        {
            var sw = new Stopwatch();
            sw.Start();

            if (!string.IsNullOrEmpty(request.Sort))
            {
                request.Sort = request.Sort.Replace("createdDate", "createdDateTime");
                request.Sort = request.Sort.Replace("lastUpdated", "lastUpdatedDateTime");
            }

            var normalizedFilterValue = !string.IsNullOrEmpty(request.FilterValue)
                ? request.FilterValue.ToAlphanumericName()
                : null;
            var result = from l in DbContext.Labels
                         where request.FilterValue.Length == 0 || request.FilterValue.Length > 0 && (
                                   l.Name != null && l.Name.Contains(request.FilterValue) ||
                                   l.AlternateNames != null && l.AlternateNames.Contains(request.FilterValue) ||
                                   l.AlternateNames != null && l.AlternateNames.Contains(normalizedFilterValue)
                               )
                         select new LabelList
                         {
                             DatabaseId = l.Id,
                             Id = l.RoadieId,
                             Label = new DataToken
                             {
                                 Text = l.Name,
                                 Value = l.RoadieId.ToString()
                             },                             
                             SortName = l.SortName,
                             CreatedDate = l.CreatedDate,
                             LastUpdated = l.LastUpdated,
                             ArtistCount = l.ArtistCount,
                             ReleaseCount = l.ReleaseCount,
                             TrackCount = l.TrackCount,
                             Thumbnail = MakeLabelThumbnailImage(l.RoadieId)
                         };
            LabelList[] rows = null;
            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).Take(request.LimitValue).ToArray();

            }
            else
            {
                var sortBy = string.IsNullOrEmpty(request.Sort)
                    ? request.OrderValue(new Dictionary<string, string> { { "SortName", "ASC" }, { "Label.Text", "ASC" } })
                    : request.OrderValue();
                rows = result.OrderBy(sortBy).Skip(request.SkipValue).Take(request.LimitValue).ToArray();
            }

            sw.Stop();
            return Task.FromResult(new Library.Models.Pagination.PagedResult<LabelList>
            {
                TotalCount = rowCount,
                CurrentPage = request.PageValue,
                TotalPages = (int)Math.Ceiling((double)rowCount / request.LimitValue),
                OperationTime = sw.ElapsedMilliseconds,
                Rows = rows
            });
        }

        public async Task<OperationResult<Image>> SetLabelImageByUrl(User user, Guid id, string imageUrl)
        {
            return await SaveImageBytes(user, id, WebHelper.BytesForImageUrl(imageUrl));
        }

        public async Task<OperationResult<bool>> UpdateLabel(User user, Label model)
        {
            var sw = new Stopwatch();
            sw.Start();
            var errors = new List<Exception>();
            var label = DbContext.Labels.FirstOrDefault(x => x.RoadieId == model.Id);
            if (label == null) return new OperationResult<bool>(true, string.Format("Label Not Found [{0}]", model.Id));
            try
            {
                var now = DateTime.UtcNow;
                label.AlternateNames = model.AlternateNamesList.ToDelimitedList();
                label.BeginDate = model.BeginDate;
                label.DiscogsId = model.DiscogsId;
                label.EndDate = model.EndDate;
                label.IsLocked = model.IsLocked;
                label.MusicBrainzId = model.MusicBrainzId;
                label.Name = model.Name;
                label.Profile = model.Profile;
                label.SortName = model.SortName;
                label.Status = SafeParser.ToEnum<Statuses>(model.Status);
                label.Tags = model.TagsList.ToDelimitedList();
                label.URLs = model.URLsList.ToDelimitedList();

                var labelImage = ImageHelper.ImageDataFromUrl(model.NewThumbnailData);
                if (labelImage != null)
                {
                    // Resize to store in database as thumbnail
                    label.Thumbnail = ImageHelper.ResizeToThumbnail(labelImage, Configuration);
                }

                label.LastUpdated = now;
                await DbContext.SaveChangesAsync();

                CacheManager.ClearRegion(label.CacheRegion);
                Logger.LogInformation($"UpdateLabel `{label}` By User `{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
            };
        }

        public async Task<OperationResult<Image>> UploadLabelImage(User 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 Task<OperationResult<Label>> LabelByIdAction(Guid id, IEnumerable<string> includes = null)
        {
            var sw = Stopwatch.StartNew();
            sw.Start();

            var label = GetLabel(id);

            if (label == null)
                return Task.FromResult(new OperationResult<Label>(true, string.Format("Label Not Found [{0}]", id)));

            var result = label.Adapt<Label>();
            result.AlternateNames = label.AlternateNames;
            result.Tags = label.Tags;
            result.URLs = label.URLs;
            result.Thumbnail = MakeLabelThumbnailImage(label.RoadieId);
            result.MediumThumbnail = MakeThumbnailImage(id, "label", Configuration.MediumImageSize.Width,
                Configuration.MediumImageSize.Height);
            if (includes != null && includes.Any())
            {
                if (includes.Contains("stats"))
                {
                    var labelTracks = from l in DbContext.Labels
                                      join rl in DbContext.ReleaseLabels on l.Id equals rl.LabelId into rld
                                      from rl in rld.DefaultIfEmpty()
                                      join r in DbContext.Releases on rl.ReleaseId equals r.Id
                                      join rm in DbContext.ReleaseMedias on r.Id equals rm.ReleaseId
                                      join t in DbContext.Tracks on rm.Id equals t.ReleaseMediaId
                                      where l.Id == label.Id
                                      select new
                                      {
                                          t.Duration,
                                          t.FileSize
                                      };
                    result.Duration = labelTracks.Sum(x => x.Duration);

                    result.Statistics = new ReleaseGroupingStatistics
                    {
                        TrackCount = label.TrackCount,
                        ArtistCount = label.ArtistCount,
                        ReleaseCount = label.ReleaseCount,
                        TrackSize = result.DurationTime,
                        FileSize = labelTracks.Sum(x => (long?)x.FileSize).ToFileSize()
                    };
                }

                if (includes.Contains("comments"))
                {
                    var labelComments = DbContext.Comments.Include(x => x.User).Where(x => x.LabelId == label.Id)
                        .OrderByDescending(x => x.CreatedDate).ToArray();
                    if (labelComments.Any())
                    {
                        var comments = new List<Comment>();
                        var commentIds = labelComments.Select(x => x.Id).ToArray();
                        var userCommentReactions = (from cr in DbContext.CommentReactions
                                                    where commentIds.Contains(cr.CommentId)
                                                    select cr).ToArray();
                        foreach (var labelComment in labelComments)
                        {
                            var comment = labelComment.Adapt<Comment>();
                            comment.DatabaseId = labelComment.Id;
                            comment.User = UserList.FromDataUser(labelComment.User,
                                MakeUserThumbnailImage(labelComment.User.RoadieId));
                            comment.DislikedCount = userCommentReactions.Count(x =>
                                x.CommentId == labelComment.Id && x.ReactionValue == CommentReaction.Dislike);
                            comment.LikedCount = userCommentReactions.Count(x =>
                                x.CommentId == labelComment.Id && x.ReactionValue == CommentReaction.Like);
                            comments.Add(comment);
                        }

                        result.Comments = comments;
                    }
                }
            }

            sw.Stop();
            return Task.FromResult(new OperationResult<Label>
            {
                Data = result,
                IsSuccess = result != null,
                OperationTime = sw.ElapsedMilliseconds
            });
        }

        private async Task<OperationResult<Image>> SaveImageBytes(User user, Guid id, byte[] imageBytes)
        {
            var sw = new Stopwatch();
            sw.Start();
            var errors = new List<Exception>();
            var label = DbContext.Labels.FirstOrDefault(x => x.RoadieId == id);
            if (label == null) return new OperationResult<Image>(true, string.Format("Label Not Found [{0}]", id));
            try
            {
                var now = DateTime.UtcNow;
                label.Thumbnail = imageBytes;
                if (label.Thumbnail != null)
                {
                    // Ensure is jpeg first
                    label.Thumbnail = ImageHelper.ResizeToThumbnail(label.Thumbnail, Configuration);
                }

                label.LastUpdated = now;
                await DbContext.SaveChangesAsync();
                CacheManager.ClearRegion(label.CacheRegion);
                Logger.LogInformation($"UploadLabelImage `{label}` By User `{user}`");
            }
            catch (Exception ex)
            {
                Logger.LogError(ex);
                errors.Add(ex);
            }

            sw.Stop();

            return new OperationResult<Image>
            {
                IsSuccess = !errors.Any(),
                Data = MakeThumbnailImage(id, "label", Configuration.MediumImageSize.Width,
                    Configuration.MediumImageSize.Height, true),
                OperationTime = sw.ElapsedMilliseconds,
                Errors = errors
            };
        }
    }
}