feat(api): REST endpoints for templates, template groups, items + block copy

Adds TemplateController mirroring BlockController: groups CRUD, template
CRUD, item replace (PUT full-replace via ReplaceTemplateItems), and a
copy endpoint. Also wires the missing POST /api/blocks/{id}/copy since
CopyBlock's CQRS shape is directly analogous to CopyTemplate.

Fixes CreateTemplateHandler to validate the target template group exists
before insert (previously an unhandled FK violation -> 500), matching the
CreateBlockHandler fix (1e34e00e) for the same class of bug.

New DTOs in ErsatzTV.Core/Api/Scheduling; TimeSpan start times serialize
the same way as PlayoutResponseModel.DailyRebuildTime.

#144 S2 (#162)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

ErsatzTV.Application/Scheduling/Commands/CreateTemplateHandler.cs

@@ -25,12 +25,28 @@ public class CreateTemplateHandler(IDbContextFactory<TvContext> dbContextFactory
         return Mapper.ProjectToViewModel(template);
     }
 
-    private static async Task<Validation<BaseError, Template>> Validate(TvContext dbContext, CreateTemplate request) =>
+    private static async Task<Validation<BaseError, Template>> Validate(TvContext dbContext, CreateTemplate request)
-        await ValidateTemplateName(dbContext, request).MapT(name => new Template
+    {
+        Validation<BaseError, Unit> templateGroupValidation = await ValidateTemplateGroupExists(dbContext, request);
+        Validation<BaseError, string> nameValidation = await ValidateTemplateName(dbContext, request);
+
+        return (templateGroupValidation, nameValidation).Apply((_, name) => new Template
         {
             TemplateGroupId = request.TemplateGroupId,
             Name = name
         });
+    }
+
+    private static async Task<Validation<BaseError, Unit>> ValidateTemplateGroupExists(
+        TvContext dbContext,
+        CreateTemplate request)
+    {
+        bool templateGroupExists = await dbContext.TemplateGroups.AnyAsync(tg => tg.Id == request.TemplateGroupId);
+
+        return templateGroupExists
+            ? Success<BaseError, Unit>(Unit.Default)
+            : BaseError.New("Template group does not exist");
+    }
 
     private static async Task<Validation<BaseError, string>> ValidateTemplateName(
         TvContext dbContext,

ErsatzTV.Core/Api/Scheduling/TemplateGroupResponseModel.cs

@@ -0,0 +1,4 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.Scheduling;
+
+public record TemplateGroupResponseModel(int Id, string Name, int TemplateCount);

ErsatzTV.Core/Api/Scheduling/TemplateItemResponseModel.cs

@@ -0,0 +1,4 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.Scheduling;
+
+public record TemplateItemResponseModel(int BlockId, string BlockName, int BlockMinutes, TimeSpan StartTime);

ErsatzTV.Core/Api/Scheduling/TemplateResponseModel.cs

@@ -0,0 +1,4 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.Scheduling;
+
+public record TemplateResponseModel(int Id, int TemplateGroupId, string GroupName, string Name);

ErsatzTV.Core/Api/Scheduling/TemplateWithItemsResponseModel.cs

@@ -0,0 +1,9 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.Scheduling;
+
+public record TemplateWithItemsResponseModel(
+    int Id,
+    int TemplateGroupId,
+    string GroupName,
+    string Name,
+    List<TemplateItemResponseModel> Items);

ErsatzTV.Tests/Controllers/ApiControllerSecurityTests.cs

@@ -42,6 +42,7 @@ public class ApiControllerSecurityTests
             typeof(SessionController),
             typeof(SettingsController),
             typeof(SmartCollectionController),
+            typeof(TemplateController),
             typeof(TraktController),
             typeof(TroubleshootController),
             typeof(WatermarkController)

ErsatzTV.Tests/Controllers/ApiErrorResponseMetadataTests.cs

@@ -79,6 +79,20 @@ public class ApiErrorResponseMetadataTests
     [TestCase(typeof(BlockController), nameof(BlockController.Replace), StatusCodes.Status404NotFound)]
     [TestCase(typeof(BlockController), nameof(BlockController.Replace), StatusCodes.Status422UnprocessableEntity)]
     [TestCase(typeof(BlockController), nameof(BlockController.Preview), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(BlockController), nameof(BlockController.Copy), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(BlockController), nameof(BlockController.Copy), StatusCodes.Status422UnprocessableEntity)]
+    [TestCase(typeof(TemplateController), nameof(TemplateController.GetById), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(TemplateController), nameof(TemplateController.CreateGroup), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(TemplateController), nameof(TemplateController.CreateGroup), StatusCodes.Status422UnprocessableEntity)]
+    [TestCase(typeof(TemplateController), nameof(TemplateController.DeleteGroup), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(TemplateController), nameof(TemplateController.Create), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(TemplateController), nameof(TemplateController.Create), StatusCodes.Status422UnprocessableEntity)]
+    [TestCase(typeof(TemplateController), nameof(TemplateController.Delete), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(TemplateController), nameof(TemplateController.GetItems), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(TemplateController), nameof(TemplateController.Replace), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(TemplateController), nameof(TemplateController.Replace), StatusCodes.Status422UnprocessableEntity)]
+    [TestCase(typeof(TemplateController), nameof(TemplateController.Copy), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(TemplateController), nameof(TemplateController.Copy), StatusCodes.Status422UnprocessableEntity)]
     [TestCase(typeof(PlayoutController), nameof(PlayoutController.GetById), StatusCodes.Status404NotFound)]
     [TestCase(typeof(PlayoutController), nameof(PlayoutController.Create), StatusCodes.Status404NotFound)]
     [TestCase(typeof(PlayoutController), nameof(PlayoutController.Create), StatusCodes.Status422UnprocessableEntity)]

ErsatzTV.Tests/Controllers/BlockControllerTests.cs

@@ -44,6 +44,7 @@ public class BlockControllerTests
         ShouldHaveActionRoute(nameof(BlockController.GetItems), "GET", "/api/blocks/{id:int}/items");
         ShouldHaveActionRoute(nameof(BlockController.Replace), "PUT", "/api/blocks/{id:int}");
         ShouldHaveActionRoute(nameof(BlockController.Preview), "POST", "/api/blocks/{id:int}/preview");
+        ShouldHaveActionRoute(nameof(BlockController.Copy), "POST", "/api/blocks/{id:int}/copy");
     }
 
     [Test]
@@ -328,6 +329,57 @@ public class BlockControllerTests
         await _mediator.DidNotReceive().Send(Arg.Any<PreviewBlockPlayout>(), Arg.Any<CancellationToken>());
     }
 
