Merged PR 18: Removed todos and added User endpoint combined with register. Id changed to guid into Master

Removed todos and added User endpoint combined with register. Id changed to guid

Related work items: #20

src/Application/Common/Interfaces/IApplicationDbContext.cs

@@ -4,11 +4,9 @@ namespace Hutopy.Application.Common.Interfaces;
 
 public interface IApplicationDbContext
 {
-    DbSet<TodoList> TodoLists { get; }
-
-    DbSet<TodoItem> TodoItems { get; }
-
     DbSet<FutureCreator> FutureCreators { get; }
 
+    DbSet<User> DomainUsers { get; }
+
     Task<int> SaveChangesAsync(CancellationToken cancellationToken);
 }

src/Application/Common/Models/LookupDto.cs

@@ -1,19 +0,0 @@
-using Hutopy.Domain.Entities;
-
-namespace Hutopy.Application.Common.Models;
-
-public class LookupDto
-{
-    public int Id { get; init; }
-
-    public string? Title { get; init; }
-
-    private class Mapping : Profile
-    {
-        public Mapping()
-        {
-            CreateMap<TodoList, LookupDto>();
-            CreateMap<TodoItem, LookupDto>();
-        }
-    }
-}

src/Application/FutureCreators/Commands/CreateFutureCreator.cs

@@ -3,7 +3,7 @@ using Hutopy.Domain.Entities;
 
 namespace Hutopy.Application.FutureCreators.Commands;
 
