QuotifyBE/Controllers/QuoteController.cs

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Authorization.Infrastructure;
using Microsoft.AspNetCore.Cors;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Update.Internal;
using QuotifyBE.Data;
using QuotifyBE.DTOs;
using QuotifyBE.Entities;
using QuotifyBE.Mapping;
using System.Reflection.Metadata.Ecma335;
using System.Security.Claims;

namespace QuotifyBE.Controllers;


[ApiController]
[Route("api/v1/quotes")]
[Produces("application/json")]
public class QuotesController : ControllerBase
{

    private readonly ApplicationDbContext _db;
    private readonly GeneralUseHelpers guhf;

    public QuotesController(ApplicationDbContext db, GeneralUseHelpers GUHF)
    {
        _db = db;
        guhf = GUHF;
    }

    // GET /api/v1/quotes
    /// <summary>
    /// Get a page of quotes
    /// </summary>
    /// <remarks>
    /// A page of quotes consists of 10 quotes or less.
    /// If a page does not contain any quotes, an empty list is returned.
    /// <br/><br/>
    /// <b>Important!</b>
    /// Has CORS set, unlike e.g. GET /api/v1/quote/{id} or GET /api/v1/quote/random.
    /// </remarks>
    /// <param name="page_no">The page number</param>
    /// <param name="category_id">(Optional) Standalone category id or comma separated ids (e.g. "1" or "1,2,3")</param>
    /// <returns>A page (&lt;= 10 quotes)</returns>
    /// <response code="200">Returned on valid request</response>
    /// <response code="404">Returned when requested page is invalid (page_no &lt;= 0)</response>
    [HttpGet("page/{page_no}")]
    [EnableCors]
    [ProducesResponseType(typeof(List<QuoteShortDTO>), 200)]
    [ProducesResponseType(typeof(ErrorDTO), 404)]
    public async Task<IActionResult> GetQuotePage(int page_no, [FromQuery] string? category_id = null)
    {
        var totalQuotes = await _db.Quotes.CountAsync();
        const int PageSize = 10;

        List<int>? categories;
        try
        {
            categories = category_id?
                                .Split(",")
                                .Select(Int32.Parse)
                                .ToList();
        } catch
        {
            // Try to catch badly formatted requests
            return BadRequest(new ErrorDTO {
                Status = "error",
                Error_msg = "Category_id can be either an integer, or comma separated integers"
            });
        }

        if (page_no <= 0)
        {
            return NotFound(new ErrorDTO { Status = "error", Error_msg = "Numer strony musi być większy niż 0" });
        }

        // Paginacja bez filtra
        var baseQuery = _db.Quotes
            .Include(q => q.QuoteCategories!)
            .ThenInclude(qc => qc.Category)
            .Include(q => q.User)
            .Include(q => q.Image)
            .OrderBy(q => q.Id);

        // Botched solution
        List<Quote> pageQuotes;

        // Filtrowanie przed pobraniem strony
        if (categories != null)
        {
            pageQuotes = await baseQuery
                .Where(q => q.QuoteCategories!
                    .Any(qc => categories.Contains(qc.CategoryId))
                    //.Any(qc => qc.CategoryId == category_id.Value)
                )
                .Skip((page_no - 1) * PageSize)
                .Take(PageSize)
                .ToListAsync();
        }
        else
        {
            pageQuotes = await baseQuery
                .Skip((page_no - 1) * PageSize)
                .Take(PageSize)
                .ToListAsync();
        }

        var result = pageQuotes
            .Select(q => q.ToQuoteShortDTO())
            .ToList();

        return Ok(result);

    }

    // GET /api/v1/quotes/{id}
    /// <summary>
    /// [AUTHED] Get specified quote summary
    /// </summary>
    /// <remarks>
    /// As per project's guidelines, requires a JWT.
    /// </remarks>
    /// <param name="id">The quote id in question</param>
    /// <returns>A quote: id, quote content and author, imageUrl and categories if successful, otherwise: error message</returns>
    /// <response code="200">Returned on valid request</response>
    /// <response code="404">Returned when quote id is invalid or simply doesn't exist</response>
    [HttpGet("{id}")]
    [Authorize]
    [ProducesResponseType(typeof(QuoteShortDTO), 200)]
    [ProducesResponseType(typeof(ErrorDTO), 404)]
    public async Task<IActionResult> GetQuoteById(int id)
    {

        var quote = await _db.Quotes
            .Include(q => q.QuoteCategories!)
            .ThenInclude(qc => qc.Category)
            .Include(q => q.User)
            .Include(q => q.Image)
            .FirstOrDefaultAsync(q => q.Id == id);

        if (quote == null)
            return NotFound(new { status = "error", error_msg = "Quote not found" });

        return Ok(quote.ToQuoteShortDTO());
    }