+    [Test]
+    public async Task Copy_Should_Return_201_And_Map_Request()
+    {
+        _mediator.Send(Arg.Any<GetBlockById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<BlockViewModel>.Some(MakeBlock(4, 2, "Morning")));
+        _mediator.Send(Arg.Any<CopyBlock>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, BlockViewModel>(MakeBlock(9, 3, "Morning Copy")));
+
+        IActionResult result = await _controller.Copy(
+            4,
+            new CopyBlockRequest(3, "Morning Copy"),
+            CancellationToken.None);
+
+        var created = result.ShouldBeOfType<CreatedResult>();
+        created.Location.ShouldBe("/api/blocks/9");
+        await _mediator.Received(1).Send(
+            Arg.Is<CopyBlock>(c => c.BlockId == 4 && c.NewBlockGroupId == 3 && c.NewBlockName == "Morning Copy"),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Copy_Should_Return_404_When_Source_Missing()
+    {
+        _mediator.Send(Arg.Any<GetBlockById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<BlockViewModel>.None);
+
+        IActionResult result = await _controller.Copy(
+            4,
+            new CopyBlockRequest(3, "Morning Copy"),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+        await _mediator.DidNotReceive().Send(Arg.Any<CopyBlock>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Copy_Should_Return_422_On_Validation_Error()
+    {
+        _mediator.Send(Arg.Any<GetBlockById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<BlockViewModel>.Some(MakeBlock(4, 2, "Morning")));
+        _mediator.Send(Arg.Any<CopyBlock>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, BlockViewModel>(BaseError.New("dupe")));
+
+        IActionResult result = await _controller.Copy(
+            4,
+            new CopyBlockRequest(3, "Morning"),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+    }
+
     private static BlockViewModel MakeBlock(int id, int groupId, string name) =>
         new(id, groupId, "Group", name, 30, BlockStopScheduling.AfterDurationEnd);
 

ErsatzTV.Tests/Controllers/TemplateControllerTests.cs

@@ -0,0 +1,380 @@
+using System.Reflection;
+using ErsatzTV.Application.Scheduling;
+using ErsatzTV.Controllers.Api;
+using ErsatzTV.Controllers.Api.Requests;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Scheduling;
+using LanguageExt;
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Routing;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Tests.Controllers;
+
+[TestFixture]
+public class TemplateControllerTests
+{
+    private TemplateController _controller = null!;
+    private IMediator _mediator = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mediator = Substitute.For<IMediator>();
+        _controller = new TemplateController(_mediator);
+    }
+
+    [Test]
+    public void Controller_Should_Expose_Idiomatic_Rest_Routes()
+    {
+        ShouldHaveActionRoute(nameof(TemplateController.GetGroups), "GET", "/api/templates/groups");
+        ShouldHaveActionRoute(nameof(TemplateController.CreateGroup), "POST", "/api/templates/groups");
+        ShouldHaveActionRoute(nameof(TemplateController.DeleteGroup), "DELETE", "/api/templates/groups/{id:int}");
+        ShouldHaveActionRoute(nameof(TemplateController.GetAll), "GET", "/api/templates");
+        ShouldHaveActionRoute(nameof(TemplateController.GetById), "GET", "/api/templates/{id:int}");
+        ShouldHaveActionRoute(nameof(TemplateController.Create), "POST", "/api/templates");
+        ShouldHaveActionRoute(nameof(TemplateController.Delete), "DELETE", "/api/templates/{id:int}");
+        ShouldHaveActionRoute(nameof(TemplateController.GetItems), "GET", "/api/templates/{id:int}/items");
+        ShouldHaveActionRoute(nameof(TemplateController.Replace), "PUT", "/api/templates/{id:int}");
+        ShouldHaveActionRoute(nameof(TemplateController.Copy), "POST", "/api/templates/{id:int}/copy");
+    }
+
+    [Test]
+    public async Task CreateGroup_Should_Return_201_With_Location_And_Body()
+    {
+        _mediator.Send(Arg.Any<CreateTemplateGroup>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, TemplateGroupViewModel>(new TemplateGroupViewModel(5, "Prime Time", 0)));
+
+        IActionResult result = await _controller.CreateGroup(
+            new CreateTemplateGroupRequest("Prime Time"),
+            CancellationToken.None);
+
+        var created = result.ShouldBeOfType<CreatedResult>();
+        created.Location.ShouldBe("/api/templates/groups/5");
+        created.Value.ShouldBeOfType<TemplateGroupResponseModel>().Name.ShouldBe("Prime Time");
+        await _mediator.Received(1).Send(
+            Arg.Is<CreateTemplateGroup>(c => c.Name == "Prime Time"),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task CreateGroup_Should_Return_422_On_Validation_Error()
+    {
+        _mediator.Send(Arg.Any<CreateTemplateGroup>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, TemplateGroupViewModel>(BaseError.New("bad")));
+
+        IActionResult result = await _controller.CreateGroup(
+            new CreateTemplateGroupRequest(string.Empty),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+    }
+
+    [Test]
+    public async Task DeleteGroup_Should_Return_204_When_Exists()
+    {
+        _mediator.Send(Arg.Any<GetAllTemplateGroups>(), Arg.Any<CancellationToken>())
+            .Returns(new List<TemplateGroupViewModel> { new(3, "Prime Time", 0) });
+        _mediator.Send(Arg.Any<DeleteTemplateGroup>(), Arg.Any<CancellationToken>())
+            .Returns(Option<BaseError>.None);
+
+        IActionResult result = await _controller.DeleteGroup(3, CancellationToken.None);
+
+        result.ShouldBeOfType<NoContentResult>();
+        await _mediator.Received(1).Send(
+            Arg.Is<DeleteTemplateGroup>(c => c.TemplateGroupId == 3),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task DeleteGroup_Should_Return_404_When_Missing()
+    {
+        _mediator.Send(Arg.Any<GetAllTemplateGroups>(), Arg.Any<CancellationToken>())
+            .Returns(new List<TemplateGroupViewModel>());
+
+        IActionResult result = await _controller.DeleteGroup(99, CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+        await _mediator.DidNotReceive().Send(Arg.Any<DeleteTemplateGroup>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task GetAll_Should_Map_ViewModels_To_Response_Models()
+    {
+        _mediator.Send(Arg.Any<GetAllTemplates>(), Arg.Any<CancellationToken>())
+            .Returns(new List<TemplateViewModel> { MakeTemplate(1, 2, "Morning") });
+
+        List<TemplateResponseModel> result = await _controller.GetAll(null, CancellationToken.None);
+
+        result.Count.ShouldBe(1);
+        result[0].Id.ShouldBe(1);
+        result[0].TemplateGroupId.ShouldBe(2);
+        result[0].Name.ShouldBe("Morning");
+        await _mediator.DidNotReceive().Send(Arg.Any<GetTemplatesByTemplateGroupId>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task GetAll_Should_Filter_By_TemplateGroupId_When_Provided()
+    {
+        _mediator.Send(Arg.Any<GetTemplatesByTemplateGroupId>(), Arg.Any<CancellationToken>())
+            .Returns(new List<TemplateViewModel> { MakeTemplate(1, 2, "Morning") });
+
+        List<TemplateResponseModel> result = await _controller.GetAll(2, CancellationToken.None);
+
+        result.Count.ShouldBe(1);
+        await _mediator.Received(1).Send(
+            Arg.Is<GetTemplatesByTemplateGroupId>(c => c.TemplateGroupId == 2),
+            Arg.Any<CancellationToken>());
+        await _mediator.DidNotReceive().Send(Arg.Any<GetAllTemplates>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Create_Should_Return_201_And_Map_Request()
+    {
+        _mediator.Send(Arg.Any<CreateTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, TemplateViewModel>(MakeTemplate(8, 2, "Morning")));
+
+        IActionResult result = await _controller.Create(
+            new CreateTemplateRequest(2, "Morning"),
+            CancellationToken.None);
+
+        var created = result.ShouldBeOfType<CreatedResult>();
+        created.Location.ShouldBe("/api/templates/8");
+        await _mediator.Received(1).Send(
+            Arg.Is<CreateTemplate>(c => c.TemplateGroupId == 2 && c.Name == "Morning"),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Create_Should_Return_422_On_Validation_Error()
+    {
+        _mediator.Send(Arg.Any<CreateTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, TemplateViewModel>(BaseError.New("dupe")));
+
+        IActionResult result = await _controller.Create(
+            new CreateTemplateRequest(2, "Morning"),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+    }
+
+    [Test]
+    public async Task GetById_Should_Return_200_For_Some()
+    {
+        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 2, "Morning")));
+
+        IActionResult result = await _controller.GetById(4, CancellationToken.None);
+
+        result.ShouldBeOfType<OkObjectResult>().Value.ShouldBeOfType<TemplateResponseModel>().Id.ShouldBe(4);
+    }
+
+    [Test]
+    public async Task GetById_Should_Return_404_For_None()
+    {
+        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<TemplateViewModel>.None);
+
+        IActionResult result = await _controller.GetById(4, CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+    }
+
+    [Test]
+    public async Task Delete_Should_Return_204_When_Exists()
+    {
+        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 2, "Morning")));
+        _mediator.Send(Arg.Any<DeleteTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Option<BaseError>.None);
+
+        IActionResult result = await _controller.Delete(4, CancellationToken.None);
+
+        result.ShouldBeOfType<NoContentResult>();
+    }
+
+    [Test]
+    public async Task Delete_Should_Return_404_When_Missing()
+    {
+        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<TemplateViewModel>.None);
+
+        IActionResult result = await _controller.Delete(4, CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+        await _mediator.DidNotReceive().Send(Arg.Any<DeleteTemplate>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task GetItems_Should_Return_200_Ordered_By_StartTime()
+    {
+        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 2, "Morning")));
+        _mediator.Send(Arg.Any<GetTemplateItems>(), Arg.Any<CancellationToken>())
+            .Returns(new List<TemplateItemViewModel>
+            {
+                MakeItem(20, "News", TimeSpan.FromHours(12), 30),
+                MakeItem(10, "Cartoons", TimeSpan.FromHours(6), 60)
+            });
+
+        IActionResult result = await _controller.GetItems(4, CancellationToken.None);
+
+        var items = result.ShouldBeOfType<OkObjectResult>().Value.ShouldBeOfType<List<TemplateItemResponseModel>>();
+        items.Count.ShouldBe(2);
+        items[0].BlockId.ShouldBe(10);
+        items[0].StartTime.ShouldBe(TimeSpan.FromHours(6));
+        items[0].BlockMinutes.ShouldBe(60);
+        items[1].BlockId.ShouldBe(20);
+    }
+
+    [Test]
+    public async Task GetItems_Should_Return_404_When_Template_Missing()
+    {
+        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<TemplateViewModel>.None);
+
+        IActionResult result = await _controller.GetItems(4, CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+    }
+
+    [Test]
+    public async Task Replace_Should_Return_200_With_Refreshed_Template_And_Map_Items()
+    {
+        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 7, "Morning")));
+        _mediator.Send(Arg.Any<ReplaceTemplateItems>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, List<TemplateItemViewModel>>([]));
+        _mediator.Send(Arg.Any<GetTemplateItems>(), Arg.Any<CancellationToken>())
+            .Returns(new List<TemplateItemViewModel>
+            {
+                MakeItem(10, "Cartoons", TimeSpan.FromHours(6), 60)
+            });
+
+        IActionResult result = await _controller.Replace(
+            4,
+            new ReplaceTemplateRequest(
+                "Morning",
+                [new TemplateItemRequest(10, TimeSpan.FromHours(6))]),
+            CancellationToken.None);
+
+        var body = result.ShouldBeOfType<OkObjectResult>().Value.ShouldBeOfType<TemplateWithItemsResponseModel>();
+        body.Id.ShouldBe(4);
+        body.Items.Count.ShouldBe(1);
+        await _mediator.Received(1).Send(
+            Arg.Is<ReplaceTemplateItems>(c =>
+                c.TemplateId == 4 &&
+                c.TemplateGroupId == 7 &&
+                c.Name == "Morning" &&
+                c.Items.Count == 1 &&
+                c.Items[0].BlockId == 10 &&
+                c.Items[0].StartTime == TimeSpan.FromHours(6)),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Replace_Should_Return_404_When_Template_Missing()
+    {
+        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<TemplateViewModel>.None);
+
+        IActionResult result = await _controller.Replace(
+            4,
+            new ReplaceTemplateRequest("Morning", []),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+        await _mediator.DidNotReceive().Send(Arg.Any<ReplaceTemplateItems>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Replace_Should_Return_422_On_Validation_Error()
+    {
+        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 7, "Morning")));
+        _mediator.Send(Arg.Any<ReplaceTemplateItems>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, List<TemplateItemViewModel>>(BaseError.New("overlap")));
+
+        IActionResult result = await _controller.Replace(
+            4,
+            new ReplaceTemplateRequest("Morning", []),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+        await _mediator.DidNotReceive().Send(Arg.Any<GetTemplateItems>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Copy_Should_Return_201_And_Map_Request()
+    {
+        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 2, "Morning")));
+        _mediator.Send(Arg.Any<CopyTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, TemplateViewModel>(MakeTemplate(9, 3, "Morning Copy")));
+
+        IActionResult result = await _controller.Copy(
+            4,
+            new CopyTemplateRequest(3, "Morning Copy"),
+            CancellationToken.None);
+
+        var created = result.ShouldBeOfType<CreatedResult>();
+        created.Location.ShouldBe("/api/templates/9");
+        await _mediator.Received(1).Send(
+            Arg.Is<CopyTemplate>(c => c.TemplateId == 4 && c.NewTemplateGroupId == 3 && c.NewTemplateName == "Morning Copy"),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Copy_Should_Return_404_When_Source_Missing()
+    {
+        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<TemplateViewModel>.None);
+
+        IActionResult result = await _controller.Copy(
+            4,
+            new CopyTemplateRequest(3, "Morning Copy"),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+        await _mediator.DidNotReceive().Send(Arg.Any<CopyTemplate>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Copy_Should_Return_422_On_Validation_Error()
+    {
+        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 2, "Morning")));
+        _mediator.Send(Arg.Any<CopyTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, TemplateViewModel>(BaseError.New("dupe")));
+
+        IActionResult result = await _controller.Copy(
+            4,
+            new CopyTemplateRequest(3, "Morning"),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+    }
+
+    private static TemplateViewModel MakeTemplate(int id, int groupId, string name) =>
+        new(id, groupId, "Group", name);
+
+    private static TemplateItemViewModel MakeItem(int blockId, string blockName, TimeSpan startTime, int minutes)
+    {
+        DateTime start = DateTime.Today.Add(startTime);
+        return new TemplateItemViewModel(blockId, blockName, start, start.AddMinutes(minutes));
+    }
+
+    private static void ShouldHaveActionRoute(string actionName, string httpMethod, string route)
+    {
+        MethodInfo action = typeof(TemplateController).GetMethod(actionName)
+            ?? throw new AssertionException($"Missing action {actionName}");
+
+        HttpMethodAttribute attribute = action.GetCustomAttributes<HttpMethodAttribute>(inherit: true).Single();
+        attribute.HttpMethods.ShouldContain(httpMethod);
+        attribute.Template.ShouldBe(route);
+    }
+}

ErsatzTV/Controllers/Api/BlockController.cs

@@ -211,6 +211,31 @@ public class BlockController(IMediator mediator) : ControllerBase
         return new OkObjectResult(preview.Map(ProjectToResponseModel).ToList());
     }
 
+    [HttpPost("/api/blocks/{id:int}/copy")]
+    [Tags("Blocks")]
+    [EndpointSummary("Copy a block")]
+    [EndpointDescription("Copies the block and its items into another (or the same) block group under a new name.")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(BlockResponseModel), StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> Copy(
+        int id,
+        [Required] [FromBody] CopyBlockRequest request,
+        CancellationToken cancellationToken)
+    {
+        Option<BlockViewModel> existing = await mediator.Send(new GetBlockById(id), cancellationToken);
+        if (existing.IsNone)
+        {
+            return ApiResults.NotFoundProblem();
+        }
+
+        Either<BaseError, BlockViewModel> result = await mediator.Send(request.ToCommand(id), cancellationToken);
+        return result.ToCreatedResult(
+            vm => $"/api/blocks/{vm.Id}",
+            vm => ProjectToResponseModel(vm));
+    }
+
     private static BlockGroupResponseModel ProjectToResponseModel(BlockGroupViewModel vm) =>
         new(vm.Id, vm.Name);
 

ErsatzTV/Controllers/Api/Requests/CopyBlockRequest.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Application.Scheduling;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+public record CopyBlockRequest(int BlockGroupId, string Name)
+{
+    public CopyBlock ToCommand(int blockId) => new(blockId, BlockGroupId, Name);
+}

ErsatzTV/Controllers/Api/Requests/CopyTemplateRequest.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Application.Scheduling;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+public record CopyTemplateRequest(int TemplateGroupId, string Name)
+{
+    public CopyTemplate ToCommand(int templateId) => new(templateId, TemplateGroupId, Name);
+}

ErsatzTV/Controllers/Api/Requests/CreateTemplateGroupRequest.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Application.Scheduling;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+public record CreateTemplateGroupRequest(string Name)
+{
+    public CreateTemplateGroup ToCommand() => new(Name);
+}

ErsatzTV/Controllers/Api/Requests/CreateTemplateRequest.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Application.Scheduling;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+public record CreateTemplateRequest(int TemplateGroupId, string Name)
+{
+    public CreateTemplate ToCommand() => new(TemplateGroupId, Name);
+}

ErsatzTV/Controllers/Api/Requests/ReplaceTemplateRequest.cs

@@ -0,0 +1,13 @@
+using ErsatzTV.Application.Scheduling;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+public record ReplaceTemplateRequest(string Name, List<TemplateItemRequest> Items)
+{
+    public ReplaceTemplateItems ToCommand(int templateGroupId, int templateId) =>
+        new(
+            templateGroupId,
+            templateId,
+            Name,
+            (Items ?? []).Select(item => item.ToReplaceItem()).ToList());
+}

ErsatzTV/Controllers/Api/Requests/TemplateItemRequest.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Application.Scheduling;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+public record TemplateItemRequest(int BlockId, TimeSpan StartTime)
+{
+    public ReplaceTemplateItem ToReplaceItem() => new(BlockId, StartTime);
+}

ErsatzTV/Controllers/Api/TemplateController.cs

@@ -0,0 +1,235 @@
+using System.ComponentModel.DataAnnotations;
+using ErsatzTV.Application.Scheduling;
+using ErsatzTV.Controllers.Api.Requests;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Scheduling;
+using ErsatzTV.Extensions;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ErsatzTV.Controllers.Api;
+
+[ApiController]
+public class TemplateController(IMediator mediator) : ControllerBase
+{
+    [HttpGet("/api/templates/groups", Name = "GetTemplateGroups")]
+    [Tags("Templates")]
+    [EndpointSummary("Get all template groups")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(List<TemplateGroupResponseModel>), StatusCodes.Status200OK)]
+    public async Task<List<TemplateGroupResponseModel>> GetGroups(CancellationToken cancellationToken)
+    {
+        List<TemplateGroupViewModel> groups = await mediator.Send(new GetAllTemplateGroups(), cancellationToken);
+        return groups.Map(ProjectToResponseModel).ToList();
+    }
+
+    [HttpPost("/api/templates/groups")]
+    [Tags("Templates")]
+    [EndpointSummary("Create a template group")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(TemplateGroupResponseModel), StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> CreateGroup(
+        [Required] [FromBody] CreateTemplateGroupRequest request,
+        CancellationToken cancellationToken)
+    {
+        Either<BaseError, TemplateGroupViewModel> result =
+            await mediator.Send(request.ToCommand(), cancellationToken);
+        return result.ToCreatedResult(
+            vm => $"/api/templates/groups/{vm.Id}",
+            vm => ProjectToResponseModel(vm));
+    }
+
+    [HttpDelete("/api/templates/groups/{id:int}")]
+    [Tags("Templates")]
+    [EndpointSummary("Delete a template group")]
+    [EndpointDescription(
+        "Deletes the template group. The database cascade removes every template (and its items) in the group.")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> DeleteGroup(int id, CancellationToken cancellationToken)
+    {
+        List<TemplateGroupViewModel> groups = await mediator.Send(new GetAllTemplateGroups(), cancellationToken);
+        if (groups.All(g => g.Id != id))
+        {
+            return ApiResults.NotFoundProblem();
+        }
+
+        Option<BaseError> result = await mediator.Send(new DeleteTemplateGroup(id), cancellationToken);
+        return result.Match<IActionResult>(
+            Some: error => error.ToErrorResult(),
+            None: () => new NoContentResult());
+    }
+
+    [HttpGet("/api/templates")]
+    [Tags("Templates")]
+    [EndpointSummary("Get all templates")]
+    [EndpointDescription(
+        "Returns every template. Pass templateGroupId to filter to the templates in a single template group.")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(List<TemplateResponseModel>), StatusCodes.Status200OK)]
+    public async Task<List<TemplateResponseModel>> GetAll(
+        [FromQuery] int? templateGroupId,
+        CancellationToken cancellationToken)
+    {
+        List<TemplateViewModel> templates = templateGroupId is { } groupId
+            ? await mediator.Send(new GetTemplatesByTemplateGroupId(groupId), cancellationToken)
+            : await mediator.Send(new GetAllTemplates(), cancellationToken);
+        return templates.Map(ProjectToResponseModel).ToList();
+    }
+
+    [HttpGet("/api/templates/{id:int}", Name = "GetTemplateById")]
+    [Tags("Templates")]
+    [EndpointSummary("Get a template by id")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(TemplateResponseModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetById(int id, CancellationToken cancellationToken)
+    {
+        Option<TemplateViewModel> result = await mediator.Send(new GetTemplateById(id), cancellationToken);
+        return result.Map(ProjectToResponseModel).ToGetResult();
+    }
+
+    [HttpPost("/api/templates")]
+    [Tags("Templates")]
+    [EndpointSummary("Create a template")]
+    [EndpointDescription("Creates an empty template in the given template group.")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(TemplateResponseModel), StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> Create(
+        [Required] [FromBody] CreateTemplateRequest request,
+        CancellationToken cancellationToken)
+    {
+        Either<BaseError, TemplateViewModel> result = await mediator.Send(request.ToCommand(), cancellationToken);
+        return result.ToCreatedResult(
+            vm => $"/api/templates/{vm.Id}",
+            vm => ProjectToResponseModel(vm));
+    }
+
+    [HttpDelete("/api/templates/{id:int}")]
+    [Tags("Templates")]
+    [EndpointSummary("Delete a template")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Delete(int id, CancellationToken cancellationToken)
+    {
+        Option<TemplateViewModel> existing = await mediator.Send(new GetTemplateById(id), cancellationToken);
+        if (existing.IsNone)
+        {
+            return ApiResults.NotFoundProblem();
+        }
+
+        Option<BaseError> result = await mediator.Send(new DeleteTemplate(id), cancellationToken);
+        return result.Match<IActionResult>(
+            Some: error => error.ToErrorResult(),
+            None: () => new NoContentResult());
+    }
+
+    [HttpGet("/api/templates/{id:int}/items")]
+    [Tags("Templates")]
+    [EndpointSummary("Get template items")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(List<TemplateItemResponseModel>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetItems(int id, CancellationToken cancellationToken)
+    {
+        Option<TemplateViewModel> template = await mediator.Send(new GetTemplateById(id), cancellationToken);
+        if (template.IsNone)
+        {
+            return ApiResults.NotFoundProblem();
+        }
+
+        List<TemplateItemViewModel> items = await mediator.Send(new GetTemplateItems(id), cancellationToken);
+        return new OkObjectResult(
+            items.OrderBy(i => i.StartTime.TimeOfDay).Map(ProjectToResponseModel).ToList());
+    }
+
+    [HttpPut("/api/templates/{id:int}")]
+    [Tags("Templates")]
+    [EndpointSummary("Replace a template and its items")]
+    [EndpointDescription(
+        "Replaces the template's name and its full item list. Each item assigns a block to a start time of day; " +
+        "items must not overlap (an item's end time is its start time plus the assigned block's duration).")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(TemplateWithItemsResponseModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> Replace(
+        int id,
+        [Required] [FromBody] ReplaceTemplateRequest request,
+        CancellationToken cancellationToken)
+    {
+        Option<TemplateViewModel> maybeTemplate = await mediator.Send(new GetTemplateById(id), cancellationToken);
+        if (maybeTemplate.IsNone)
+        {
+            return ApiResults.NotFoundProblem();
+        }
+
+        int templateGroupId = maybeTemplate.Map(t => t.TemplateGroupId).IfNone(0);
+
+        Either<BaseError, List<TemplateItemViewModel>> result =
+            await mediator.Send(request.ToCommand(templateGroupId, id), cancellationToken);
+
+        return await result.Match(
+            Left: error => Task.FromResult(error.ToErrorResult()),
+            Right: async _ =>
+            {
+                Option<TemplateViewModel> refreshed = await mediator.Send(new GetTemplateById(id), cancellationToken);
+                List<TemplateItemViewModel> items = await mediator.Send(new GetTemplateItems(id), cancellationToken);
+                return refreshed.Match(
+                    Some: vm => (IActionResult)new OkObjectResult(ProjectToWithItemsResponseModel(vm, items)),
+                    None: () => ApiResults.NotFoundProblem());
+            });
+    }
+
+    [HttpPost("/api/templates/{id:int}/copy")]
+    [Tags("Templates")]
+    [EndpointSummary("Copy a template")]
+    [EndpointDescription("Copies the template and its items into another (or the same) template group under a new name.")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(TemplateResponseModel), StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> Copy(
+        int id,
+        [Required] [FromBody] CopyTemplateRequest request,
+        CancellationToken cancellationToken)
+    {
+        Option<TemplateViewModel> existing = await mediator.Send(new GetTemplateById(id), cancellationToken);
+        if (existing.IsNone)
+        {
+            return ApiResults.NotFoundProblem();
+        }
+
+        Either<BaseError, TemplateViewModel> result =
+            await mediator.Send(request.ToCommand(id), cancellationToken);
+        return result.ToCreatedResult(
+            vm => $"/api/templates/{vm.Id}",
+            vm => ProjectToResponseModel(vm));
+    }
+
+    private static TemplateGroupResponseModel ProjectToResponseModel(TemplateGroupViewModel vm) =>
+        new(vm.Id, vm.Name, vm.TemplateCount);
+
+    private static TemplateResponseModel ProjectToResponseModel(TemplateViewModel vm) =>
+        new(vm.Id, vm.TemplateGroupId, vm.GroupName, vm.Name);
+
+    private static TemplateWithItemsResponseModel ProjectToWithItemsResponseModel(
+        TemplateViewModel vm,
+        List<TemplateItemViewModel> items) =>
+        new(
+            vm.Id,
+            vm.TemplateGroupId,
+            vm.GroupName,
+            vm.Name,
+            items.OrderBy(i => i.StartTime.TimeOfDay).Map(ProjectToResponseModel).ToList());
+
+    private static TemplateItemResponseModel ProjectToResponseModel(TemplateItemViewModel vm) =>
+        new(vm.BlockId, vm.BlockName, (int)(vm.EndTime - vm.StartTime).TotalMinutes, vm.StartTime.TimeOfDay);
+}