-public abstract record CreateFutureCreatorCommand : IRequest<int>
+public record CreateFutureCreatorCommand : IRequest<Guid>
 {
     public required string FirstName { get; init; }
     public required string LastName { get; init; }
@@ -15,9 +15,9 @@ public abstract record CreateFutureCreatorCommand : IRequest<int>
 
 public class CreateFutureCreatorCommandHandler(
     IApplicationDbContext context)
-    : IRequestHandler<CreateFutureCreatorCommand, int>
+    : IRequestHandler<CreateFutureCreatorCommand, Guid>
 {
-    public async Task<int> Handle(CreateFutureCreatorCommand request, CancellationToken cancellationToken)
+    public async Task<Guid> Handle(CreateFutureCreatorCommand request, CancellationToken cancellationToken)
     {
         var entity = new FutureCreator
         {

src/Application/FutureCreators/Queries/FutureCreatorListDto.cs

@@ -0,0 +1,20 @@
+using Hutopy.Domain.Entities;
+
+namespace Hutopy.Application.FutureCreators.Queries;
+
+public class FutureCreatorListDto
+{
+    public Guid Id { get; init; }
+
+    public required string FirstName { get; init; }
+
+    public required string LastName { get; init; }
+
+    private class Mapping : Profile
+    {
+        public Mapping()
+        {
+            CreateMap<FutureCreator, FutureCreatorListDto>();
+        }
+    }
+}

src/Application/FutureCreators/Queries/GetFutureCreatorList.cs

@@ -0,0 +1,26 @@
+
+using Hutopy.Application.Common.Interfaces;
+using Hutopy.Application.Common.Mappings;
+using Hutopy.Application.Common.Models;
+
+namespace Hutopy.Application.FutureCreators.Queries;
+
+public record GetFutureCreatorListQuery : IRequest<PaginatedList<FutureCreatorListDto>>
+{
+    public int PageNumber { get; init; } = 1;
+    public int PageSize { get; init; } = 10;
+}
+
+public class GetFutureCreatorListQueryHandler(
+    IApplicationDbContext context,
+    IMapper mapper)
+    : IRequestHandler<GetFutureCreatorListQuery, PaginatedList<FutureCreatorListDto>>
+{
+    public async Task<PaginatedList<FutureCreatorListDto>> Handle(GetFutureCreatorListQuery request, CancellationToken cancellationToken)
+    {
+        return await context.FutureCreators
+            .OrderBy(x => x.FirstName)
+            .ProjectTo<FutureCreatorListDto>(mapper.ConfigurationProvider)
+            .PaginatedListAsync(request.PageNumber, request.PageSize);
+    }
+}

src/Application/TodoItems/Commands/CreateTodoItem/CreateTodoItem.cs

@@ -1,35 +0,0 @@
-using Hutopy.Application.Common.Interfaces;
-using Hutopy.Domain.Entities;
-using Hutopy.Domain.Events;
-
-namespace Hutopy.Application.TodoItems.Commands.CreateTodoItem;
-
-public record CreateTodoItemCommand : IRequest<int>
-{
-    public int ListId { get; init; }
-
-    public string? Title { get; init; }
-}
-
-public class CreateTodoItemCommandHandler(
-    IApplicationDbContext context) 
-    : IRequestHandler<CreateTodoItemCommand, int>
-{
-    public async Task<int> Handle(CreateTodoItemCommand request, CancellationToken cancellationToken)
-    {
-        var entity = new TodoItem
-        {
-            ListId = request.ListId,
-            Title = request.Title,
-            Done = false
-        };
-
-        entity.AddDomainEvent(new TodoItemCreatedEvent(entity));
-
-        context.TodoItems.Add(entity);
-
-        await context.SaveChangesAsync(cancellationToken);
-
-        return entity.Id;
-    }
-}

src/Application/TodoItems/Commands/CreateTodoItem/CreateTodoItemCommandValidator.cs

@@ -1,11 +0,0 @@
-namespace Hutopy.Application.TodoItems.Commands.CreateTodoItem;
-
-public class CreateTodoItemCommandValidator : AbstractValidator<CreateTodoItemCommand>
-{
-    public CreateTodoItemCommandValidator()
-    {
-        RuleFor(v => v.Title)
-            .MaximumLength(200)
-            .NotEmpty();
-    }
-}

src/Application/TodoItems/Commands/DeleteTodoItem/DeleteTodoItem.cs

@@ -1,30 +0,0 @@
-using Hutopy.Application.Common.Interfaces;
-using Hutopy.Domain.Events;
-using Hutopy.Application.Common.Security;
-using Hutopy.Domain.Constants;
-
-namespace Hutopy.Application.TodoItems.Commands.DeleteTodoItem;
-
-[Authorize(Roles = Roles.Administrator)]
-[Authorize(Policy = Policies.CanDelete)]
-public record DeleteTodoItemCommand(int Id) : IRequest;
-
-public class DeleteTodoItemCommandHandler(
-    IApplicationDbContext context) 
-    : IRequestHandler<DeleteTodoItemCommand>
-{
-    public async Task Handle(DeleteTodoItemCommand request, CancellationToken cancellationToken)
-    {
-        var entity = await context.TodoItems
-            .FindAsync(new object[] { request.Id }, cancellationToken);
-
-        Guard.Against.NotFound(request.Id, entity);
-
-        context.TodoItems.Remove(entity);
-
-        entity.AddDomainEvent(new TodoItemDeletedEvent(entity));
-
-        await context.SaveChangesAsync(cancellationToken);
-    }
-
-}

src/Application/TodoItems/Commands/UpdateTodoItem/UpdateTodoItem.cs

@@ -1,30 +0,0 @@
-using Hutopy.Application.Common.Interfaces;
-
-namespace Hutopy.Application.TodoItems.Commands.UpdateTodoItem;
-
-public record UpdateTodoItemCommand : IRequest
-{
-    public int Id { get; init; }
-
-    public string? Title { get; init; }
-
-    public bool Done { get; init; }
-}
-
-public class UpdateTodoItemCommandHandler(
-    IApplicationDbContext context) 
-    : IRequestHandler<UpdateTodoItemCommand>
-{
-    public async Task Handle(UpdateTodoItemCommand request, CancellationToken cancellationToken)
-    {
-        var entity = await context.TodoItems
-            .FindAsync(new object[] { request.Id }, cancellationToken);
-
-        Guard.Against.NotFound(request.Id, entity);
-
-        entity.Title = request.Title;
-        entity.Done = request.Done;
-
-        await context.SaveChangesAsync(cancellationToken);
-    }
-}

src/Application/TodoItems/Commands/UpdateTodoItem/UpdateTodoItemCommandValidator.cs

@@ -1,11 +0,0 @@
-namespace Hutopy.Application.TodoItems.Commands.UpdateTodoItem;
-
-public class UpdateTodoItemCommandValidator : AbstractValidator<UpdateTodoItemCommand>
-{
-    public UpdateTodoItemCommandValidator()
-    {
-        RuleFor(v => v.Title)
-            .MaximumLength(200)
-            .NotEmpty();
-    }
-}

src/Application/TodoItems/Commands/UpdateTodoItemDetail/UpdateTodoItemDetail.cs

@@ -1,34 +0,0 @@
-using Hutopy.Application.Common.Interfaces;
-using Hutopy.Domain.Enums;
-
-namespace Hutopy.Application.TodoItems.Commands.UpdateTodoItemDetail;
-
-public record UpdateTodoItemDetailCommand : IRequest
-{
-    public int Id { get; init; }
-
-    public int ListId { get; init; }
-
-    public PriorityLevel Priority { get; init; }
-
-    public string? Note { get; init; }
-}
-
-public class UpdateTodoItemDetailCommandHandler(
-    IApplicationDbContext context)
-    : IRequestHandler<UpdateTodoItemDetailCommand>
-{
-    public async Task Handle(UpdateTodoItemDetailCommand request, CancellationToken cancellationToken)
-    {
-        var entity = await context.TodoItems
-            .FindAsync(new object[] { request.Id }, cancellationToken);
-
-        Guard.Against.NotFound(request.Id, entity);
-
-        entity.ListId = request.ListId;
-        entity.Priority = request.Priority;
-        entity.Note = request.Note;
-
-        await context.SaveChangesAsync(cancellationToken);
-    }
-}

src/Application/TodoItems/EventHandlers/TodoItemCompletedEventHandler.cs

@@ -1,16 +0,0 @@
-using Hutopy.Domain.Events;
-using Microsoft.Extensions.Logging;
-
-namespace Hutopy.Application.TodoItems.EventHandlers;
-
-public class TodoItemCompletedEventHandler(
-    ILogger<TodoItemCompletedEventHandler> logger)
-    : INotificationHandler<TodoItemCompletedEvent>
-{
-    public Task Handle(TodoItemCompletedEvent notification, CancellationToken cancellationToken)
-    {
-        logger.LogInformation("Hutopy Domain Event: {DomainEvent}", notification.GetType().Name);
-
-        return Task.CompletedTask;
-    }
-}

src/Application/TodoItems/EventHandlers/TodoItemCreatedEventHandler.cs

@@ -1,16 +0,0 @@
-using Hutopy.Domain.Events;
-using Microsoft.Extensions.Logging;
-
-namespace Hutopy.Application.TodoItems.EventHandlers;
-
-public class TodoItemCreatedEventHandler(
-    ILogger<TodoItemCreatedEventHandler> logger)
-    : INotificationHandler<TodoItemCreatedEvent>
-{
-    public Task Handle(TodoItemCreatedEvent notification, CancellationToken cancellationToken)
-    {
-        logger.LogInformation("Hutopy Domain Event: {DomainEvent}", notification.GetType().Name);
-
-        return Task.CompletedTask;
-    }
-}

src/Application/TodoItems/Queries/GetTodoItemsWithPagination/GetTodoItemsWithPagination.cs

@@ -1,28 +0,0 @@
-using Hutopy.Application.Common.Interfaces;
-using Hutopy.Application.Common.Mappings;
-using Hutopy.Application.Common.Models;
-
-namespace Hutopy.Application.TodoItems.Queries.GetTodoItemsWithPagination;
-
-public abstract record GetTodoItemsWithPaginationQuery : IRequest<PaginatedList<TodoItemBriefDto>>
-{
-    public int ListId { get; init; }
-    public int PageNumber { get; init; } = 1;
-    public int PageSize { get; init; } = 10;
-}
-
-public class GetTodoItemsWithPaginationQueryHandler(
-    IApplicationDbContext context, 
-    IMapper mapper)
-    : IRequestHandler<GetTodoItemsWithPaginationQuery, PaginatedList<TodoItemBriefDto>>
-{
-    public async Task<PaginatedList<TodoItemBriefDto>> Handle(GetTodoItemsWithPaginationQuery request, CancellationToken cancellationToken)
-    {
-        Console.WriteLine(request);
-        return await context.TodoItems
-            .Where(x => x.ListId == request.ListId)
-            .OrderBy(x => x.Title)
-            .ProjectTo<TodoItemBriefDto>(mapper.ConfigurationProvider)
-            .PaginatedListAsync(request.PageNumber, request.PageSize);
-    }
-}

src/Application/TodoItems/Queries/GetTodoItemsWithPagination/GetTodoItemsWithPaginationQueryValidator.cs

@@ -1,16 +0,0 @@
-namespace Hutopy.Application.TodoItems.Queries.GetTodoItemsWithPagination;
-
-public class GetTodoItemsWithPaginationQueryValidator : AbstractValidator<GetTodoItemsWithPaginationQuery>
-{
-    public GetTodoItemsWithPaginationQueryValidator()
-    {
-        RuleFor(x => x.ListId)
-            .NotEmpty().WithMessage("ListId is required.");
-
-        RuleFor(x => x.PageNumber)
-            .GreaterThanOrEqualTo(1).WithMessage("PageNumber at least greater than or equal to 1.");
-
-        RuleFor(x => x.PageSize)
-            .GreaterThanOrEqualTo(1).WithMessage("PageSize at least greater than or equal to 1.");
-    }
-}

src/Application/TodoItems/Queries/GetTodoItemsWithPagination/TodoItemBriefDto.cs

@@ -1,22 +0,0 @@
-using Hutopy.Domain.Entities;
-
-namespace Hutopy.Application.TodoItems.Queries.GetTodoItemsWithPagination;
-
-public class TodoItemBriefDto
-{
-    public int Id { get; init; }
-
-    public int ListId { get; init; }
-
-    public string? Title { get; init; }
-
-    public bool Done { get; init; }
-
-    private class Mapping : Profile
-    {
-        public Mapping()
-        {
-            CreateMap<TodoItem, TodoItemBriefDto>();
-        }
-    }
-}

src/Application/TodoLists/Commands/CreateTodoList/CreateTodoList.cs

@@ -1,25 +0,0 @@
-using Hutopy.Application.Common.Interfaces;
-using Hutopy.Domain.Entities;
-
-namespace Hutopy.Application.TodoLists.Commands.CreateTodoList;
-
-public record CreateTodoListCommand : IRequest<int>
-{
-    public string? Title { get; init; }
-}
-
-public class CreateTodoListCommandHandler(
-    IApplicationDbContext context) 
-    : IRequestHandler<CreateTodoListCommand, int>
-{
-    public async Task<int> Handle(CreateTodoListCommand request, CancellationToken cancellationToken)
-    {
-        var entity = new TodoList { Title = request.Title };
-
-        context.TodoLists.Add(entity);
-
-        await context.SaveChangesAsync(cancellationToken);
-
-        return entity.Id;
-    }
-}

src/Application/TodoLists/Commands/CreateTodoList/CreateTodoListCommandValidator.cs

@@ -1,26 +0,0 @@
-using Hutopy.Application.Common.Interfaces;
-
-namespace Hutopy.Application.TodoLists.Commands.CreateTodoList;
-
-public class CreateTodoListCommandValidator : AbstractValidator<CreateTodoListCommand>
-{
-    private readonly IApplicationDbContext _context;
-
-    public CreateTodoListCommandValidator(IApplicationDbContext context)
-    {
-        _context = context;
-
-        RuleFor(v => v.Title)
-            .NotEmpty()
-            .MaximumLength(200)
-            .MustAsync(BeUniqueTitle)
-                .WithMessage("'{PropertyName}' must be unique.")
-                .WithErrorCode("Unique");
-    }
-
-    public async Task<bool> BeUniqueTitle(string title, CancellationToken cancellationToken)
-    {
-        return await _context.TodoLists
-            .AllAsync(l => l.Title != title, cancellationToken);
-    }
-}

src/Application/TodoLists/Commands/DeleteTodoList/DeleteTodoList.cs

@@ -1,23 +0,0 @@
-using Hutopy.Application.Common.Interfaces;
-
-namespace Hutopy.Application.TodoLists.Commands.DeleteTodoList;
-
-public record DeleteTodoListCommand(int Id) : IRequest;
-
-public class DeleteTodoListCommandHandler(
-    IApplicationDbContext context) 
-    : IRequestHandler<DeleteTodoListCommand>
-{
-    public async Task Handle(DeleteTodoListCommand request, CancellationToken cancellationToken)
-    {
-        var entity = await context.TodoLists
-            .Where(l => l.Id == request.Id)
-            .SingleOrDefaultAsync(cancellationToken);
-
-        Guard.Against.NotFound(request.Id, entity);
-
-        context.TodoLists.Remove(entity);
-
-        await context.SaveChangesAsync(cancellationToken);
-    }
-}

src/Application/TodoLists/Commands/PurgeTodoLists/PurgeTodoLists.cs

@@ -1,21 +0,0 @@
-using Hutopy.Application.Common.Interfaces;
-using Hutopy.Application.Common.Security;
-using Hutopy.Domain.Constants;
-
-namespace Hutopy.Application.TodoLists.Commands.PurgeTodoLists;
-
-[Authorize(Roles = Roles.Administrator)]
-[Authorize(Policy = Policies.CanPurge)]
-public record PurgeTodoListsCommand : IRequest;
-
-public class PurgeTodoListsCommandHandler(
-    IApplicationDbContext context) 
-    : IRequestHandler<PurgeTodoListsCommand>
-{
-    public async Task Handle(PurgeTodoListsCommand request, CancellationToken cancellationToken)
-    {
-        context.TodoLists.RemoveRange(context.TodoLists);
-
-        await context.SaveChangesAsync(cancellationToken);
-    }
-}

src/Application/TodoLists/Commands/UpdateTodoList/UpdateTodoList.cs

@@ -1,28 +0,0 @@
-using Hutopy.Application.Common.Interfaces;
-
-namespace Hutopy.Application.TodoLists.Commands.UpdateTodoList;
-
-public record UpdateTodoListCommand : IRequest
-{
-    public int Id { get; init; }
-
-    public string? Title { get; init; }
-}
-
-public class UpdateTodoListCommandHandler(
-    IApplicationDbContext context) 
-    : IRequestHandler<UpdateTodoListCommand>
-{
-    public async Task Handle(UpdateTodoListCommand request, CancellationToken cancellationToken)
-    {
-        var entity = await context.TodoLists
-            .FindAsync(new object[] { request.Id }, cancellationToken);
-
-        Guard.Against.NotFound(request.Id, entity);
-
-        entity.Title = request.Title;
-
-        await context.SaveChangesAsync(cancellationToken);
-
-    }
-}

src/Application/TodoLists/Commands/UpdateTodoList/UpdateTodoListCommandValidator.cs

@@ -1,27 +0,0 @@
-using Hutopy.Application.Common.Interfaces;
-
-namespace Hutopy.Application.TodoLists.Commands.UpdateTodoList;
-
-public class UpdateTodoListCommandValidator : AbstractValidator<UpdateTodoListCommand>
-{
-    private readonly IApplicationDbContext _context;
-
-    public UpdateTodoListCommandValidator(IApplicationDbContext context)
-    {
-        _context = context;
-
-        RuleFor(v => v.Title)
-            .NotEmpty()
-            .MaximumLength(200)
-            .MustAsync(BeUniqueTitle)
-                .WithMessage("'{PropertyName}' must be unique.")
-                .WithErrorCode("Unique");
-    }
-
-    private async Task<bool> BeUniqueTitle(UpdateTodoListCommand model, string title, CancellationToken cancellationToken)
-    {
-        return await _context.TodoLists
-            .Where(l => l.Id != model.Id)
-            .AllAsync(l => l.Title != title, cancellationToken);
-    }
-}

src/Application/TodoLists/Queries/GetTodos/GetTodos.cs

@@ -1,32 +0,0 @@
-using Hutopy.Application.Common.Interfaces;
-using Hutopy.Application.Common.Models;
-using Hutopy.Application.Common.Security;
-using Hutopy.Domain.Enums;
-
-namespace Hutopy.Application.TodoLists.Queries.GetTodos;
-
-[Authorize]
-public record GetTodosQuery : IRequest<TodosVm>;
-
-public class GetTodosQueryHandler(
-    IApplicationDbContext context, 
-    IMapper mapper)
-    : IRequestHandler<GetTodosQuery, TodosVm>
-{
-    public async Task<TodosVm> Handle(GetTodosQuery request, CancellationToken cancellationToken)
-    {
-        return new TodosVm
-        {
-            PriorityLevels = Enum.GetValues(typeof(PriorityLevel))
-                .Cast<PriorityLevel>()
-                .Select(p => new LookupDto { Id = (int)p, Title = p.ToString() })
-                .ToList(),
-
-            Lists = await context.TodoLists
-                .AsNoTracking()
-                .ProjectTo<TodoListDto>(mapper.ConfigurationProvider)
-                .OrderBy(t => t.Title)
-                .ToListAsync(cancellationToken)
-        };
-    }
-}

src/Application/TodoLists/Queries/GetTodos/TodoItemDto.cs

@@ -1,27 +0,0 @@
-using Hutopy.Domain.Entities;
-
-namespace Hutopy.Application.TodoLists.Queries.GetTodos;
-
-public class TodoItemDto
-{
-    public int Id { get; init; }
-
-    public int ListId { get; init; }
-
-    public string? Title { get; init; }
-
-    public bool Done { get; init; }
-
-    public int Priority { get; init; }
-
-    public string? Note { get; init; }
-
-    private class Mapping : Profile
-    {
-        public Mapping()
-        {
-            CreateMap<TodoItem, TodoItemDto>().ForMember(d => d.Priority, 
-                opt => opt.MapFrom(s => (int)s.Priority));
-        }
-    }
-}

src/Application/TodoLists/Queries/GetTodos/TodoListDto.cs

@@ -1,22 +0,0 @@
-using Hutopy.Domain.Entities;
-
-namespace Hutopy.Application.TodoLists.Queries.GetTodos;
-
-public class TodoListDto
-{
-    public int Id { get; init; }
-
-    public string? Title { get; init; }
-
-    public string? Colour { get; init; }
-
-    public IReadOnlyCollection<TodoItemDto> Items { get; init; } = Array.Empty<TodoItemDto>();
-
-    private class Mapping : Profile
-    {
-        public Mapping()
-        {
-            CreateMap<TodoList, TodoListDto>();
-        }
-    }
-}

src/Application/TodoLists/Queries/GetTodos/TodosVm.cs

@@ -1,10 +0,0 @@
-using Hutopy.Application.Common.Models;
-
-namespace Hutopy.Application.TodoLists.Queries.GetTodos;
-
-public class TodosVm
-{
-    public IReadOnlyCollection<LookupDto> PriorityLevels { get; init; } = Array.Empty<LookupDto>();
-
-    public IReadOnlyCollection<TodoListDto> Lists { get; init; } = Array.Empty<TodoListDto>();
-}

src/Application/Users/Commands/CreateUser.cs

@@ -0,0 +1,39 @@
+using Hutopy.Application.Common.Interfaces;
+using Hutopy.Domain.Entities;
+
+namespace Hutopy.Application.Users.Commands;
+public record CreateUserCommand : IRequest<Guid>
+{
+    public required string FirstName { get; init; }
+    public required string LastName { get; init; }
+    public required string EmailAddress { get; init; }
+    public required string UserName { get; init; }
+    public required string Password { get; init; }
+}
+
+public class CreateUserCommandHandler : IRequestHandler<CreateUserCommand, Guid>
+{
+    private readonly IApplicationDbContext _context;
+
+    public CreateUserCommandHandler(IApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<Guid> Handle(CreateUserCommand request, CancellationToken cancellationToken)
+    {
+        var entity = new User
+        {
+            FirstName = request.FirstName,
+            LastName = request.LastName,
+            EmailAddress = request.EmailAddress,
+            UserName = request.UserName,
+        };
+
+        _context.DomainUsers.Add(entity);
+
+        await _context.SaveChangesAsync(cancellationToken);
+
+        return entity.Id;
+    }
+}

src/Domain/Common/BaseEntity.cs

@@ -6,7 +6,7 @@ public abstract class BaseEntity
 {
     // This can easily be modified to be BaseEntity<T> and public T Id to support different key types.
     // Using non-generic integer types for simplicity
-    public int Id { get; set; }
+    public Guid Id { get; set; }
 
     private readonly List<BaseEvent> _domainEvents = [];
 

src/Domain/Entities/TodoItem.cs

@@ -1,31 +0,0 @@
-namespace Hutopy.Domain.Entities;
-
-public class TodoItem : BaseAuditableEntity
-{
-    public int ListId { get; set; }
-
-    public string? Title { get; set; }
-
-    public string? Note { get; set; }
-
-    public PriorityLevel Priority { get; set; }
-
-    public DateTime? Reminder { get; set; }
-
-    private bool _done;
-    public bool Done
-    {
-        get => _done;
-        set
-        {
-            if (value && !_done)
-            {
-                AddDomainEvent(new TodoItemCompletedEvent(this));
-            }
-
-            _done = value;
-        }
-    }
-
-    public TodoList List { get; set; } = null!;
-}

src/Domain/Entities/TodoList.cs

@@ -1,10 +0,0 @@
-namespace Hutopy.Domain.Entities;
-
-public class TodoList : BaseAuditableEntity
-{
-    public string? Title { get; set; }
-
-    public Colour Colour { get; set; } = Colour.White;
-
-    public IList<TodoItem> Items { get; private set; } = new List<TodoItem>();
-}

src/Domain/Entities/User.cs

@@ -0,0 +1,10 @@
+namespace Hutopy.Domain.Entities;
+
+public class User : BaseAuditableEntity
+{
+    public Guid IdentityUserId { get; set; }
+    public required string FirstName { get; set; }
+    public required string LastName { get; set; }
+    public required string UserName { get; set; }
+    public required string EmailAddress { get; set; }
+}

src/Domain/Events/TodoItemCompletedEvent.cs

@@ -1,8 +0,0 @@
-namespace Hutopy.Domain.Events;
-
-public class TodoItemCompletedEvent(
-    TodoItem item) 
-    : BaseEvent
-{
-    public TodoItem Item { get; } = item;
-}

src/Domain/Events/TodoItemCreatedEvent.cs

@@ -1,8 +0,0 @@
-namespace Hutopy.Domain.Events;
-
-public class TodoItemCreatedEvent(
-    TodoItem item) 
-    : BaseEvent
-{
-    public TodoItem Item { get; } = item;
-}

src/Domain/Events/TodoItemDeletedEvent.cs

@@ -1,8 +0,0 @@
-namespace Hutopy.Domain.Events;
-
-public class TodoItemDeletedEvent(
-    TodoItem item) 
-    : BaseEvent
-{
-    public TodoItem Item { get; } = item;
-}

src/Domain/GlobalUsings.cs

@@ -1,6 +1,5 @@
 global using Hutopy.Domain.Common;
 global using Hutopy.Domain.Entities;
 global using Hutopy.Domain.Enums;
-global using Hutopy.Domain.Events;
 global using Hutopy.Domain.Exceptions;
 global using Hutopy.Domain.ValueObjects;

src/Domain/Interfaces/IUserService.cs

@@ -0,0 +1,7 @@
+namespace Hutopy.Domain.Interfaces;
+
+public interface IUserService
+{
+    Task CreateUserAsync(string email, string userName, string password);
+
+}

src/Infrastructure/Data/ApplicationDbContext.cs

@@ -11,12 +11,10 @@ public class ApplicationDbContext(
     DbContextOptions<ApplicationDbContext> options)
     : IdentityDbContext<ApplicationUser>(options), IApplicationDbContext
 {
-    public DbSet<TodoList> TodoLists => Set<TodoList>();
-
-    public DbSet<TodoItem> TodoItems => Set<TodoItem>();
-
     public DbSet<FutureCreator> FutureCreators => Set<FutureCreator>();
 
+    public DbSet<User> DomainUsers => Set<User>();
+
     protected override void OnModelCreating(ModelBuilder builder)
     {
         base.OnModelCreating(builder);

src/Infrastructure/Data/ApplicationDbContextInitializer.cs

@@ -73,27 +73,8 @@ public class ApplicationDbContextInitializer(
             await userManager.CreateAsync(administrator, "Administrator1!");
             if (!string.IsNullOrWhiteSpace(administratorRole.Name))
             {
-                await userManager.AddToRolesAsync(administrator, new [] { administratorRole.Name });
+                await userManager.AddToRolesAsync(administrator, new[] { administratorRole.Name });
             }
         }
-
-        // Default data
-        // Seed, if necessary
-        if (!context.TodoLists.Any())
-        {
-            context.TodoLists.Add(new TodoList
-            {
-                Title = "Todo List",
-                Items =
-                {
-                    new TodoItem { Title = "Make a todo list 📃" },
-                    new TodoItem { Title = "Check off the first item ✅" },
-                    new TodoItem { Title = "Realise you've already done two things on the list! 🤯"},
-                    new TodoItem { Title = "Reward yourself with a nice, long nap 🏆" },
-                }
-            });
-
-            await context.SaveChangesAsync();
-        }
     }
 }

src/Infrastructure/Data/Configurations/TodoItemConfiguration.cs

@@ -1,15 +0,0 @@
-using Hutopy.Domain.Entities;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Metadata.Builders;
-
-namespace Hutopy.Infrastructure.Data.Configurations;
-
-public class TodoItemConfiguration : IEntityTypeConfiguration<TodoItem>
-{
-    public void Configure(EntityTypeBuilder<TodoItem> builder)
-    {
-        builder.Property(t => t.Title)
-            .HasMaxLength(200)
-            .IsRequired();
-    }
-}

src/Infrastructure/Data/Configurations/TodoListConfiguration.cs

@@ -1,18 +0,0 @@
-using Hutopy.Domain.Entities;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Metadata.Builders;
-
-namespace Hutopy.Infrastructure.Data.Configurations;
-
-public class TodoListConfiguration : IEntityTypeConfiguration<TodoList>
-{
-    public void Configure(EntityTypeBuilder<TodoList> builder)
-    {
-        builder.Property(t => t.Title)
-            .HasMaxLength(200)
-            .IsRequired();
-
-        builder
-            .OwnsOne(b => b.Colour);
-    }
-}

src/Infrastructure/Data/Migrations/20240404013754_AddDomainUser.Designer.cs

@@ -0,0 +1,492 @@
+// <auto-generated />
+using System;
+using Hutopy.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Hutopy.Infrastructure.Data.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20240404013754_AddDomainUser")]
+    partial class AddDomainUser
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("Hutopy.Domain.Entities.FutureCreator", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("EmailAddress")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("LastModified")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ReasonToJoin")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SocialNetworkAccount")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("FutureCreators");
+                });
+
+            modelBuilder.Entity("Hutopy.Domain.Entities.TodoItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Done")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTimeOffset>("LastModified")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ListId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("Reminder")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ListId");
+
+                    b.ToTable("TodoItems");
+                });
+
+            modelBuilder.Entity("Hutopy.Domain.Entities.TodoList", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("LastModified")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TodoLists");
+                });
+
+            modelBuilder.Entity("Hutopy.Domain.Entities.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("EmailAddress")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("IdentityUserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTimeOffset>("LastModified")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DomainUsers");
+                });
+
+            modelBuilder.Entity("Hutopy.Infrastructure.Identity.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex")
+                        .HasFilter("[NormalizedUserName] IS NOT NULL");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex")
+                        .HasFilter("[NormalizedName] IS NOT NULL");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Hutopy.Domain.Entities.TodoItem", b =>
+                {
+                    b.HasOne("Hutopy.Domain.Entities.TodoList", "List")
+                        .WithMany("Items")
+                        .HasForeignKey("ListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("List");
+                });
+
+            modelBuilder.Entity("Hutopy.Domain.Entities.TodoList", b =>
+                {
+                    b.OwnsOne("Hutopy.Domain.ValueObjects.Colour", "Colour", b1 =>
+                        {
+                            b1.Property<int>("TodoListId")
+                                .HasColumnType("int");
+
+                            b1.Property<string>("Code")
+                                .IsRequired()
+                                .HasColumnType("nvarchar(max)");
+
+                            b1.HasKey("TodoListId");
+
+                            b1.ToTable("TodoLists");
+
+                            b1.WithOwner()
+                                .HasForeignKey("TodoListId");
+                        });
+
+                    b.Navigation("Colour")
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Hutopy.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Hutopy.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Hutopy.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Hutopy.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Hutopy.Domain.Entities.TodoList", b =>
+                {
+                    b.Navigation("Items");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/Infrastructure/Data/Migrations/20240404013754_AddDomainUser.cs

@@ -0,0 +1,44 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Hutopy.Infrastructure.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddDomainUser : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "DomainUsers",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    IdentityUserId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
+                    FirstName = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    LastName = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    UserName = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    EmailAddress = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    Password = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    Created = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false),
+                    CreatedBy = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    LastModified = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false),
+                    LastModifiedBy = table.Column<string>(type: "nvarchar(max)", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_DomainUsers", x => x.Id);
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "DomainUsers");
+        }
+    }
+}

