OData Fundamentals

// Install: dotnet add package Microsoft.AspNetCore.OData

// 1. Definiera din data-model
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public string Category { get; set; }
    public DateTime CreatedDate { get; set; }
    public bool IsActive { get; set; }

    // Navigation property för relationer
    public virtual ICollection<Order> Orders { get; set; }
}

public class Order
{
    public int Id { get; set; }
    public int ProductId { get; set; }
    public string CustomerName { get; set; }
    public DateTime OrderDate { get; set; }
    public int Quantity { get; set; }

    public virtual Product Product { get; set; }
}

// 2. Konfigurera OData i Program.cs
using Microsoft.AspNetCore.OData;
using Microsoft.OData.Edm;
using Microsoft.OData.ModelBuilder;

var builder = WebApplication.CreateBuilder(args);

// Bygg OData EDM model
static IEdmModel GetEdmModel()
{
    var odataBuilder = new ODataConventionModelBuilder();
    odataBuilder.EntitySet<Product>("Products");
    odataBuilder.EntitySet<Order>("Orders");
    return odataBuilder.GetEdmModel();
}

// Lägg till OData services
builder.Services.AddControllers()
    .AddOData(options => options
        .Select()           // Tillåt $select
        .Filter()           // Tillåt $filter
        .OrderBy()          // Tillåt $orderby
        .SetMaxTop(100)     // Max 100 items
        .Count()            // Tillåt $count
        .Expand()           // Tillåt $expand
        .AddRouteComponents("api", GetEdmModel())
    );

var app = builder.Build();

app.MapControllers();
app.Run();

// 3. Skapa OData Controller
[Route("api/[controller]")]
[ApiController]
public class ProductsController : ControllerBase
{
    private readonly List<Product> _products;

    public ProductsController()
    {
        // Dummy data för demo
        _products = new List<Product>
        {
            new() { Id = 1, Name = "Laptop", Price = 15999, Category = "Electronics", CreatedDate = DateTime.Now.AddDays(-10), IsActive = true },
            new() { Id = 2, Name = "Mouse", Price = 299, Category = "Electronics", CreatedDate = DateTime.Now.AddDays(-5), IsActive = true },
            new() { Id = 3, Name = "Book", Price = 199, Category = "Books", CreatedDate = DateTime.Now.AddDays(-2), IsActive = false }
        };
    }

    // OData endpoint - automatisk query-hantering
    [HttpGet]
    [EnableQuery] // Detta är magin - aktiverar OData queries
    public IQueryable<Product> Get()
    {
        return _products.AsQueryable();
    }

    // Specifik produkt med OData-support
    [HttpGet("{id}")]
    [EnableQuery]
    public IActionResult Get(int id)
    {
        var product = _products.FirstOrDefault(p => p.Id == id);
        if (product == null) return NotFound();

        return Ok(product);
    }
}

// Anpassad validering och begränsningar
[HttpGet]
[EnableQuery(MaxTop = 50, AllowedQueryOptions =
    AllowedQueryOptions.Select |
    AllowedQueryOptions.Filter |
    AllowedQueryOptions.OrderBy)]
public IQueryable<Product> GetProducts()
{
    return _products.AsQueryable();
}

// Custom query-hantering
[HttpGet("search")]
public IActionResult Search(ODataQueryOptions<Product> options)
{
    IQueryable<Product> query = _products.AsQueryable();

    // Anpassad logik innan OData tillämpas
    if (options.Filter != null)
    {
        query = options.Filter.ApplyTo(query, new ODataQuerySettings()) as IQueryable<Product>;
    }

    // Lägg till egen affärslogik
    query = query.Where(p => p.IsActive);

    if (options.OrderBy != null)
    {
        query = options.OrderBy.ApplyTo(query) as IQueryable<Product>;
    }

    // Räkna innan paginering för metadata
    var totalCount = query.Count();

    if (options.Skip != null)
    {
        query = options.Skip.ApplyTo(query, new ODataQuerySettings()) as IQueryable<Product>;
    }

    if (options.Top != null)
    {
        query = options.Top.ApplyTo(query, new ODataQuerySettings()) as IQueryable<Product>;
    }

    var result = new
    {
        value = query.ToList(),
        count = totalCount
    };

    return Ok(result);
}

// SÄKERHET: Begränsa vad som är tillåtet
[EnableQuery(
    AllowedQueryOptions = AllowedQueryOptions.Filter | AllowedQueryOptions.OrderBy,
    MaxTop = 100,
    MaxSkip = 1000)]
public IQueryable<Product> GetProducts()
{
    // VIKTIGT: Filtrera känslig data före OData
    return _products
        .Where(p => p.IsActive) // Affärslogik först
        .AsQueryable();
}

// Performance: Var försiktig med $expand
[EnableQuery(MaxExpansionDepth = 2)] // Begränsa djup
public IQueryable<Product> GetProductsWithOrders()
{
    return _products.AsQueryable();
}

// Validering: Kontrollera queries
public class CustomEnableQueryAttribute : EnableQueryAttribute
{
    public override void OnActionExecuting(ActionExecutingContext context)
    {
        var request = context.HttpContext.Request;

        // Blockera farliga queries
        if (request.QueryString.Value?.Contains("password") == true)
        {
            context.Result = new BadRequestResult();
            return;
        }

        base.OnActionExecuting(context);
    }
}

// Unit test för OData
[Test]
public async Task GetProducts_WithFilter_ReturnsFilteredResults()
{
    // Arrange
    var client = _factory.CreateClient();

    // Act
    var response = await client.GetAsync("/api/products?$filter=price gt 1000&$select=name,price");

    // Assert
    response.EnsureSuccessStatusCode();
    var json = await response.Content.ReadAsStringAsync();
    var result = JsonSerializer.Deserialize<ODataResponse<Product>>(json);

    Assert.All(result.Value, p => Assert.True(p.Price > 1000));
}

public class ODataResponse<T>
{
    public List<T> Value { get; set; }
    public int Count { get; set; }
}