Exemplo n.º 1
0
        public async Task <Result <PlexServer> > Handle(GetPlexServerByPlexTvShowEpisodeIdQuery request,
                                                        CancellationToken cancellationToken)
        {
            var plexTvShowEpisode = await _dbContext.PlexTvShowEpisodes
                                    .Include(x => x.TvShowSeason)
                                    .ThenInclude(x => x.TvShow)
                                    .ThenInclude(x => x.PlexLibrary)
                                    .ThenInclude(x => x.PlexServer)
                                    .ThenInclude(x => x.ServerStatus)
                                    .FirstOrDefaultAsync(x => x.Id == request.Id, cancellationToken);

            if (plexTvShowEpisode == null)
            {
                return(ResultExtensions.Create404NotFoundResult());
            }

            var plexServer = plexTvShowEpisode?.TvShowSeason?.TvShow?.PlexLibrary?.PlexServer;

            if (plexServer == null)
            {
                return(ResultExtensions.GetEntityNotFound(nameof(PlexServer), request.Id)
                       .LogError(null, $"Could not retrieve the PlexServer from PlexTvShowEpisode with id: {request.Id}"));
            }

            return(Result.Ok(plexServer));
        }
Exemplo n.º 2
0
        /// <summary>
        /// Check if a <see cref="PlexDownloadClient"/> has already been assigned to this <see cref="DownloadTask"/>.
        /// </summary>
        /// <param name="downloadTaskId">The id of the <see cref="DownloadTask"/>.</param>
        /// <returns>Returns the <see cref="PlexDownloadClient"/> if found and fails otherwise.</returns>
        private Result <PlexDownloadClient> GetDownloadClient(int downloadTaskId)
        {
            var downloadClient = _downloadsList.Find(x => x.DownloadTaskId == downloadTaskId);

            if (downloadClient == null)
            {
                return(ResultExtensions
                       .Create404NotFoundResult($"There is no DownloadClient currently working on a downloadTask with Id {downloadTaskId}"));
            }

            return(Result.Ok(downloadClient));
        }
        public async Task <Result <bool> > Handle(UpdateDownloadStatusOfDownloadTaskCommand command, CancellationToken cancellationToken)
        {
            var downloadTask = await _dbContext.DownloadTasks.AsTracking()
                               .FirstOrDefaultAsync(x => x.Id == command.DownloadTaskId, cancellationToken);

            if (downloadTask != null)
            {
                downloadTask.DownloadStatus = command.DownloadStatus;
                await _dbContext.SaveChangesAsync(cancellationToken);

                return(Result.Ok(true));
            }

            return(ResultExtensions.Create404NotFoundResult());
        }
Exemplo n.º 4
0
        public async Task <Result <PlexAccount> > Handle(GetPlexAccountByUsernameQuery request, CancellationToken cancellationToken)
        {
            var query = _dbContext.PlexAccounts.AsQueryable();

            if (request.IncludePlexServers && !request.IncludePlexLibraries)
            {
                query = query
                        .Include(x => x.PlexAccountServers)
                        .ThenInclude(x => x.PlexServer);
            }

            if (request.IncludePlexServers && request.IncludePlexLibraries)
            {
                query = query
                        .Include(v => v.PlexAccountServers)
                        .ThenInclude(x => x.PlexServer)
                        .ThenInclude(x => x.PlexLibraries)
                        .ThenInclude(x => x.PlexAccountLibraries);
            }

            var plexAccount = await query
                              .FirstOrDefaultAsync(x => x.Username == request.Username, cancellationToken);

            if (plexAccount == null)
            {
                return(ResultExtensions.Create404NotFoundResult($"Could not find a {nameof(PlexAccount)} with the username: {request.Username}"));
            }

            // Remove any PlexLibraries the plexAccount has no access to
            // TODO This might be improved further since now all PlexLibraries will be retrieved from the database.
            var plexServers = plexAccount?.PlexAccountServers?.Select(x => x.PlexServer).ToList() ?? new List <PlexServer>();

            foreach (var plexServer in plexServers)
            {
                // Remove inaccessible PlexLibraries
                for (int i = plexServer.PlexLibraries.Count - 1; i >= 0; i--)
                {
                    var x = plexServer?.PlexLibraries[i].PlexAccountLibraries.Select(y => y.PlexAccountId).ToList();
                    if (!x.Contains(plexAccount.Id))
                    {
                        plexServer.PlexLibraries.RemoveAt(i);
                    }
                }
            }

            return(Result.Ok(plexAccount));
        }
        public void ShouldHave404NotFoundError()
        {
            // Arrange
            string testMessage = "TestMessage2";

            // Act
            var result  = ResultExtensions.Create404NotFoundResult(testMessage).LogError();
            var result2 = Result.Fail("").Add404NotFoundError(testMessage);

            // Assert
            result.Has404NotFoundError().Should().BeTrue();
            result.Has400BadRequestError().Should().BeFalse();
            result.Errors.Count.Should().Be(1);
            result.Errors[0].Message.Should().Be(testMessage);

            result2.Has404NotFoundError().Should().BeTrue();
            result2.Has400BadRequestError().Should().BeFalse();
            result2.Errors.Count.Should().Be(2);
            result2.Errors[1].Message.Should().Be(testMessage);
        }
        public async Task <Result <DownloadTask> > Handle(GetDownloadTaskByRatingKeyQuery request, CancellationToken cancellationToken)
        {
            var query = _dbContext.DownloadTasks.AsQueryable();

            if (request.IncludeServer)
            {
                query = query.Include(x => x.PlexServer);
            }

            var downloadTask = await query
                               .Include(x => x.DownloadWorkerTasks)
                               .Include(x => x.DestinationFolder)
                               .Include(x => x.DownloadFolder)
                               .FirstOrDefaultAsync(x => x.RatingKey == request.RatingKey, cancellationToken);

            if (downloadTask == null)
            {
                return(ResultExtensions.Create404NotFoundResult($"Could not find {nameof(downloadTask)} with ratingKey: {request.RatingKey}"));
            }

            return(Result.Ok(downloadTask));
        }
Exemplo n.º 7
0
        public async Task <Result <PlexServer> > Handle(GetPlexServerByPlexLibraryIdQuery request,
                                                        CancellationToken cancellationToken)
        {
            var query = _dbContext.PlexServers
                        .Include(x => x.ServerStatus)
                        .AsQueryable();

            if (request.IncludePlexLibraries)
            {
                query = query.Include(x => x.PlexLibraries);
            }

            var plexServer = await query
                             .Where(x => x.PlexLibraries.Any(y => y.Id == request.Id))
                             .FirstOrDefaultAsync(cancellationToken);

            if (plexServer == null)
            {
                return(ResultExtensions.Create404NotFoundResult($"Could not find PlexLibrary with Id {request.Id} in any PlexServer"));
            }

            return(Result.Ok(plexServer));
        }