src/Infrastructure/Data/Migrations/20240404023737_ChangeIdsToGuidsAndRemoveTodos.Designer.cs

@@ -0,0 +1,372 @@
+// <auto-generated />
+using System;
+using Hutopy.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Hutopy.Infrastructure.Data.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20240404023737_ChangeIdsToGuidsAndRemoveTodos")]
+    partial class ChangeIdsToGuidsAndRemoveTodos
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("Hutopy.Domain.Entities.FutureCreator", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("EmailAddress")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("LastModified")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ReasonToJoin")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SocialNetworkAccount")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("FutureCreators");
+                });
+
+            modelBuilder.Entity("Hutopy.Domain.Entities.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("EmailAddress")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("IdentityUserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTimeOffset>("LastModified")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DomainUsers");
+                });
+
+            modelBuilder.Entity("Hutopy.Infrastructure.Identity.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex")
+                        .HasFilter("[NormalizedUserName] IS NOT NULL");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex")
+                        .HasFilter("[NormalizedName] IS NOT NULL");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Hutopy.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Hutopy.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Hutopy.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Hutopy.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/Infrastructure/Data/Migrations/20240404023737_ChangeIdsToGuidsAndRemoveTodos.cs

@@ -0,0 +1,149 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Hutopy.Infrastructure.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class ChangeIdsToGuidsAndRemoveTodos : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "TodoItems");
+
+            migrationBuilder.DropTable(
+                name: "TodoLists");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_FuturCreators",
+                table: "FutureCreators");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_DomainUsers",
+                table: "DomainUsers");
+
+            migrationBuilder.DropColumn(
+                name: "Id",
+                table: "FutureCreators");
+
+            migrationBuilder.DropColumn(
+                name: "Id",
+                table: "DomainUsers");
+
+            migrationBuilder.AddColumn<Guid>(
+                name: "Id",
+                table: "FutureCreators",
+                type: "uniqueidentifier",
+                nullable: false,
+                defaultValueSql: "NEWID()"
+            );
+
+            migrationBuilder.AddColumn<Guid>(
+                name: "Id",
+                table: "DomainUsers",
+                type: "uniqueidentifier",
+                nullable: false,
+                defaultValueSql: "NEWID()"
+            );
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_FutureCreators",
+                table: "FutureCreators",
+                column: "Id");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_DomainUsers",
+                table: "DomainUsers",
+                column: "Id");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_FutureCreators",
+                table: "FutureCreators");
+
+            migrationBuilder.RenameTable(
+                name: "FutureCreators",
+                newName: "FutureCreator");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "Id",
+                table: "DomainUsers",
+                type: "int",
+                nullable: false,
+                oldClrType: typeof(Guid),
+                oldType: "uniqueidentifier")
+                .Annotation("SqlServer:Identity", "1, 1");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "Id",
+                table: "FutureCreator",
+                type: "int",
+                nullable: false,
+                oldClrType: typeof(Guid),
+                oldType: "uniqueidentifier")
+                .Annotation("SqlServer:Identity", "1, 1");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_FutureCreator",
+                table: "FutureCreator",
+                column: "Id");
+
+            migrationBuilder.CreateTable(
+                name: "TodoLists",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    Created = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false),
+                    CreatedBy = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    LastModified = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false),
+                    LastModifiedBy = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    Title = table.Column<string>(type: "nvarchar(200)", maxLength: 200, nullable: false),
+                    Colour_Code = table.Column<string>(type: "nvarchar(max)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_TodoLists", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "TodoItems",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    ListId = table.Column<int>(type: "int", nullable: false),
+                    Created = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false),
+                    CreatedBy = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    Done = table.Column<bool>(type: "bit", nullable: false),
+                    LastModified = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false),
+                    LastModifiedBy = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    Note = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    Priority = table.Column<int>(type: "int", nullable: false),
+                    Reminder = table.Column<DateTime>(type: "datetime2", nullable: true),
+                    Title = table.Column<string>(type: "nvarchar(200)", maxLength: 200, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_TodoItems", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_TodoItems_TodoLists_ListId",
+                        column: x => x.ListId,
+                        principalTable: "TodoLists",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_TodoItems_ListId",
+                table: "TodoItems",
+                column: "ListId");
+        }
+    }
+}

