feat: LLM API endpoint

now it requires authorization

Controllers/CategoryController.cs

@@ -27,7 +27,7 @@ public class CategoryController : ControllerBase
         guhf = GUHF;
     }
 
-    // GET /api/v1/categories
+    // GET /api/v1/categories/page/1
     /// <summary>
     /// Get a category page
     /// </summary>
@@ -40,7 +40,7 @@ public class CategoryController : ControllerBase
     /// <response code="404">Returned when requested page is invalid (page_no &lt;= 0)</response>
     [HttpGet("page/{page_no}")]
     [EnableCors]
-    [ProducesResponseType(typeof(CategoryShortDTO), 200)]
+    [ProducesResponseType(typeof(List<CategoryShortDTO>), 200)]
     [ProducesResponseType(typeof(ErrorDTO), 404)]
     public async Task<IActionResult> GetCategoryPage(int page_no = 1)
     {
@@ -78,6 +78,47 @@ public class CategoryController : ControllerBase
 
     }
 
+    // GET /api/v1/categories
+    /// <summary>
+    /// [AUTHED] Get every category
+    /// </summary>
+    /// <remarks>
+    /// Can (and will) return an empty list if no categories are found in DB. <br/>
+    /// Unlike GET /api/v1/categories/page/..., requires authorization with a JWT.
+    /// Has CORS set.
+    /// </remarks>
+    /// <response code="200">Returned on valid request</response>
+    // /// <response code="404">Returned when there are no categories to list</response>
+    [HttpGet]
+    [Authorize]
+    [EnableCors]
+    [ProducesResponseType(typeof(List<CategoryShortDTO>), 200)]
+    public async Task<IActionResult> GetQuotePage()
+    {
+        // The following seems to be a bad idea, so I leave it as is. ~eee4
+        // 
+        // int totalCategories = await _db.Categories.CountAsync();
+        // 
+        // if (totalCategories <= 0)
+        // {
+        //     return NotFound(new ErrorDTO { Status = "error", Error_msg = "No categories to list" });
+        // }
+
+        // Get all the categories
+        List<Category> categories = await _db.Categories
+                                            .ToListAsync();
+
+        // Convert them to a list of DTO
+        List<CategoryShortDTO> result = categories
+                                            .Select(c => c.ToCategoryShortDTO())
+                                            .ToList();
+
+        // Return to user
+        return Ok(result);
+
+    }
+
+
     // POST /api/v1/categories
     /// <summary>
     /// [AUTHED] Create a new category

Controllers/GeneralUseHelperFunctions.cs

@@ -1,5 +1,7 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.IdentityModel.Tokens;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using QuotifyBE.Data;
 using QuotifyBE.Entities;
 using System.IdentityModel.Tokens.Jwt;
@@ -132,4 +134,108 @@ public class GeneralUseHelpers(ApplicationDbContext db, IConfiguration appsettin
 
         return new JwtSecurityTokenHandler().WriteToken(token);
     }
