Пример #1
0
        public async Task <RequestEngineResult> RequestAlbum([FromBody] MusicAlbumRequestViewModel album)
        {
            var result = await _engine.RequestAlbum(album);

            if (result.Result)
            {
                var voteResult = await _voteEngine.UpVote(result.RequestId, RequestType.Album);

                if (voteResult.IsError)
                {
                    _log.LogError("Couldn't automatically add the vote for the album {0} because {1}", album.ForeignAlbumId, voteResult.ErrorMessage);
                }
            }

            return(result);
        }
Пример #2
0
        /// <summary>
        /// Requests the Album.
        /// </summary>
        /// <param name="model">The model.</param>
        /// <returns></returns>
        public async Task <RequestEngineResult> RequestAlbum(MusicAlbumRequestViewModel model)
        {
            var s = await _lidarrSettings.GetSettingsAsync();

            var album = await _lidarrApi.GetAlbumByForeignId(model.ForeignAlbumId, s.ApiKey, s.FullUri);

            if (album == null)
            {
                return(new RequestEngineResult
                {
                    Result = false,
                    Message = "There was an issue adding this album!",
                    ErrorMessage = "Please try again later"
                });
            }

            var userDetails = await GetUser();

            var requestModel = new AlbumRequest
            {
                ForeignAlbumId   = model.ForeignAlbumId,
                ArtistName       = album.artist?.artistName,
                ReleaseDate      = album.releaseDate,
                RequestedDate    = DateTime.Now,
                RequestType      = RequestType.Album,
                Rating           = album.ratings?.value ?? 0m,
                RequestedUserId  = userDetails.Id,
                Title            = album.title,
                Disk             = album.images?.FirstOrDefault(x => x.coverType.Equals("disc"))?.url,
                Cover            = album.images?.FirstOrDefault(x => x.coverType.Equals("cover"))?.url,
                ForeignArtistId  = album?.artist?.foreignArtistId ?? string.Empty,
                RequestedByAlias = model.RequestedByAlias
            };

            if (requestModel.Cover.IsNullOrEmpty())
            {
                requestModel.Cover = album.remoteCover;
            }

            var ruleResults = (await RunRequestRules(requestModel)).ToList();

            if (ruleResults.Any(x => !x.Success))
            {
                return(new RequestEngineResult
                {
                    ErrorMessage = ruleResults.FirstOrDefault(x => x.Message.HasValue()).Message
                });
            }

            if (requestModel.Approved) // The rules have auto approved this
            {
                var requestEngineResult = await AddAlbumRequest(requestModel);

                if (requestEngineResult.Result)
                {
                    var result = await ApproveAlbum(requestModel);

                    if (result.IsError)
                    {
                        Logger.LogWarning("Tried auto sending Album but failed. Message: {0}", result.Message);
                        return(new RequestEngineResult
                        {
                            Message = result.Message,
                            ErrorMessage = result.Message,
                            Result = false
                        });
                    }

                    return(requestEngineResult);
                }

                // If there are no providers then it's successful but album has not been sent
            }

            return(await AddAlbumRequest(requestModel));
        }