src/Infrastructure/Data/Migrations/20240404030232_RemovePasswordFromDomainUser.Designer.cs

@@ -0,0 +1,368 @@
+// <auto-generated />
+using System;
+using Hutopy.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Hutopy.Infrastructure.Data.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20240404030232_RemovePasswordFromDomainUser")]
+    partial class RemovePasswordFromDomainUser
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("Hutopy.Domain.Entities.FutureCreator", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("EmailAddress")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("LastModified")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ReasonToJoin")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SocialNetworkAccount")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("FutureCreators");
+                });
+
+            modelBuilder.Entity("Hutopy.Domain.Entities.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTimeOffset>("Created")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("EmailAddress")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("IdentityUserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTimeOffset>("LastModified")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("LastModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DomainUsers");
+                });
+
+            modelBuilder.Entity("Hutopy.Infrastructure.Identity.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex")
+                        .HasFilter("[NormalizedUserName] IS NOT NULL");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex")
+                        .HasFilter("[NormalizedName] IS NOT NULL");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Hutopy.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Hutopy.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Hutopy.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Hutopy.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/Infrastructure/Data/Migrations/20240404030232_RemovePasswordFromDomainUser.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Hutopy.Infrastructure.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class RemovePasswordFromDomainUser : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Password",
+                table: "DomainUsers");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "Password",
+                table: "DomainUsers",
+                type: "nvarchar(max)",
+                nullable: false,
+                defaultValue: "");
+        }
+    }
+}

src/Infrastructure/Data/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -24,11 +24,9 @@ namespace Hutopy.Infrastructure.Data.Migrations
 
             modelBuilder.Entity("Hutopy.Domain.Entities.FutureCreator", b =>
                 {
-                    b.Property<int>("Id")
+                    b.Property<Guid>("Id")
                         .ValueGeneratedOnAdd()
-                        .HasColumnType("int");
+                        .HasColumnType("uniqueidentifier");
-
-                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
 
                     b.Property<DateTimeOffset>("Created")
                         .HasColumnType("datetimeoffset");
@@ -68,16 +66,14 @@ namespace Hutopy.Infrastructure.Data.Migrations
 
                     b.HasKey("Id");
 
-                    b.ToTable("FutureCreator");
+                    b.ToTable("FutureCreators");
                 });
 
-            modelBuilder.Entity("Hutopy.Domain.Entities.TodoItem", b =>
+            modelBuilder.Entity("Hutopy.Domain.Entities.User", b =>
                 {
-                    b.Property<int>("Id")
+                    b.Property<Guid>("Id")
                         .ValueGeneratedOnAdd()
-                        .HasColumnType("int");
+                        .HasColumnType("uniqueidentifier");
-
-                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
 
                     b.Property<DateTimeOffset>("Created")
                         .HasColumnType("datetimeoffset");
@@ -85,8 +81,16 @@ namespace Hutopy.Infrastructure.Data.Migrations
                     b.Property<string>("CreatedBy")
                         .HasColumnType("nvarchar(max)");
 
-                    b.Property<bool>("Done")
+                    b.Property<string>("EmailAddress")
-                        .HasColumnType("bit");
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("IdentityUserId")
+                        .HasColumnType("uniqueidentifier");
 
                     b.Property<DateTimeOffset>("LastModified")
                         .HasColumnType("datetimeoffset");
@@ -94,58 +98,17 @@ namespace Hutopy.Infrastructure.Data.Migrations
                     b.Property<string>("LastModifiedBy")
                         .HasColumnType("nvarchar(max)");
 
-                    b.Property<int>("ListId")
+                    b.Property<string>("LastName")
-                        .HasColumnType("int");
+                        .IsRequired()
-
-                    b.Property<string>("Note")
                         .HasColumnType("nvarchar(max)");
 
-                    b.Property<int>("Priority")
+                    b.Property<string>("UserName")
-                        .HasColumnType("int");
-
-                    b.Property<DateTime?>("Reminder")
-                        .HasColumnType("datetime2");
-
-                    b.Property<string>("Title")
                         .IsRequired()
-                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(max)");
-                        .HasColumnType("nvarchar(200)");
 
                     b.HasKey("Id");
 
-                    b.HasIndex("ListId");
+                    b.ToTable("DomainUsers");
-
-                    b.ToTable("TodoItems");
-                });
-
-            modelBuilder.Entity("Hutopy.Domain.Entities.TodoList", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("int");
-
-                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
-
-                    b.Property<DateTimeOffset>("Created")
-                        .HasColumnType("datetimeoffset");
-
-                    b.Property<string>("CreatedBy")
-                        .HasColumnType("nvarchar(max)");
-
-                    b.Property<DateTimeOffset>("LastModified")
-                        .HasColumnType("datetimeoffset");
-
-                    b.Property<string>("LastModifiedBy")
-                        .HasColumnType("nvarchar(max)");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasMaxLength(200)
-                        .HasColumnType("nvarchar(200)");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("TodoLists");
                 });
 
             modelBuilder.Entity("Hutopy.Infrastructure.Identity.ApplicationUser", b =>
@@ -346,40 +309,6 @@ namespace Hutopy.Infrastructure.Data.Migrations
                     b.ToTable("AspNetUserTokens", (string)null);
                 });
 
