public override async Task <UpdateBookPageRequest> HandleAsync(UpdateBookPageRequest command, CancellationToken cancellationToken = new CancellationToken())
        {
            var book = await _bookRepository.GetBookById(command.LibraryId, command.BookPage.BookId, command.AccountId, cancellationToken);

            if (book == null)
            {
                throw new BadRequestException();
            }

            var existingBookPage = await _bookPageRepository.GetPageBySequenceNumber(command.LibraryId, command.BookPage.BookId, command.BookPage.SequenceNumber, cancellationToken);

            if (existingBookPage == null)
            {
                command.Result.BookPage = await _bookPageRepository.AddPage(command.LibraryId, command.BookPage.BookId, command.BookPage.SequenceNumber, command.BookPage.Text, 0, command.BookPage.ChapterId, cancellationToken);

                command.Result.HasAddedNew = true;
            }
            else
            {
                command.Result.BookPage = await _bookPageRepository.UpdatePage(command.LibraryId, command.BookPage.BookId, command.BookPage.SequenceNumber, command.BookPage.Text, existingBookPage.ImageId ?? 0, command.BookPage.Status, command.BookPage.ChapterId, cancellationToken);
            }

            var previousPage = await _bookPageRepository.GetPageBySequenceNumber(command.LibraryId, command.BookPage.BookId, command.SequenceNumber - 1, cancellationToken);

            var nextPage = await _bookPageRepository.GetPageBySequenceNumber(command.LibraryId, command.BookPage.BookId, command.SequenceNumber + 1, cancellationToken);

            command.Result.BookPage.PreviousPage = previousPage;
            command.Result.BookPage.NextPage     = nextPage;

            return(await base.HandleAsync(command, cancellationToken));
        }
        public override async Task <AssignBookPageToUserRequest> HandleAsync(AssignBookPageToUserRequest command, CancellationToken cancellationToken = new CancellationToken())
        {
            var page = await _bookPageRepository.GetPageBySequenceNumber(command.LibraryId, command.BookId, command.SequenceNumber, cancellationToken);

            if (page == null)
            {
                throw new BadRequestException();
            }

            if (page.Status == EditingStatus.Available || page.Status == EditingStatus.Typing)
            {
                command.Result = await _bookPageRepository.UpdateWriterAssignment(command.LibraryId, command.BookId, command.SequenceNumber, command.AccountId, cancellationToken);
            }
            else if (page.Status == EditingStatus.Typed || page.Status == EditingStatus.InReview)
            {
                command.Result = await _bookPageRepository.UpdateReviewerAssignment(command.LibraryId, command.BookId, command.SequenceNumber, command.AccountId, cancellationToken);
            }
            else
            {
                throw new BadRequestException("Page status does not allow it to be assigned");
            }


            return(await base.HandleAsync(command, cancellationToken));
        }
Exemple #3
0
        public override async Task <DeleteBookPageRequest> HandleAsync(DeleteBookPageRequest command, CancellationToken cancellationToken = new CancellationToken())
        {
            var bookPage = await _bookPageRepository.GetPageBySequenceNumber(command.LibraryId, command.BookId, command.SequenceNumber, cancellationToken);

            if (bookPage != null)
            {
                if (bookPage.ImageId.HasValue)
                {
                    var existingImage = await _fileRepository.GetFileById(bookPage.ImageId.Value, cancellationToken);

                    if (existingImage != null && !string.IsNullOrWhiteSpace(existingImage.FilePath))
                    {
                        await _fileStorage.TryDeleteImage(existingImage.FilePath, cancellationToken);
                    }

                    await _fileRepository.DeleteFile(existingImage.Id, cancellationToken);

                    await _bookPageRepository.DeletePageImage(command.LibraryId, command.BookId, command.SequenceNumber, cancellationToken);
                }

                await _bookPageRepository.DeletePage(command.LibraryId, command.BookId, command.SequenceNumber, cancellationToken);
            }

            return(await base.HandleAsync(command, cancellationToken));
        }
        public override async Task <BookPageModel> ExecuteAsync(GetBookPageByNumberQuery command, CancellationToken cancellationToken = new CancellationToken())
        {
            var page = await _bookPageRepository.GetPageBySequenceNumber(command.LibraryId, command.BookId, command.SequenceNumber, cancellationToken);

            if (page != null)
            {
                var previousPage = await _bookPageRepository.GetPageBySequenceNumber(command.LibraryId, command.BookId, command.SequenceNumber - 1, cancellationToken);

                var nextPage = await _bookPageRepository.GetPageBySequenceNumber(command.LibraryId, command.BookId, command.SequenceNumber + 1, cancellationToken);

                page.PreviousPage = previousPage;
                page.NextPage     = nextPage;
            }

            return(page);
        }
        public override async Task <UpdateBookPageImageRequest> HandleAsync(UpdateBookPageImageRequest command, CancellationToken cancellationToken = new CancellationToken())
        {
            var bookPage = await _bookPageRepository.GetPageBySequenceNumber(command.LibraryId, command.BookId, command.SequenceNumber, cancellationToken);

            if (bookPage == null)
            {
                throw new NotFoundException();
            }

            if (bookPage.ImageId.HasValue)
            {
                command.Image.Id = bookPage.ImageId.Value;
                var existingImage = await _fileRepository.GetFileById(bookPage.ImageId.Value, cancellationToken);

                if (existingImage != null && !string.IsNullOrWhiteSpace(existingImage.FilePath))
                {
                    await _fileStorage.TryDeleteImage(existingImage.FilePath, cancellationToken);
                }

                var url = await AddImageToFileStore(command.BookId, command.SequenceNumber, command.Image.FileName, command.Image.Contents, command.Image.MimeType, cancellationToken);

                command.Image.FilePath = url;
                command.Image.IsPublic = true;
                await _fileRepository.UpdateFile(command.Image, cancellationToken);

                command.Result.File    = command.Image;
                command.Result.File.Id = bookPage.ImageId.Value;
            }
            else
            {
                command.Image.Id = default(int);
                var url = await AddImageToFileStore(command.BookId, command.SequenceNumber, command.Image.FileName, command.Image.Contents, command.Image.MimeType, cancellationToken);

                command.Image.FilePath = url;
                command.Image.IsPublic = true;
                command.Result.File    = await _fileRepository.AddFile(command.Image, cancellationToken);

                command.Result.HasAddedNew = true;

                await _bookPageRepository.UpdatePageImage(command.LibraryId, command.BookId, command.SequenceNumber, command.Result.File.Id, cancellationToken);
            }

            return(await base.HandleAsync(command, cancellationToken));
        }
