【C#、Blazor】Webアプリ開発入門編（7）「Todoアプリ」へ入力バリデーションをつける ～Data Annotationsの使い方～【ASP.NET Core】

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using TodoListApp.Data;

namespace TodoListApp.Models;

public class TodoItem
{
    [Key]
    public int Id { get; set; }

    [Required(ErrorMessage = "Title is required.")] //★(a)
    [StringLength(10, ErrorMessage = "Title must be less than 10 characters.")] //★(b)
    public string Title { get; set; } = string.Empty;
    
    [ForeignKey(nameof(ApplicationUser))]
    public string UserId { get; set; } = string.Empty;
}

dotnet ef migrations add AddConstraintsToTodoItem -o Data\Migrations
dotnet ef database update

@using TodoListApp.Models

@* ★(a) *@
<EditForm Model="@TodoItem" OnValidSubmit="OnSubmit" style="display: inline">
    @* ★(b) *@
    <DataAnnotationsValidator />
    <InputText @bind-Value="TodoItem.Title" placeholder="@Placeholder" />
    @* ★(c) *@
    <ValidationMessage For="@(() => TodoItem.Title)" style="display: inline"/>
    <button type="submit">@ButtonText</button>
</EditForm>

@code {
    [Parameter] public TodoItem TodoItem { get; set; } = new TodoItem();
    [Parameter] public string ButtonText { get; set; } = "Submit";
    [Parameter] public string Placeholder { get; set; } = "";
    [Parameter] public Func<Task> OnSubmit { get; set; } = () => Task.CompletedTask;
}

namespace TodoListApp.Services;

public class TodoListServiceException : Exception
{
    public TodoListServiceException(string message) : base(message) { }
    public TodoListServiceException(string message, Exception inner) : base(message, inner) { }
}

using Microsoft.EntityFrameworkCore;
using TodoListApp.Data;
using TodoListApp.Models;

namespace TodoListApp.Services;

public class TodoListService
{
    private readonly ApplicationDbContext _context;

    public TodoListService(ApplicationDbContext context)
    {
        _context = context;
    }

    public async Task<List<TodoItem>> GetTodosAsync(string userId)
    {
        //★(a)
        try
        {
            var items = await _context.TodoItems.Where(t => t.UserId == userId).ToListAsync();
            return items;
        }
        catch (Exception ex)
        {
            throw new TodoListServiceException("Failed to retrieve todo items.", ex);
        }
    }

    public async Task UpdateTodoAsync(string userId, TodoItem todoItemInput)
    {
        //★(b)
        try
        {
            var existingTodoItem = await _context.TodoItems.FindAsync(todoItemInput.Id);
            if (existingTodoItem == null || existingTodoItem.UserId != userId)
            {
                throw new TodoListServiceException("Todo item not found or access denied.");
            }
            existingTodoItem.Title = todoItemInput.Title;
            await _context.SaveChangesAsync();
        }
        catch (Exception ex)
        {
            throw new TodoListServiceException("Failed to update todo item.", ex);
        }
    }

    public async Task DeleteTodoAsync(string userId, int todoId)
    {
        //★(c)
        try
        {
            var existingTodoItem = await _context.TodoItems.FindAsync(todoId);
            if (existingTodoItem == null || existingTodoItem.UserId != userId)
            {
                throw new TodoListServiceException("Todo item not found or access denied.");
            }
            _context.TodoItems.Remove(existingTodoItem);
            await _context.SaveChangesAsync();
        }
        catch (Exception ex)
        {
            throw new TodoListServiceException("Failed to delete todo item.", ex);
        }
    }

    public async Task AddTodoAsync(string userId, TodoItem newTodoItem)
    {
        //★(d)
        try
        {
            newTodoItem.UserId = userId;
            _context.TodoItems.Add(newTodoItem);
            await _context.SaveChangesAsync();
        }
        catch (Exception ex)
        {
            throw new TodoListServiceException("Failed to add todo item.", ex);
        }
    }
}

@page "/todolist"
@rendermode InteractiveServer
@using Microsoft.AspNetCore.Identity
@using TodoListApp.Components.Shared
@using TodoListApp.Data
@using TodoListApp.Models
@using TodoListApp.Services
@inject AuthenticationStateProvider _authenticationStateProvider
@inject UserManager<ApplicationUser> _userManager
@inject TodoListService _todoService