-            modelBuilder.Entity("Hutopy.Domain.Entities.TodoItem", b =>
-                {
-                    b.HasOne("Hutopy.Domain.Entities.TodoList", "List")
-                        .WithMany("Items")
-                        .HasForeignKey("ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("List");
-                });
-
-            modelBuilder.Entity("Hutopy.Domain.Entities.TodoList", b =>
-                {
-                    b.OwnsOne("Hutopy.Domain.ValueObjects.Colour", "Colour", b1 =>
-                        {
-                            b1.Property<int>("TodoListId")
-                                .HasColumnType("int");
-
-                            b1.Property<string>("Code")
-                                .IsRequired()
-                                .HasColumnType("nvarchar(max)");
-
-                            b1.HasKey("TodoListId");
-
-                            b1.ToTable("TodoLists");
-
-                            b1.WithOwner()
-                                .HasForeignKey("TodoListId");
-                        });
-
-                    b.Navigation("Colour")
-                        .IsRequired();
-                });
-
             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
                 {
                     b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
@@ -430,11 +359,6 @@ namespace Hutopy.Infrastructure.Data.Migrations
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
                 });
-
-            modelBuilder.Entity("Hutopy.Domain.Entities.TodoList", b =>
-                {
-                    b.Navigation("Items");
-                });
 #pragma warning restore 612, 618
         }
     }

src/Infrastructure/DependencyInjection.cs

@@ -1,8 +1,10 @@
 using Hutopy.Application.Common.Interfaces;
 using Hutopy.Domain.Constants;
+using Hutopy.Domain.Interfaces;
 using Hutopy.Infrastructure.Data;
 using Hutopy.Infrastructure.Data.Interceptors;
 using Hutopy.Infrastructure.Identity;
+using Hutopy.Infrastructure.Services;
 using Hutopy.Infrastructure.Stripe;
 using Microsoft.AspNetCore.Identity;
 using Microsoft.EntityFrameworkCore;
@@ -41,6 +43,8 @@ public static class DependencyInjection
             .AddBearerToken(IdentityConstants.BearerScheme);
 
         services.AddAuthorizationBuilder();
+        services.AddScoped<IUserService, UserService>();
+
 
         // Might need to change and use AddIdentity<User, Role>() when we need to integrate connection via third party ( facebook, google )
         services

src/Infrastructure/Services/UserService.cs

@@ -0,0 +1,30 @@
+using Hutopy.Domain.Interfaces;
+using Hutopy.Infrastructure.Identity;
+using Microsoft.AspNetCore.Identity;
+
+namespace Hutopy.Infrastructure.Services;
+
+public class UserService(UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager) : IUserService
+{
+    private readonly UserManager<ApplicationUser> _userManager = userManager;
+    private readonly SignInManager<ApplicationUser> _signInManager = signInManager;
+
+
+    public async Task CreateUserAsync(string email, string userName, string password)
+    {
+        var applicationUser = new ApplicationUser
+        {
+            UserName = userName,
+            Email = email,
+        };
+
+        //todo: Need to handle errors better for the user.
+        var response = await _userManager.CreateAsync(applicationUser, password);
+
+        if (response.Errors.Any())
+        {
+            throw new InvalidOperationException(response.Errors.First().Description);
+        }
+    }
+}
+

src/Web/DependencyInjection.cs

@@ -1,6 +1,8 @@
 using Azure.Identity;
 using Hutopy.Application.Common.Interfaces;
+using Hutopy.Domain.Interfaces;
 using Hutopy.Infrastructure.Data;
+using Hutopy.Infrastructure.Services;
 using Hutopy.Web.Services;
 using Microsoft.AspNetCore.Mvc;
 using NSwag;
@@ -15,6 +17,8 @@ public static class DependencyInjection
         services.AddDatabaseDeveloperPageExceptionFilter();
 
         services.AddScoped<IUser, CurrentUser>();
+        services.AddScoped<IUserService, UserService>();
+
 
         services.AddHttpContextAccessor();
 

src/Web/Endpoints/JoinUs.cs

@@ -1,4 +1,6 @@
-using Hutopy.Application.FutureCreators.Commands;
+using Hutopy.Application.Common.Models;
+using Hutopy.Application.FutureCreators.Commands;
+using Hutopy.Application.FutureCreators.Queries;
 
 namespace Hutopy.Web.Endpoints;
 
@@ -7,11 +9,17 @@ public class JoinUs : EndpointGroupBase
     public override void Map(WebApplication app)
     {
         app.MapGroup(this)
+            .MapGet(GetFutureCreators)
             .MapPost(CreateFutureCreator);
     }
 
-    private static Task<int> CreateFutureCreator(ISender sender, CreateFutureCreatorCommand command)
+    private static Task<Guid> CreateFutureCreator(ISender sender, CreateFutureCreatorCommand command)
     {
         return sender.Send(command);
     }
+
+    private static Task<PaginatedList<FutureCreatorListDto>> GetFutureCreators(ISender sender, [AsParameters] GetFutureCreatorListQuery query)
+    {
+        return sender.Send(query);
+    }
 }

src/Web/Endpoints/TodoItems.cs

@@ -1,52 +0,0 @@
-using Hutopy.Application.Common.Models;
-using Hutopy.Application.TodoItems.Commands.CreateTodoItem;
-using Hutopy.Application.TodoItems.Commands.DeleteTodoItem;
-using Hutopy.Application.TodoItems.Commands.UpdateTodoItem;
-using Hutopy.Application.TodoItems.Commands.UpdateTodoItemDetail;
-using Hutopy.Application.TodoItems.Queries.GetTodoItemsWithPagination;
-
-namespace Hutopy.Web.Endpoints;
-
-public class TodoItems : EndpointGroupBase
-{
-    public override void Map(WebApplication app)
-    {
-        app.MapGroup(this)
-            .RequireAuthorization()
-            .MapGet(GetTodoItemsWithPagination)
-            .MapPost(CreateTodoItem)
-            .MapPut(UpdateTodoItem, "{id}")
-            .MapPut(UpdateTodoItemDetail, "UpdateDetail/{id}")
-            .MapDelete(DeleteTodoItem, "{id}");
-    }
-
-    private static Task<PaginatedList<TodoItemBriefDto>> GetTodoItemsWithPagination(ISender sender, [AsParameters] GetTodoItemsWithPaginationQuery query)
-    {
-        return sender.Send(query);
-    }
-
-    private static Task<int> CreateTodoItem(ISender sender, CreateTodoItemCommand command)
-    {
-        return sender.Send(command);
-    }
-
-    private static async Task<IResult> UpdateTodoItem(ISender sender, int id, UpdateTodoItemCommand command)
-    {
-        if (id != command.Id) return Results.BadRequest();
-        await sender.Send(command);
-        return Results.NoContent();
-    }
-
-    private static async Task<IResult> UpdateTodoItemDetail(ISender sender, int id, UpdateTodoItemDetailCommand command)
-    {
-        if (id != command.Id) return Results.BadRequest();
-        await sender.Send(command);
-        return Results.NoContent();
-    }
-
-    private static async Task<IResult> DeleteTodoItem(ISender sender, int id)
-    {
-        await sender.Send(new DeleteTodoItemCommand(id));
-        return Results.NoContent();
-    }
-}

src/Web/Endpoints/TodoLists.cs

@@ -1,42 +0,0 @@
-using Hutopy.Application.TodoLists.Commands.CreateTodoList;
-using Hutopy.Application.TodoLists.Commands.DeleteTodoList;
-using Hutopy.Application.TodoLists.Commands.UpdateTodoList;
-using Hutopy.Application.TodoLists.Queries.GetTodos;
-
-namespace Hutopy.Web.Endpoints;
-
-public class TodoLists : EndpointGroupBase
-{
-    public override void Map(WebApplication app)
-    {
-        app.MapGroup(this)
-            .RequireAuthorization()
-            .MapGet(GetTodoLists)
-            .MapPost(CreateTodoList)
-            .MapPut(UpdateTodoList, "{id}")
-            .MapDelete(DeleteTodoList, "{id}");
-    }
-
-    private static Task<TodosVm> GetTodoLists(ISender sender)
-    {
-        return sender.Send(new GetTodosQuery());
-    }
-
-    private static Task<int> CreateTodoList(ISender sender, CreateTodoListCommand command)
-    {
-        return sender.Send(command);
-    }
-
-    private static async Task<IResult> UpdateTodoList(ISender sender, int id, UpdateTodoListCommand command)
-    {
-        if (id != command.Id) return Results.BadRequest();
-        await sender.Send(command);
-        return Results.NoContent();
-    }
-
-    private static async Task<IResult> DeleteTodoList(ISender sender, int id)
-    {
-        await sender.Send(new DeleteTodoListCommand(id));
-        return Results.NoContent();
-    }
-}

src/Web/Endpoints/Users.cs

@@ -1,4 +1,6 @@
-using Hutopy.Infrastructure.Identity;
+using Hutopy.Application.Users.Commands;
+using Hutopy.Domain.Interfaces;
+using Hutopy.Infrastructure.Identity;
 
 namespace Hutopy.Web.Endpoints;
 
@@ -7,6 +9,13 @@ public class Users : EndpointGroupBase
     public override void Map(WebApplication app)
     {
         app.MapGroup(this)
+            .MapPost(CreateUser)
             .MapIdentityApi<ApplicationUser>();
     }
+
+    public async Task<Guid> CreateUser(ISender sender, CreateUserCommand command, IUserService userService)
+    {
+        await userService.CreateUserAsync(command.EmailAddress, command.UserName, command.Password);
+        return await sender.Send(command);
+    }
 }

src/Web/Program.cs

@@ -1,6 +1,8 @@
 using Hutopy.Application;