+
+    public async Task<JObject?> GenerateLLMResponse(string? prompt, string? model, float? temp, int? includedCategory, bool? includeCategorySample)
+    {
+
+        string           _model = model ?? _appsettings.GetSection("LlmIntegration")["DefaultModel"] ?? "deepclaude";
+        float             _temp = temp ?? 0.6f; // sane default
+        string _included_sample = string.Empty;
+        string          _prompt = prompt ?? _appsettings.GetSection("LlmIntegration")["DefaultPrompt"] ??
+                                    "Cześć, czy jesteś w stanie wymyślić i stworzyć jeden oryginalny cytat? " +
+                                    "Zastanów się nad jego puentą, a kiedy będziesz gotów - zwróć sam cytat. " +
+                                    "Nie pytaj mnie co o nim sądzę, ani nie używaj emotikonów (emoji). " +
+                                    "Pamiętaj, że dobre cytaty są krótkie, zwięzłe.";
+
+        if (includedCategory != null)
+        {
+            // Check if category to be included is present.
+            Category? cat = await _db.Categories.FirstOrDefaultAsync(c => c.Id == includedCategory.Value);
+            // It isn't?
+            if (cat == null) return null;
+            // It is?
+            _prompt += $" Niech należy on do kategorii o nazwie \"{cat.Name}\" ({cat.Description}).";
+        }
+
+        // Sanity check
+        if (includeCategorySample != null && includeCategorySample == true)
+        {
+            if (includedCategory == null)
+            {
+                // Can't append something that we're not given.
+                return null;
+            }
+            else
+            {
+                // Try to find the category in question.
+                Category? cat = await _db.Categories.FirstOrDefaultAsync(c => c.Id == includedCategory.Value);
+                // Failed?
+                if (cat == null)
+                {
+                    return null;
+                }
+                else
+                {
+                    IQueryable<Quote> query = _db.Quotes
+                                        .Include(q => q.QuoteCategories!)
+                                        .Where(q => q.QuoteCategories
+                                            .Any(qc => qc.Category == cat)
+                                        );
+                    int totalQuotes = await query.CountAsync();
+                    if (totalQuotes > 0) {
+
+                        Random random = new();
+                        int skip = random.Next(0, totalQuotes);
+
+                        Quote? quote = await query
+                            .Skip(skip)
+                            .Take(1)
+                            .FirstOrDefaultAsync();
+
+                        if (quote != null) {
+                            _prompt += $" Przykładowy cytat z tej kategorii brzmi: \"{quote.Text} ~ {quote.Author}\".\n";
+                        }
+                    }
+                }
+            }
+        }
+
+        List<Dictionary<string, string>> promptMessages = 
+        [
+            new() { { "role", "user" }, {"content", _prompt } }
+        ];
+
+        // Will throw error if not present
+        string apiUrl = _appsettings.GetSection("LlmIntegration")["ApiUrl"] + "/chat/completions"
+            ?? throw new MissingFieldException("API URL missing in LlmIntegration section of appsettings.json!");
+        string apiKey = _appsettings.GetSection("LlmIntegration")["ApiKey"]
+            ?? throw new MissingFieldException("API key missing in LlmIntegration section of appsettings.json!");
+
+        using (var client = new HttpClient())
+        {
+            // Not the best practice if we want reusable connections
+            // https://stackoverflow.com/a/40707446
+            client.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}");
+            var json = JsonConvert.SerializeObject(new
+            {
+                model = _model,
+                temperature = _temp,
+                max_tokens = (includeCategorySample ?? false) ? 2000 : 1000,
+                messages = promptMessages
+            });
+            var content = new StringContent(json, Encoding.UTF8, "application/json");
+            var response = await client.PostAsync(apiUrl, content);
+            if (response.IsSuccessStatusCode)
+            {
+                string receivedResponse = await response.Content.ReadAsStringAsync();
+                return JObject.Parse(receivedResponse);
+            }
+            else
+            {
+                // Handle the error
+                Console.WriteLine($"[QuotifyBE] Error: response status code from API was {response.StatusCode}.");
+                return null;
+            }
+        }
+    }
 }

Controllers/QuoteController.cs

@@ -2,6 +2,7 @@ using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Cors;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json.Linq;
 using QuotifyBE.Data;
 using QuotifyBE.DTOs;
 using QuotifyBE.Entities;
