WebNovelPortal/WebNovelPortalAPI/Controllers/NovelController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using DBConnection;
using DBConnection.Repositories;
using DBConnection.Repositories.Interfaces;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Treestar.Shared.Models.DBDomain;
using Treestar.Shared.Models.DTO;
using Treestar.Shared.Models.DTO.Requests;
using Treestar.Shared.Models.DTO.Responses;
using WebNovelPortalAPI.Exceptions;
using WebNovelPortalAPI.Scrapers;

namespace WebNovelPortalAPI.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class NovelController : ControllerBase
    {
        private readonly INovelRepository _novelRepository;
        private readonly IEnumerable<IScraper> _scrapers;

        public NovelController(IEnumerable<IScraper> scrapers, INovelRepository novelRepository)
        {
            _scrapers = scrapers;
            _novelRepository = novelRepository;
        }

        private async Task<Novel?> ScrapeNovel(string url)
        {
            var scraper = MatchScraper(url);
            if (scraper == null)
            {
                throw new NoMatchingScraperException(url);
            }
            var novel = scraper.ScrapeNovel(url);
            return novel;
        }

        private IScraper? MatchScraper(string novelUrl)
        {
            return _scrapers.FirstOrDefault(i => i.MatchesUrl(novelUrl));
        }

        [HttpGet]
        [Route("{guid:guid}")]
        public async Task<Novel?> GetNovel(Guid guid)
        {
            return await _novelRepository.GetNovel(guid);
        }

        [HttpGet]
        public async Task<List<Novel>> GetNovels()
        {
            return (await _novelRepository.GetAllIncluded()).ToList();
        }

        [HttpPost]
        [Route("scrapeNovels")]
        public async Task<IActionResult> ScrapeNovels(ScrapeNovelsRequest request)
        {
            var successfulScrapes = new List<Novel>();
            var failures = new Dictionary<string, Exception>();
            foreach (var novelUrl in request.NovelUrls)
            {
                try
                {
                    successfulScrapes.Add(await ScrapeNovel(novelUrl));
                }
                catch (Exception e)
                {
                    failures[novelUrl] = e;
                }
            }

            IEnumerable<Novel> successfulUploads;
            try
            {
                successfulUploads = await _novelRepository.UpsertMany(successfulScrapes);
            }
            catch (Exception e)
            {
                return StatusCode(500, e);
            }
            return Ok(new ScrapeNovelsResponse
            {
                Failures = failures,
                SuccessfulNovels = successfulScrapes
            });
        }

        [HttpPost]
        [Route("scrapeNovel")]
        public async Task<IActionResult> ScrapeNovel(ScrapeNovelRequest request)
        {
            try
            {
                var novel = await ScrapeNovel(request.NovelUrl);
                var dbNovel = await _novelRepository.Upsert(novel);
                return Ok(dbNovel);
            }
            catch (NoMatchingScraperException e)
            {
                return BadRequest("Invalid url, no valid scraper configured");
            }
            catch (Exception e)
            {
                return StatusCode(500, e);
            }
        }
    }
}