+using Hutopy.Domain.Interfaces;
 using Hutopy.Infrastructure;
 using Hutopy.Infrastructure.Data;
+using Hutopy.Infrastructure.Services;
 using Hutopy.Web;
 
 var builder = WebApplication.CreateBuilder(args);
@@ -22,6 +24,7 @@ builder.Services.AddApplicationServices();
 builder.Services.AddInfrastructureServices(builder.Configuration);
 builder.Services.AddWebServices();
 
+builder.Services.AddScoped<IUserService, UserService>();
 
 var app = builder.Build();
 

src/Web/wwwroot/api/specification.json

@@ -7,6 +7,46 @@
   },
   "paths": {
     "/api/JoinUs": {
+      "get": {
+        "tags": [
+          "JoinUs"
+        ],
+        "operationId": "GetFutureCreators",
+        "parameters": [
+          {
+            "name": "PageNumber",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int32"
+            },
+            "x-position": 1
+          },
+          {
+            "name": "PageSize",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int32"
+            },
+            "x-position": 2
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PaginatedListOfFutureCreatorListDto"
+                }
+              }
+            }
+          }
+        }
+      },
       "post": {
         "tags": [
           "JoinUs"
@@ -30,8 +70,8 @@
             "content": {
               "application/json": {
                 "schema": {
-                  "type": "integer",
+                  "type": "string",
-                  "format": "int32"
+                  "format": "guid"
                 }
               }
             }
@@ -71,73 +111,18 @@
         }
       }
     },
-    "/api/TodoItems": {
+    "/api/Users": {
-      "get": {
-        "tags": [
-          "TodoItems"
-        ],
-        "operationId": "GetTodoItemsWithPagination",
-        "parameters": [
-          {
-            "name": "ListId",
-            "in": "query",
-            "required": true,
-            "schema": {
-              "type": "integer",
-              "format": "int32"
-            },
-            "x-position": 1
-          },
-          {
-            "name": "PageNumber",
-            "in": "query",
-            "required": true,
-            "schema": {
-              "type": "integer",
-              "format": "int32"
-            },
-            "x-position": 2
-          },
-          {
-            "name": "PageSize",
-            "in": "query",
-            "required": true,
-            "schema": {
-              "type": "integer",
-              "format": "int32"
-            },
-            "x-position": 3
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/PaginatedListOfTodoItemBriefDto"
-                }
-              }
-            }
-          }
-        },
-        "security": [
-          {
-            "JWT": []
-          }
-        ]
-      },
       "post": {
         "tags": [
-          "TodoItems"
+          "Users"
         ],
-        "operationId": "CreateTodoItem",
+        "operationId": "CreateUser",
         "requestBody": {
           "x-name": "command",
           "content": {
             "application/json": {
               "schema": {
-                "$ref": "#/components/schemas/CreateTodoItemCommand"
+                "$ref": "#/components/schemas/CreateUserCommand"
               }
             }
           },
@@ -150,261 +135,13 @@
             "content": {
               "application/json": {
                 "schema": {
-                  "type": "integer",
+                  "type": "string",
-                  "format": "int32"
+                  "format": "guid"
                 }
               }
             }
           }
-        },
+        }
-        "security": [
-          {
-            "JWT": []
-          }
-        ]
-      }
-    },
-    "/api/TodoItems/{id}": {
-      "put": {
-        "tags": [
-          "TodoItems"
-        ],
-        "operationId": "UpdateTodoItem",
-        "parameters": [
-          {
-            "name": "id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "integer",
-              "format": "int32"
-            },
-            "x-position": 1
-          }
-        ],
-        "requestBody": {
-          "x-name": "command",
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/UpdateTodoItemCommand"
-              }
-            }
-          },
-          "required": true,
-          "x-position": 2
-        },
-        "responses": {
-          "200": {
-            "description": ""
-          }
-        },
-        "security": [
-          {
-            "JWT": []
-          }
-        ]
-      },
-      "delete": {
-        "tags": [
-          "TodoItems"
-        ],
-        "operationId": "DeleteTodoItem",
-        "parameters": [
-          {
-            "name": "id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "integer",
-              "format": "int32"
-            },
-            "x-position": 1
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": ""
-          }
-        },
-        "security": [
-          {
-            "JWT": []
-          }
-        ]
-      }
-    },
-    "/api/TodoItems/UpdateDetail/{id}": {
-      "put": {
-        "tags": [
-          "TodoItems"
-        ],
-        "operationId": "UpdateTodoItemDetail",
-        "parameters": [
-          {
-            "name": "id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "integer",
-              "format": "int32"
-            },
-            "x-position": 1
-          }
-        ],
-        "requestBody": {
-          "x-name": "command",
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/UpdateTodoItemDetailCommand"
-              }
-            }
-          },
-          "required": true,
-          "x-position": 2
-        },
-        "responses": {
-          "200": {
-            "description": ""
-          }
-        },
-        "security": [
-          {
-            "JWT": []
-          }
-        ]
-      }
-    },
-    "/api/TodoLists": {
-      "get": {
-        "tags": [
-          "TodoLists"
-        ],
-        "operationId": "GetTodoLists",
-        "responses": {
-          "200": {
-            "description": "",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/TodosVm"
-                }
-              }
-            }
-          }
-        },
-        "security": [
-          {
-            "JWT": []
-          }
-        ]
-      },
-      "post": {
-        "tags": [
-          "TodoLists"
-        ],
-        "operationId": "CreateTodoList",
-        "requestBody": {
-          "x-name": "command",
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/CreateTodoListCommand"
-              }
-            }
-          },
-          "required": true,
-          "x-position": 1
-        },
-        "responses": {
-          "200": {
-            "description": "",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "type": "integer",
-                  "format": "int32"
-                }
-              }
-            }
-          }
-        },
-        "security": [
-          {
-            "JWT": []
-          }
-        ]
-      }
-    },
-    "/api/TodoLists/{id}": {
-      "put": {
-        "tags": [
-          "TodoLists"
-        ],
-        "operationId": "UpdateTodoList",
-        "parameters": [
-          {
-            "name": "id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "integer",
-              "format": "int32"
-            },
-            "x-position": 1
-          }
-        ],
-        "requestBody": {
-          "x-name": "command",
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/UpdateTodoListCommand"
-              }
-            }
-          },
-          "required": true,
-          "x-position": 2
-        },
-        "responses": {
-          "200": {
-            "description": ""
-          }
-        },
-        "security": [
-          {
-            "JWT": []
-          }
-        ]
-      },
-      "delete": {
-        "tags": [
-          "TodoLists"
-        ],
-        "operationId": "DeleteTodoList",
-        "parameters": [
-          {
-            "name": "id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "integer",
-              "format": "int32"
-            },
-            "x-position": 1
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": ""
-          }
-        },
-        "security": [
-          {
-            "JWT": []
-          }
-        ]
       }
     },
     "/api/Users/register": {
@@ -822,6 +559,52 @@
   },
   "components": {
     "schemas": {
+      "PaginatedListOfFutureCreatorListDto": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "items": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/FutureCreatorListDto"
+            }
+          },
+          "pageNumber": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "totalPages": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "totalCount": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "hasPreviousPage": {
+            "type": "boolean"
+          },
+          "hasNextPage": {
+            "type": "boolean"
+          }
+        }
+      },
+      "FutureCreatorListDto": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "id": {
+            "type": "string",
+            "format": "guid"
+          },
+          "firstName": {
+            "type": "string"
+          },
+          "lastName": {
+            "type": "string"
+          }
+        }
+      },
       "CreateFutureCreatorCommand": {
         "type": "object",
         "additionalProperties": false,
@@ -848,6 +631,7 @@
       },
       "CreateSessionCheckoutCommand": {
         "type": "object",
+        "x-abstract": true,
         "additionalProperties": false,
         "properties": {
           "price": {
@@ -859,231 +643,24 @@
           }
         }
       },
-      "PaginatedListOfTodoItemBriefDto": {
+      "CreateUserCommand": {
         "type": "object",
         "additionalProperties": false,
         "properties": {
-          "items": {
+          "firstName": {
-            "type": "array",
+            "type": "string"
-            "items": {
-              "$ref": "#/components/schemas/TodoItemBriefDto"
-            }
           },
-          "pageNumber": {
+          "lastName": {
-            "type": "integer",
+            "type": "string"
-            "format": "int32"
           },
-          "totalPages": {
+          "emailAddress": {
-            "type": "integer",
+            "type": "string"
-            "format": "int32"
           },
-          "totalCount": {
+          "userName": {
-            "type": "integer",
+            "type": "string"
-            "format": "int32"
           },
-          "hasPreviousPage": {
+          "password": {
-            "type": "boolean"
+            "type": "string"
-          },
-          "hasNextPage": {
-            "type": "boolean"
-          }
-        }
-      },
-      "TodoItemBriefDto": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
-          "id": {
-            "type": "integer",
-            "format": "int32"
-          },
-          "listId": {
-            "type": "integer",
-            "format": "int32"
-          },
-          "title": {
-            "type": "string",
-            "nullable": true
-          },
-          "done": {
-            "type": "boolean"
-          }
-        }
-      },
-      "CreateTodoItemCommand": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
-          "listId": {
-            "type": "integer",
-            "format": "int32"
-          },
-          "title": {
-            "type": "string",
-            "nullable": true
-          }
-        }
-      },
-      "UpdateTodoItemCommand": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
-          "id": {
-            "type": "integer",
-            "format": "int32"
-          },
-          "title": {
-            "type": "string",
-            "nullable": true
-          },
-          "done": {
-            "type": "boolean"
-          }
-        }
-      },
-      "UpdateTodoItemDetailCommand": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
-          "id": {
-            "type": "integer",
-            "format": "int32"
-          },
-          "listId": {
-            "type": "integer",
-            "format": "int32"
-          },
-          "priority": {
-            "$ref": "#/components/schemas/PriorityLevel"
-          },
-          "note": {
-            "type": "string",
-            "nullable": true
-          }
-        }
-      },
-      "PriorityLevel": {
-        "type": "integer",
-        "description": "",
-        "x-enumNames": [
-          "None",
-          "Low",
-          "Medium",
-          "High"
-        ],
-        "enum": [
-          0,
-          1,
-          2,
-          3
-        ]
-      },
-      "TodosVm": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
-          "priorityLevels": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/LookupDto"
-            }
-          },
-          "lists": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/TodoListDto"
-            }
-          }
-        }
-      },
-      "LookupDto": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
-          "id": {
-            "type": "integer",
-            "format": "int32"
-          },
-          "title": {
-            "type": "string",
-            "nullable": true
-          }
-        }
-      },
-      "TodoListDto": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
-          "id": {
-            "type": "integer",
-            "format": "int32"
-          },
-          "title": {
-            "type": "string",
-            "nullable": true
-          },
-          "colour": {
-            "type": "string",
-            "nullable": true
-          },
-          "items": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/TodoItemDto"
-            }
-          }
-        }
-      },
-      "TodoItemDto": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
-          "id": {
-            "type": "integer",
-            "format": "int32"
-          },
-          "listId": {
-            "type": "integer",
-            "format": "int32"
-          },
-          "title": {
-            "type": "string",
-            "nullable": true
-          },
-          "done": {
-            "type": "boolean"
-          },
-          "priority": {
-            "type": "integer",
-            "format": "int32"
-          },
-          "note": {
-            "type": "string",
-            "nullable": true
-          }
-        }
-      },
-      "CreateTodoListCommand": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
-          "title": {
-            "type": "string",
-            "nullable": true
-          }
-        }
-      },
-      "UpdateTodoListCommand": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
-          "id": {
-            "type": "integer",
-            "format": "int32"
-          },
-          "title": {
-            "type": "string",
-            "nullable": true
           }
         }
       },