<PageTitle>TodoList</PageTitle>

<h1>Todo List</h1>

//★(a)
@if (!string.IsNullOrEmpty(_latestMessage))
{
    <div class="alert @(_isLatestMessageSuccess ? "alert-success" : "alert-danger")">
        @_latestMessage
    </div>
}

@if (IsAuthenticated)
{
    <p>@_userName (Authenticated)</p>
    <ul>
        @foreach (var todoItem in _todoItems)
        {
            <li>
                <span>Id: @todoItem.Id, @todoItem.Title</span> 
                @if (_editingTodoItem != null && _editingTodoItem.Id == todoItem.Id)
                {
                    <TodoItemEditor TodoItem="_editingTodoItem" OnSubmit="UpdateTodoAsync" Placeholder="Edit title" ButtonText="Save" />
                }
                else
                {
                    <button @onclick="() => EnterEditMode(todoItem)">Edit</button>
                }
                 
                <button @onclick="() => DeleteTodoAsync(todoItem.Id)">Delete</button>
            </li>
        }
    </ul>

    <TodoItemEditor TodoItem="_newTodoItem" OnSubmit="AddTodoAsync" Placeholder="New todo title" ButtonText="Add" />
}
else
{
    <p>Not authenticated</p>
}

@code {
    //★(b)
    private string? _latestMessage;
    private bool _isLatestMessageSuccess;

    private List<TodoItem> _todoItems = new();
    private TodoItem? _newTodoItem;
    private TodoItem? _editingTodoItem;
    private string _userId = string.Empty;
    private string _userName = string.Empty;

    private bool IsAuthenticated => !string.IsNullOrEmpty(_userId);

    protected override async Task OnInitializedAsync()
    {
        var authState = await _authenticationStateProvider.GetAuthenticationStateAsync();
        var user = authState.User;

        if (user.Identity?.IsAuthenticated == true)
        {
            _userId = _userManager.GetUserId(user) ?? string.Empty;
            _userName = user.Identity.Name ?? string.Empty;
            if (IsAuthenticated)
            {
                CreateNewTodo();
                await ReloadTodosAsync();
            }
        }
    }

    private void CreateNewTodo()
    {
        _newTodoItem = new TodoItem { UserId = _userId };
    }

    private async Task ReloadTodosAsync()
    {
        //★(c)
        try
        {
            _todoItems = await _todoService.GetTodosAsync(_userId);
        }
        catch (TodoListServiceException ex)
        {
            SetUserMessage($"Error loading todos: {ex.Message}", false);
        }
    }

    private void EnterEditMode(TodoItem todoItem)
    {
        _editingTodoItem = new TodoItem
            {
                Id = todoItem.Id,
                Title = todoItem.Title,
                UserId = todoItem.UserId
            };
    }

    private async Task UpdateTodoAsync()
    {
        if (_editingTodoItem != null)
        {
            //★(d)
            try
            {
                await _todoService.UpdateTodoAsync(_userId, _editingTodoItem);
                _editingTodoItem = null;
                await ReloadTodosAsync();
                SetUserMessage("Todo item updated successfully.", true);
            }
            catch (TodoListServiceException ex)
            {
                SetUserMessage($"Error updating todo: {ex.Message}", false);
            }
        }
    }

    private async Task DeleteTodoAsync(int todoId)
    {
        //★(e)
        try
        {
            await _todoService.DeleteTodoAsync(_userId, todoId);
            await ReloadTodosAsync();
            SetUserMessage("Todo item deleted successfully.", true);
        }
        catch (TodoListServiceException ex)
        {
            SetUserMessage($"Error deleting todo: {ex.Message}", false);
        }
    }

    private async Task AddTodoAsync()
    {
        //★(f)
        if (_newTodoItem != null)
        {
            try
            {
                await _todoService.AddTodoAsync(_userId, _newTodoItem);
                CreateNewTodo();
                await ReloadTodosAsync();
                SetUserMessage("Todo item added successfully.", true);
            }
            catch (TodoListServiceException ex)
            {
                SetUserMessage($"Error adding todo: {ex.Message}", false);
            }
        }
    }

    //★(g)
    private void SetUserMessage(string message, bool isSuccess)
    {
        _latestMessage = message + " " + DateTime.Now.ToString("HH:mm:ss");
        _isLatestMessageSuccess = isSuccess;
    }
}