using Microsoft.EntityFrameworkCore;

namespace LookMaWhatEntityFrameworkDoes;

public class Award
{
    public int Id { get; set; }
    public string Name { get; set; }
}
public class Movie
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int? AwardId { get; set; }
    //       ^^^
    // Optional

    public Award Award { get; set; }
}

public class MovieContext : DbContext
{
    public MovieContext(DbContextOptions<MovieContext> options) : base(options)
    {
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder
            .Entity<Movie>()
            .HasOne(m => m.Award)
            .WithOne()
            .HasForeignKey<Movie>(m => m.AwardId)
            .OnDelete(DeleteBehavior.Restrict);
    }

    public DbSet<Movie> Movies { get; set; }
    public DbSet<Award> Awards { get; set; }
}

using Microsoft.EntityFrameworkCore;

namespace LookMaWhatEntityFrameworkDoes;

[TestClass]
public class MovieTests
{
    [TestMethod]
    public async Task AllAwardsPlease()
    {
        const string connectionString = $"Server=(localdb)\\MSSQLLocalDB;Database=Movies;Trusted_Connection=True;";

        var options = new DbContextOptionsBuilder<MovieContext>()
            .UseSqlServer(connectionString)
            .LogTo(Console.WriteLine)
            .Options;

        // 1. Let's create an "Oscar"
        using (var context = new MovieContext(options))
        {
            context.Awards.Add(new Award
            {
                Name = "Oscar"
            });
            context.SaveChanges();
        }

        // 2. Let's create two movies that have won an "Oscar"
        using (var context = new MovieContext(options))
        {
            var oscar = await context.Awards.FirstOrDefaultAsync();
            Assert.IsNotNull(oscar);

            context.Movies.AddRange(
                new Movie
                {
                    Name = "Forrest Gump",
                    AwardId = oscar.Id
                },
                new Movie
                {
                    Name = "Titanic",
                    AwardId = oscar.Id
                }
            );
            context.SaveChanges();
        }

        // 3. Let's retrieve all movies, expecting to have an Award
        using (var context = new MovieContext(options))
        {
            var movies = await context.Movies
                                // Imagine more filters here			
                                .Include(m => m.Award)
                                // ^^^^^
                                // Yes, I'm including it here
                                .ToListAsync();

            foreach (var movie in movies)
            {
                Assert.IsNotNull(movie);
                Assert.IsNotNull(movie.Award);
                //     ^^^^^
                // Assert.IsNotNull failed.
                // Play sad trumpet sound.
            }
        }
    }
}

public class MovieContext : DbContext
{
    public MovieContext(DbContextOptions<MovieContext> options) : base(options)
    {
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Remove the entire configuration
		// Or,		
        modelBuilder
            .Entity<Movie>()
            .HasOne(m => m.Award);
            // ^^^^^
            // Just this
    }

    public DbSet<Movie> Movies { get; set; }
    public DbSet<Award> Awards { get; set; }
}

@using Microsoft.AspNetCore.Components.Sections

<HeadContent>
    <link rel="stylesheet" href="css/summernote.css" />
</HeadContent>

<div id="@_id">@((MarkupString)Value)</div>

<SectionContent SectionName="scripts">
    <script src="js/summernote.js" type="text/javascript"></script>
</SectionContent>

using Microsoft.AspNetCore.Components;
using Microsoft.JSInterop;

namespace MyCoolComponents.HtmlEditor;

public partial class Summernote : IAsyncDisposable
{
    private readonly string _id = $"summernote_{Guid.NewGuid()}";

    private IJSObjectReference? _module;
    private DotNetObjectReference<Summernote>? _dotnetRef;
    private bool _editorInitialized = false;

    [Parameter]
    public string Value { get; set; }

    [Parameter]
    public EventCallback<string> ValueChanged { get; set; }

    [Inject]
    public IJSRuntime JsRuntime { get; set; } = default!;

    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        if (!_editorInitialized)
        {
            _dotnetRef = DotNetObjectReference.Create(this);

            _module = await JsRuntime.InvokeAsync<IJSObjectReference>("import", "./PutYourPathHere/Summernote.razor.js");
            await _module.InvokeVoidAsync("edit", _id, _dotnetRef, nameof(OnTextChange));

            _editorInitialized = true;
        }
    }

    [JSInvokable]
    public async Task OnTextChange(string editorText)
    {
        Value = editorText;
        await ValueChanged.InvokeAsync(editorText);
    }

    public async ValueTask DisposeAsync()
    {
        if (_module is not null)
        {
            await _module.DisposeAsync();
        }

        _dotnetRef?.Dispose();
    }
}

@using MyCoolComponents.HtmlEditor

<EditForm Model="MyCoolRequest" OnValidSubmit="OnValidSubmit">
    <DataAnnotationsValidator />
    <ValidationSummary />

    <div class="row">
        <div class="form-group col-sm-9">
            <label for="content" class="form-label">Content</label>
            <Summernote @bind-Value="Annotation.Content" />
            @* ^^^^^ *@
            @* Look, Ma! It works! *@
            <ValidationMessage For="() => Annotation.Content" class="invalid-feedback" />
        </div>
    </div>

    <button type="submit" class="btn btn-primary">Submit</button>
</EditForm>