tests/Application.FunctionalTests/TodoItems/Commands/CreateTodoItemTests.cs

@@ -1,49 +0,0 @@
-using Hutopy.Application.Common.Exceptions;
-using Hutopy.Application.TodoItems.Commands.CreateTodoItem;
-using Hutopy.Application.TodoLists.Commands.CreateTodoList;
-using Hutopy.Domain.Entities;
-
-namespace Hutopy.Application.FunctionalTests.TodoItems.Commands;
-
-using static Testing;
-
-public class CreateTodoItemTests : BaseTestFixture
-{
-    [Test]
-    public async Task ShouldRequireMinimumFields()
-    {
-        var command = new CreateTodoItemCommand();
-
-        await FluentActions.Invoking(() =>
-            SendAsync(command)).Should().ThrowAsync<ValidationException>();
-    }
-
-    [Test]
-    public async Task ShouldCreateTodoItem()
-    {
-        var userId = await RunAsDefaultUserAsync();
-
-        var listId = await SendAsync(new CreateTodoListCommand
-        {
-            Title = "New List"
-        });
-
-        var command = new CreateTodoItemCommand
-        {
-            ListId = listId,
-            Title = "Tasks"
-        };
-
-        var itemId = await SendAsync(command);
-
-        var item = await FindAsync<TodoItem>(itemId);
-
-        item.Should().NotBeNull();
-        item!.ListId.Should().Be(command.ListId);
-        item.Title.Should().Be(command.Title);
-        item.CreatedBy.Should().Be(userId);
-        item.Created.Should().BeCloseTo(DateTime.Now, TimeSpan.FromMilliseconds(10000));
-        item.LastModifiedBy.Should().Be(userId);
-        item.LastModified.Should().BeCloseTo(DateTime.Now, TimeSpan.FromMilliseconds(10000));
-    }
-}

tests/Application.FunctionalTests/TodoItems/Commands/DeleteTodoItemTests.cs

@@ -1,41 +0,0 @@
-using Hutopy.Application.TodoItems.Commands.CreateTodoItem;
-using Hutopy.Application.TodoItems.Commands.DeleteTodoItem;
-using Hutopy.Application.TodoLists.Commands.CreateTodoList;
-using Hutopy.Domain.Entities;
-
-namespace Hutopy.Application.FunctionalTests.TodoItems.Commands;
-
-using static Testing;
-
-public class DeleteTodoItemTests : BaseTestFixture
-{
-    [Test]
-    public async Task ShouldRequireValidTodoItemId()
-    {
-        var command = new DeleteTodoItemCommand(99);
-
-        await FluentActions.Invoking(() =>
-            SendAsync(command)).Should().ThrowAsync<NotFoundException>();
-    }
-
-    [Test]
-    public async Task ShouldDeleteTodoItem()
-    {
-        var listId = await SendAsync(new CreateTodoListCommand
-        {
-            Title = "New List"
-        });
-
-        var itemId = await SendAsync(new CreateTodoItemCommand
-        {
-            ListId = listId,
-            Title = "New Item"
-        });
-
-        await SendAsync(new DeleteTodoItemCommand(itemId));
-
-        var item = await FindAsync<TodoItem>(itemId);
-
-        item.Should().BeNull();
-    }
-}

tests/Application.FunctionalTests/TodoItems/Commands/UpdateTodoItemDetailTests.cs

@@ -1,57 +0,0 @@
-using Hutopy.Application.TodoItems.Commands.CreateTodoItem;
-using Hutopy.Application.TodoItems.Commands.UpdateTodoItem;
-using Hutopy.Application.TodoItems.Commands.UpdateTodoItemDetail;
-using Hutopy.Application.TodoLists.Commands.CreateTodoList;
-using Hutopy.Domain.Entities;
-using Hutopy.Domain.Enums;
-
-namespace Hutopy.Application.FunctionalTests.TodoItems.Commands;
-
-using static Testing;
-
-public class UpdateTodoItemDetailTests : BaseTestFixture
-{
-    [Test]
-    public async Task ShouldRequireValidTodoItemId()
-    {
-        var command = new UpdateTodoItemCommand { Id = 99, Title = "New Title" };
-        await FluentActions.Invoking(() => SendAsync(command)).Should().ThrowAsync<NotFoundException>();
-    }
-
-    [Test]
-    public async Task ShouldUpdateTodoItem()
-    {
-        var userId = await RunAsDefaultUserAsync();
-
-        var listId = await SendAsync(new CreateTodoListCommand
-        {
-            Title = "New List"
-        });
-
-        var itemId = await SendAsync(new CreateTodoItemCommand
-        {
-            ListId = listId,
-            Title = "New Item"
-        });
-
-        var command = new UpdateTodoItemDetailCommand
-        {
-            Id = itemId,
-            ListId = listId,
-            Note = "This is the note.",
-            Priority = PriorityLevel.High
-        };
-
-        await SendAsync(command);
-
-        var item = await FindAsync<TodoItem>(itemId);
-
-        item.Should().NotBeNull();
-        item!.ListId.Should().Be(command.ListId);
-        item.Note.Should().Be(command.Note);
-        item.Priority.Should().Be(command.Priority);
-        item.LastModifiedBy.Should().NotBeNull();
-        item.LastModifiedBy.Should().Be(userId);
-        item.LastModified.Should().BeCloseTo(DateTime.Now, TimeSpan.FromMilliseconds(10000));
-    }
-}

tests/Application.FunctionalTests/TodoItems/Commands/UpdateTodoItemTests.cs

@@ -1,51 +0,0 @@
-using Hutopy.Application.TodoItems.Commands.CreateTodoItem;
-using Hutopy.Application.TodoItems.Commands.UpdateTodoItem;
-using Hutopy.Application.TodoLists.Commands.CreateTodoList;
-using Hutopy.Domain.Entities;
-
-namespace Hutopy.Application.FunctionalTests.TodoItems.Commands;
-
-using static Testing;
-
-public class UpdateTodoItemTests : BaseTestFixture
-{
-    [Test]
-    public async Task ShouldRequireValidTodoItemId()
-    {
-        var command = new UpdateTodoItemCommand { Id = 99, Title = "New Title" };
-        await FluentActions.Invoking(() => SendAsync(command)).Should().ThrowAsync<NotFoundException>();
-    }
-
-    [Test]
-    public async Task ShouldUpdateTodoItem()
-    {
-        var userId = await RunAsDefaultUserAsync();
-
-        var listId = await SendAsync(new CreateTodoListCommand
-        {
-            Title = "New List"
-        });
-
-        var itemId = await SendAsync(new CreateTodoItemCommand
-        {
-            ListId = listId,
-            Title = "New Item"
-        });
-
-        var command = new UpdateTodoItemCommand
-        {
-            Id = itemId,
-            Title = "Updated Item Title"
-        };
-
-        await SendAsync(command);
-
-        var item = await FindAsync<TodoItem>(itemId);
-
-        item.Should().NotBeNull();
-        item!.Title.Should().Be(command.Title);
-        item.LastModifiedBy.Should().NotBeNull();
-        item.LastModifiedBy.Should().Be(userId);
-        item.LastModified.Should().BeCloseTo(DateTime.Now, TimeSpan.FromMilliseconds(10000));
-    }
-}

tests/Application.FunctionalTests/TodoLists/Commands/CreateTodoListTests.cs

@@ -1,54 +0,0 @@
-using Hutopy.Application.Common.Exceptions;
-using Hutopy.Application.TodoLists.Commands.CreateTodoList;
-using Hutopy.Domain.Entities;
-
-namespace Hutopy.Application.FunctionalTests.TodoLists.Commands;
-
-using static Testing;
-
-public class CreateTodoListTests : BaseTestFixture
-{
-    [Test]
-    public async Task ShouldRequireMinimumFields()
-    {
-        var command = new CreateTodoListCommand();
-        await FluentActions.Invoking(() => SendAsync(command)).Should().ThrowAsync<ValidationException>();
-    }
-
-    [Test]
-    public async Task ShouldRequireUniqueTitle()
-    {
-        await SendAsync(new CreateTodoListCommand
-        {
-            Title = "Shopping"
-        });
-
-        var command = new CreateTodoListCommand
-        {
-            Title = "Shopping"
-        };
-
-        await FluentActions.Invoking(() =>
-            SendAsync(command)).Should().ThrowAsync<ValidationException>();
-    }
-
-    [Test]
-    public async Task ShouldCreateTodoList()
-    {
-        var userId = await RunAsDefaultUserAsync();
-
-        var command = new CreateTodoListCommand
-        {
-            Title = "Tasks"
-        };
-
-        var id = await SendAsync(command);
-
-        var list = await FindAsync<TodoList>(id);
-
-        list.Should().NotBeNull();
-        list!.Title.Should().Be(command.Title);
-        list.CreatedBy.Should().Be(userId);
-        list.Created.Should().BeCloseTo(DateTime.Now, TimeSpan.FromMilliseconds(10000));
-    }
-}

tests/Application.FunctionalTests/TodoLists/Commands/DeleteTodoListTests.cs