Exemple #6
0
        public override async Task <UpdateBookPageSequenceRequest> HandleAsync(UpdateBookPageSequenceRequest command, CancellationToken cancellationToken = new CancellationToken())
        {
            // No Change in page sequence
            if (command.OldSequenceNumber == command.NewSequenceNumber)
            {
                return(await base.HandleAsync(command, cancellationToken));
            }

            var page = await _bookPageRepository.GetPageBySequenceNumber(command.LibraryId, command.BookId, command.OldSequenceNumber, cancellationToken);

            // Check if the page exist
            if (page == null)
            {
                throw new NotFoundException();
            }

            await _bookPageRepository.UpdatePageSequenceNumber(command.LibraryId, command.BookId, command.OldSequenceNumber, command.NewSequenceNumber, cancellationToken);

            return(await base.HandleAsync(command, cancellationToken));
        }
        public override async Task <BookPageOcrRequest> HandleAsync(BookPageOcrRequest command, CancellationToken cancellationToken = new CancellationToken())
        {
            var bookPage = await _bookPageRepository.GetPageBySequenceNumber(command.LibraryId, command.BookId, command.SequenceNumber, cancellationToken);

            if (bookPage != null && bookPage.ImageId.HasValue)
            {
                var image = await _queryProcessor.ExecuteAsync(new GetFileQuery(bookPage.ImageId.Value, 0, 0));

                if (image != null)
                {
                    var text = await _ocr.PerformOcr(image.Contents, command.ApiKey, cancellationToken);

                    bookPage.Text = text;
                    await _bookPageRepository.UpdatePage(command.LibraryId, bookPage.BookId, bookPage.SequenceNumber, text, bookPage.ImageId.Value, bookPage.Status, bookPage.ChapterId, cancellationToken);

                    return(await base.HandleAsync(command, cancellationToken));
                }
            }

            throw new NotFoundException();
        }
Exemple #8
0
        public override async Task <AddBookPageRequest> HandleAsync(AddBookPageRequest command, CancellationToken cancellationToken = new CancellationToken())
        {
            var book = await _bookRepository.GetBookById(command.LibraryId, command.BookPage.BookId, command.AccountId, cancellationToken);

            if (book == null)
            {
                throw new BadRequestException();
            }

            var existingBookPage = await _bookPageRepository.GetPageBySequenceNumber(command.LibraryId, command.BookPage.BookId, command.BookPage.SequenceNumber, cancellationToken);

            if (existingBookPage == null)
            {
                command.Result = await _bookPageRepository.AddPage(command.LibraryId, command.BookPage.BookId, command.BookPage.SequenceNumber, command.BookPage.Text, 0, command.BookPage.ChapterId, cancellationToken);

                command.IsAdded = true;
            }
            else
            {
                command.Result = await _bookPageRepository.UpdatePage(command.LibraryId, command.BookPage.BookId, command.BookPage.SequenceNumber, command.BookPage.Text, 0, command.BookPage.Status, command.BookPage.ChapterId, cancellationToken);
            }

            return(await base.HandleAsync(command, cancellationToken));
        }