@@ -255,7 +256,8 @@ public class QuotesController : ControllerBase
     {
         IQueryable<Quote> query = _db.Quotes
             .Include(q => q.QuoteCategories!)
-            .ThenInclude(qc => qc.Category);
+            .ThenInclude(qc => qc.Category)
+            .Include(q => q.Image);
 
         if (category_id.HasValue)
         {
@@ -278,8 +280,6 @@ public class QuotesController : ControllerBase
         var skip = random.Next(0, totalQuotes);
 
         var quote = await query
-            .Include(q => q.QuoteCategories!)
-            .ThenInclude(qc => qc.Category)
             .Skip(skip)
             .Take(1)
             .FirstOrDefaultAsync();
@@ -482,4 +482,75 @@ public class QuotesController : ControllerBase
         return Ok(quote.ToQuoteShortDTO());
     }
 
+    // POST /api/v1/quotes/ai
+    /// <summary>
+    /// [AUTHED] Request a LLM-generated quote
+    /// </summary>
+    /// <returns>Generated quote's text</returns>
+    /// <remarks>
+    /// <b>Notes</b>:<br/>
+    ///
+    /// <ul>
+    /// If <i>customPrompt</i> is passed:
+    /// <li>The default prompt is overriden by whatever has been passed by the user.</li>
+    /// </ul><br/>
+    /// 
+    /// <ul>
+    /// If <i>model</i> is passed:
+    /// <li>The default large language model is overriden by whatever has been passed by the user.</li>
+    /// </ul><br/>
+    /// 
+    /// <ul>
+    /// If <i>temperature</i> is passed:
+    /// <li>The default temperature (= 0.8) is overriden by whatever has been passed by the user.</li>
+    /// </ul><br/>
+    /// 
+    /// <ul>
+    /// If <i>categoryId</i> is passed:
+    /// <li>The prompt is appended with an instruction in Polish to generate quotes based on the provided category
+    /// (both name and description get passed to the model).</li>
+    /// <li><b>Heads up!</b> The text is appended even if <i>customPrompt</i> has been provided.</li>
+    /// </ul><br/>
+    /// 
+    /// <ul>
+    /// If <i>useSampleQuote</i> is passed:
+    /// <li>The prompt will be appended with a randomly chosen quote from the categoryId (if any exist),
+    /// thus passing categoryId becomes a prerequisite.</li>
+    /// <li><b>Heads up!</b> The request will fail returning status code 400 if categoryId isn't provided!</li>
+    /// </ul>
+    /// </remarks>
+    /// <param name="request">Form data containing required quote information</param>
+    /// <response code="200">Returned on valid request</response>
+    /// <response code="400">Returned when generation failed due to remote server error (likely because of a bad request)</response>
+    /// <response code="500">Returned when response has been generated, but couldn't be parsed (likely because of incompatible server or bad URL)</response>
+    [HttpPost("ai")]
+    [Authorize]
+    [EnableCors]
+    [ProducesResponseType(200)]
+    [ProducesResponseType(typeof(ErrorDTO), 400)]
+    [ProducesResponseType(typeof(ErrorDTO), 500)]
+    public async Task<IActionResult> CreateLLMQuote([FromBody] AskLLMInDTO request)
+    {
+
+        JObject? generatedResponse = await guhf.GenerateLLMResponse(
+            request.CustomPrompt, request.Model, request.Temperature, request.CategoryId, request.UseSampleQuote
+        );
+
+        // Check if any errors occurred
+        if (generatedResponse == null)
+        {
+            return StatusCode(400, new ErrorDTO { Status = "error", Error_msg = "Generation failed most likely due to bad request" });
+        }
+
+        // Parse JSON to get the bot reply
+        string? llmResponse = generatedResponse["choices"]?[0]?["message"]?["content"]?.ToString().Trim('"');
+
+        // If response string is not where we expect it, return 500
+        if (llmResponse == null)
+            return StatusCode(500, new ErrorDTO { Status = "error", Error_msg = "Unexpected API response" });
+
+        // Otherwise, return the response
+        return Ok(new { Status = "ok", BotResponse = llmResponse });
+    }
+
 }

Controllers/UserContentController.cs