    // POST /api/v1/quotes/new
    /// <summary>
    /// [AUTHED] Add a new quote
    /// </summary>
    /// <returns>Newly created quote's id</returns>
    /// <param name="request">Form data containing required quote information</param>
    /// <response code="201">Returned on valid request</response>
    /// <response code="400">Returned when any of the categories does not exist</response>
    /// <response code="403">Returned when user's id does not match the creator's id</response>
    [HttpPost("new")]
    [Authorize]
    [EnableCors]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(ErrorDTO), 400)]
    [ProducesResponseType(typeof(ErrorDTO), 403)]
    public async Task<IActionResult> CreateQuote([FromBody] CreateQuoteDTO request)
    {
        // Get user ID from claims

        var userIdClaim = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
        if (userIdClaim == null || !int.TryParse(userIdClaim, out int userId))
            // https://stackoverflow.com/a/47708867
            return StatusCode(403, new ErrorDTO { Status = "error", Error_msg = "Invalid user ID" });

        // Find or create image
        Image? image = null;
        if (!string.IsNullOrEmpty(request.ImageUrl))
        {
            image = await _db.Images.FirstOrDefaultAsync(i => i.Url == request.ImageUrl);
            if (image == null)
            {
                image = new Image { Url = request.ImageUrl };
                _db.Images.Add(image);
                await _db.SaveChangesAsync();
            }
        }

        // Create quote
        var quote = new Quote
        {
            Text = request.Text,
            Author = request.Author,
            CreatedAt = DateTime.UtcNow,
            LastUpdatedAt = DateTime.UtcNow,
            ImageId = image?.Id ?? null,
            UserId = userId,
            QuoteCategories = new List<QuoteCategory>()
        };

        // Attach categories
        foreach (var categoryId in request.CategoryIds ?? [])
        {
            Category? category = await _db.Categories.FirstOrDefaultAsync(c => c.Id == categoryId);
            if (category == null)
                return BadRequest(new ErrorDTO { Status = "error", Error_msg = $"Category ID {categoryId} not found" });

            quote.QuoteCategories.Add(new QuoteCategory
            {
                Category = category,
                Quote = quote
            });
        }

        _db.Quotes.Add(quote);
        await _db.SaveChangesAsync();

        return CreatedAtAction(nameof(GetQuoteById), new { id = quote.Id }, quote.ToQuoteShortDTO());
    }

    // GET /api/v1/quotes/random
    /// <summary>
    /// Draw a random quote
    /// </summary>
    /// <returns>A quote: id, quote content and author, imageUrl and categories if successful, otherwise: error message</returns>
    /// <param name="category_id">(Optional) category id to draw from</param>
    /// <response code="200">Returned on valid request</response>
    /// <response code="204">Returned when no quotes exist matching provided criteria</response>
    /// <response code="404">Returned when no quotes exist (in the DB)</response>
    [HttpGet("random")]
    [AllowAnonymous]
    [ProducesResponseType(typeof(QuoteShortDTO), 200)]
    [ProducesResponseType(204)]
    [ProducesResponseType(typeof(ErrorDTO), 404)]
    public async Task<IActionResult> GetRandomQuote([FromQuery] int? category_id = null)
    {
        IQueryable<Quote> query = _db.Quotes
            .Include(q => q.QuoteCategories!)
            .ThenInclude(qc => qc.Category);

        if (category_id.HasValue)
        {
            query = query
                .Where(q => q.QuoteCategories!
                    .Any(qc => qc.CategoryId == category_id.Value)
                );
        }

        var totalQuotes = await query.CountAsync();
        if (totalQuotes == 0)
        {
            if (category_id.HasValue)
                return NoContent(); // Brak cytatów w wybranej kategorii
            else
                return NotFound(new ErrorDTO { Status = "error", Error_msg = "No quotes to choose from" });
        }

        var random = new Random();
        var skip = random.Next(0, totalQuotes);

        var quote = await query
            .Include(q => q.QuoteCategories!)
            .ThenInclude(qc => qc.Category)
            .Skip(skip)
            .Take(1)
            .FirstOrDefaultAsync();

        if (quote == null)
            return NotFound(new ErrorDTO { Status = "error", Error_msg = "Unknown error - couldn't get quote" });

        // After getting and checking the quote, update the number of draws
        Statistic s = await _db.Statistics
                                .FirstAsync(s => s.Label == "number_of_draws");
        s.IValue += 1;
        await _db.SaveChangesAsync();

        return Ok(quote.ToQuoteShortDTO());

    }

    // DELETE /api/v1/quotes/{id}
    /// <summary>
    /// [AUTHED] Delete a quote
    /// </summary>
    /// <remarks>
    /// Deletes a quote, granted it exists. <br/>
    /// <br/>
    /// <i>
    /// Is this the best practice? Marking the quote as hidden is also an option.
    /// </i> ~eee4
    /// </remarks>
    /// <returns>Json with status</returns>
    /// <param name="id">Quote id which will be deleted</param>
    /// <response code="200">Returned on valid request</response>
    /// <response code="404">Returned when no such quote exists</response>
    [HttpDelete("{id}")]
    [Authorize]
    [EnableCors]
    [ProducesResponseType(200)]
    [ProducesResponseType(typeof(ErrorDTO), 404)]
    public async Task<IActionResult> DeleteQuote(int id)
    {
        // (Attempt to) find the quote
        Quote? quote = await _db.Quotes
                            .FirstOrDefaultAsync(q => q.Id == id);
        // Failed?
        if (quote == null)
            return NotFound(new { status = "error", error_msg = "Quote not found" });

        // If succeded, remove the quote
        _db.Quotes.Remove(quote);
        await _db.SaveChangesAsync();

        // ====================================================================== //
        // Important!                                                             //
        // Is this the best we can do? Won't marking the quote as "hidden"        //
        // be better than explicitly deleting it? ~eee4                           //
        // ====================================================================== //

        // Return ok
        return Ok(new { Status = "ok" });
    }

    // PATCH /api/v1/quotes/{id}
    /// <summary>
    /// [AUTHED] Modify an existing quote
    /// </summary>
    /// <remarks>
    /// Modifies an existing quote.
    /// <br/><br/>
    /// <b>Warning!</b>
    /// We don't check the user id which created the quote.
    /// In case of single-user instances, this should not be a problem.
    /// This might become one, if we want users with non-admin roles;
    /// that would need some proper ACL checks here (with the help of GUHF).
    /// <br/><br/>
    /// <b>Important!</b>
    /// Image handling works the same as with creating new quote.
    /// This means that images not present in the DB will be added automatically.
    /// <br/><br/>
    /// <b>Important!</b>
    /// "categories = null" is not the same as "categories = []"!
    /// While "categories = null" will not alter the quote's categories,
    /// "categories = []" will (and in turn, empty each and every present category)!<br/>
    /// Be careful when handling user-provided categories!
    /// </remarks>
    /// <returns>Newly modified quote as a DTO</returns>
    /// <param name="id">Quote to be modified</param>
    /// <param name="updatedQuote">Updated quote form data</param>
    /// <response code="204">Returned on valid request</response>
    /// <response code="400">Returned when request text or author is empty (or whitespace)</response>
    /// <response code="404">Returned when no such quote exists</response>
    [HttpPatch("{id}")]
    [Authorize]
    [EnableCors]
    [ProducesResponseType(typeof(QuoteShortDTO), 200)]
    [ProducesResponseType(typeof(ErrorDTO), 400)]
    [ProducesResponseType(typeof(ErrorDTO), 404)]
    public async Task<IActionResult> EditQuote(int id, [FromBody] QuoteShortDTO updatedQuote)
    {
        // Try to find the quote in question
        Quote? quote = await _db.Quotes
            .Include(q => q.QuoteCategories)
            .FirstOrDefaultAsync(q => q.Id == id);

        // Failed?
        if (quote == null)
            return NotFound(new { status = "error", error_msg = "Quote not found" });

        // Is quote contents or author empty?
        if (string.IsNullOrWhiteSpace(updatedQuote.Text) || string.IsNullOrWhiteSpace(updatedQuote.Author))
            return BadRequest(new ErrorDTO { Status = "error", Error_msg = "Text and author are required." });

        // Alter the quote's content
        quote.Text = updatedQuote.Text;
        quote.Author = updatedQuote.Author;
        quote.LastUpdatedAt = DateTime.UtcNow;

        // Try to find the image inside the DB
        Image? image = null;
        if (!string.IsNullOrEmpty(updatedQuote.ImageUrl))
        {
            image = await _db.Images.FirstOrDefaultAsync(i => i.Url == updatedQuote.ImageUrl);
            // Failed? Just insert it yourself
            if (image == null)
            {
                image = new Image { Url = updatedQuote.ImageUrl };
                _db.Images.Add(image);
                await _db.SaveChangesAsync();
            }
        }
        quote.Image = image;

        // Don't touch categories if they are explicitly null
        if (updatedQuote.Categories == null) { }
        // If they aren't
        else if (updatedQuote.Categories.Any())
        {
            // Get all the categories associated with a quote from DB
            List<Category> categoriesFromDb = await _db.Categories
                .Where(c => updatedQuote.Categories.Contains(c.Name))
                .ToListAsync();

            // Determine which ones are already present, and which to add
            IEnumerable<string> existingNames = categoriesFromDb
                .Select(c => c.Name);
            List<string> newNames = updatedQuote.Categories
                .Except(existingNames)
                .ToList();

            // For all the categories not present
            foreach (var name in newNames)
            {
                // Add them to the DB
                var newCat = new Category
                {
                    Name = name,
                    Description = string.Empty,
                    CreatedAt = DateTime.UtcNow
                };
                _db.Categories.Add(newCat);
                categoriesFromDb.Add(newCat);
            }

            // If any categories were added, save changes
            if (newNames.Any())
                await _db.SaveChangesAsync();

            // Assign all the new categories to the quote
            quote.QuoteCategories = categoriesFromDb
                .Select(cat => new QuoteCategory
                {
                    CategoryId = cat.Id,
                    QuoteId = quote.Id
                })
                .ToList();
        }
        else
        {
            // No categories (empty list) inside DTO?
            // Clear them all!
            quote.QuoteCategories.Clear();
        }

        // Save changes, return new quote as a DTO
        await _db.SaveChangesAsync();
        return Ok(quote.ToQuoteShortDTO());
    }

}