@@ -1,32 +0,0 @@
-using Hutopy.Application.TodoLists.Commands.CreateTodoList;
-using Hutopy.Application.TodoLists.Commands.DeleteTodoList;
-using Hutopy.Domain.Entities;
-
-namespace Hutopy.Application.FunctionalTests.TodoLists.Commands;
-
-using static Testing;
-
-public class DeleteTodoListTests : BaseTestFixture
-{
-    [Test]
-    public async Task ShouldRequireValidTodoListId()
-    {
-        var command = new DeleteTodoListCommand(99);
-        await FluentActions.Invoking(() => SendAsync(command)).Should().ThrowAsync<NotFoundException>();
-    }
-
-    [Test]
-    public async Task ShouldDeleteTodoList()
-    {
-        var listId = await SendAsync(new CreateTodoListCommand
-        {
-            Title = "New List"
-        });
-
-        await SendAsync(new DeleteTodoListCommand(listId));
-
-        var list = await FindAsync<TodoList>(listId);
-
-        list.Should().BeNull();
-    }
-}

tests/Application.FunctionalTests/TodoLists/Commands/PurgeTodoListsTests.cs

@@ -1,75 +0,0 @@
-using Hutopy.Application.Common.Exceptions;
-using Hutopy.Application.Common.Security;
-using Hutopy.Application.TodoLists.Commands.CreateTodoList;
-using Hutopy.Application.TodoLists.Commands.PurgeTodoLists;
-using Hutopy.Domain.Entities;
-
-namespace Hutopy.Application.FunctionalTests.TodoLists.Commands;
-
-using static Testing;
-
-public class PurgeTodoListsTests : BaseTestFixture
-{
-    [Test]
-    public async Task ShouldDenyAnonymousUser()
-    {
-        var command = new PurgeTodoListsCommand();
-
-        command.GetType().Should().BeDecoratedWith<AuthorizeAttribute>();
-
-        var action = () => SendAsync(command);
-
-        await action.Should().ThrowAsync<UnauthorizedAccessException>();
-    }
-
-    [Test]
-    public async Task ShouldDenyNonAdministrator()
-    {
-        await RunAsDefaultUserAsync();
-
-        var command = new PurgeTodoListsCommand();
-
-        var action = () => SendAsync(command);
-
-        await action.Should().ThrowAsync<ForbiddenAccessException>();
-    }
-
-    [Test]
-    public async Task ShouldAllowAdministrator()
-    {
-        await RunAsAdministratorAsync();
-
-        var command = new PurgeTodoListsCommand();
-
-        var action = () => SendAsync(command);
-
-        await action.Should().NotThrowAsync<ForbiddenAccessException>();
-    }
-
-    [Test]
-    public async Task ShouldDeleteAllLists()
-    {
-        await RunAsAdministratorAsync();
-
-        await SendAsync(new CreateTodoListCommand
-        {
-            Title = "New List #1"
-        });
-
-        await SendAsync(new CreateTodoListCommand
-        {
-            Title = "New List #2"
-        });
-
-        await SendAsync(new CreateTodoListCommand
-        {
-            Title = "New List #3"
-        });
-
-        await SendAsync(new PurgeTodoListsCommand());
-
-        var count = await CountAsync<TodoList>();
-
-        count.Should().Be(0);
-    }
-}

tests/Application.FunctionalTests/TodoLists/Commands/UpdateTodoListTests.cs

@@ -1,70 +0,0 @@
-using Hutopy.Application.Common.Exceptions;
-using Hutopy.Application.TodoLists.Commands.CreateTodoList;
-using Hutopy.Application.TodoLists.Commands.UpdateTodoList;
-using Hutopy.Domain.Entities;
-
-namespace Hutopy.Application.FunctionalTests.TodoLists.Commands;
-
-using static Testing;
-
-public class UpdateTodoListTests : BaseTestFixture
-{
-    [Test]
-    public async Task ShouldRequireValidTodoListId()
-    {
-        var command = new UpdateTodoListCommand { Id = 99, Title = "New Title" };
-        await FluentActions.Invoking(() => SendAsync(command)).Should().ThrowAsync<NotFoundException>();
-    }
-
-    [Test]
-    public async Task ShouldRequireUniqueTitle()
-    {
-        var listId = await SendAsync(new CreateTodoListCommand
-        {
-            Title = "New List"
-        });
-
-        await SendAsync(new CreateTodoListCommand
-        {
-            Title = "Other List"
-        });
-
-        var command = new UpdateTodoListCommand
-        {
-            Id = listId,
-            Title = "Other List"
-        };
-
-        (await FluentActions.Invoking(() =>
-            SendAsync(command))
-                .Should().ThrowAsync<ValidationException>().Where(ex => ex.Errors.ContainsKey("Title")))
-                .And.Errors["Title"].Should().Contain("'Title' must be unique.");
-    }
-
-    [Test]
-    public async Task ShouldUpdateTodoList()
-    {
-        var userId = await RunAsDefaultUserAsync();
-
-        var listId = await SendAsync(new CreateTodoListCommand
-        {
-            Title = "New List"
-        });
-
-        var command = new UpdateTodoListCommand
-        {
-            Id = listId,
-            Title = "Updated List Title"
-        };
-
-        await SendAsync(command);
-
-        var list = await FindAsync<TodoList>(listId);
-
-        list.Should().NotBeNull();
-        list!.Title.Should().Be(command.Title);
-        list.LastModifiedBy.Should().NotBeNull();
-        list.LastModifiedBy.Should().Be(userId);
-        list.LastModified.Should().BeCloseTo(DateTime.Now, TimeSpan.FromMilliseconds(10000));
-    }
-}

tests/Application.FunctionalTests/TodoLists/Queries/GetTodosTests.cs

@@ -1,61 +0,0 @@
-using Hutopy.Application.TodoLists.Queries.GetTodos;
-using Hutopy.Domain.Entities;
-using Hutopy.Domain.ValueObjects;
-
-namespace Hutopy.Application.FunctionalTests.TodoLists.Queries;
-
-using static Testing;
-
-public class GetTodosTests : BaseTestFixture
-{
-    [Test]
-    public async Task ShouldReturnPriorityLevels()
-    {
-        await RunAsDefaultUserAsync();
-
-        var query = new GetTodosQuery();
-
-        var result = await SendAsync(query);
-
-        result.PriorityLevels.Should().NotBeEmpty();
-    }
-
-    [Test]
-    public async Task ShouldReturnAllListsAndItems()
-    {
-        await RunAsDefaultUserAsync();
-
-        await AddAsync(new TodoList
-        {
-            Title = "Shopping",
-            Colour = Colour.Blue,
-            Items =
-                    {
-                        new TodoItem { Title = "Apples", Done = true },
-                        new TodoItem { Title = "Milk", Done = true },
-                        new TodoItem { Title = "Bread", Done = true },
-                        new TodoItem { Title = "Toilet paper" },
-                        new TodoItem { Title = "Pasta" },
-                        new TodoItem { Title = "Tissues" },
-                        new TodoItem { Title = "Tuna" }
-                    }
-        });
-
-        var query = new GetTodosQuery();
-
-        var result = await SendAsync(query);
-
-        result.Lists.Should().HaveCount(1);
-        result.Lists.First().Items.Should().HaveCount(7);
-    }
-
-    [Test]
-    public async Task ShouldDenyAnonymousUser()
-    {
-        var query = new GetTodosQuery();
-
-        var action = () => SendAsync(query);
-        
-        await action.Should().ThrowAsync<UnauthorizedAccessException>();
-    }
-}

tests/Application.UnitTests/Common/Behaviours/RequestLoggerTests.cs

@@ -1,6 +1,5 @@
 using Hutopy.Application.Common.Behaviours;
 using Hutopy.Application.Common.Interfaces;
-using Hutopy.Application.TodoItems.Commands.CreateTodoItem;
 using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
@@ -9,37 +8,13 @@ namespace Hutopy.Application.UnitTests.Common.Behaviours;
 
 public class RequestLoggerTests
 {
-    private Mock<ILogger<CreateTodoItemCommand>> _logger = null!;
     private Mock<IUser> _user = null!;
     private Mock<IIdentityService> _identityService = null!;
 
     [SetUp]
     public void Setup()
     {
-        _logger = new Mock<ILogger<CreateTodoItemCommand>>();
         _user = new Mock<IUser>();
         _identityService = new Mock<IIdentityService>();
     }
-
-    [Test]
-    public async Task ShouldCallGetUserNameAsyncOnceIfAuthenticated()
-    {
-        _user.Setup(x => x.Id).Returns(Guid.NewGuid().ToString());
-
-        var requestLogger = new LoggingBehaviour<CreateTodoItemCommand>(_logger.Object, _user.Object, _identityService.Object);
-
-        await requestLogger.Process(new CreateTodoItemCommand { ListId = 1, Title = "title" }, new CancellationToken());
-
-        _identityService.Verify(i => i.GetUserNameAsync(It.IsAny<string>()), Times.Once);
-    }
-
-    [Test]
-    public async Task ShouldNotCallGetUserNameAsyncOnceIfUnauthenticated()
-    {
-        var requestLogger = new LoggingBehaviour<CreateTodoItemCommand>(_logger.Object, _user.Object, _identityService.Object);
-
-        await requestLogger.Process(new CreateTodoItemCommand { ListId = 1, Title = "title" }, new CancellationToken());
-
-        _identityService.Verify(i => i.GetUserNameAsync(It.IsAny<string>()), Times.Never);
-    }
 }

tests/Application.UnitTests/Common/Mappings/MappingTests.cs

@@ -3,8 +3,6 @@ using System.Runtime.CompilerServices;
 using AutoMapper;
 using Hutopy.Application.Common.Interfaces;
 using Hutopy.Application.Common.Models;
-using Hutopy.Application.TodoItems.Queries.GetTodoItemsWithPagination;
-using Hutopy.Application.TodoLists.Queries.GetTodos;
 using Hutopy.Domain.Entities;
 using NUnit.Framework;
 
@@ -29,19 +27,6 @@ public class MappingTests
         _configuration.AssertConfigurationIsValid();
     }
 
-    [Test]
-    [TestCase(typeof(TodoList), typeof(TodoListDto))]
-    [TestCase(typeof(TodoItem), typeof(TodoItemDto))]
-    [TestCase(typeof(TodoList), typeof(LookupDto))]
-    [TestCase(typeof(TodoItem), typeof(LookupDto))]
-    [TestCase(typeof(TodoItem), typeof(TodoItemBriefDto))]
-    public void ShouldSupportMappingFromSourceToDestination(Type source, Type destination)
-    {
-        var instance = GetInstanceOf(source);
-
-        _mapper.Map(instance, source, destination);
-    }
-
     private object GetInstanceOf(Type type)
     {
         if (type.GetConstructor(Type.EmptyTypes) != null)