@@ -0,0 +1,119 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using QuotifyBE.Data;
+using QuotifyBE.Entities;
+using QuotifyBE.DTOs;
+using QuotifyBE.Mapping;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.EntityFrameworkCore;
+
+namespace QuotifyBE.Controllers;
+
+
+[ApiController]
+[EnableCors]
+[Route("api/v1/uc")]
+[Produces("application/json")]
+public class UserContentController : ControllerBase
+{
+
+    private readonly IConfiguration _appsettings;
+    private readonly ApplicationDbContext _db;
+    private readonly GeneralUseHelpers guhf;
+
+    public UserContentController(IConfiguration appsettings, ApplicationDbContext db, GeneralUseHelpers GUHF)
+    {
+        _appsettings = appsettings;
+        _db = db;
+        guhf = GUHF;
+    }
+
+    // GET /api/v1/uc/images
+    /// <summary>
+    /// [AUTHED] Get every image
+    /// </summary>
+    /// <remarks>
+    /// Can (and will) return an empty list if no images are found in DB. <br/>
+    /// Requires authorization with a JWT, has CORS set.
+    /// </remarks>
+    /// <response code="200">Returned on valid request</response>
+    [HttpGet]
+    [Authorize]
+    [EnableCors]
+    [ProducesResponseType(typeof(List<Image>), 200)]
+    public async Task<IActionResult> GetImages()
+    {
+
+        // Get all the images
+        List<Image> images = await _db.Images
+                                        .ToListAsync();
+
+        // Return to user
+        return Ok(images);
+
+    }
+
+
+    // POST /api/v1/uc/images
+    /// <summary>
+    /// [AUTHED] Upload an image and get an its URI
+    /// </summary>
+    /// <remarks>
+    /// Allows authorized users to publish images.
+    /// A user-reachable path is returned on success.<br/>
+    /// </remarks>
+    /// <response code="200">Returned on valid request</response>
+    /// <response code="400">Returned when file extension is unknown</response>
+    /// <response code="406">Returned when request does not follow user-provided config</response>
+    [HttpPost]
+    [Authorize]
+    [EnableCors]
+    [ProducesResponseType(200)]
+    [ProducesResponseType(typeof(ErrorDTO), 400)]
+    [ProducesResponseType(typeof(ErrorDTO), 406)]
+    public IActionResult PostNewImage(IFormFile file)
+    {
+
+        // Ideally, a hash of the file would be stored somewhere
+        // in the database to have a basic redundancy check,
+        // but this will do for now. ~eee4
+
+        // A good idea would be to also check the Content-Type
+        // of submitted files. ~eee4
+
+        List<string> allowedExtensions = new List<string>() { ".jpg", ".jpeg", ".jfif", ".png", ".gif", ".avif", ".webp" };
+
+        string fileExtension = Path.GetExtension(file.FileName);
+        if (!allowedExtensions.Contains(fileExtension.ToLower())) {
+            return BadRequest(new ErrorDTO {
+                Status = "error",
+                Error_msg = $"Unknown file extension. Please use one of the following: {string.Join(", ", allowedExtensions)}"
+            });
+        }
+
+        // TODO:
+        // https://www.youtube.com/watch?v=6-FNejMrVuk
+
+        // Sprawdź, czy plik spełnia ograniczenia:
+        // 1. Czy rozmiar jest mniejszy od _appsettings["UserContent"]["MaxFileSize"] ?
+
+
+        // Jeśli nie, zwróć ErrorDTO ze wiadomością: $"File size exceeds {_appsettings["UserContent"]["MaxFileSize"]}"
+
+
+        // Zapisz plik na dysku z pseudolosową nazwą GUID
+
+
+        // Wrzucić go do folderu "uploads/images/"
+
+
+        // Stwórz URL postaci: "/uploads/images/<nazwa pliku>.<rozszerzenie>"
+
+
+        // Zwróć powyższy URL
+        return Ok(new { Status = "ok", Filepath = "miejsce na wspomniany URL" });
+
+    }
+
+}
+

DTOs/AskLLMInDTO.cs

@@ -0,0 +1,12 @@
+namespace QuotifyBE.DTOs;
+
+public record class AskLLMInDTO
+{
+    public string? CustomPrompt { get; set; }
+    public string? Model { get; set; } = "deepclaude";
+    public float? Temperature { get; set; } = 0.8f;
+    public int? CategoryId { get; set; } = null;
+    public bool? UseSampleQuote { get; set; } = false;
+
+};
+

QuotifyBE.csproj

@@ -29,10 +29,15 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.22.1" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageReference Include="Npgsql" Version="9.0.3" />
     <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.4" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="9.0.3" />
     <PackageReference Include="Swashbuckle.AspNetCore.Annotations" Version="9.0.3" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="uploads\images\" />
+  </ItemGroup>
+
 </Project>

appsettings.example.json

@@ -2,8 +2,17 @@
   "JwtSecret": "this is a sample jwt secret token required for quotify - it needs to have at least 256 bits (32 bytes long)",
   "DomainName": "example.com",
   "CorsOrigins": [
-    "http://localhost:5259", "http://localhost:5258", "http://example.com"
+    "https://localhost:7029", "http://localhost:5259", "http://localhost:5258", "http://localhost:3000", "http://example.com"
   ],
+  "UserContent": {
+    "MaxFileSize": 5242880
+  },
+  "LlmIntegration": {
+    "ApiUrl": "URL to OpenAI-compatible API server, e.g. https://example.com/api/v1",
+    "ApiKey": "FILL ME for AI-generation capabilities",
+    "DefaultPrompt": "Cześć, czy jesteś w stanie wymyślić i stworzyć jeden oryginalny cytat?\nZastanów się nad jego puentą, a kiedy będziesz gotów - zwróć sam cytat.\nNie pytaj mnie co o nim sądzę, ani nie używaj emotikonów (emoji).\nPamiętaj, że dobre cytaty są krótkie, zwięzłe.",
+    "DefaultModel": "deepclaude"
+  },
   "ConnectionStrings": {
     "DefaultConnection": "Server=server-host;Database=db-name;Username=quotify-user;Password=user-secret"
   },