littleshop/LittleShop/Controllers/TestController.cs

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using LittleShop.Services;
using LittleShop.DTOs;
using LittleShop.Data;

namespace LittleShop.Controllers;

[ApiController]
[Route("api/[controller]")]
public class TestController : ControllerBase
{
    private readonly ICategoryService _categoryService;
    private readonly IProductService _productService;
    private readonly LittleShopContext _context;

    public TestController(ICategoryService categoryService, IProductService productService, LittleShopContext context)
    {
        _categoryService = categoryService;
        _productService = productService;
        _context = context;
    }

    [HttpPost("create-product")]
    public async Task<IActionResult> CreateTestProduct()
    {
        try
        {
            // Get the first category
            var categories = await _categoryService.GetAllCategoriesAsync();
            var firstCategory = categories.FirstOrDefault();
            
            if (firstCategory == null)
            {
                return BadRequest("No categories found. Create a category first.");
            }

            var product = await _productService.CreateProductAsync(new CreateProductDto
            {
                Name = "Test Product via API",
                Description = "This product was created via the test API endpoint 🚀",
                Price = 49.99m,
                Weight = 0.5m,
                WeightUnit = LittleShop.Enums.ProductWeightUnit.Pounds,
                CategoryId = firstCategory.Id
            });

            return Ok(new { 
                message = "Product created successfully",
                product = product
            });
        }
        catch (Exception ex)
        {
            return BadRequest(new { error = ex.Message });
        }
    }

    [HttpPost("setup-test-data")]
    public async Task<IActionResult> SetupTestData()
    {
        try
        {
            // Create test category
            var category = await _categoryService.CreateCategoryAsync(new CreateCategoryDto
            {
                Name = "Electronics",
                Description = "Electronic devices and gadgets"
            });

            // Create test product
            var product = await _productService.CreateProductAsync(new CreateProductDto
            {
                Name = "Sample Product",
                Description = "This is a test product with emoji support 📱💻",
                Price = 99.99m,
                Weight = 1.5m,
                WeightUnit = LittleShop.Enums.ProductWeightUnit.Pounds,
                CategoryId = category.Id
            });

            return Ok(new { 
                message = "Test data created successfully",
                category = category,
                product = product
            });
        }
        catch (Exception ex)
        {
            return BadRequest(new { error = ex.Message });
        }
    }

    [HttpPost("cleanup-bots")]
    public async Task<IActionResult> CleanupBots()
    {
        try
        {
            // Get count before cleanup
            var totalBots = await _context.Bots.CountAsync();
            
            // Keep only the most recent active bot per platform
            var keepBots = await _context.Bots
                .Where(b => b.IsActive && b.Status == Enums.BotStatus.Active)
                .GroupBy(b => b.PlatformId)
                .Select(g => g.OrderByDescending(b => b.LastSeenAt ?? b.CreatedAt).First())
                .ToListAsync();
            
            var keepBotIds = keepBots.Select(b => b.Id).ToList();
            
            // Delete old/inactive bots and related data
            var botsToDelete = await _context.Bots
                .Where(b => !keepBotIds.Contains(b.Id))
                .ToListAsync();
                
            _context.Bots.RemoveRange(botsToDelete);
            await _context.SaveChangesAsync();
            
            var deletedCount = botsToDelete.Count;
            var remainingCount = keepBots.Count;
            
            return Ok(new { 
                message = "Bot cleanup completed",
                totalBots = totalBots,
                deletedBots = deletedCount,
                remainingBots = remainingCount,
                keptBots = keepBots.Select(b => new {
                    id = b.Id,
                    name = b.Name,
                    platformUsername = b.PlatformUsername,
                    lastSeen = b.LastSeenAt,
                    created = b.CreatedAt
                })
            });
        }
        catch (Exception ex)
        {
            return BadRequest(new { error = ex.Message });
        }
    }
}