From 2df09752048840117d6014aa4152db171944a86b Mon Sep 17 00:00:00 2001
From: lop4cwru <lop4@case.edu>
Date: Mon, 30 Mar 2026 16:19:55 -0400
Subject: [PATCH 01/17] re-initial commit

adding back all the changes from the earlier branches so it's consistent with main
---
 LineUp.AppHost/AppHost.cs                     | 15 ++++---
 .../Controllers/SwapRequestController.cs      | 43 +++++++++++++++++++
 LineUp.Backend/LineUpContext.cs               |  1 +
 .../Migrations/20260322220958_UniqueEmail.cs  |  6 ++-
 LineUp.Core/Models/SwapRequest.cs             | 22 ++++++++++
 5 files changed, 79 insertions(+), 8 deletions(-)
 create mode 100644 LineUp.Backend/Controllers/SwapRequestController.cs
 create mode 100644 LineUp.Core/Models/SwapRequest.cs

diff --git a/LineUp.AppHost/AppHost.cs b/LineUp.AppHost/AppHost.cs
index 4be8ede..fba39b5 100644
--- a/LineUp.AppHost/AppHost.cs
+++ b/LineUp.AppHost/AppHost.cs
@@ -57,24 +57,27 @@
         .WaitFor(api);
 }
 
-builder.Eventing.Subscribe<ResourceEndpointsAllocatedEvent>((e, ct) => {
-    switch (e.Resource.Name)
+builder.Eventing.Subscribe<ResourceEndpointsAllocatedEvent>(
+    (e, ct) =>
     {
-        case "api":
+        switch (e.Resource.Name)
+        {
+            case "api":
             {
                 var endpoint = api.GetEndpoint("http");
                 Console.WriteLine($"Backend: {endpoint.Url}");
                 Console.WriteLine($"Scalar: {endpoint.Url}/scalar");
                 break;
             }
-        case "web":
+            case "web":
             {
                 var endpoint = web.GetEndpoint("http");
                 Console.WriteLine($"Frontend: {endpoint.Url}");
                 break;
             }
+        }
+        return Task.CompletedTask;
     }
-    return Task.CompletedTask;
-});
+);
 
 builder.Build().Run();
diff --git a/LineUp.Backend/Controllers/SwapRequestController.cs b/LineUp.Backend/Controllers/SwapRequestController.cs
new file mode 100644
index 0000000..76cc051
--- /dev/null
+++ b/LineUp.Backend/Controllers/SwapRequestController.cs
@@ -0,0 +1,43 @@
+using System.Security.Claims;
+using LineUp.Backend.Models;
+using LineUp.Core.Attributes;
+using LineUp.Core.Models;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace LineUp.Backend.Controllers;
+
+[Route("api/Swap")]
+[ApiController]
+public class SwapRequestController(LineUpContext context) : ControllerBase
+{
+    [HttpGet("{guid:guid}/processSwap")]
+    public IActionResult ProcessSwap(Guid guid)
+    {
+        SwapRequest? swap = context.SwapRequests.FirstOrDefault<SwapRequest>(s => s.Guid == guid);
+        if (swap == null)
+        {
+            return NotFound();
+        }
+        List<ShiftAssignment> fromPartyA = swap.FromPartyA;
+        List<ShiftAssignment> fromPartyB = swap.FromPartyB;
+        //set the ShiftOwner on all partyBshifts to A and vice versa
+        if (fromPartyA == null || fromPartyB == null)
+        {
+            return NotFound();
+        }
+        Availability partyA = fromPartyA[0].Availability;
+        Availability partyB = fromPartyA[0].Availability;
+        foreach (ShiftAssignment shift in fromPartyB)
+        {
+            shift.Availability = partyA;
+        }
+        foreach (ShiftAssignment shift in fromPartyA)
+        {
+            shift.Availability = partyB;
+        }
+        context.SaveChanges();
+        return Ok();
+    }
+}
diff --git a/LineUp.Backend/LineUpContext.cs b/LineUp.Backend/LineUpContext.cs
index d5dbb13..a945491 100644
--- a/LineUp.Backend/LineUpContext.cs
+++ b/LineUp.Backend/LineUpContext.cs
@@ -13,6 +13,7 @@ public class LineUpContext : DbContext
     public DbSet<QuestionOptions> QuestionOptions { get; set; }
     public DbSet<FormQuestionAnswer> FormQuestionAnswers { get; set; }
     public DbSet<ShiftAssignment> ShiftAssignments { get; set; }
+    public DbSet<SwapRequest> SwapRequests { get; set; }
 
     public LineUpContext(DbContextOptions<LineUpContext> options)
         : base(options) { }
diff --git a/LineUp.Backend/Migrations/20260322220958_UniqueEmail.cs b/LineUp.Backend/Migrations/20260322220958_UniqueEmail.cs
index c5837f9..1b208fc 100644
--- a/LineUp.Backend/Migrations/20260322220958_UniqueEmail.cs
+++ b/LineUp.Backend/Migrations/20260322220958_UniqueEmail.cs
@@ -14,7 +14,8 @@ protected override void Up(MigrationBuilder migrationBuilder)
                 name: "IX_Availabilities_Id_UserEmail",
                 table: "Availabilities",
                 columns: new[] { "Id", "UserEmail" },
-                unique: true);
+                unique: true
+            );
         }
 
         /// <inheritdoc />
@@ -22,7 +23,8 @@ protected override void Down(MigrationBuilder migrationBuilder)
         {
             migrationBuilder.DropIndex(
                 name: "IX_Availabilities_Id_UserEmail",
-                table: "Availabilities");
+                table: "Availabilities"
+            );
         }
     }
 }
diff --git a/LineUp.Core/Models/SwapRequest.cs b/LineUp.Core/Models/SwapRequest.cs
new file mode 100644
index 0000000..acecb39
--- /dev/null
+++ b/LineUp.Core/Models/SwapRequest.cs
@@ -0,0 +1,22 @@
+using System.Text.Json.Serialization;
+using LineUp.Core.Attributes;
+using Microsoft.EntityFrameworkCore;
+
+namespace LineUp.Core.Models;
+
+[Index(nameof(Guid))]
+public class SwapRequest
+{
+    public int Id { get; set; }
+    public Guid Guid { get; init; } = Guid.NewGuid();
+    public required List<ShiftAssignment> FromPartyA { get; set; }
+
+    public required List<ShiftAssignment> FromPartyB { get; set; }
+
+    public bool partyAConfirm = false;
+
+    public bool partyBConfirm = false;
+
+    [JsonDoNotSerialize]
+    public required Schedule Schedule { get; set; }
+}

From 05f484e41decfef53278aeac3a5ef47f28d8ac9e Mon Sep 17 00:00:00 2001
From: lop4cwru <lop4@case.edu>
Date: Tue, 31 Mar 2026 18:57:27 -0400
Subject: [PATCH 02/17] Swap migrations and a lil bit of frontend

---
 .../20260330203452_SwapSystem.Designer.cs     | 442 ++++++++++++++++++
 .../Migrations/20260330203452_SwapSystem.cs   | 126 +++++
 .../Migrations/LineUpContextModelSnapshot.cs  |  59 +++
 lineup-client/src/pages/Availability.tsx      |   8 +
 4 files changed, 635 insertions(+)
 create mode 100644 LineUp.Backend/Migrations/20260330203452_SwapSystem.Designer.cs
 create mode 100644 LineUp.Backend/Migrations/20260330203452_SwapSystem.cs

diff --git a/LineUp.Backend/Migrations/20260330203452_SwapSystem.Designer.cs b/LineUp.Backend/Migrations/20260330203452_SwapSystem.Designer.cs
new file mode 100644
index 0000000..06e0878
--- /dev/null
+++ b/LineUp.Backend/Migrations/20260330203452_SwapSystem.Designer.cs
@@ -0,0 +1,442 @@
+// <auto-generated />
+using System;
+using LineUp.Backend;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace LineUp.Backend.Migrations
+{
+    [DbContext(typeof(LineUpContext))]
+    [Migration("20260330203452_SwapSystem")]
+    partial class SwapSystem
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("LineUp.Core.Models.Availability", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.PrimitiveCollection<DateTime[]>("AvailabilitySlots")
+                        .IsRequired()
+                        .HasColumnType("timestamp with time zone[]");
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("PreferencesId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("ScheduleId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UserEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Guid");
+
+                    b.HasIndex("PreferencesId");
+
+                    b.HasIndex("ScheduleId");
+
+                    b.HasIndex("Id", "UserEmail")
+                        .IsUnique();
+
+                    b.ToTable("Availabilities");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.AvailabilityPreferences", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AvailabilityPreferences");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.Form", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Forms");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestion", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("FormId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("QuestionText")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FormId");
+
+                    b.ToTable("FormQuestions");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestionAnswer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AnswerId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AnswerText")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("AvailabilityId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("FormQuestionId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AvailabilityId");
+
+                    b.HasIndex("FormQuestionId");
+
+                    b.ToTable("FormQuestionAnswers");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.QuestionOptions", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("FormQuestionId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("OptionText")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FormQuestionId");
+
+                    b.ToTable("QuestionOptions");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Schedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Auth0UserId")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.PrimitiveCollection<DateOnly[]>("DateCoverage")
+                        .IsRequired()
+                        .HasColumnType("date[]");
+
+                    b.Property<TimeOnly>("EndTime")
+                        .HasColumnType("time without time zone");
+
+                    b.Property<int?>("FormId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<Guid>("SchedulePreferencesId")
+                        .HasColumnType("uuid");
+
+                    b.Property<TimeOnly>("StartTime")
+                        .HasColumnType("time without time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FormId")
+                        .IsUnique();
+
+                    b.HasIndex("SchedulePreferencesId");
+
+                    b.HasIndex("Auth0UserId", "Guid");
+
+                    b.ToTable("Schedules");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SchedulePreferences", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MaximumShiftDurationMinutes")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaximumShiftsPerWorker")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MinutesPerSlot")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ShiftIntervals")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("UsersPerShift")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SchedulePreferences");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.ShiftAssignment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AvailabilityId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("EndTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("ScheduleId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("StartTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("SwapRequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SwapRequestId1")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AvailabilityId");
+
+                    b.HasIndex("ScheduleId");
+
+                    b.HasIndex("SwapRequestId");
+
+                    b.HasIndex("SwapRequestId1");
+
+                    b.ToTable("ShiftAssignments");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("ScheduleId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Guid");
+
+                    b.HasIndex("ScheduleId");
+
+                    b.ToTable("SwapRequests");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Availability", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.AvailabilityPreferences", "Preferences")
+                        .WithMany()
+                        .HasForeignKey("PreferencesId");
+
+                    b.HasOne("LineUp.Core.Models.Schedule", "Schedule")
+                        .WithMany()
+                        .HasForeignKey("ScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Preferences");
+
+                    b.Navigation("Schedule");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestion", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Forms.Form", null)
+                        .WithMany("Questions")
+                        .HasForeignKey("FormId");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestionAnswer", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Availability", null)
+                        .WithMany("FormAnswers")
+                        .HasForeignKey("AvailabilityId");
+
+                    b.HasOne("LineUp.Core.Models.Forms.FormQuestion", "Question")
+                        .WithMany()
+                        .HasForeignKey("FormQuestionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Question");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.QuestionOptions", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Forms.FormQuestion", null)
+                        .WithMany("Options")
+                        .HasForeignKey("FormQuestionId");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Schedule", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Forms.Form", "Form")
+                        .WithOne("Schedule")
+                        .HasForeignKey("LineUp.Core.Models.Schedule", "FormId");
+
+                    b.HasOne("LineUp.Core.Models.SchedulePreferences", "SchedulePreferences")
+                        .WithMany()
+                        .HasForeignKey("SchedulePreferencesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Form");
+
+                    b.Navigation("SchedulePreferences");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.ShiftAssignment", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Availability", "Availability")
+                        .WithMany()
+                        .HasForeignKey("AvailabilityId");
+
+                    b.HasOne("LineUp.Core.Models.Schedule", null)
+                        .WithMany("ShiftAssignments")
+                        .HasForeignKey("ScheduleId");
+
+                    b.HasOne("LineUp.Core.Models.SwapRequest", null)
+                        .WithMany("FromPartyA")
+                        .HasForeignKey("SwapRequestId");
+
+                    b.HasOne("LineUp.Core.Models.SwapRequest", null)
+                        .WithMany("FromPartyB")
+                        .HasForeignKey("SwapRequestId1");
+
+                    b.Navigation("Availability");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Schedule", "Schedule")
+                        .WithMany()
+                        .HasForeignKey("ScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Schedule");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Availability", b =>
+                {
+                    b.Navigation("FormAnswers");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.Form", b =>
+                {
+                    b.Navigation("Questions");
+
+                    b.Navigation("Schedule")
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestion", b =>
+                {
+                    b.Navigation("Options");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Schedule", b =>
+                {
+                    b.Navigation("ShiftAssignments");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.Navigation("FromPartyA");
+
+                    b.Navigation("FromPartyB");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/LineUp.Backend/Migrations/20260330203452_SwapSystem.cs b/LineUp.Backend/Migrations/20260330203452_SwapSystem.cs
new file mode 100644
index 0000000..4c8080a
--- /dev/null
+++ b/LineUp.Backend/Migrations/20260330203452_SwapSystem.cs
@@ -0,0 +1,126 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace LineUp.Backend.Migrations
+{
+    /// <inheritdoc />
+    public partial class SwapSystem : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "SwapRequestId",
+                table: "ShiftAssignments",
+                type: "integer",
+                nullable: true
+            );
+
+            migrationBuilder.AddColumn<int>(
+                name: "SwapRequestId1",
+                table: "ShiftAssignments",
+                type: "integer",
+                nullable: true
+            );
+
+            migrationBuilder.CreateTable(
+                name: "SwapRequests",
+                columns: table => new
+                {
+                    Id = table
+                        .Column<int>(type: "integer", nullable: false)
+                        .Annotation(
+                            "Npgsql:ValueGenerationStrategy",
+                            NpgsqlValueGenerationStrategy.IdentityByDefaultColumn
+                        ),
+                    Guid = table.Column<Guid>(type: "uuid", nullable: false),
+                    ScheduleId = table.Column<int>(type: "integer", nullable: false),
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_SwapRequests", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_SwapRequests_Schedules_ScheduleId",
+                        column: x => x.ScheduleId,
+                        principalTable: "Schedules",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade
+                    );
+                }
+            );
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ShiftAssignments_SwapRequestId",
+                table: "ShiftAssignments",
+                column: "SwapRequestId"
+            );
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ShiftAssignments_SwapRequestId1",
+                table: "ShiftAssignments",
+                column: "SwapRequestId1"
+            );
+
+            migrationBuilder.CreateIndex(
+                name: "IX_SwapRequests_Guid",
+                table: "SwapRequests",
+                column: "Guid"
+            );
+
+            migrationBuilder.CreateIndex(
+                name: "IX_SwapRequests_ScheduleId",
+                table: "SwapRequests",
+                column: "ScheduleId"
+            );
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestId",
+                table: "ShiftAssignments",
+                column: "SwapRequestId",
+                principalTable: "SwapRequests",
+                principalColumn: "Id"
+            );
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestId1",
+                table: "ShiftAssignments",
+                column: "SwapRequestId1",
+                principalTable: "SwapRequests",
+                principalColumn: "Id"
+            );
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestId",
+                table: "ShiftAssignments"
+            );
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestId1",
+                table: "ShiftAssignments"
+            );
+
+            migrationBuilder.DropTable(name: "SwapRequests");
+
+            migrationBuilder.DropIndex(
+                name: "IX_ShiftAssignments_SwapRequestId",
+                table: "ShiftAssignments"
+            );
+
+            migrationBuilder.DropIndex(
+                name: "IX_ShiftAssignments_SwapRequestId1",
+                table: "ShiftAssignments"
+            );
+
+            migrationBuilder.DropColumn(name: "SwapRequestId", table: "ShiftAssignments");
+
+            migrationBuilder.DropColumn(name: "SwapRequestId1", table: "ShiftAssignments");
+        }
+    }
+}
diff --git a/LineUp.Backend/Migrations/LineUpContextModelSnapshot.cs b/LineUp.Backend/Migrations/LineUpContextModelSnapshot.cs
index 67f3a26..25002fe 100644
--- a/LineUp.Backend/Migrations/LineUpContextModelSnapshot.cs
+++ b/LineUp.Backend/Migrations/LineUpContextModelSnapshot.cs
@@ -267,15 +267,48 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<DateTime>("StartTime")
                         .HasColumnType("timestamp with time zone");
 
+                    b.Property<int?>("SwapRequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SwapRequestId1")
+                        .HasColumnType("integer");
+
                     b.HasKey("Id");
 
                     b.HasIndex("AvailabilityId");
 
                     b.HasIndex("ScheduleId");
 
+                    b.HasIndex("SwapRequestId");
+
+                    b.HasIndex("SwapRequestId1");
+
                     b.ToTable("ShiftAssignments");
                 });
 
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("ScheduleId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Guid");
+
+                    b.HasIndex("ScheduleId");
+
+                    b.ToTable("SwapRequests");
+                });
+
             modelBuilder.Entity("LineUp.Core.Models.Availability", b =>
                 {
                     b.HasOne("LineUp.Core.Models.AvailabilityPreferences", "Preferences")
@@ -349,9 +382,28 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .WithMany("ShiftAssignments")
                         .HasForeignKey("ScheduleId");
 
+                    b.HasOne("LineUp.Core.Models.SwapRequest", null)
+                        .WithMany("FromPartyA")
+                        .HasForeignKey("SwapRequestId");
+
+                    b.HasOne("LineUp.Core.Models.SwapRequest", null)
+                        .WithMany("FromPartyB")
+                        .HasForeignKey("SwapRequestId1");
+
                     b.Navigation("Availability");
                 });
 
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Schedule", "Schedule")
+                        .WithMany()
+                        .HasForeignKey("ScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Schedule");
+                });
+
             modelBuilder.Entity("LineUp.Core.Models.Availability", b =>
                 {
                     b.Navigation("FormAnswers");
@@ -374,6 +426,13 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                 {
                     b.Navigation("ShiftAssignments");
                 });
+
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.Navigation("FromPartyA");
+
+                    b.Navigation("FromPartyB");
+                });
 #pragma warning restore 612, 618
         }
     }
diff --git a/lineup-client/src/pages/Availability.tsx b/lineup-client/src/pages/Availability.tsx
index 6d12460..f863adb 100644
--- a/lineup-client/src/pages/Availability.tsx
+++ b/lineup-client/src/pages/Availability.tsx
@@ -174,6 +174,14 @@ const Availability = () => {
               )}
             </div>
           </MousePopup>
+          <button
+            className="scheduleBtn"
+            onClick={() => {
+              navigate(`/schedule/requestSwap/${guid}`);
+            }}
+          >
+            Request to swap a shift
+          </button>
         </>
       ) : (
         <>

From 414a365319a91a4180e3b936080284f04bdd50e9 Mon Sep 17 00:00:00 2001
From: lop4cwru <lop4@case.edu>
Date: Fri, 3 Apr 2026 23:35:50 -0400
Subject: [PATCH 03/17] reinstate the base functionality that I forgot to bring
 over the first time

---
 LineUp.Backend.Tests/CRUDTests.cs             |  1 -
 .../Controllers/ScheduleController.cs         | 39 +++++++++++++++++++
 LineUp.Backend/LineUpContext.cs               |  1 +
 3 files changed, 40 insertions(+), 1 deletion(-)

diff --git a/LineUp.Backend.Tests/CRUDTests.cs b/LineUp.Backend.Tests/CRUDTests.cs
index 95921e9..070248b 100644
--- a/LineUp.Backend.Tests/CRUDTests.cs
+++ b/LineUp.Backend.Tests/CRUDTests.cs
@@ -237,7 +237,6 @@ public async Task DeleteSchedule_Test()
     public async Task CreateAvailability_Test()
     {
         // Arrange
-        sampleAvailability.Schedule = sampleSchedule;
         var options = new DbContextOptionsBuilder<LineUpContext>()
             .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
             .Options;
diff --git a/LineUp.Backend/Controllers/ScheduleController.cs b/LineUp.Backend/Controllers/ScheduleController.cs
index 60e05f9..3b7d129 100644
--- a/LineUp.Backend/Controllers/ScheduleController.cs
+++ b/LineUp.Backend/Controllers/ScheduleController.cs
@@ -261,4 +261,43 @@ await context.Availabilities.AnyAsync(a =>
             availabilityToInsert
         );
     }
+
+    [HttpPost("{guid:guid}/requestSwap")]
+    public IActionResult RequestSwap(Guid guid, [FromBody] List<ShiftAssignment> shiftCollection)
+    {
+        Schedule? schedule = context.Schedules.FirstOrDefault<Schedule>(s => s.Guid == guid);
+        if (schedule == null || shiftCollection == null || shiftCollection[0] == null)
+        {
+            return NotFound();
+        }
+        //Sort through the shifts (assume an unsorted list)
+        Availability partyA = shiftCollection[0].Availability;
+        List<ShiftAssignment> partyAShifts = [];
+        Availability partyB = null;
+        List<ShiftAssignment> partyBShifts = [];
+        foreach (ShiftAssignment shift in shiftCollection)
+        {
+            Availability shiftOwner = shift.Availability;
+            if (shiftOwner == partyA)
+                partyAShifts.Append(shift);
+            else if (partyB == null)
+            {
+                partyB = shiftOwner;
+                partyBShifts.Append(shift);
+            }
+            else if (shiftOwner == partyB)
+                partyBShifts.Append(shift);
+            else
+                return BadRequest("More than two parties identified");
+        }
+        SwapRequest swapRequest = new SwapRequest
+        {
+            FromPartyA = partyAShifts,
+            FromPartyB = partyBShifts,
+            Schedule = schedule,
+        };
+        context.SwapRequests.Add(swapRequest);
+        context.SaveChanges();
+        return Ok(swapRequest.Guid);
+    }
 }
diff --git a/LineUp.Backend/LineUpContext.cs b/LineUp.Backend/LineUpContext.cs
index 5b246cf..de516a5 100644
--- a/LineUp.Backend/LineUpContext.cs
+++ b/LineUp.Backend/LineUpContext.cs
@@ -13,6 +13,7 @@ public class LineUpContext : DbContext
     public virtual DbSet<QuestionOptions> QuestionOptions { get; set; }
     public virtual DbSet<FormQuestionAnswer> FormQuestionAnswers { get; set; }
     public virtual DbSet<ShiftAssignment> ShiftAssignments { get; set; }
+    public virtual DbSet<SwapRequest> SwapRequests { get; set; }
 
     public LineUpContext(DbContextOptions<LineUpContext> options)
         : base(options) { }

From f38a892704b0b02edb5f562f2ae793830d4d22e7 Mon Sep 17 00:00:00 2001
From: lop4cwru <lop4@case.edu>
Date: Sat, 4 Apr 2026 14:18:52 -0400
Subject: [PATCH 04/17] Progress... (aka I figured out how to make a page
 redirect)

---
 .../Controllers/SwapRequestController.cs      |  4 +-
 lineup-client/src/App.tsx                     |  6 ++
 lineup-client/src/pages/Availability.tsx      |  2 +-
 lineup-client/src/pages/RequestSwap.tsx       | 60 +++++++++++++++++++
 4 files changed, 69 insertions(+), 3 deletions(-)
 create mode 100644 lineup-client/src/pages/RequestSwap.tsx

diff --git a/LineUp.Backend/Controllers/SwapRequestController.cs b/LineUp.Backend/Controllers/SwapRequestController.cs
index 76cc051..c5b0f5f 100644
--- a/LineUp.Backend/Controllers/SwapRequestController.cs
+++ b/LineUp.Backend/Controllers/SwapRequestController.cs
@@ -8,7 +8,7 @@
 
 namespace LineUp.Backend.Controllers;
 
-[Route("api/Swap")]
+[Route("api/swap")]
 [ApiController]
 public class SwapRequestController(LineUpContext context) : ControllerBase
 {
@@ -28,7 +28,7 @@ public IActionResult ProcessSwap(Guid guid)
             return NotFound();
         }
         Availability partyA = fromPartyA[0].Availability;
-        Availability partyB = fromPartyA[0].Availability;
+        Availability partyB = fromPartyB[0].Availability;
         foreach (ShiftAssignment shift in fromPartyB)
         {
             shift.Availability = partyA;
diff --git a/lineup-client/src/App.tsx b/lineup-client/src/App.tsx
index 3b71d81..cc28522 100644
--- a/lineup-client/src/App.tsx
+++ b/lineup-client/src/App.tsx
@@ -7,6 +7,7 @@ import Error from "@/pages/Error";
 import Home from "@/pages/Home";
 import NewSchedule from "@/pages/NewSchedule";
 import ViewEditSchedule from "@/pages/ViewEditSchedule";
+import RequestSwap from "@/pages/RequestSwap";
 import { queryClient } from "@/utils/api";
 import { loaderQuery } from "@/utils/db";
 import { createBrowserRouter, Navigate, Outlet, RouterProvider, type LoaderFunctionArgs } from "react-router";
@@ -62,6 +63,11 @@ const router = createBrowserRouter([
             element: <ViewEditSchedule />,
             loader: scheduleLoader,
           },
+          {
+            path: ":guid/requestSwap", // matches /schedule/:guid/edit
+            element: <RequestSwap />,
+            loader: scheduleLoader,
+          },
         ],
       },
       {
diff --git a/lineup-client/src/pages/Availability.tsx b/lineup-client/src/pages/Availability.tsx
index f863adb..5e225b2 100644
--- a/lineup-client/src/pages/Availability.tsx
+++ b/lineup-client/src/pages/Availability.tsx
@@ -177,7 +177,7 @@ const Availability = () => {
           <button
             className="scheduleBtn"
             onClick={() => {
-              navigate(`/schedule/requestSwap/${guid}`);
+              navigate(`/schedule/${guid}/requestSwap/`);
             }}
           >
             Request to swap a shift
diff --git a/lineup-client/src/pages/RequestSwap.tsx b/lineup-client/src/pages/RequestSwap.tsx
new file mode 100644
index 0000000..de8f115
--- /dev/null
+++ b/lineup-client/src/pages/RequestSwap.tsx
@@ -0,0 +1,60 @@
+import { Calendar } from "@/components/Calendar";
+import { ColoredCell, FillableCell } from "@/components/CalendarCells";
+import { MousePopup } from "@/components/MousePopup";
+import { queryClient, useApi } from "@/utils/api";
+import { addToasts, loaderQuery } from "@/utils/db";
+import { parseTimeString } from "@/utils/time";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { useState } from "react";
+import { useNavigate, useParams } from "react-router";
+
+const RequestSwap = () => {
+  const navigate = useNavigate();
+  const { fetchWithAuth } = useApi();
+  const { guid } = useParams();
+  const { data } = useQuery(loaderQuery("/api/schedule/{}/requestSwap", guid!));
+  const [focusedTime, setFocusedTime] = useState<string | null>(null);
+  //   const storageKey = `availability-${guid}`;
+  const backgroundColors = Array.from({ length: 10 }, (_, i) => `hsl(${Math.round((360 / 10) * i)}, 100%, 80%)`);
+  console.log(backgroundColors);
+
+  console.log(data);
+
+  type SwapRequestProps = {
+    //define what will be sent to the backend function ScheduleController.cs/RequestSwap()
+    shifts: string[]; //List<ShiftAssignment>;
+    // userName: string;
+    // userEmail: string;
+    // availabilitySlots: string[]; // full of ISO strings
+  };
+
+  const updateAvailabilityMutation = useMutation({
+    mutationFn: async (updatedAvailability: SwapRequestProps) => {
+      const res = await fetchWithAuth(`/api/schedule/${guid}/requestSwap`, {
+        method: "POST",
+        body: JSON.stringify(updatedAvailability),
+        headers: {
+          "Content-Type": "application/json",
+        },
+      });
+
+      if (!res.ok) {
+        throw new Error("Failed to edit availability");
+      }
+
+      return true;
+    },
+    // onSuccess: () => {
+    //   try {
+    //     localStorage.removeItem(storageKey);
+    //   } catch {
+    //     // ignore storage errors
+    //   }
+    //   queryClient.invalidateQueries({ queryKey: ["availability"] });
+    //   navigate("/");
+    // },
+  });
+  return <div>hello :wave:</div>;
+};
+
+export default RequestSwap;

From c189b5ad9a9b743dd9b0a4f9b247dc0b1c94ad66 Mon Sep 17 00:00:00 2001
From: lop4cwru <lop4@case.edu>
Date: Sun, 5 Apr 2026 01:40:03 -0400
Subject: [PATCH 05/17] Progress...

- Filled out RequestSwap.tsx
    - Contains the generated schedule and a place to submit your email. If your email has an availability in this schedule, you may proceed to the next.
    - Contains a selectable schedule w/ text in the cells where you can select which shifts you'd like to swap. Then, you can submit that to create the SwapRequest in the backend (FUNCTIONALITY STILL WIP)
- Modified the CalendarInnerCell css class to allow for text inside as well (with help from Rhyder)
- Added a method to the backend that lets you find if an email has an Availability on this particular Schedule.
---
 .../Controllers/ScheduleController.cs         |  11 +
 lineup-client/src/App.css                     |   4 +
 .../src/components/CalendarCells.tsx          |   5 +-
 lineup-client/src/components/calendar.css     |  12 +-
 lineup-client/src/pages/RequestSwap.tsx       | 220 ++++++++++++++++--
 5 files changed, 223 insertions(+), 29 deletions(-)

diff --git a/LineUp.Backend/Controllers/ScheduleController.cs b/LineUp.Backend/Controllers/ScheduleController.cs
index 3b7d129..db6fbe5 100644
--- a/LineUp.Backend/Controllers/ScheduleController.cs
+++ b/LineUp.Backend/Controllers/ScheduleController.cs
@@ -262,6 +262,17 @@ await context.Availabilities.AnyAsync(a =>
         );
     }
 
+    [HttpGet("{guid:guid}/getByEmail")]
+    public async Task<IActionResult> GetAvailability(Guid guid, [FromQuery] string email)
+    {
+        var result = await context
+            .Availabilities.Include(a => a.Schedule)
+            .FirstOrDefaultAsync(a => a.UserEmail == email && a.Schedule.Guid == guid);
+        if (result != null)
+            return Ok(result);
+        return StatusCode(StatusCodes.Status406NotAcceptable);
+    }
+
     [HttpPost("{guid:guid}/requestSwap")]
     public IActionResult RequestSwap(Guid guid, [FromBody] List<ShiftAssignment> shiftCollection)
     {
diff --git a/lineup-client/src/App.css b/lineup-client/src/App.css
index 908d40e..7a91690 100644
--- a/lineup-client/src/App.css
+++ b/lineup-client/src/App.css
@@ -197,3 +197,7 @@
   font-size: 0.75rem;
   margin-right: 1em;
 }
+
+.swapBtn {
+  margin-left: 1em;
+}
diff --git a/lineup-client/src/components/CalendarCells.tsx b/lineup-client/src/components/CalendarCells.tsx
index dd74d57..323170f 100644
--- a/lineup-client/src/components/CalendarCells.tsx
+++ b/lineup-client/src/components/CalendarCells.tsx
@@ -24,6 +24,7 @@ const FillableCell = ({
   setIsPointerDown,
   isEnablingCells,
   setIsEnablingCells,
+  text,
 }: CalendarCellProps) => {
   const dateString = standardizeDateAndTime(date, time);
   const isClicked = selectedCells?.includes(dateString);
@@ -56,7 +57,9 @@ const FillableCell = ({
       onPointerEnter={onPointerEnter}
       className={"unstyledButton calendarInnerCell" + (isClicked ? " clicked" : "")}
       title={dayNumberToWeekday(date.getDay()) + " " + formatTime(time)}
-    ></button>
+    >
+      {text[dateString] ?? ""}
+    </button>
   );
 };
 
diff --git a/lineup-client/src/components/calendar.css b/lineup-client/src/components/calendar.css
index 2adb24c..56077af 100644
--- a/lineup-client/src/components/calendar.css
+++ b/lineup-client/src/components/calendar.css
@@ -81,11 +81,17 @@
   text-overflow: ellipsis;
   color: var(--background);
 
-  &button {
-    cursor: pointer;
+  &.clicked {
+    background-color: var(--primary-active-hover);
   }
+}
+
+button.calendarInnerCell {
+  cursor: pointer;
+  color: var(--primary);
+  font-size: 12px;
 
   &.clicked {
-    background-color: var(--primary-active-hover);
+    color: var(--background);
   }
 }
diff --git a/lineup-client/src/pages/RequestSwap.tsx b/lineup-client/src/pages/RequestSwap.tsx
index de8f115..a5a4506 100644
--- a/lineup-client/src/pages/RequestSwap.tsx
+++ b/lineup-client/src/pages/RequestSwap.tsx
@@ -1,7 +1,7 @@
 import { Calendar } from "@/components/Calendar";
 import { ColoredCell, FillableCell } from "@/components/CalendarCells";
 import { MousePopup } from "@/components/MousePopup";
-import { queryClient, useApi } from "@/utils/api";
+import { useApi } from "@/utils/api";
 import { addToasts, loaderQuery } from "@/utils/db";
 import { parseTimeString } from "@/utils/time";
 import { useMutation, useQuery } from "@tanstack/react-query";
@@ -12,49 +12,219 @@ const RequestSwap = () => {
   const navigate = useNavigate();
   const { fetchWithAuth } = useApi();
   const { guid } = useParams();
-  const { data } = useQuery(loaderQuery("/api/schedule/{}/requestSwap", guid!));
+  const { data } = useQuery(loaderQuery("/api/schedule/{}", guid!));
   const [focusedTime, setFocusedTime] = useState<string | null>(null);
-  //   const storageKey = `availability-${guid}`;
   const backgroundColors = Array.from({ length: 10 }, (_, i) => `hsl(${Math.round((360 / 10) * i)}, 100%, 80%)`);
   console.log(backgroundColors);
 
   console.log(data);
 
-  type SwapRequestProps = {
-    //define what will be sent to the backend function ScheduleController.cs/RequestSwap()
-    shifts: string[]; //List<ShiftAssignment>;
-    // userName: string;
-    // userEmail: string;
-    // availabilitySlots: string[]; // full of ISO strings
-  };
+  const [email, setEmail] = useState<string>("");
+  const [selectedCells, setSelectedCells] = useState<string[]>([]);
+  const [userFound, setUserFound] = useState<boolean>(false);
+
+  const confirmEmailmutation = useMutation({
+    //
+    mutationFn: async (email: string) => {
+      const res = await fetchWithAuth(`/api/schedule/${guid}/getByEmail?email=${email}`, {
+        method: "GET",
+      });
 
-  const updateAvailabilityMutation = useMutation({
-    mutationFn: async (updatedAvailability: SwapRequestProps) => {
+      if (res.status == 406) {
+        throw new Error("Availability Not Found");
+      } else if (!res.ok) {
+        throw new Error("Failed to send Swap Request");
+      }
+      return res;
+    },
+    onSuccess: (res) => {
+      console.log("Email Mutation:" + res.json);
+      setUserFound(true);
+      setSelectedCells(["H"]); //res.json
+      //.Availability.Availiabilityslots  --- note
+    },
+  });
+
+  const CreateSwapRequestMutation = useMutation({
+    //creates a SwapRequest in the DB
+    mutationFn: async (shifts: string[]) => {
       const res = await fetchWithAuth(`/api/schedule/${guid}/requestSwap`, {
         method: "POST",
-        body: JSON.stringify(updatedAvailability),
+        body: JSON.stringify(shifts),
         headers: {
           "Content-Type": "application/json",
         },
       });
 
+      shifts.forEach((element) => {
+        //note each shift assignment
+        console.log(element);
+      });
+
       if (!res.ok) {
-        throw new Error("Failed to edit availability");
+        throw new Error("Failed to create Swap Request");
       }
 
-      return true;
+      return res;
     },
-    // onSuccess: () => {
-    //   try {
-    //     localStorage.removeItem(storageKey);
-    //   } catch {
-    //     // ignore storage errors
-    //   }
-    //   queryClient.invalidateQueries({ queryKey: ["availability"] });
-    //   navigate("/");
-    // },
+    onSuccess: () => {},
   });
-  return <div>hello :wave:</div>;
+
+  if (!data) return <div>Loading...</div>;
+
+  const scheduleGenerated = true;
+  const [assignmentColors, assignmentText] = mapAssignments();
+
+  function mapAssignments() {
+    const colors: { [key: string]: string } = {};
+    const text: { [key: string]: string } = {};
+    const nameToColor: { [key: string]: string } = {};
+
+    if (!scheduleGenerated) {
+      return [colors, text];
+    }
+
+    for (const availability of data.shiftAssignments) {
+      if (availability.startTime in text) {
+        text[availability.startTime] = text[availability.startTime] + ", " + availability.userName;
+      } else {
+        text[availability.startTime] = availability.userName;
+      }
+    }
+
+    let numColors = 0;
+    for (const time of Object.keys(text)) {
+      if (text[time] in nameToColor) {
+        colors[time] = nameToColor[text[time]];
+      } else {
+        nameToColor[text[time]] = backgroundColors[numColors % backgroundColors.length];
+        colors[time] = backgroundColors[numColors % backgroundColors.length];
+        numColors++;
+      }
+    }
+    return [colors, text];
+  }
+
+  const handleInputChange = (event: React.ChangeEvent<HTMLInputElement | HTMLSelectElement>) => {
+    const { value } = event.target;
+    setEmail(value);
+  };
+
+  return (
+    <div className="availabilityRoot">
+      <>
+        <div className="scheduleName">
+          Schedule for <b>{data.name}</b>
+        </div>
+        {userFound ? (
+          <>
+            <div>
+              <em>Please select the shifts that you would like to swap.</em>
+            </div>
+            <br />
+
+            <form
+              onSubmit={(event: React.SubmitEvent<HTMLFormElement>) => {
+                event.preventDefault();
+                addToasts(
+                  CreateSwapRequestMutation.mutateAsync(selectedCells),
+                  undefined,
+                  "Request created! Please check your email to authenticate this request.",
+                ); //remove success message
+              }}
+            >
+              <Calendar
+                Cell={FillableCell}
+                selectedCells={selectedCells}
+                setSelectedCells={(cells) => {
+                  const next = typeof cells === "function" ? cells(selectedCells) : cells;
+                  setSelectedCells(next);
+                }}
+                minutesPerCell={data.schedulePreferences?.minutesPerSlot || 15}
+                dates={
+                  data.dateCoverage?.map((d: string) => {
+                    const [year, month, day] = d.split("-").map(Number);
+                    return new Date(year, month - 1, day);
+                  }) ?? []
+                }
+                range={{
+                  start: parseTimeString(data.startTime)!,
+                  end: parseTimeString(data.endTime)!,
+                }}
+                colors={assignmentColors}
+                text={assignmentText}
+                setFocusedCell={setFocusedTime}
+              />
+              <div>
+                <button type="submit" className="scheduleBtn swapBtn">
+                  Submit
+                </button>
+              </div>
+            </form>
+          </>
+        ) : (
+          <>
+            <Calendar
+              Cell={ColoredCell}
+              minutesPerCell={data.schedulePreferences?.minutesPerSlot || 15}
+              dates={
+                data.dateCoverage?.map((d: string) => {
+                  const [year, month, day] = d.split("-").map(Number);
+                  return new Date(year, month - 1, day);
+                }) ?? []
+              }
+              range={{
+                start: parseTimeString(data.startTime)!,
+                end: parseTimeString(data.endTime)!,
+              }}
+              colors={assignmentColors}
+              text={assignmentText}
+              setFocusedCell={setFocusedTime}
+            />
+            <MousePopup isOpen={focusedTime !== null && focusedTime in assignmentText} width={250}>
+              <div className="availablePeoplePopupRoot">
+                <div className="availablePeoplePopupHeader">{focusedTime && assignmentText[focusedTime]}</div>
+                {focusedTime && (
+                  <div className="availablePeoplePopupTime">
+                    {new Intl.DateTimeFormat("en-US", {
+                      weekday: "long",
+                      hour: "2-digit",
+                      minute: "2-digit",
+                      hour12: true,
+                      timeZone: "UTC",
+                    }).format(new Date(focusedTime))}
+                  </div>
+                )}
+              </div>
+            </MousePopup>
+            <form
+              onSubmit={(event: React.SubmitEvent<HTMLFormElement>) => {
+                event.preventDefault();
+                addToasts(confirmEmailmutation.mutateAsync(email));
+              }}
+            >
+              <label htmlFor="email">Please input the email address you used to input your availability.</label>
+              <div>
+                <input
+                  className="input"
+                  type="email"
+                  id="email"
+                  name="email"
+                  value={email}
+                  onChange={handleInputChange}
+                  placeholder="name@example.com..."
+                  required
+                />
+                <button type="submit" className="scheduleBtn swapBtn" disabled={confirmEmailmutation.isPending}>
+                  Submit
+                </button>
+              </div>
+            </form>
+          </>
+        )}
+      </>
+    </div>
+  );
 };
 
 export default RequestSwap;

From 4dcd0e352dc1e2a6577a6a982b15a7a9be2dedf2 Mon Sep 17 00:00:00 2001
From: lop4cwru <lop4@case.edu>
Date: Sun, 5 Apr 2026 06:04:09 -0400
Subject: [PATCH 06/17] As far as I'm getting before passing out

I really tried, man.

Anyway, progress is stuck at the "validate selection" portion: I need a way of guaranteeing that exactly two people are swapping, one is known (the user that gave their email and created the request) and the second is going to be selected from a button on the left, if I can get that to render right.

Still needs to happen:
- shift assignments need to be correctly read and interpreted by the backend into a SwapRequest object (shouldn't be that bad, but ScheduleController.RequestSwap() needs to have the input changed from List<ShiftAssignment> to a string array of times, then parse each of those times to find which party (A or B) owns that shift, *then* it can add that into the backend.

- Send out the email confirmation to the creating user when they send the request to the backend (probably a new backend function)

- Send out the email request to the other swapping user (will probably use function created from above)

- Create a landing page for the two requested swappers that just shows the trade offer

- process that (just make the backend call "api/swap/{swapRequestGuid}/processSwap) and that should work

- send an email to the manager informing of the swap

- add a preference for the manager to block/allow swaps and the corresponding functionality for that (i.e. disable the request swap button or block it w/ a ternary)
---
 lineup-client/src/App.css               |  5 ++++
 lineup-client/src/pages/RequestSwap.tsx | 36 ++++++++++++++++++++-----
 2 files changed, 34 insertions(+), 7 deletions(-)

diff --git a/lineup-client/src/App.css b/lineup-client/src/App.css
index 7a91690..b303cfb 100644
--- a/lineup-client/src/App.css
+++ b/lineup-client/src/App.css
@@ -201,3 +201,8 @@
 .swapBtn {
   margin-left: 1em;
 }
+
+.swapPartnerLabel {
+  display: flex;
+  align-items: left;
+}
diff --git a/lineup-client/src/pages/RequestSwap.tsx b/lineup-client/src/pages/RequestSwap.tsx
index a5a4506..cfc370e 100644
--- a/lineup-client/src/pages/RequestSwap.tsx
+++ b/lineup-client/src/pages/RequestSwap.tsx
@@ -15,13 +15,15 @@ const RequestSwap = () => {
   const { data } = useQuery(loaderQuery("/api/schedule/{}", guid!));
   const [focusedTime, setFocusedTime] = useState<string | null>(null);
   const backgroundColors = Array.from({ length: 10 }, (_, i) => `hsl(${Math.round((360 / 10) * i)}, 100%, 80%)`);
-  console.log(backgroundColors);
+  // console.log(backgroundColors);
 
-  console.log(data);
+  // console.log(data);
 
   const [email, setEmail] = useState<string>("");
   const [selectedCells, setSelectedCells] = useState<string[]>([]);
   const [userFound, setUserFound] = useState<boolean>(false);
+  const [swapPartner, setSwapPartner] = useState<string>("");
+  const [swapPartnerGuid, setSwapPartnerGuid] = useState<string>("");
 
   const confirmEmailmutation = useMutation({
     //
@@ -35,13 +37,12 @@ const RequestSwap = () => {
       } else if (!res.ok) {
         throw new Error("Failed to send Swap Request");
       }
-      return res;
+      const resJson = await res.json();
+      return resJson;
     },
-    onSuccess: (res) => {
-      console.log("Email Mutation:" + res.json);
+    onSuccess: (resJson) => {
       setUserFound(true);
-      setSelectedCells(["H"]); //res.json
-      //.Availability.Availiabilityslots  --- note
+      // setSelectedCells(resJson.availabilitySlots); //This would make all the availiability light up at the start, but that feels confusing if others have shifts at that time.
     },
   });
 
@@ -110,6 +111,20 @@ const RequestSwap = () => {
     setEmail(value);
   };
 
+  const renderPartnerSelect = (name: string, guid: string) => (
+    <>
+      <button
+        className="scheduleBtn"
+        onClick={() => {
+          setSwapPartner(name);
+          setSwapPartnerGuid(guid);
+        }}
+      >
+        {name}
+      </button>
+    </>
+  );
+
   return (
     <div className="availabilityRoot">
       <>
@@ -156,6 +171,13 @@ const RequestSwap = () => {
                 setFocusedCell={setFocusedTime}
               />
               <div>
+                <div className="swapPartnerLabel">
+                  <label>Swapping with:</label>
+                  <label>
+                    {/* {data.shiftAssignments.map(() => renderPartnerSelect())}
+                    {renderPartnerSelect(data.shiftAssignments.name, data.shiftAssignments.AvailabilityDbId)} */}
+                  </label>
+                </div>
                 <button type="submit" className="scheduleBtn swapBtn">
                   Submit
                 </button>

From f708107ec868559bf2f5cc1d5ee82e79af0418e6 Mon Sep 17 00:00:00 2001
From: lop4cwru <lop4@case.edu>
Date: Mon, 6 Apr 2026 16:58:36 -0400
Subject: [PATCH 07/17] I mean if they'll let me count this as fuzz testing I
 won't complain

---
 LineUp.Backend.Tests/CRUDTests.cs     | 79 +++++++++++++++++++++++++++
 LineUp.Core/Models/ShiftAssignment.cs |  3 +-
 2 files changed, 80 insertions(+), 2 deletions(-)

diff --git a/LineUp.Backend.Tests/CRUDTests.cs b/LineUp.Backend.Tests/CRUDTests.cs
index 070248b..9e582ef 100644
--- a/LineUp.Backend.Tests/CRUDTests.cs
+++ b/LineUp.Backend.Tests/CRUDTests.cs
@@ -392,4 +392,83 @@ public async Task UpdateAvailability_Test()
             Assert.IsType<NotFoundResult>(failedAvailabilityUpdateResult);
         }
     }
+
+    [Fact]
+    public async Task CreateRandomSchedule_Test()
+    {
+        // Arrange
+        var options = new DbContextOptionsBuilder<LineUpContext>()
+            .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+            .Options;
+
+        Random random = new Random();
+
+        List<DateOnly> randomCoverage = new List<DateOnly>();
+
+        for (int i = 0; i < random.Next(10); i++)
+        {
+            randomCoverage.Add(DateOnly.FromDateTime(DateTime.UtcNow.AddDays(i)));
+        }
+
+        Schedule randomSchedule = new Schedule
+        {
+            Guid = Guid.Empty,
+            Auth0UserId = "always-test-on-schedule",
+            DateCoverage = randomCoverage.ToArray(),
+            StartTime = new TimeOnly(9, 0),
+            EndTime = new TimeOnly(17, 0),
+            SchedulePreferences = new SchedulePreferences
+            {
+                MinutesPerSlot = 30,
+                ShiftIntervals = 30,
+                UsersPerShift = 1,
+                MaximumShiftDurationMinutes = 120,
+                MaximumShiftsPerWorker = 1,
+            },
+            Name = "Test Schedule",
+        };
+
+        using (var context = new LineUpContext(options))
+        {
+            context.Database.EnsureCreated();
+
+            var controller = new ScheduleController(context);
+
+            // Create a mock ClaimsPrincipal with the required NameIdentifier claim
+            var claims = new List<Claim> { new Claim(ClaimTypes.NameIdentifier, "test-user-123") };
+            var identity = new ClaimsIdentity(claims);
+            var principal = new ClaimsPrincipal(identity);
+            controller.ControllerContext = new ControllerContext
+            {
+                HttpContext = new DefaultHttpContext { User = principal },
+            };
+
+            var scheduleDto = new ScheduleDto
+            {
+                DateCoverage = randomSchedule.DateCoverage,
+                StartTime = randomSchedule.StartTime,
+                EndTime = randomSchedule.EndTime,
+                SchedulePreferences = randomSchedule.SchedulePreferences,
+                Name = randomSchedule.Name,
+            };
+
+            // Act
+            var result = await controller.CreateSchedule(scheduleDto);
+
+            // Assert
+            var createdResult = Assert.IsType<CreatedAtActionResult>(result);
+            Assert.Equal(nameof(ScheduleController.GetSchedule), createdResult.ActionName);
+            Assert.NotNull(createdResult.Value);
+
+            var returnedSchedule = Assert.IsType<Schedule>(createdResult.Value);
+            Assert.Equal("test-user-123", returnedSchedule.Auth0UserId);
+            Assert.Equal(randomSchedule.Name, returnedSchedule.Name);
+            Assert.Equal(randomSchedule.StartTime, returnedSchedule.StartTime);
+            Assert.Equal(randomSchedule.EndTime, returnedSchedule.EndTime);
+
+            // Verify that the schedule was actually saved to the database
+            var savedSchedules = await context.Schedules.CountAsync();
+            Assert.Equal(1, savedSchedules);
+        }
+    }
 }
diff --git a/LineUp.Core/Models/ShiftAssignment.cs b/LineUp.Core/Models/ShiftAssignment.cs
index 1b3dd5f..fc88673 100644
--- a/LineUp.Core/Models/ShiftAssignment.cs
+++ b/LineUp.Core/Models/ShiftAssignment.cs
@@ -8,12 +8,11 @@ public class ShiftAssignment
 
     public DateTime StartTime { get; set; }
     public DateTime EndTime { get; set; }
-    
+
     public string? UserName => Availability?.UserName;
     public int? AvailabilityDbId => Availability?.Id;
     public Availability? Availability { get; set; }
     // Navigation properties, ignored in JSON to not loop forever
-    
     public int? ScheduleId { get; set; }
     [JsonDoNotSerialize]
     public Schedule? Schedule => Availability?.Schedule;

From 4026e2f3019b6d7f3c17da3987a2abacbe602d58 Mon Sep 17 00:00:00 2001
From: lop4cwru <lop4@case.edu>
Date: Fri, 17 Apr 2026 18:02:17 -0400
Subject: [PATCH 08/17] eughhhhhh

---
 LineUp.Backend.Tests/CRUDTests.cs             | 149 +++++++++++++
 LineUp.Backend.Tests/SwapTests.cs             | 196 ++++++++++++++++++
 .../Controllers/ScheduleController.cs         |  56 ++++-
 aspire.config.json                            |   5 +
 lineup-client/src/pages/NewSchedule.tsx       |  15 ++
 lineup-client/src/pages/RequestSwap.tsx       |  32 ++-
 6 files changed, 432 insertions(+), 21 deletions(-)
 create mode 100644 LineUp.Backend.Tests/SwapTests.cs
 create mode 100644 aspire.config.json

diff --git a/LineUp.Backend.Tests/CRUDTests.cs b/LineUp.Backend.Tests/CRUDTests.cs
index 9e582ef..cc0a6c7 100644
--- a/LineUp.Backend.Tests/CRUDTests.cs
+++ b/LineUp.Backend.Tests/CRUDTests.cs
@@ -471,4 +471,153 @@ public async Task CreateRandomSchedule_Test()
             Assert.Equal(1, savedSchedules);
         }
     }
+    /*
+    [Fact]
+    public async Task CreateRandomAvailability_Test()
+    {
+        // Arrange
+        var options = new DbContextOptionsBuilder<LineUpContext>()
+            .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+            .Options;
+
+        Random random = new Random();
+        int totalDays = random.Next(10);
+
+        List<DateOnly> randomCoverage = new List<DateOnly>();
+
+        for (int i = 0; i < totalDays; i++)
+        {
+            randomCoverage.Add(DateOnly.FromDateTime(DateTime.UtcNow.AddDays(i)));
+        }
+
+        Schedule randomSchedule = new Schedule
+        {
+            Guid = Guid.Empty,
+            Auth0UserId = "always-test-on-schedule",
+            DateCoverage = randomCoverage.ToArray(),
+            StartTime = new TimeOnly(9, 0),
+            EndTime = new TimeOnly(17, 0),
+            SchedulePreferences = new SchedulePreferences
+            {
+                MinutesPerSlot = 30,
+                ShiftIntervals = 30,
+                UsersPerShift = 1,
+                MaximumShiftDurationMinutes = 120,
+                MaximumShiftsPerWorker = 1,
+            },
+            Name = "Test Schedule",
+        };
+
+        List<DateTime> randomAvailSlots = new List<DateTime>();
+
+        for (int i = 0; i < totalDays; i++)
+        {
+            randomAvailSlots.Add(DateTime.UtcNow.Date.AddHours(9));
+            DateTime.UtcNow.Date.AddHours(9).AddMinutes(30);
+            DateTime.UtcNow.Date.AddHours(10);
+            DateTime.UtcNow.Date.AddHours(10).AddMinutes(30);
+            DateTime.UtcNow.Date.AddHours(11);
+            DateTime.UtcNow.Date.AddHours(11).AddMinutes(30);
+            randomCoverage.Add(DateOnly.FromDateTime(DateTime.UtcNow.AddDays(i)));
+        }
+
+        Availability randomAvailability = new Availability
+        {
+        UserName = "Test Availability",
+        UserEmail = "test@email.com",
+        AvailabilitySlots =
+        [
+            // Day 0: 9:00 - 12:00
+            DateTime.UtcNow.Date.AddHours(9),
+            DateTime.UtcNow.Date.AddHours(9).AddMinutes(30),
+            DateTime.UtcNow.Date.AddHours(10),
+            DateTime.UtcNow.Date.AddHours(10).AddMinutes(30),
+            DateTime.UtcNow.Date.AddHours(11),
+            DateTime.UtcNow.Date.AddHours(11).AddMinutes(30),
+            // Day 1: 13:00 - 17:00
+            DateTime.UtcNow.Date.AddDays(1).AddHours(13),
+            DateTime.UtcNow.Date.AddDays(1).AddHours(13).AddMinutes(30),
+            DateTime.UtcNow.Date.AddDays(1).AddHours(14),
+            DateTime.UtcNow.Date.AddDays(1).AddHours(14).AddMinutes(30),
+            DateTime.UtcNow.Date.AddDays(1).AddHours(15),
+            DateTime.UtcNow.Date.AddDays(1).AddHours(15).AddMinutes(30),
+            DateTime.UtcNow.Date.AddDays(1).AddHours(16),
+            DateTime.UtcNow.Date.AddDays(1).AddHours(16).AddMinutes(30),
+        ],
+        Schedule = new Schedule
+        {
+            Guid = Guid.Empty,
+            Auth0UserId = "replace this schedule",
+            DateCoverage = [],
+            StartTime = new TimeOnly(0, 0),
+            EndTime = new TimeOnly(0, 0),
+            SchedulePreferences = new SchedulePreferences
+            {
+                MinutesPerSlot = 30,
+                ShiftIntervals = 30,
+                UsersPerShift = 1,
+                MaximumShiftDurationMinutes = 120,
+                MaximumShiftsPerWorker = 1,
+            },
+            Name = "ReplaceThisScheduleWithSampleSchedule",
+        },
+        Preferences = new AvailabilityPreferences(),
+    };
+
+        using (var context = new LineUpContext(options))
+        {
+            context.Database.EnsureCreated();
+
+            var controller = new ScheduleController(context);
+
+            // Create a mock ClaimsPrincipal with the required NameIdentifier claim
+            var claims = new List<Claim> { new Claim(ClaimTypes.NameIdentifier, "test-user-123") };
+            var identity = new ClaimsIdentity(claims);
+            var principal = new ClaimsPrincipal(identity);
+            controller.ControllerContext = new ControllerContext
+            {
+                HttpContext = new DefaultHttpContext { User = principal },
+            };
+
+            var scheduleDto = new ScheduleDto
+            {
+                DateCoverage = randomSchedule.DateCoverage,
+                StartTime = randomSchedule.StartTime,
+                EndTime = randomSchedule.EndTime,
+                SchedulePreferences = randomSchedule.SchedulePreferences,
+                Name = randomSchedule.Name,
+            };
+
+            var result = await controller.CreateSchedule(scheduleDto);
+            CreatedAtActionResult scheduleCreatedResult = Assert.IsType<CreatedAtActionResult>(
+                result
+            );
+            Schedule returnedSchedule = Assert.IsType<Schedule>(scheduleCreatedResult.Value);
+            Guid guid = returnedSchedule.Guid;
+
+            var availabilityDto = new AvailabilityCreateDto
+            {
+                AvailabilitySlots = randomAvailability.AvailabilitySlots,
+                UserName = randomAvailability.UserName,
+                UserEmail = randomAvailability.UserEmail,
+                Preferences = randomAvailability.Preferences,
+                FormAnswers = randomAvailability.FormAnswers,
+            };
+
+            // Act
+            var availabilityCreateResult = await controller.CreateAvailability(
+                guid,
+                availabilityDto
+            );
+            var failedAvailabilityCreateResult = await controller.CreateAvailability(
+                Guid.Empty,
+                availabilityDto
+            );
+
+            // Assert
+            Assert.IsType<CreatedAtActionResult>(availabilityCreateResult);
+            Assert.IsType<NotFoundResult>(failedAvailabilityCreateResult);
+        }
+    }
+    //*/
 }
diff --git a/LineUp.Backend.Tests/SwapTests.cs b/LineUp.Backend.Tests/SwapTests.cs
new file mode 100644
index 0000000..218a24d
--- /dev/null
+++ b/LineUp.Backend.Tests/SwapTests.cs
@@ -0,0 +1,196 @@
+using System.Net;
+using System.Security.Claims;
+using Azure;
+using LineUp.Backend.Controllers;
+using LineUp.Backend.Models;
+using LineUp.Core.Models;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Moq;
+
+namespace LineUp.Backend.Tests;
+
+public class SwapTests
+{
+    Schedule sampleSchedule = new Schedule
+    {
+        Guid = Guid.Empty,
+        Auth0UserId = "always-test-on-schedule",
+        DateCoverage =
+        [
+            DateOnly.FromDateTime(DateTime.UtcNow),
+            DateOnly.FromDateTime(DateTime.UtcNow.AddDays(1)),
+            DateOnly.FromDateTime(DateTime.UtcNow.AddDays(2)),
+        ],
+        StartTime = new TimeOnly(9, 0),
+        EndTime = new TimeOnly(12, 0),
+        SchedulePreferences = new SchedulePreferences
+        {
+            MinutesPerSlot = 30,
+            ShiftIntervals = 30,
+            UsersPerShift = 1,
+            MaximumShiftDurationMinutes = 120,
+            MaximumShiftsPerWorker = 1,
+        },
+        Name = "Test Schedule",
+    };
+
+    Availability sample1 = new Availability
+    {
+        UserName = "Test Availability",
+        UserEmail = "test@email.com",
+        AvailabilitySlots =
+        [
+            // Day 0: 9:00 - 12:00
+            DateTime.UtcNow.Date.AddHours(9),
+            DateTime.UtcNow.Date.AddHours(9).AddMinutes(30),
+            DateTime.UtcNow.Date.AddHours(10),
+            DateTime.UtcNow.Date.AddHours(10).AddMinutes(30),
+            DateTime.UtcNow.Date.AddHours(11),
+            DateTime.UtcNow.Date.AddHours(11).AddMinutes(30),
+        ],
+        Schedule = new Schedule
+        {
+            Guid = Guid.Empty,
+            Auth0UserId = "replace this schedule",
+            DateCoverage = [],
+            StartTime = new TimeOnly(0, 0),
+            EndTime = new TimeOnly(0, 0),
+            SchedulePreferences = new SchedulePreferences
+            {
+                MinutesPerSlot = 30,
+                ShiftIntervals = 30,
+                UsersPerShift = 1,
+                MaximumShiftDurationMinutes = 120,
+                MaximumShiftsPerWorker = 1,
+            },
+            Name = "ReplaceThisScheduleWithSampleSchedule",
+        },
+        Preferences = new AvailabilityPreferences(),
+    };
+    Availability sample2 = new Availability
+    {
+        UserName = "Test Availability",
+        UserEmail = "test@email.com",
+        AvailabilitySlots =
+        [
+            // Day 1: 9:00 - 12:00
+            DateTime.UtcNow.Date.AddDays(1).AddHours(9),
+            DateTime.UtcNow.Date.AddDays(1).AddHours(9).AddMinutes(30),
+            DateTime.UtcNow.Date.AddDays(1).AddHours(10),
+            DateTime.UtcNow.Date.AddDays(1).AddHours(10).AddMinutes(30),
+            DateTime.UtcNow.Date.AddDays(1).AddHours(11),
+            DateTime.UtcNow.Date.AddDays(1).AddHours(11).AddMinutes(30),
+        ],
+        Schedule = new Schedule
+        {
+            Guid = Guid.Empty,
+            Auth0UserId = "replace this schedule",
+            DateCoverage = [],
+            StartTime = new TimeOnly(0, 0),
+            EndTime = new TimeOnly(0, 0),
+            SchedulePreferences = new SchedulePreferences
+            {
+                MinutesPerSlot = 30,
+                ShiftIntervals = 30,
+                UsersPerShift = 1,
+                MaximumShiftDurationMinutes = 120,
+                MaximumShiftsPerWorker = 1,
+            },
+            Name = "ReplaceThisScheduleWithSampleSchedule",
+        },
+        Preferences = new AvailabilityPreferences(),
+    };
+    Availability sample3 = new Availability
+    {
+        UserName = "Test Availability",
+        UserEmail = "test@email.com",
+        AvailabilitySlots =
+        [
+            // Day 2: 9:00 - 12:00
+            DateTime.UtcNow.Date.AddDays(2).AddHours(9),
+            DateTime.UtcNow.Date.AddDays(2).AddHours(9).AddMinutes(30),
+            DateTime.UtcNow.Date.AddDays(2).AddHours(10),
+            DateTime.UtcNow.Date.AddDays(2).AddHours(10).AddMinutes(30),
+            DateTime.UtcNow.Date.AddDays(2).AddHours(11),
+            DateTime.UtcNow.Date.AddDays(2).AddHours(11).AddMinutes(30),
+        ],
+        Schedule = new Schedule
+        {
+            Guid = Guid.Empty,
+            Auth0UserId = "replace this schedule",
+            DateCoverage = [],
+            StartTime = new TimeOnly(0, 0),
+            EndTime = new TimeOnly(0, 0),
+            SchedulePreferences = new SchedulePreferences
+            {
+                MinutesPerSlot = 30,
+                ShiftIntervals = 30,
+                UsersPerShift = 1,
+                MaximumShiftDurationMinutes = 120,
+                MaximumShiftsPerWorker = 1,
+            },
+            Name = "ReplaceThisScheduleWithSampleSchedule",
+        },
+        Preferences = new AvailabilityPreferences(),
+    };
+
+    //[Fact]
+    public async Task SwapAccepted_Test()
+    {
+        // Arrange
+        var options = new DbContextOptionsBuilder<LineUpContext>()
+            .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+            .Options;
+
+        using (var context = new LineUpContext(options))
+        {
+            context.Database.EnsureCreated();
+
+            var controller = new ScheduleController(context);
+
+            // Create a mock ClaimsPrincipal with the required NameIdentifier claim
+            var claims = new List<Claim> { new Claim(ClaimTypes.NameIdentifier, "test-user-123") };
+            var identity = new ClaimsIdentity(claims);
+            var principal = new ClaimsPrincipal(identity);
+            controller.ControllerContext = new ControllerContext
+            {
+                HttpContext = new DefaultHttpContext { User = principal },
+            };
+
+            var scheduleDto = new ScheduleDto
+            {
+                DateCoverage = sampleSchedule.DateCoverage,
+                StartTime = sampleSchedule.StartTime,
+                EndTime = sampleSchedule.EndTime,
+                SchedulePreferences = sampleSchedule.SchedulePreferences,
+                Name = sampleSchedule.Name,
+            };
+            var result = await controller.CreateSchedule(scheduleDto);
+            CreatedAtActionResult scheduleCreatedResult = Assert.IsType<CreatedAtActionResult>(
+                result
+            );
+            Schedule returnedSchedule = Assert.IsType<Schedule>(scheduleCreatedResult.Value);
+            Guid guid = returnedSchedule.Guid;
+
+            var availability1Dto = new AvailabilityCreateDto
+            {
+                AvailabilitySlots = sample1.AvailabilitySlots,
+                UserName = sample1.UserName,
+                UserEmail = sample1.UserEmail,
+                Preferences = sample1.Preferences,
+                FormAnswers = sample1.FormAnswers,
+            };
+            var availabilityCreateResult = await controller.CreateAvailability(
+                guid,
+                availability1Dto
+            );
+
+            // Act
+
+            // Assert
+            Assert.IsType<CreatedAtActionResult>(availabilityCreateResult);
+        }
+    }
+}
diff --git a/LineUp.Backend/Controllers/ScheduleController.cs b/LineUp.Backend/Controllers/ScheduleController.cs
index db6fbe5..f2d291c 100644
--- a/LineUp.Backend/Controllers/ScheduleController.cs
+++ b/LineUp.Backend/Controllers/ScheduleController.cs
@@ -1,9 +1,12 @@
+using System.Diagnostics;
 using System.Security.Claims;
 using LineUp.Backend.Models;
 using LineUp.Core.Models;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
+using NuGet.Protocol;
+using SQLitePCL;
 
 namespace LineUp.Backend.Controllers;
 
@@ -274,29 +277,60 @@ public async Task<IActionResult> GetAvailability(Guid guid, [FromQuery] string e
     }
 
     [HttpPost("{guid:guid}/requestSwap")]
-    public IActionResult RequestSwap(Guid guid, [FromBody] List<ShiftAssignment> shiftCollection)
+    public async Task<IActionResult> RequestSwap(Guid guid, [FromBody] DateTime[] shiftStartTimes)
     {
         Schedule? schedule = context.Schedules.FirstOrDefault<Schedule>(s => s.Guid == guid);
-        if (schedule == null || shiftCollection == null || shiftCollection[0] == null)
+        if (schedule == null || shiftStartTimes == null || !shiftStartTimes.Any())
         {
             return NotFound();
         }
+        List<ShiftAssignment> shiftCollection = new List<ShiftAssignment>();
+        var scheduleResult = await context.Schedules.FirstOrDefaultAsync(s => s.Guid == guid);
+
+        if (scheduleResult == null)
+            return BadRequest("The provided schedule could not be found.");
+        int scheduleID = scheduleResult.Id;
+
+        try
+        { //Attempt to find the shift assignments from the backend.
+            foreach (DateTime start in shiftStartTimes)
+            {
+                var result = await context
+                    .ShiftAssignments.Include(a => a.AvailabilityDbId)
+                    .FirstOrDefaultAsync(s => s.StartTime == start && s.ScheduleId == scheduleID); //**TODO: This will not work if there is more than one worker per shift.**
+                Console.WriteLine(result.ToJson());
+                if (result == null || result is not ShiftAssignment) // throw an error if no shift assigned at that time
+                    throw new FileNotFoundException();
+                else
+                    shiftCollection.Add(result);
+            }
+        }
+        catch (FileNotFoundException e)
+        {
+            return UnprocessableEntity(
+                "The database did not recognize one or more of the times as shifts."
+            );
+        }
+        if (shiftCollection.Count < 1)
+            return UnprocessableEntity("No shift assignments were found for the time specified.");
+
         //Sort through the shifts (assume an unsorted list)
-        Availability partyA = shiftCollection[0].Availability;
+        Console.WriteLine(shiftCollection.ToJson());
+        int partyAId = (int)shiftCollection[0].AvailabilityDbId;
         List<ShiftAssignment> partyAShifts = [];
-        Availability partyB = null;
+        int partyBId = -1;
         List<ShiftAssignment> partyBShifts = [];
         foreach (ShiftAssignment shift in shiftCollection)
         {
-            Availability shiftOwner = shift.Availability;
-            if (shiftOwner == partyA)
-                partyAShifts.Append(shift);
-            else if (partyB == null)
+            int shiftOwner = (int)shift.AvailabilityDbId;
+            if (shiftOwner == partyAId)
+                partyAShifts.Add(shift);
+            else if (partyBId == -1)
             {
-                partyB = shiftOwner;
-                partyBShifts.Append(shift);
+                partyBId = shiftOwner;
+                partyBShifts.Add(shift);
             }
-            else if (shiftOwner == partyB)
+            else if (shiftOwner == partyBId)
                 partyBShifts.Append(shift);
             else
                 return BadRequest("More than two parties identified");
diff --git a/aspire.config.json b/aspire.config.json
new file mode 100644
index 0000000..515419f
--- /dev/null
+++ b/aspire.config.json
@@ -0,0 +1,5 @@
+{
+  "appHost": {
+    "path": "LineUp.AppHost/LineUp.AppHost.csproj"
+  }
+}
\ No newline at end of file
diff --git a/lineup-client/src/pages/NewSchedule.tsx b/lineup-client/src/pages/NewSchedule.tsx
index 474a125..e01d955 100644
--- a/lineup-client/src/pages/NewSchedule.tsx
+++ b/lineup-client/src/pages/NewSchedule.tsx
@@ -400,6 +400,21 @@ const NewSchedule = () => {
             onChange={handleInputChange}
           />
         </div>
+        {/* <div>
+          <label htmlFor="AllowSwaps">Allow workers to swap shifts?</label>
+          <br />
+          <input
+            className="input"
+            type="number"
+            id="maxShifts"
+            name="maxShifts"
+            step="1"
+            min="1"
+            max="99999"
+            value={scheduleData.maxShifts ?? ""}
+            onChange={handleInputChange}
+          />
+        </div>  ========== use this to let the schedule creator enable a swap ====*/}
         <br />
         <div className="submitContainer">
           <button type="submit" className="submitBtn" disabled={createScheduleMutation.isPending}>
diff --git a/lineup-client/src/pages/RequestSwap.tsx b/lineup-client/src/pages/RequestSwap.tsx
index cfc370e..e68f415 100644
--- a/lineup-client/src/pages/RequestSwap.tsx
+++ b/lineup-client/src/pages/RequestSwap.tsx
@@ -17,13 +17,13 @@ const RequestSwap = () => {
   const backgroundColors = Array.from({ length: 10 }, (_, i) => `hsl(${Math.round((360 / 10) * i)}, 100%, 80%)`);
   // console.log(backgroundColors);
 
-  // console.log(data);
+  console.log(data);
 
   const [email, setEmail] = useState<string>("");
   const [selectedCells, setSelectedCells] = useState<string[]>([]);
   const [userFound, setUserFound] = useState<boolean>(false);
   const [swapPartner, setSwapPartner] = useState<string>("");
-  const [swapPartnerGuid, setSwapPartnerGuid] = useState<string>("");
+  const [swapPartnerAvailabilityId, setSwapPartnerAvailabilityId] = useState<number>(-1);
 
   const confirmEmailmutation = useMutation({
     //
@@ -57,10 +57,10 @@ const RequestSwap = () => {
         },
       });
 
-      shifts.forEach((element) => {
-        //note each shift assignment
-        console.log(element);
-      });
+      // shifts.forEach((element) => {
+      //   //note each shift assignment
+      //   console.log(element);
+      // });
 
       if (!res.ok) {
         throw new Error("Failed to create Swap Request");
@@ -111,20 +111,26 @@ const RequestSwap = () => {
     setEmail(value);
   };
 
-  const renderPartnerSelect = (name: string, guid: string) => (
+  const renderPartnerSelect = (name: string, id: number) => (
     <>
       <button
         className="scheduleBtn"
         onClick={() => {
           setSwapPartner(name);
-          setSwapPartnerGuid(guid);
+          setSwapPartnerAvailabilityId(id);
         }}
       >
         {name}
       </button>
+      {console.log("name = " + name + " and id = " + id)}
     </>
   );
 
+  type AvailabilityObject = {
+    name: string;
+    AvailabilityDbId: number;
+  };
+
   return (
     <div className="availabilityRoot">
       <>
@@ -174,8 +180,14 @@ const RequestSwap = () => {
                 <div className="swapPartnerLabel">
                   <label>Swapping with:</label>
                   <label>
-                    {/* {data.shiftAssignments.map(() => renderPartnerSelect())}
-                    {renderPartnerSelect(data.shiftAssignments.name, data.shiftAssignments.AvailabilityDbId)} */}
+                    {data.shiftAssignments.map((availabilityDbId: number, username: string) =>
+                      renderPartnerSelect(username, availabilityDbId),
+                    )}
+                    {/* {data.shiftAssignments.forEach((element) => {
+                      //note each shift assignment
+                      renderPartnerSelect(element.username, element.availabilityDbId);
+                      console.log(element);
+                    })} */}
                   </label>
                 </div>
                 <button type="submit" className="scheduleBtn swapBtn">

From bb55aa625d4934e0153c7e49aef1c482607973e6 Mon Sep 17 00:00:00 2001
From: lop4cwru <lop4@case.edu>
Date: Sat, 18 Apr 2026 01:08:12 -0400
Subject: [PATCH 09/17] name selection yayy

---
 lineup-client/src/pages/RequestSwap.tsx | 83 +++++++++++++++----------
 1 file changed, 49 insertions(+), 34 deletions(-)

diff --git a/lineup-client/src/pages/RequestSwap.tsx b/lineup-client/src/pages/RequestSwap.tsx
index e68f415..d969b68 100644
--- a/lineup-client/src/pages/RequestSwap.tsx
+++ b/lineup-client/src/pages/RequestSwap.tsx
@@ -2,9 +2,10 @@ import { Calendar } from "@/components/Calendar";
 import { ColoredCell, FillableCell } from "@/components/CalendarCells";
 import { MousePopup } from "@/components/MousePopup";
 import { useApi } from "@/utils/api";
-import { addToasts, loaderQuery } from "@/utils/db";
+import { addToasts, unauthorizedLoaderQuery } from "@/utils/db";
 import { parseTimeString } from "@/utils/time";
 import { useMutation, useQuery } from "@tanstack/react-query";
+import React from "react";
 import { useState } from "react";
 import { useNavigate, useParams } from "react-router";
 
@@ -12,18 +13,17 @@ const RequestSwap = () => {
   const navigate = useNavigate();
   const { fetchWithAuth } = useApi();
   const { guid } = useParams();
-  const { data } = useQuery(loaderQuery("/api/schedule/{}", guid!));
+  const { data } = useQuery(unauthorizedLoaderQuery("/api/schedule/{}", guid!));
   const [focusedTime, setFocusedTime] = useState<string | null>(null);
   const backgroundColors = Array.from({ length: 10 }, (_, i) => `hsl(${Math.round((360 / 10) * i)}, 100%, 80%)`);
   // console.log(backgroundColors);
 
-  console.log(data);
+  // console.log(data);
 
   const [email, setEmail] = useState<string>("");
   const [selectedCells, setSelectedCells] = useState<string[]>([]);
-  const [userFound, setUserFound] = useState<boolean>(false);
-  const [swapPartner, setSwapPartner] = useState<string>("");
-  const [swapPartnerAvailabilityId, setSwapPartnerAvailabilityId] = useState<number>(-1);
+  const [userId, setUserId] = useState<number | null>(null);
+  const [selectedSwapPartnerAvailabilityId, setSelectedSwapPartnerAvailabilityId] = useState<number | null>(null);
 
   const confirmEmailmutation = useMutation({
     //
@@ -41,7 +41,7 @@ const RequestSwap = () => {
       return resJson;
     },
     onSuccess: (resJson) => {
-      setUserFound(true);
+      setUserId(resJson.id);
       // setSelectedCells(resJson.availabilitySlots); //This would make all the availiability light up at the start, but that feels confusing if others have shifts at that time.
     },
   });
@@ -111,33 +111,35 @@ const RequestSwap = () => {
     setEmail(value);
   };
 
-  const renderPartnerSelect = (name: string, id: number) => (
-    <>
-      <button
-        className="scheduleBtn"
-        onClick={() => {
-          setSwapPartner(name);
-          setSwapPartnerAvailabilityId(id);
-        }}
-      >
-        {name}
-      </button>
-      {console.log("name = " + name + " and id = " + id)}
-    </>
-  );
-
-  type AvailabilityObject = {
-    name: string;
-    AvailabilityDbId: number;
-  };
+  // const respondentNames = Array.from(
+  //   new Set(
+  //     (data.shiftAssignments as { userName: string; availabilityDbId: number }[]).map((shift) => ({
+  //       userName: shift.userName,
+  //       id: shift.availabilityDbId,
+  //     })),
+  //   ),
+  // );
 
+  const respondentNames: { name: string; id: number }[] = data.shiftAssignments.reduce(
+    (nameSet: { name: string; id: number }[], assignment: any) => {
+      if (
+        nameSet.every(
+          (existingName) => existingName.id !== assignment.availabilityDbId,
+        ) /*&& assignment.availabilityDbId != */
+      ) {
+        nameSet.push({ name: assignment.userName, id: assignment.availabilityDbId });
+      }
+      return nameSet;
+    },
+    [],
+  );
   return (
     <div className="availabilityRoot">
       <>
         <div className="scheduleName">
           Schedule for <b>{data.name}</b>
         </div>
-        {userFound ? (
+        {userId !== null ? (
           <>
             <div>
               <em>Please select the shifts that you would like to swap.</em>
@@ -179,16 +181,29 @@ const RequestSwap = () => {
               <div>
                 <div className="swapPartnerLabel">
                   <label>Swapping with:</label>
-                  <label>
+                  {/* <label>
                     {data.shiftAssignments.map((availabilityDbId: number, username: string) =>
                       renderPartnerSelect(username, availabilityDbId),
                     )}
-                    {/* {data.shiftAssignments.forEach((element) => {
-                      //note each shift assignment
-                      renderPartnerSelect(element.username, element.availabilityDbId);
-                      console.log(element);
-                    })} */}
-                  </label>
+                  </label> */}
+                  <div className="respondentList">
+                    <ul>
+                      {respondentNames.map((shift) => (
+                        <li
+                          key={shift.id}
+                          className={selectedSwapPartnerAvailabilityId === shift.id ? "selectedRespondent" : ""}
+                          onClick={() => {
+                            setSelectedSwapPartnerAvailabilityId((prev) => {
+                              console.log(`selected name: ${shift.name}, selected id: ${shift.id}`);
+                              return prev === shift.id ? null : shift.id;
+                            });
+                          }}
+                        >
+                          {shift.name}
+                        </li>
+                      ))}
+                    </ul>
+                  </div>
                 </div>
                 <button type="submit" className="scheduleBtn swapBtn">
                   Submit

From f7a95647f47869ea79caf276ae15bc01fef266e7 Mon Sep 17 00:00:00 2001
From: Rembi Time <rembitime@gmail.com>
Date: Sat, 18 Apr 2026 01:23:48 -0400
Subject: [PATCH 10/17] Add the ability to specify which cells are selectable

---
 lineup-client/src/components/Calendar.tsx      | 11 ++++++++++-
 lineup-client/src/components/CalendarCells.tsx |  5 +++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/lineup-client/src/components/Calendar.tsx b/lineup-client/src/components/Calendar.tsx
index 34565bc..5551bc6 100644
--- a/lineup-client/src/components/Calendar.tsx
+++ b/lineup-client/src/components/Calendar.tsx
@@ -22,6 +22,7 @@ interface CalendarProps {
   setFocusedCell?: React.Dispatch<React.SetStateAction<string | null>>;
   selectedCells?: string[];
   setSelectedCells?: React.Dispatch<React.SetStateAction<string[]>>;
+  selectableCells?: string[];
 }
 
 // Children are each cell of the calendar
@@ -35,6 +36,7 @@ const Calendar = ({
   text,
   selectedCells,
   setSelectedCells,
+  selectableCells,
 }: CalendarProps) => {
   const [isPointerDown, setIsPointerDown] = useState(false);
   const [isEnablingCells, setIsEnablingCells] = useState(false);
@@ -42,6 +44,12 @@ const Calendar = ({
   const numRows = calculateNumRows();
   const pageDates = getPageDates(currentPage);
 
+  useEffect(() => {
+    if (setSelectedCells && selectableCells) {
+      setSelectedCells((cells) => cells.filter((cell) => selectableCells.includes(cell)));
+    }
+  }, [selectableCells, setSelectedCells]);
+
   // Calculates the number of rows a calender should have based on the time range and minutes per cell
   function calculateNumRows() {
     if (rangeIs24Hours(range)) {
@@ -205,7 +213,7 @@ const Calendar = ({
             className="calendarLabel unstyledButton"
             style={extraColMargin(col)}
             onClick={() => colClicked(date)}
-            disabled={!setSelectedCells}
+            disabled={!setSelectedCells || selectableCells !== undefined}
           >
             {dayNumberToWeekday(date.getDay())}
             <br />
@@ -235,6 +243,7 @@ const Calendar = ({
                   date={date}
                   selectedCells={selectedCells}
                   setSelectedCells={setSelectedCells}
+                  selectableCells={selectableCells}
                   isPointerDown={isPointerDown}
                   setIsPointerDown={setIsPointerDown}
                   isEnablingCells={isEnablingCells}
diff --git a/lineup-client/src/components/CalendarCells.tsx b/lineup-client/src/components/CalendarCells.tsx
index 514d656..7e786e5 100644
--- a/lineup-client/src/components/CalendarCells.tsx
+++ b/lineup-client/src/components/CalendarCells.tsx
@@ -7,6 +7,7 @@ export interface CalendarCellProps {
   date: Date;
   selectedCells?: string[];
   setSelectedCells?: React.Dispatch<React.SetStateAction<string[]>>;
+  selectableCells?: string[];
   isPointerDown: boolean;
   setIsPointerDown: React.Dispatch<React.SetStateAction<boolean>>;
   isEnablingCells: boolean;
@@ -21,11 +22,13 @@ const FillableCell = ({
   date,
   selectedCells,
   setSelectedCells,
+  selectableCells,
   isPointerDown,
   setIsPointerDown,
   isEnablingCells,
   setIsEnablingCells,
   text,
+  colors,
 }: CalendarCellProps) => {
   const dateString = standardizeDateAndTime(date, time);
   const isClicked = selectedCells?.includes(dateString);
@@ -78,6 +81,8 @@ const FillableCell = ({
       onPointerEnter={onPointerEnter}
       onPointerMove={onPointerMove}
       className={"unstyledButton calendarInnerCell" + (isClicked ? " clicked" : "")}
+      style={{ backgroundColor: !isClicked ? (colors[dateString] ?? "transparent") : undefined }}
+      disabled={!selectableCells?.includes(dateString)}
       title={dayNumberToWeekday(date.getDay()) + " " + formatTime(time)}
     >
       {text[dateString] ?? ""}

From b77634bf3151b09eb45b3793b6179e07870cc778 Mon Sep 17 00:00:00 2001
From: lop4cwru <lop4@case.edu>
Date: Mon, 20 Apr 2026 04:42:20 -0400
Subject: [PATCH 11/17] who up data transferring they object

meeee

- I made a DTO for the swap request that takes in the necessary info to be sent to the backend. It comes with a corressponding type on the frontend (`CreateSwapRequestProps`) that stores start times, requesterID, and recipient ID.

- I also attempted to make selection colors w/ Rhyder's help, but it doesn't work so well since the calendar object assigns color based on string rather than AvailDbId's. So schedules w/ multiple people will not cooperate.
---
 .../Controllers/ScheduleController.cs         |  7 +-
 LineUp.Backend/Models/SwapRequestDto.cs       | 12 ++++
 lineup-client/src/pages/RequestSwap.tsx       | 67 ++++++++++++++++---
 3 files changed, 73 insertions(+), 13 deletions(-)
 create mode 100644 LineUp.Backend/Models/SwapRequestDto.cs

diff --git a/LineUp.Backend/Controllers/ScheduleController.cs b/LineUp.Backend/Controllers/ScheduleController.cs
index 8b4c902..c17cb9e 100644
--- a/LineUp.Backend/Controllers/ScheduleController.cs
+++ b/LineUp.Backend/Controllers/ScheduleController.cs
@@ -311,9 +311,12 @@ public async Task<IActionResult> GetAvailability(Guid guid, [FromQuery] string e
         return StatusCode(StatusCodes.Status406NotAcceptable);
     }
 
-    [HttpPost("{guid:guid}/requestSwap")]
-    public async Task<IActionResult> RequestSwap(Guid guid, [FromBody] DateTime[] shiftStartTimes)
+    [HttpPost("{guid:guid}/requestSwap/{requesterId:int}/{recipientId:int}")]
+    public async Task<IActionResult> RequestSwap(Guid guid, [FromBody] SwapRequestDto request)
     {
+        DateTime[] shiftStartTimes = request.shiftStartTimes;
+        int requesterId = request.RequesterId;
+        int recipientId = request.RecipientId;
         Schedule? schedule = context.Schedules.FirstOrDefault<Schedule>(s => s.Guid == guid);
         if (schedule == null || shiftStartTimes == null || !shiftStartTimes.Any())
         {
diff --git a/LineUp.Backend/Models/SwapRequestDto.cs b/LineUp.Backend/Models/SwapRequestDto.cs
new file mode 100644
index 0000000..6a06ffe
--- /dev/null
+++ b/LineUp.Backend/Models/SwapRequestDto.cs
@@ -0,0 +1,12 @@
+using LineUp.Core.Models;
+
+namespace LineUp.Backend.Models;
+
+public class SwapRequestDto
+{
+    public DateTime[] shiftStartTimes { get; set; }
+
+    public int RequesterId { get; set; }
+
+    public int RecipientId { get; set; }
+}
diff --git a/lineup-client/src/pages/RequestSwap.tsx b/lineup-client/src/pages/RequestSwap.tsx
index d969b68..1ebdf3f 100644
--- a/lineup-client/src/pages/RequestSwap.tsx
+++ b/lineup-client/src/pages/RequestSwap.tsx
@@ -24,6 +24,7 @@ const RequestSwap = () => {
   const [selectedCells, setSelectedCells] = useState<string[]>([]);
   const [userId, setUserId] = useState<number | null>(null);
   const [selectedSwapPartnerAvailabilityId, setSelectedSwapPartnerAvailabilityId] = useState<number | null>(null);
+  const [selectedSwapPartner, setSelectedSwapPartner] = useState<string | null>(null);
 
   const confirmEmailmutation = useMutation({
     //
@@ -46,21 +47,27 @@ const RequestSwap = () => {
     },
   });
 
+  type CreateSwapRequestProps = {
+    shiftStartTimes: string[];
+    requesterId: number;
+    recipientId: number | null;
+  };
+
   const CreateSwapRequestMutation = useMutation({
     //creates a SwapRequest in the DB
-    mutationFn: async (shifts: string[]) => {
+    mutationFn: async (swapRequest: CreateSwapRequestProps) => {
+      if (swapRequest.recipientId == null) {
+        throw new Error("Failed to create Swap Request: Recipient not specified");
+      }
       const res = await fetchWithAuth(`/api/schedule/${guid}/requestSwap`, {
         method: "POST",
-        body: JSON.stringify(shifts),
+        body: JSON.stringify(swapRequest),
         headers: {
           "Content-Type": "application/json",
         },
       });
 
-      // shifts.forEach((element) => {
-      //   //note each shift assignment
-      //   console.log(element);
-      // });
+      // console.log(JSON.stringify(swapRequest));
 
       if (!res.ok) {
         throw new Error("Failed to create Swap Request");
@@ -75,6 +82,7 @@ const RequestSwap = () => {
 
   const scheduleGenerated = true;
   const [assignmentColors, assignmentText] = mapAssignments();
+  const selectionColors = mapSelectionColors();
 
   function mapAssignments() {
     const colors: { [key: string]: string } = {};
@@ -106,6 +114,37 @@ const RequestSwap = () => {
     return [colors, text];
   }
 
+  function mapSelectionColors() {
+    const colors: { [key: string]: string } = {};
+
+    if (userId === null) {
+      return colors;
+    }
+
+    return colors;
+
+    /*
+    // this needs to be based on AvailDbIds instead of off of strings :D
+    for (const time of Object.keys(assignmentText)) {
+      // if it's mine make it a thing and if its another's make it diff
+      if (assignmentText[time] == ) {
+        colors[time] = `hsl(${Math.round((360 / 10) * 1)}, 100%, 80%)`;
+      } else if (assignmentText[time] == selectedSwapPartner) {
+        colors[time] = `hsl(${Math.round((360 / 10) * 2)}, 100%, 80%)`;
+      }
+
+      // if (text[time] in nameToColor) {
+      //   colors[time] = nameToColor[text[time]];
+      // } else {
+      //   nameToColor[text[time]] = backgroundColors[numColors % backgroundColors.length];
+      //   colors[time] = backgroundColors[numColors % backgroundColors.length];
+      //   numColors++;
+      // }
+    }
+    return colors;
+      //*/
+  }
+
   const handleInputChange = (event: React.ChangeEvent<HTMLInputElement | HTMLSelectElement>) => {
     const { value } = event.target;
     setEmail(value);
@@ -123,9 +162,8 @@ const RequestSwap = () => {
   const respondentNames: { name: string; id: number }[] = data.shiftAssignments.reduce(
     (nameSet: { name: string; id: number }[], assignment: any) => {
       if (
-        nameSet.every(
-          (existingName) => existingName.id !== assignment.availabilityDbId,
-        ) /*&& assignment.availabilityDbId != */
+        nameSet.every((existingName) => existingName.id !== assignment.availabilityDbId) &&
+        assignment.availabilityDbId != userId
       ) {
         nameSet.push({ name: assignment.userName, id: assignment.availabilityDbId });
       }
@@ -150,7 +188,11 @@ const RequestSwap = () => {
               onSubmit={(event: React.SubmitEvent<HTMLFormElement>) => {
                 event.preventDefault();
                 addToasts(
-                  CreateSwapRequestMutation.mutateAsync(selectedCells),
+                  CreateSwapRequestMutation.mutateAsync({
+                    shiftStartTimes: selectedCells,
+                    requesterId: userId,
+                    recipientId: selectedSwapPartnerAvailabilityId,
+                  }),
                   undefined,
                   "Request created! Please check your email to authenticate this request.",
                 ); //remove success message
@@ -174,7 +216,7 @@ const RequestSwap = () => {
                   start: parseTimeString(data.startTime)!,
                   end: parseTimeString(data.endTime)!,
                 }}
-                colors={assignmentColors}
+                colors={/*selectionColors*/ assignmentColors}
                 text={assignmentText}
                 setFocusedCell={setFocusedTime}
               />
@@ -197,6 +239,9 @@ const RequestSwap = () => {
                               console.log(`selected name: ${shift.name}, selected id: ${shift.id}`);
                               return prev === shift.id ? null : shift.id;
                             });
+                            setSelectedSwapPartner((prev) => {
+                              return prev === shift.name ? null : shift.name;
+                            });
                           }}
                         >
                           {shift.name}

From a1f2a98927f732ff3ccb32d2604a2e03ea94f287 Mon Sep 17 00:00:00 2001
From: lop4cwru <lop4@case.edu>
Date: Mon, 20 Apr 2026 04:44:24 -0400
Subject: [PATCH 12/17] A reasonable man does not transmit all the important
 data in the URL

why did I think this would work? Anyway it's redudndant bc we have dto now.
---
 LineUp.Backend/Controllers/ScheduleController.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/LineUp.Backend/Controllers/ScheduleController.cs b/LineUp.Backend/Controllers/ScheduleController.cs
index c17cb9e..51e8f7f 100644
--- a/LineUp.Backend/Controllers/ScheduleController.cs
+++ b/LineUp.Backend/Controllers/ScheduleController.cs
@@ -311,7 +311,7 @@ public async Task<IActionResult> GetAvailability(Guid guid, [FromQuery] string e
         return StatusCode(StatusCodes.Status406NotAcceptable);
     }
 
-    [HttpPost("{guid:guid}/requestSwap/{requesterId:int}/{recipientId:int}")]
+    [HttpPost("{guid:guid}/requestSwap")]
     public async Task<IActionResult> RequestSwap(Guid guid, [FromBody] SwapRequestDto request)
     {
         DateTime[] shiftStartTimes = request.shiftStartTimes;

From 14a5602d29d79e2cc1cbe609e0e2cef5d5a38d7b Mon Sep 17 00:00:00 2001
From: lop4cwru <lop4@case.edu>
Date: Mon, 20 Apr 2026 06:38:17 -0400
Subject: [PATCH 13/17] IT MAKES THEM EXIST IN DA BACKEND FINALLY :DDDDDD

- I need to still validate a couple things:
    - atm, the system does not check to make sure that all selected times belong to either the requester or the recipient of the swap request. But it does make sure that any selected shifts that belong to the requester or the recipient will be added to the backend request. So, it's like... kinda working.
---
 .../Controllers/ScheduleController.cs         | 67 +++++++++----------
 LineUp.Backend/Models/SwapRequestDto.cs       |  6 +-
 2 files changed, 36 insertions(+), 37 deletions(-)

diff --git a/LineUp.Backend/Controllers/ScheduleController.cs b/LineUp.Backend/Controllers/ScheduleController.cs
index 51e8f7f..e1343ef 100644
--- a/LineUp.Backend/Controllers/ScheduleController.cs
+++ b/LineUp.Backend/Controllers/ScheduleController.cs
@@ -317,30 +317,47 @@ public async Task<IActionResult> RequestSwap(Guid guid, [FromBody] SwapRequestDt
         DateTime[] shiftStartTimes = request.shiftStartTimes;
         int requesterId = request.RequesterId;
         int recipientId = request.RecipientId;
+
         Schedule? schedule = context.Schedules.FirstOrDefault<Schedule>(s => s.Guid == guid);
         if (schedule == null || shiftStartTimes == null || !shiftStartTimes.Any())
         {
-            return NotFound();
+            return BadRequest("Request does not specify all necessary fields.");
         }
-        List<ShiftAssignment> shiftCollection = new List<ShiftAssignment>();
+        List<ShiftAssignment> requesterShiftCollection = new List<ShiftAssignment>();
+        List<ShiftAssignment> recipientShiftCollection = new List<ShiftAssignment>();
         var scheduleResult = await context.Schedules.FirstOrDefaultAsync(s => s.Guid == guid);
 
         if (scheduleResult == null)
-            return BadRequest("The provided schedule could not be found.");
+            return NotFound("The provided schedule could not be found.");
         int scheduleID = scheduleResult.Id;
 
         try
         { //Attempt to find the shift assignments from the backend.
             foreach (DateTime start in shiftStartTimes)
             {
-                var result = await context
-                    .ShiftAssignments.Include(a => a.AvailabilityDbId)
-                    .FirstOrDefaultAsync(s => s.StartTime == start && s.ScheduleId == scheduleID); //**TODO: This will not work if there is more than one worker per shift.**
-                Console.WriteLine(result.ToJson());
-                if (result == null || result is not ShiftAssignment) // throw an error if no shift assigned at that time
-                    throw new FileNotFoundException();
-                else
-                    shiftCollection.Add(result);
+                var result = await context.ShiftAssignments.FirstOrDefaultAsync(s =>
+                    s.ScheduleId == scheduleID
+                    && s.StartTime == start
+                    && s.Availability.Id == requesterId
+                );
+                Console.WriteLine("\n Found Requester Shift: " + result.ToJson());
+                // if (result == null || result is not ShiftAssignment) // throw an error if no shift assigned at that time
+                //     throw new FileNotFoundException();
+                if (result != null)
+                    requesterShiftCollection.Add(result);
+            }
+
+            foreach (DateTime start in shiftStartTimes)
+            {
+                var result = await context.ShiftAssignments.FirstOrDefaultAsync(s =>
+                    s.ScheduleId == scheduleID
+                    && s.StartTime == start
+                    && s.Availability.Id == recipientId
+                );
+                // if (result == null || result is not ShiftAssignment) // throw an error if no shift assigned at that time
+                //     throw new FileNotFoundException();
+                if (result != null)
+                    recipientShiftCollection.Add(result);
             }
         }
         catch (FileNotFoundException e)
@@ -349,36 +366,18 @@ public async Task<IActionResult> RequestSwap(Guid guid, [FromBody] SwapRequestDt
                 "The database did not recognize one or more of the times as shifts."
             );
         }
-        if (shiftCollection.Count < 1)
+        if (requesterShiftCollection.Count < 1 && recipientShiftCollection.Count < 1)
             return UnprocessableEntity("No shift assignments were found for the time specified.");
 
         //Sort through the shifts (assume an unsorted list)
-        Console.WriteLine(shiftCollection.ToJson());
-        int partyAId = (int)shiftCollection[0].AvailabilityDbId;
-        List<ShiftAssignment> partyAShifts = [];
-        int partyBId = -1;
-        List<ShiftAssignment> partyBShifts = [];
-        foreach (ShiftAssignment shift in shiftCollection)
-        {
-            int shiftOwner = (int)shift.AvailabilityDbId;
-            if (shiftOwner == partyAId)
-                partyAShifts.Add(shift);
-            else if (partyBId == -1)
-            {
-                partyBId = shiftOwner;
-                partyBShifts.Add(shift);
-            }
-            else if (shiftOwner == partyBId)
-                partyBShifts.Append(shift);
-            else
-                return BadRequest("More than two parties identified");
-        }
+        Console.WriteLine(requesterShiftCollection.ToJson());
         SwapRequest swapRequest = new SwapRequest
         {
-            FromPartyA = partyAShifts,
-            FromPartyB = partyBShifts,
+            FromPartyA = requesterShiftCollection,
+            FromPartyB = recipientShiftCollection,
             Schedule = schedule,
         };
+        Console.WriteLine("\n Creating Swap Request: " + swapRequest.ToJson());
         context.SwapRequests.Add(swapRequest);
         context.SaveChanges();
         return Ok(swapRequest.Guid);
diff --git a/LineUp.Backend/Models/SwapRequestDto.cs b/LineUp.Backend/Models/SwapRequestDto.cs
index 6a06ffe..e02a017 100644
--- a/LineUp.Backend/Models/SwapRequestDto.cs
+++ b/LineUp.Backend/Models/SwapRequestDto.cs
@@ -4,9 +4,9 @@ namespace LineUp.Backend.Models;
 
 public class SwapRequestDto
 {
-    public DateTime[] shiftStartTimes { get; set; }
+    public required DateTime[] shiftStartTimes { get; set; }
 
-    public int RequesterId { get; set; }
+    public required int RequesterId { get; set; }
 
-    public int RecipientId { get; set; }
+    public required int RecipientId { get; set; }
 }

From 93a69aa4ff9b8b21bd416eb3f24b134c060a9887 Mon Sep 17 00:00:00 2001
From: lop4cwru <lop4@case.edu>
Date: Mon, 20 Apr 2026 06:57:56 -0400
Subject: [PATCH 14/17] Remembering to take out the unfinished availability
 test

---
 LineUp.Backend.Tests/CRUDTests.cs | 149 ------------------------------
 1 file changed, 149 deletions(-)

diff --git a/LineUp.Backend.Tests/CRUDTests.cs b/LineUp.Backend.Tests/CRUDTests.cs
index 42fbf26..ac6fda9 100644
--- a/LineUp.Backend.Tests/CRUDTests.cs
+++ b/LineUp.Backend.Tests/CRUDTests.cs
@@ -489,153 +489,4 @@ public async Task CreateRandomSchedule_Test()
             Assert.Equal(1, savedSchedules);
         }
     }
-    /*
-    [Fact]
-    public async Task CreateRandomAvailability_Test()
-    {
-        // Arrange
-        var options = new DbContextOptionsBuilder<LineUpContext>()
-            .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
-            .Options;
-
-        Random random = new Random();
-        int totalDays = random.Next(10);
-
-        List<DateOnly> randomCoverage = new List<DateOnly>();
-
-        for (int i = 0; i < totalDays; i++)
-        {
-            randomCoverage.Add(DateOnly.FromDateTime(DateTime.UtcNow.AddDays(i)));
-        }
-
-        Schedule randomSchedule = new Schedule
-        {
-            Guid = Guid.Empty,
-            Auth0UserId = "always-test-on-schedule",
-            DateCoverage = randomCoverage.ToArray(),
-            StartTime = new TimeOnly(9, 0),
-            EndTime = new TimeOnly(17, 0),
-            SchedulePreferences = new SchedulePreferences
-            {
-                MinutesPerSlot = 30,
-                ShiftIntervals = 30,
-                UsersPerShift = 1,
-                MaximumShiftDurationMinutes = 120,
-                MaximumShiftsPerWorker = 1,
-            },
-            Name = "Test Schedule",
-        };
-
-        List<DateTime> randomAvailSlots = new List<DateTime>();
-
-        for (int i = 0; i < totalDays; i++)
-        {
-            randomAvailSlots.Add(DateTime.UtcNow.Date.AddHours(9));
-            DateTime.UtcNow.Date.AddHours(9).AddMinutes(30);
-            DateTime.UtcNow.Date.AddHours(10);
-            DateTime.UtcNow.Date.AddHours(10).AddMinutes(30);
-            DateTime.UtcNow.Date.AddHours(11);
-            DateTime.UtcNow.Date.AddHours(11).AddMinutes(30);
-            randomCoverage.Add(DateOnly.FromDateTime(DateTime.UtcNow.AddDays(i)));
-        }
-
-        Availability randomAvailability = new Availability
-        {
-        UserName = "Test Availability",
-        UserEmail = "test@email.com",
-        AvailabilitySlots =
-        [
-            // Day 0: 9:00 - 12:00
-            DateTime.UtcNow.Date.AddHours(9),
-            DateTime.UtcNow.Date.AddHours(9).AddMinutes(30),
-            DateTime.UtcNow.Date.AddHours(10),
-            DateTime.UtcNow.Date.AddHours(10).AddMinutes(30),
-            DateTime.UtcNow.Date.AddHours(11),
-            DateTime.UtcNow.Date.AddHours(11).AddMinutes(30),
-            // Day 1: 13:00 - 17:00
-            DateTime.UtcNow.Date.AddDays(1).AddHours(13),
-            DateTime.UtcNow.Date.AddDays(1).AddHours(13).AddMinutes(30),
-            DateTime.UtcNow.Date.AddDays(1).AddHours(14),
-            DateTime.UtcNow.Date.AddDays(1).AddHours(14).AddMinutes(30),
-            DateTime.UtcNow.Date.AddDays(1).AddHours(15),
-            DateTime.UtcNow.Date.AddDays(1).AddHours(15).AddMinutes(30),
-            DateTime.UtcNow.Date.AddDays(1).AddHours(16),
-            DateTime.UtcNow.Date.AddDays(1).AddHours(16).AddMinutes(30),
-        ],
-        Schedule = new Schedule
-        {
-            Guid = Guid.Empty,
-            Auth0UserId = "replace this schedule",
-            DateCoverage = [],
-            StartTime = new TimeOnly(0, 0),
-            EndTime = new TimeOnly(0, 0),
-            SchedulePreferences = new SchedulePreferences
-            {
-                MinutesPerSlot = 30,
-                ShiftIntervals = 30,
-                UsersPerShift = 1,
-                MaximumShiftDurationMinutes = 120,
-                MaximumShiftsPerWorker = 1,
-            },
-            Name = "ReplaceThisScheduleWithSampleSchedule",
-        },
-        Preferences = new AvailabilityPreferences(),
-    };
-
-        using (var context = new LineUpContext(options))
-        {
-            context.Database.EnsureCreated();
-
-            var controller = new ScheduleController(context);
-
-            // Create a mock ClaimsPrincipal with the required NameIdentifier claim
-            var claims = new List<Claim> { new Claim(ClaimTypes.NameIdentifier, "test-user-123") };
-            var identity = new ClaimsIdentity(claims);
-            var principal = new ClaimsPrincipal(identity);
-            controller.ControllerContext = new ControllerContext
-            {
-                HttpContext = new DefaultHttpContext { User = principal },
-            };
-
-            var scheduleDto = new ScheduleDto
-            {
-                DateCoverage = randomSchedule.DateCoverage,
-                StartTime = randomSchedule.StartTime,
-                EndTime = randomSchedule.EndTime,
-                SchedulePreferences = randomSchedule.SchedulePreferences,
-                Name = randomSchedule.Name,
-            };
-
-            var result = await controller.CreateSchedule(scheduleDto);
-            CreatedAtActionResult scheduleCreatedResult = Assert.IsType<CreatedAtActionResult>(
-                result
-            );
-            Schedule returnedSchedule = Assert.IsType<Schedule>(scheduleCreatedResult.Value);
-            Guid guid = returnedSchedule.Guid;
-
-            var availabilityDto = new AvailabilityCreateDto
-            {
-                AvailabilitySlots = randomAvailability.AvailabilitySlots,
-                UserName = randomAvailability.UserName,
-                UserEmail = randomAvailability.UserEmail,
-                Preferences = randomAvailability.Preferences,
-                FormAnswers = randomAvailability.FormAnswers,
-            };
-
-            // Act
-            var availabilityCreateResult = await controller.CreateAvailability(
-                guid,
-                availabilityDto
-            );
-            var failedAvailabilityCreateResult = await controller.CreateAvailability(
-                Guid.Empty,
-                availabilityDto
-            );
-
-            // Assert
-            Assert.IsType<CreatedAtActionResult>(availabilityCreateResult);
-            Assert.IsType<NotFoundResult>(failedAvailabilityCreateResult);
-        }
-    }
-    //*/
 }

From a65eb66c894fdbcc6f82bcef3f8629cf5a331b43 Mon Sep 17 00:00:00 2001
From: lop4cwru <lop4@case.edu>
Date: Mon, 20 Apr 2026 07:05:55 -0400
Subject: [PATCH 15/17] remove extra debug console statements

---
 LineUp.Backend/Controllers/ScheduleController.cs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/LineUp.Backend/Controllers/ScheduleController.cs b/LineUp.Backend/Controllers/ScheduleController.cs
index e1343ef..6c34dd7 100644
--- a/LineUp.Backend/Controllers/ScheduleController.cs
+++ b/LineUp.Backend/Controllers/ScheduleController.cs
@@ -340,7 +340,6 @@ public async Task<IActionResult> RequestSwap(Guid guid, [FromBody] SwapRequestDt
                     && s.StartTime == start
                     && s.Availability.Id == requesterId
                 );
-                Console.WriteLine("\n Found Requester Shift: " + result.ToJson());
                 // if (result == null || result is not ShiftAssignment) // throw an error if no shift assigned at that time
                 //     throw new FileNotFoundException();
                 if (result != null)
@@ -370,7 +369,6 @@ public async Task<IActionResult> RequestSwap(Guid guid, [FromBody] SwapRequestDt
             return UnprocessableEntity("No shift assignments were found for the time specified.");
 
         //Sort through the shifts (assume an unsorted list)
-        Console.WriteLine(requesterShiftCollection.ToJson());
         SwapRequest swapRequest = new SwapRequest
         {
             FromPartyA = requesterShiftCollection,

From a713fa190b3a4d2a2fb4204e8bd0749009fa6adb Mon Sep 17 00:00:00 2001
From: lop4cwru <lop4@case.edu>
Date: Mon, 20 Apr 2026 15:10:22 -0400
Subject: [PATCH 16/17] Request validation on the backend

It should def be handled on the frontend too, but right now a request that has a time selected that belongs to neither the requester or recipient will throw an error.
---
 .../Controllers/ScheduleController.cs         | 33 +++++++++----------
 1 file changed, 16 insertions(+), 17 deletions(-)

diff --git a/LineUp.Backend/Controllers/ScheduleController.cs b/LineUp.Backend/Controllers/ScheduleController.cs
index 6c34dd7..bd0e942 100644
--- a/LineUp.Backend/Controllers/ScheduleController.cs
+++ b/LineUp.Backend/Controllers/ScheduleController.cs
@@ -339,30 +339,29 @@ public async Task<IActionResult> RequestSwap(Guid guid, [FromBody] SwapRequestDt
                     s.ScheduleId == scheduleID
                     && s.StartTime == start
                     && s.Availability.Id == requesterId
-                );
-                // if (result == null || result is not ShiftAssignment) // throw an error if no shift assigned at that time
-                //     throw new FileNotFoundException();
+                ); //Attempt to find if the given shift belongs to requester
                 if (result != null)
                     requesterShiftCollection.Add(result);
-            }
-
-            foreach (DateTime start in shiftStartTimes)
-            {
-                var result = await context.ShiftAssignments.FirstOrDefaultAsync(s =>
-                    s.ScheduleId == scheduleID
-                    && s.StartTime == start
-                    && s.Availability.Id == recipientId
-                );
-                // if (result == null || result is not ShiftAssignment) // throw an error if no shift assigned at that time
-                //     throw new FileNotFoundException();
-                if (result != null)
-                    recipientShiftCollection.Add(result);
+                else
+                {
+                    result = await context.ShiftAssignments.FirstOrDefaultAsync(s =>
+                        s.ScheduleId == scheduleID
+                        && s.StartTime == start
+                        && s.Availability.Id == recipientId
+                    );  //Attempt to find if the given shift belongs to recipient
+                    if (result != null)
+                        requesterShiftCollection.Add(result);
+                    else
+                    { //If it doesn't belong to either, throw an exception
+                        throw new FileNotFoundException();
+                    }
+                }
             }
         }
         catch (FileNotFoundException e)
         {
             return UnprocessableEntity(
-                "The database did not recognize one or more of the times as shifts."
+                "One or more of the dates provided did not have a shift assigned to either party."
             );
         }
         if (requesterShiftCollection.Count < 1 && recipientShiftCollection.Count < 1)

From bc996abcdadd0d755354817acb3b9b196c9e0034 Mon Sep 17 00:00:00 2001
From: lop4cwru <lop4@case.edu>
Date: Tue, 7 Jul 2026 01:13:41 -0400
Subject: [PATCH 17/17] kinda muddy and in-between but I'm actually getting the
 swapreqs to work in the backend fr this time!

---
 .../Controllers/ScheduleController.cs         |  18 +-
 .../Controllers/SwapRequestController.cs      |  14 +
 .../20260707024147_swappinForTrue.Designer.cs | 443 +++++++++++++++++
 .../20260707024147_swappinForTrue.cs          |  16 +
 ...0707032450_swappinForSuperTrue.Designer.cs | 443 +++++++++++++++++
 .../20260707032450_swappinForSuperTrue.cs     |  16 +
 .../20260707034657_ForPosterity.Designer.cs   | 449 +++++++++++++++++
 .../Migrations/20260707034657_ForPosterity.cs | 120 +++++
 .../20260707035542_okShouldWorkFr.Designer.cs | 449 +++++++++++++++++
 .../20260707035542_okShouldWorkFr.cs          | 140 ++++++
 .../Migrations/LineUpContextModelSnapshot.cs  |   6 +
 LineUp.Core/Models/ShiftAssignment.cs         |   2 +-
 LineUp.Core/Models/SwapRequest.cs             |   4 +-
 lineup-client/src/App.tsx                     |  11 +-
 lineup-client/src/pages/ViewSwapRequest.tsx   | 457 ++++++++++++++++++
 15 files changed, 2580 insertions(+), 8 deletions(-)
 create mode 100644 LineUp.Backend/Migrations/20260707024147_swappinForTrue.Designer.cs
 create mode 100644 LineUp.Backend/Migrations/20260707024147_swappinForTrue.cs
 create mode 100644 LineUp.Backend/Migrations/20260707032450_swappinForSuperTrue.Designer.cs
 create mode 100644 LineUp.Backend/Migrations/20260707032450_swappinForSuperTrue.cs
 create mode 100644 LineUp.Backend/Migrations/20260707034657_ForPosterity.Designer.cs
 create mode 100644 LineUp.Backend/Migrations/20260707034657_ForPosterity.cs
 create mode 100644 LineUp.Backend/Migrations/20260707035542_okShouldWorkFr.Designer.cs
 create mode 100644 LineUp.Backend/Migrations/20260707035542_okShouldWorkFr.cs
 create mode 100644 lineup-client/src/pages/ViewSwapRequest.tsx

diff --git a/LineUp.Backend/Controllers/ScheduleController.cs b/LineUp.Backend/Controllers/ScheduleController.cs
index bd0e942..2b79f0b 100644
--- a/LineUp.Backend/Controllers/ScheduleController.cs
+++ b/LineUp.Backend/Controllers/ScheduleController.cs
@@ -335,30 +335,40 @@ public async Task<IActionResult> RequestSwap(Guid guid, [FromBody] SwapRequestDt
         { //Attempt to find the shift assignments from the backend.
             foreach (DateTime start in shiftStartTimes)
             {
+                // Console.WriteLine("\n Finding owner of shift " + start + " ...");
                 var result = await context.ShiftAssignments.FirstOrDefaultAsync(s =>
                     s.ScheduleId == scheduleID
                     && s.StartTime == start
                     && s.Availability.Id == requesterId
                 ); //Attempt to find if the given shift belongs to requester
                 if (result != null)
+                {
                     requesterShiftCollection.Add(result);
+                    // Console.WriteLine("\n Shift found for " + requesterId);
+                    // Console.WriteLine("Look: " + requesterShiftCollection.ToString());
+                }
                 else
                 {
                     result = await context.ShiftAssignments.FirstOrDefaultAsync(s =>
                         s.ScheduleId == scheduleID
                         && s.StartTime == start
                         && s.Availability.Id == recipientId
-                    );  //Attempt to find if the given shift belongs to recipient
+                    ); //Attempt to find if the given shift belongs to recipient
                     if (result != null)
-                        requesterShiftCollection.Add(result);
+                    {
+                        recipientShiftCollection.Add(result);
+                        // Console.WriteLine("\n Shift found for " + recipientId);
+                        // Console.WriteLine("Look: " + recipientShiftCollection[^1].ToJson);
+                    }
                     else
                     { //If it doesn't belong to either, throw an exception
+                        // Console.WriteLine("\n shift aint go nowhere hon");
                         throw new FileNotFoundException();
                     }
                 }
             }
         }
-        catch (FileNotFoundException e)
+        catch (FileNotFoundException)
         {
             return UnprocessableEntity(
                 "One or more of the dates provided did not have a shift assigned to either party."
@@ -376,7 +386,7 @@ public async Task<IActionResult> RequestSwap(Guid guid, [FromBody] SwapRequestDt
         };
         Console.WriteLine("\n Creating Swap Request: " + swapRequest.ToJson());
         context.SwapRequests.Add(swapRequest);
-        context.SaveChanges();
+        await context.SaveChangesAsync();
         return Ok(swapRequest.Guid);
     }
 }
diff --git a/LineUp.Backend/Controllers/SwapRequestController.cs b/LineUp.Backend/Controllers/SwapRequestController.cs
index c5b0f5f..7c3ef43 100644
--- a/LineUp.Backend/Controllers/SwapRequestController.cs
+++ b/LineUp.Backend/Controllers/SwapRequestController.cs
@@ -40,4 +40,18 @@ public IActionResult ProcessSwap(Guid guid)
         context.SaveChanges();
         return Ok();
     }
+
+    [HttpGet("{guid:guid}")]
+    public async Task<IActionResult> GetSwapRequest(Guid guid)
+    {
+        SwapRequest? result = await context
+            .SwapRequests.Include(a => a.Schedule)
+            .Include(a => a.FromPartyA)
+            .Include(a => a.FromPartyB)
+            .FirstOrDefaultAsync(a => a.Guid == guid);
+        if (result == null)
+            return NotFound();
+
+        return Ok(result);
+    }
 }
diff --git a/LineUp.Backend/Migrations/20260707024147_swappinForTrue.Designer.cs b/LineUp.Backend/Migrations/20260707024147_swappinForTrue.Designer.cs
new file mode 100644
index 0000000..451ce28
--- /dev/null
+++ b/LineUp.Backend/Migrations/20260707024147_swappinForTrue.Designer.cs
@@ -0,0 +1,443 @@
+// <auto-generated />
+using System;
+using LineUp.Backend;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace LineUp.Backend.Migrations
+{
+    [DbContext(typeof(LineUpContext))]
+    [Migration("20260707024147_swappinForTrue")]
+    partial class swappinForTrue
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("LineUp.Core.Models.Availability", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.PrimitiveCollection<DateTime[]>("AvailabilitySlots")
+                        .IsRequired()
+                        .HasColumnType("timestamp with time zone[]");
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("PreferencesId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("ScheduleId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UserEmail")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Guid");
+
+                    b.HasIndex("PreferencesId");
+
+                    b.HasIndex("ScheduleId");
+
+                    b.HasIndex("Id", "UserEmail")
+                        .IsUnique();
+
+                    b.ToTable("Availabilities");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.AvailabilityPreferences", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AvailabilityPreferences");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.Form", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Forms");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestion", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("FormId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("QuestionText")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FormId");
+
+                    b.ToTable("FormQuestions");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestionAnswer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AnswerId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AnswerText")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("AvailabilityId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("FormQuestionId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AvailabilityId");
+
+                    b.HasIndex("FormQuestionId");
+
+                    b.ToTable("FormQuestionAnswers");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.QuestionOptions", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("FormQuestionId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("OptionText")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FormQuestionId");
+
+                    b.ToTable("QuestionOptions");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Schedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Auth0UserId")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.PrimitiveCollection<DateOnly[]>("DateCoverage")
+                        .IsRequired()
+                        .HasColumnType("date[]");
+
+                    b.Property<TimeOnly>("EndTime")
+                        .HasColumnType("time without time zone");
+
+                    b.Property<int?>("FormId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<Guid>("SchedulePreferencesId")
+                        .HasColumnType("uuid");
+
+                    b.Property<TimeOnly>("StartTime")
+                        .HasColumnType("time without time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FormId")
+                        .IsUnique();
+
+                    b.HasIndex("SchedulePreferencesId");
+
+                    b.HasIndex("Auth0UserId", "Guid");
+
+                    b.ToTable("Schedules");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SchedulePreferences", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MaximumShiftDurationMinutes")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaximumShiftsPerWorker")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MinutesPerSlot")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ShiftIntervals")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("UsersPerShift")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SchedulePreferences");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.ShiftAssignment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AvailabilityId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("EndTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("ScheduleId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("StartTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("SwapRequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SwapRequestId1")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AvailabilityId");
+
+                    b.HasIndex("ScheduleId");
+
+                    b.HasIndex("SwapRequestId");
+
+                    b.HasIndex("SwapRequestId1");
+
+                    b.ToTable("ShiftAssignments");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("ScheduleId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Guid");
+
+                    b.HasIndex("ScheduleId");
+
+                    b.ToTable("SwapRequests");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Availability", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.AvailabilityPreferences", "Preferences")
+                        .WithMany()
+                        .HasForeignKey("PreferencesId");
+
+                    b.HasOne("LineUp.Core.Models.Schedule", "Schedule")
+                        .WithMany()
+                        .HasForeignKey("ScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Preferences");
+
+                    b.Navigation("Schedule");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestion", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Forms.Form", null)
+                        .WithMany("Questions")
+                        .HasForeignKey("FormId");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestionAnswer", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Availability", null)
+                        .WithMany("FormAnswers")
+                        .HasForeignKey("AvailabilityId");
+
+                    b.HasOne("LineUp.Core.Models.Forms.FormQuestion", "Question")
+                        .WithMany()
+                        .HasForeignKey("FormQuestionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Question");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.QuestionOptions", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Forms.FormQuestion", null)
+                        .WithMany("Options")
+                        .HasForeignKey("FormQuestionId");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Schedule", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Forms.Form", "Form")
+                        .WithOne("Schedule")
+                        .HasForeignKey("LineUp.Core.Models.Schedule", "FormId");
+
+                    b.HasOne("LineUp.Core.Models.SchedulePreferences", "SchedulePreferences")
+                        .WithMany()
+                        .HasForeignKey("SchedulePreferencesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Form");
+
+                    b.Navigation("SchedulePreferences");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.ShiftAssignment", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Availability", "Availability")
+                        .WithMany()
+                        .HasForeignKey("AvailabilityId");
+
+                    b.HasOne("LineUp.Core.Models.Schedule", null)
+                        .WithMany("ShiftAssignments")
+                        .HasForeignKey("ScheduleId");
+
+                    b.HasOne("LineUp.Core.Models.SwapRequest", null)
+                        .WithMany("FromPartyA")
+                        .HasForeignKey("SwapRequestId");
+
+                    b.HasOne("LineUp.Core.Models.SwapRequest", null)
+                        .WithMany("FromPartyB")
+                        .HasForeignKey("SwapRequestId1");
+
+                    b.Navigation("Availability");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Schedule", "Schedule")
+                        .WithMany()
+                        .HasForeignKey("ScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Schedule");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Availability", b =>
+                {
+                    b.Navigation("FormAnswers");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.Form", b =>
+                {
+                    b.Navigation("Questions");
+
+                    b.Navigation("Schedule")
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestion", b =>
+                {
+                    b.Navigation("Options");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Schedule", b =>
+                {
+                    b.Navigation("ShiftAssignments");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.Navigation("FromPartyA");
+
+                    b.Navigation("FromPartyB");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/LineUp.Backend/Migrations/20260707024147_swappinForTrue.cs b/LineUp.Backend/Migrations/20260707024147_swappinForTrue.cs
new file mode 100644
index 0000000..3e43990
--- /dev/null
+++ b/LineUp.Backend/Migrations/20260707024147_swappinForTrue.cs
@@ -0,0 +1,16 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LineUp.Backend.Migrations
+{
+    /// <inheritdoc />
+    public partial class swappinForTrue : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder) { }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder) { }
+    }
+}
diff --git a/LineUp.Backend/Migrations/20260707032450_swappinForSuperTrue.Designer.cs b/LineUp.Backend/Migrations/20260707032450_swappinForSuperTrue.Designer.cs
new file mode 100644
index 0000000..4167c2c
--- /dev/null
+++ b/LineUp.Backend/Migrations/20260707032450_swappinForSuperTrue.Designer.cs
@@ -0,0 +1,443 @@
+// <auto-generated />
+using System;
+using LineUp.Backend;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace LineUp.Backend.Migrations
+{
+    [DbContext(typeof(LineUpContext))]
+    [Migration("20260707032450_swappinForSuperTrue")]
+    partial class swappinForSuperTrue
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("LineUp.Core.Models.Availability", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.PrimitiveCollection<DateTime[]>("AvailabilitySlots")
+                        .IsRequired()
+                        .HasColumnType("timestamp with time zone[]");
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("PreferencesId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("ScheduleId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UserEmail")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Guid");
+
+                    b.HasIndex("PreferencesId");
+
+                    b.HasIndex("ScheduleId");
+
+                    b.HasIndex("Id", "UserEmail")
+                        .IsUnique();
+
+                    b.ToTable("Availabilities");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.AvailabilityPreferences", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AvailabilityPreferences");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.Form", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Forms");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestion", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("FormId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("QuestionText")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FormId");
+
+                    b.ToTable("FormQuestions");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestionAnswer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AnswerId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AnswerText")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("AvailabilityId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("FormQuestionId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AvailabilityId");
+
+                    b.HasIndex("FormQuestionId");
+
+                    b.ToTable("FormQuestionAnswers");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.QuestionOptions", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("FormQuestionId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("OptionText")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FormQuestionId");
+
+                    b.ToTable("QuestionOptions");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Schedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Auth0UserId")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.PrimitiveCollection<DateOnly[]>("DateCoverage")
+                        .IsRequired()
+                        .HasColumnType("date[]");
+
+                    b.Property<TimeOnly>("EndTime")
+                        .HasColumnType("time without time zone");
+
+                    b.Property<int?>("FormId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<Guid>("SchedulePreferencesId")
+                        .HasColumnType("uuid");
+
+                    b.Property<TimeOnly>("StartTime")
+                        .HasColumnType("time without time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FormId")
+                        .IsUnique();
+
+                    b.HasIndex("SchedulePreferencesId");
+
+                    b.HasIndex("Auth0UserId", "Guid");
+
+                    b.ToTable("Schedules");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SchedulePreferences", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MaximumShiftDurationMinutes")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaximumShiftsPerWorker")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MinutesPerSlot")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ShiftIntervals")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("UsersPerShift")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SchedulePreferences");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.ShiftAssignment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AvailabilityId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("EndTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("ScheduleId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("StartTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("SwapRequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SwapRequestId1")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AvailabilityId");
+
+                    b.HasIndex("ScheduleId");
+
+                    b.HasIndex("SwapRequestId");
+
+                    b.HasIndex("SwapRequestId1");
+
+                    b.ToTable("ShiftAssignments");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("ScheduleId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Guid");
+
+                    b.HasIndex("ScheduleId");
+
+                    b.ToTable("SwapRequests");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Availability", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.AvailabilityPreferences", "Preferences")
+                        .WithMany()
+                        .HasForeignKey("PreferencesId");
+
+                    b.HasOne("LineUp.Core.Models.Schedule", "Schedule")
+                        .WithMany()
+                        .HasForeignKey("ScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Preferences");
+
+                    b.Navigation("Schedule");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestion", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Forms.Form", null)
+                        .WithMany("Questions")
+                        .HasForeignKey("FormId");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestionAnswer", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Availability", null)
+                        .WithMany("FormAnswers")
+                        .HasForeignKey("AvailabilityId");
+
+                    b.HasOne("LineUp.Core.Models.Forms.FormQuestion", "Question")
+                        .WithMany()
+                        .HasForeignKey("FormQuestionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Question");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.QuestionOptions", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Forms.FormQuestion", null)
+                        .WithMany("Options")
+                        .HasForeignKey("FormQuestionId");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Schedule", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Forms.Form", "Form")
+                        .WithOne("Schedule")
+                        .HasForeignKey("LineUp.Core.Models.Schedule", "FormId");
+
+                    b.HasOne("LineUp.Core.Models.SchedulePreferences", "SchedulePreferences")
+                        .WithMany()
+                        .HasForeignKey("SchedulePreferencesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Form");
+
+                    b.Navigation("SchedulePreferences");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.ShiftAssignment", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Availability", "Availability")
+                        .WithMany()
+                        .HasForeignKey("AvailabilityId");
+
+                    b.HasOne("LineUp.Core.Models.Schedule", null)
+                        .WithMany("ShiftAssignments")
+                        .HasForeignKey("ScheduleId");
+
+                    b.HasOne("LineUp.Core.Models.SwapRequest", null)
+                        .WithMany("FromPartyA")
+                        .HasForeignKey("SwapRequestId");
+
+                    b.HasOne("LineUp.Core.Models.SwapRequest", null)
+                        .WithMany("FromPartyB")
+                        .HasForeignKey("SwapRequestId1");
+
+                    b.Navigation("Availability");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Schedule", "Schedule")
+                        .WithMany()
+                        .HasForeignKey("ScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Schedule");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Availability", b =>
+                {
+                    b.Navigation("FormAnswers");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.Form", b =>
+                {
+                    b.Navigation("Questions");
+
+                    b.Navigation("Schedule")
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestion", b =>
+                {
+                    b.Navigation("Options");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Schedule", b =>
+                {
+                    b.Navigation("ShiftAssignments");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.Navigation("FromPartyA");
+
+                    b.Navigation("FromPartyB");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/LineUp.Backend/Migrations/20260707032450_swappinForSuperTrue.cs b/LineUp.Backend/Migrations/20260707032450_swappinForSuperTrue.cs
new file mode 100644
index 0000000..51d6966
--- /dev/null
+++ b/LineUp.Backend/Migrations/20260707032450_swappinForSuperTrue.cs
@@ -0,0 +1,16 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LineUp.Backend.Migrations
+{
+    /// <inheritdoc />
+    public partial class swappinForSuperTrue : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder) { }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder) { }
+    }
+}
diff --git a/LineUp.Backend/Migrations/20260707034657_ForPosterity.Designer.cs b/LineUp.Backend/Migrations/20260707034657_ForPosterity.Designer.cs
new file mode 100644
index 0000000..4bf688e
--- /dev/null
+++ b/LineUp.Backend/Migrations/20260707034657_ForPosterity.Designer.cs
@@ -0,0 +1,449 @@
+// <auto-generated />
+using System;
+using LineUp.Backend;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace LineUp.Backend.Migrations
+{
+    [DbContext(typeof(LineUpContext))]
+    [Migration("20260707034657_ForPosterity")]
+    partial class ForPosterity
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("LineUp.Core.Models.Availability", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.PrimitiveCollection<DateTime[]>("AvailabilitySlots")
+                        .IsRequired()
+                        .HasColumnType("timestamp with time zone[]");
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("PreferencesId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("ScheduleId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UserEmail")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Guid");
+
+                    b.HasIndex("PreferencesId");
+
+                    b.HasIndex("ScheduleId");
+
+                    b.HasIndex("Id", "UserEmail")
+                        .IsUnique();
+
+                    b.ToTable("Availabilities");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.AvailabilityPreferences", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AvailabilityPreferences");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.Form", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Forms");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestion", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("FormId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("QuestionText")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FormId");
+
+                    b.ToTable("FormQuestions");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestionAnswer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AnswerId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AnswerText")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("AvailabilityId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("FormQuestionId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AvailabilityId");
+
+                    b.HasIndex("FormQuestionId");
+
+                    b.ToTable("FormQuestionAnswers");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.QuestionOptions", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("FormQuestionId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("OptionText")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FormQuestionId");
+
+                    b.ToTable("QuestionOptions");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Schedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Auth0UserId")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.PrimitiveCollection<DateOnly[]>("DateCoverage")
+                        .IsRequired()
+                        .HasColumnType("date[]");
+
+                    b.Property<TimeOnly>("EndTime")
+                        .HasColumnType("time without time zone");
+
+                    b.Property<int?>("FormId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<Guid>("SchedulePreferencesId")
+                        .HasColumnType("uuid");
+
+                    b.Property<TimeOnly>("StartTime")
+                        .HasColumnType("time without time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FormId")
+                        .IsUnique();
+
+                    b.HasIndex("SchedulePreferencesId");
+
+                    b.HasIndex("Auth0UserId", "Guid");
+
+                    b.ToTable("Schedules");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SchedulePreferences", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MaximumShiftDurationMinutes")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaximumShiftsPerWorker")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MinutesPerSlot")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ShiftIntervals")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("UsersPerShift")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SchedulePreferences");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.ShiftAssignment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AvailabilityId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("EndTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("ScheduleId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("StartTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("SwapRequestPartyAId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SwapRequestPartyBId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AvailabilityId");
+
+                    b.HasIndex("ScheduleId");
+
+                    b.HasIndex("SwapRequestPartyAId");
+
+                    b.HasIndex("SwapRequestPartyBId");
+
+                    b.ToTable("ShiftAssignments");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("ScheduleId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Guid");
+
+                    b.HasIndex("ScheduleId");
+
+                    b.ToTable("SwapRequests");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Availability", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.AvailabilityPreferences", "Preferences")
+                        .WithMany()
+                        .HasForeignKey("PreferencesId");
+
+                    b.HasOne("LineUp.Core.Models.Schedule", "Schedule")
+                        .WithMany()
+                        .HasForeignKey("ScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Preferences");
+
+                    b.Navigation("Schedule");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestion", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Forms.Form", null)
+                        .WithMany("Questions")
+                        .HasForeignKey("FormId");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestionAnswer", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Availability", null)
+                        .WithMany("FormAnswers")
+                        .HasForeignKey("AvailabilityId");
+
+                    b.HasOne("LineUp.Core.Models.Forms.FormQuestion", "Question")
+                        .WithMany()
+                        .HasForeignKey("FormQuestionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Question");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.QuestionOptions", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Forms.FormQuestion", null)
+                        .WithMany("Options")
+                        .HasForeignKey("FormQuestionId");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Schedule", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Forms.Form", "Form")
+                        .WithOne("Schedule")
+                        .HasForeignKey("LineUp.Core.Models.Schedule", "FormId");
+
+                    b.HasOne("LineUp.Core.Models.SchedulePreferences", "SchedulePreferences")
+                        .WithMany()
+                        .HasForeignKey("SchedulePreferencesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Form");
+
+                    b.Navigation("SchedulePreferences");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.ShiftAssignment", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Availability", "Availability")
+                        .WithMany()
+                        .HasForeignKey("AvailabilityId");
+
+                    b.HasOne("LineUp.Core.Models.Schedule", null)
+                        .WithMany("ShiftAssignments")
+                        .HasForeignKey("ScheduleId");
+
+                    b.HasOne("LineUp.Core.Models.SwapRequest", "PartyASwapRequest")
+                        .WithMany("FromPartyA")
+                        .HasForeignKey("SwapRequestPartyAId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("LineUp.Core.Models.SwapRequest", "PartyBSwapRequest")
+                        .WithMany("FromPartyB")
+                        .HasForeignKey("SwapRequestPartyBId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Availability");
+
+                    b.Navigation("PartyASwapRequest");
+
+                    b.Navigation("PartyBSwapRequest");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Schedule", "Schedule")
+                        .WithMany()
+                        .HasForeignKey("ScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Schedule");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Availability", b =>
+                {
+                    b.Navigation("FormAnswers");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.Form", b =>
+                {
+                    b.Navigation("Questions");
+
+                    b.Navigation("Schedule")
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestion", b =>
+                {
+                    b.Navigation("Options");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Schedule", b =>
+                {
+                    b.Navigation("ShiftAssignments");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.Navigation("FromPartyA");
+
+                    b.Navigation("FromPartyB");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/LineUp.Backend/Migrations/20260707034657_ForPosterity.cs b/LineUp.Backend/Migrations/20260707034657_ForPosterity.cs
new file mode 100644
index 0000000..2949957
--- /dev/null
+++ b/LineUp.Backend/Migrations/20260707034657_ForPosterity.cs
@@ -0,0 +1,120 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LineUp.Backend.Migrations
+{
+    /// <inheritdoc />
+    public partial class ForPosterity : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestId",
+                table: "ShiftAssignments"
+            );
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestId1",
+                table: "ShiftAssignments"
+            );
+
+            migrationBuilder.RenameColumn(
+                name: "SwapRequestId1",
+                table: "ShiftAssignments",
+                newName: "SwapRequestPartyBId"
+            );
+
+            migrationBuilder.RenameColumn(
+                name: "SwapRequestId",
+                table: "ShiftAssignments",
+                newName: "SwapRequestPartyAId"
+            );
+
+            migrationBuilder.RenameIndex(
+                name: "IX_ShiftAssignments_SwapRequestId1",
+                table: "ShiftAssignments",
+                newName: "IX_ShiftAssignments_SwapRequestPartyBId"
+            );
+
+            migrationBuilder.RenameIndex(
+                name: "IX_ShiftAssignments_SwapRequestId",
+                table: "ShiftAssignments",
+                newName: "IX_ShiftAssignments_SwapRequestPartyAId"
+            );
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestPartyAId",
+                table: "ShiftAssignments",
+                column: "SwapRequestPartyAId",
+                principalTable: "SwapRequests",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.SetNull
+            );
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestPartyBId",
+                table: "ShiftAssignments",
+                column: "SwapRequestPartyBId",
+                principalTable: "SwapRequests",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.SetNull
+            );
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestPartyAId",
+                table: "ShiftAssignments"
+            );
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestPartyBId",
+                table: "ShiftAssignments"
+            );
+
+            migrationBuilder.RenameColumn(
+                name: "SwapRequestPartyBId",
+                table: "ShiftAssignments",
+                newName: "SwapRequestId1"
+            );
+
+            migrationBuilder.RenameColumn(
+                name: "SwapRequestPartyAId",
+                table: "ShiftAssignments",
+                newName: "SwapRequestId"
+            );
+
+            migrationBuilder.RenameIndex(
+                name: "IX_ShiftAssignments_SwapRequestPartyBId",
+                table: "ShiftAssignments",
+                newName: "IX_ShiftAssignments_SwapRequestId1"
+            );
+
+            migrationBuilder.RenameIndex(
+                name: "IX_ShiftAssignments_SwapRequestPartyAId",
+                table: "ShiftAssignments",
+                newName: "IX_ShiftAssignments_SwapRequestId"
+            );
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestId",
+                table: "ShiftAssignments",
+                column: "SwapRequestId",
+                principalTable: "SwapRequests",
+                principalColumn: "Id"
+            );
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestId1",
+                table: "ShiftAssignments",
+                column: "SwapRequestId1",
+                principalTable: "SwapRequests",
+                principalColumn: "Id"
+            );
+        }
+    }
+}
diff --git a/LineUp.Backend/Migrations/20260707035542_okShouldWorkFr.Designer.cs b/LineUp.Backend/Migrations/20260707035542_okShouldWorkFr.Designer.cs
new file mode 100644
index 0000000..f300e25
--- /dev/null
+++ b/LineUp.Backend/Migrations/20260707035542_okShouldWorkFr.Designer.cs
@@ -0,0 +1,449 @@
+// <auto-generated />
+using System;
+using LineUp.Backend;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace LineUp.Backend.Migrations
+{
+    [DbContext(typeof(LineUpContext))]
+    [Migration("20260707035542_okShouldWorkFr")]
+    partial class okShouldWorkFr
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("LineUp.Core.Models.Availability", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.PrimitiveCollection<DateTime[]>("AvailabilitySlots")
+                        .IsRequired()
+                        .HasColumnType("timestamp with time zone[]");
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("PreferencesId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("ScheduleId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UserEmail")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Guid");
+
+                    b.HasIndex("PreferencesId");
+
+                    b.HasIndex("ScheduleId");
+
+                    b.HasIndex("Id", "UserEmail")
+                        .IsUnique();
+
+                    b.ToTable("Availabilities");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.AvailabilityPreferences", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AvailabilityPreferences");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.Form", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Forms");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestion", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("FormId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("QuestionText")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FormId");
+
+                    b.ToTable("FormQuestions");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestionAnswer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AnswerId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AnswerText")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("AvailabilityId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("FormQuestionId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AvailabilityId");
+
+                    b.HasIndex("FormQuestionId");
+
+                    b.ToTable("FormQuestionAnswers");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.QuestionOptions", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("FormQuestionId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("OptionText")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FormQuestionId");
+
+                    b.ToTable("QuestionOptions");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Schedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Auth0UserId")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.PrimitiveCollection<DateOnly[]>("DateCoverage")
+                        .IsRequired()
+                        .HasColumnType("date[]");
+
+                    b.Property<TimeOnly>("EndTime")
+                        .HasColumnType("time without time zone");
+
+                    b.Property<int?>("FormId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<Guid>("SchedulePreferencesId")
+                        .HasColumnType("uuid");
+
+                    b.Property<TimeOnly>("StartTime")
+                        .HasColumnType("time without time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FormId")
+                        .IsUnique();
+
+                    b.HasIndex("SchedulePreferencesId");
+
+                    b.HasIndex("Auth0UserId", "Guid");
+
+                    b.ToTable("Schedules");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SchedulePreferences", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MaximumShiftDurationMinutes")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaximumShiftsPerWorker")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MinutesPerSlot")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ShiftIntervals")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("UsersPerShift")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SchedulePreferences");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.ShiftAssignment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AvailabilityId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("EndTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("ScheduleId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("StartTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("SwapRequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SwapRequestId1")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AvailabilityId");
+
+                    b.HasIndex("ScheduleId");
+
+                    b.HasIndex("SwapRequestId");
+
+                    b.HasIndex("SwapRequestId1");
+
+                    b.ToTable("ShiftAssignments");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("ScheduleId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("partyAConfirm")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("partyBConfirm")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Guid");
+
+                    b.HasIndex("ScheduleId");
+
+                    b.ToTable("SwapRequests");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Availability", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.AvailabilityPreferences", "Preferences")
+                        .WithMany()
+                        .HasForeignKey("PreferencesId");
+
+                    b.HasOne("LineUp.Core.Models.Schedule", "Schedule")
+                        .WithMany()
+                        .HasForeignKey("ScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Preferences");
+
+                    b.Navigation("Schedule");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestion", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Forms.Form", null)
+                        .WithMany("Questions")
+                        .HasForeignKey("FormId");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestionAnswer", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Availability", null)
+                        .WithMany("FormAnswers")
+                        .HasForeignKey("AvailabilityId");
+
+                    b.HasOne("LineUp.Core.Models.Forms.FormQuestion", "Question")
+                        .WithMany()
+                        .HasForeignKey("FormQuestionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Question");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.QuestionOptions", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Forms.FormQuestion", null)
+                        .WithMany("Options")
+                        .HasForeignKey("FormQuestionId");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Schedule", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Forms.Form", "Form")
+                        .WithOne("Schedule")
+                        .HasForeignKey("LineUp.Core.Models.Schedule", "FormId");
+
+                    b.HasOne("LineUp.Core.Models.SchedulePreferences", "SchedulePreferences")
+                        .WithMany()
+                        .HasForeignKey("SchedulePreferencesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Form");
+
+                    b.Navigation("SchedulePreferences");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.ShiftAssignment", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Availability", "Availability")
+                        .WithMany()
+                        .HasForeignKey("AvailabilityId");
+
+                    b.HasOne("LineUp.Core.Models.Schedule", null)
+                        .WithMany("ShiftAssignments")
+                        .HasForeignKey("ScheduleId");
+
+                    b.HasOne("LineUp.Core.Models.SwapRequest", null)
+                        .WithMany("FromPartyA")
+                        .HasForeignKey("SwapRequestId");
+
+                    b.HasOne("LineUp.Core.Models.SwapRequest", null)
+                        .WithMany("FromPartyB")
+                        .HasForeignKey("SwapRequestId1");
+
+                    b.Navigation("Availability");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.HasOne("LineUp.Core.Models.Schedule", "Schedule")
+                        .WithMany()
+                        .HasForeignKey("ScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Schedule");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Availability", b =>
+                {
+                    b.Navigation("FormAnswers");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.Form", b =>
+                {
+                    b.Navigation("Questions");
+
+                    b.Navigation("Schedule")
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Forms.FormQuestion", b =>
+                {
+                    b.Navigation("Options");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.Schedule", b =>
+                {
+                    b.Navigation("ShiftAssignments");
+                });
+
+            modelBuilder.Entity("LineUp.Core.Models.SwapRequest", b =>
+                {
+                    b.Navigation("FromPartyA");
+
+                    b.Navigation("FromPartyB");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/LineUp.Backend/Migrations/20260707035542_okShouldWorkFr.cs b/LineUp.Backend/Migrations/20260707035542_okShouldWorkFr.cs
new file mode 100644
index 0000000..44dda50
--- /dev/null
+++ b/LineUp.Backend/Migrations/20260707035542_okShouldWorkFr.cs
@@ -0,0 +1,140 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LineUp.Backend.Migrations
+{
+    /// <inheritdoc />
+    public partial class okShouldWorkFr : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestPartyAId",
+                table: "ShiftAssignments"
+            );
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestPartyBId",
+                table: "ShiftAssignments"
+            );
+
+            migrationBuilder.RenameColumn(
+                name: "SwapRequestPartyBId",
+                table: "ShiftAssignments",
+                newName: "SwapRequestId1"
+            );
+
+            migrationBuilder.RenameColumn(
+                name: "SwapRequestPartyAId",
+                table: "ShiftAssignments",
+                newName: "SwapRequestId"
+            );
+
+            migrationBuilder.RenameIndex(
+                name: "IX_ShiftAssignments_SwapRequestPartyBId",
+                table: "ShiftAssignments",
+                newName: "IX_ShiftAssignments_SwapRequestId1"
+            );
+
+            migrationBuilder.RenameIndex(
+                name: "IX_ShiftAssignments_SwapRequestPartyAId",
+                table: "ShiftAssignments",
+                newName: "IX_ShiftAssignments_SwapRequestId"
+            );
+
+            migrationBuilder.AddColumn<bool>(
+                name: "partyAConfirm",
+                table: "SwapRequests",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false
+            );
+
+            migrationBuilder.AddColumn<bool>(
+                name: "partyBConfirm",
+                table: "SwapRequests",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false
+            );
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestId",
+                table: "ShiftAssignments",
+                column: "SwapRequestId",
+                principalTable: "SwapRequests",
+                principalColumn: "Id"
+            );
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestId1",
+                table: "ShiftAssignments",
+                column: "SwapRequestId1",
+                principalTable: "SwapRequests",
+                principalColumn: "Id"
+            );
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestId",
+                table: "ShiftAssignments"
+            );
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestId1",
+                table: "ShiftAssignments"
+            );
+
+            migrationBuilder.DropColumn(name: "partyAConfirm", table: "SwapRequests");
+
+            migrationBuilder.DropColumn(name: "partyBConfirm", table: "SwapRequests");
+
+            migrationBuilder.RenameColumn(
+                name: "SwapRequestId1",
+                table: "ShiftAssignments",
+                newName: "SwapRequestPartyBId"
+            );
+
+            migrationBuilder.RenameColumn(
+                name: "SwapRequestId",
+                table: "ShiftAssignments",
+                newName: "SwapRequestPartyAId"
+            );
+
+            migrationBuilder.RenameIndex(
+                name: "IX_ShiftAssignments_SwapRequestId1",
+                table: "ShiftAssignments",
+                newName: "IX_ShiftAssignments_SwapRequestPartyBId"
+            );
+
+            migrationBuilder.RenameIndex(
+                name: "IX_ShiftAssignments_SwapRequestId",
+                table: "ShiftAssignments",
+                newName: "IX_ShiftAssignments_SwapRequestPartyAId"
+            );
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestPartyAId",
+                table: "ShiftAssignments",
+                column: "SwapRequestPartyAId",
+                principalTable: "SwapRequests",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.SetNull
+            );
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ShiftAssignments_SwapRequests_SwapRequestPartyBId",
+                table: "ShiftAssignments",
+                column: "SwapRequestPartyBId",
+                principalTable: "SwapRequests",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.SetNull
+            );
+        }
+    }
+}
diff --git a/LineUp.Backend/Migrations/LineUpContextModelSnapshot.cs b/LineUp.Backend/Migrations/LineUpContextModelSnapshot.cs
index 86a816a..5089f9c 100644
--- a/LineUp.Backend/Migrations/LineUpContextModelSnapshot.cs
+++ b/LineUp.Backend/Migrations/LineUpContextModelSnapshot.cs
@@ -301,6 +301,12 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<int>("ScheduleId")
                         .HasColumnType("integer");
 
+                    b.Property<bool>("partyAConfirm")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("partyBConfirm")
+                        .HasColumnType("boolean");
+
                     b.HasKey("Id");
 
                     b.HasIndex("Guid");
diff --git a/LineUp.Core/Models/ShiftAssignment.cs b/LineUp.Core/Models/ShiftAssignment.cs
index 3e174ec..050d91a 100644
--- a/LineUp.Core/Models/ShiftAssignment.cs
+++ b/LineUp.Core/Models/ShiftAssignment.cs
@@ -11,7 +11,7 @@ public class ShiftAssignment
 
     public string? UserName => Availability?.UserName;
     public int? AvailabilityDbId => Availability?.Id;
-    
+
     [JsonDoNotSerialize]
     public Availability? Availability { get; set; }
     // Navigation properties, ignored in JSON to not loop forever
diff --git a/LineUp.Core/Models/SwapRequest.cs b/LineUp.Core/Models/SwapRequest.cs
index acecb39..9d7be52 100644
--- a/LineUp.Core/Models/SwapRequest.cs
+++ b/LineUp.Core/Models/SwapRequest.cs
@@ -13,9 +13,9 @@ public class SwapRequest
 
     public required List<ShiftAssignment> FromPartyB { get; set; }
 
-    public bool partyAConfirm = false;
+    public bool partyAConfirm { get; set; } = false;
 
-    public bool partyBConfirm = false;
+    public bool partyBConfirm { get; set; } = false;
 
     [JsonDoNotSerialize]
     public required Schedule Schedule { get; set; }
diff --git a/lineup-client/src/App.tsx b/lineup-client/src/App.tsx
index fb25e7e..1a5b503 100644
--- a/lineup-client/src/App.tsx
+++ b/lineup-client/src/App.tsx
@@ -7,6 +7,7 @@ import Home from "@/pages/Home";
 import NewSchedule from "@/pages/NewSchedule";
 import ViewEditSchedule from "@/pages/ViewEditSchedule";
 import RequestSwap from "@/pages/RequestSwap";
+import ViewSwapRequest from "@/pages/ViewSwapRequest";
 import { queryClient } from "@/utils/api";
 import { authorizedLoaderQuery, unauthorizedLoaderQuery } from "@/utils/db";
 import { createBrowserRouter, Navigate, Outlet, RouterProvider, type LoaderFunctionArgs } from "react-router";
@@ -28,6 +29,10 @@ async function scheduleLoader({ params }: LoaderFunctionArgs) {
   return queryClient.ensureQueryData(authorizedLoaderQuery("/api/schedule/{}/details", params.guid!));
 }
 
+async function requestSwapLoader({ params }: LoaderFunctionArgs) {
+  return queryClient.ensureQueryData(authorizedLoaderQuery("/api/schedule/{}/details", params.guid!));
+}
+
 async function editAvailabilityLoader({ params }: LoaderFunctionArgs) {
   return queryClient.ensureQueryData(unauthorizedLoaderQuery("/api/availability/{}", params.guid!));
 }
@@ -65,7 +70,7 @@ const router = createBrowserRouter([
           {
             path: ":guid/requestSwap", // matches /schedule/:guid/edit
             element: <RequestSwap />,
-            loader: scheduleLoader,
+            loader: requestSwapLoader,
           },
         ],
       },
@@ -83,6 +88,10 @@ const router = createBrowserRouter([
           },
         ],
       },
+      {
+        path: "/viewSwapRequest/:swapRequestGuid/:viewerGuid",
+        element: <ViewSwapRequest />,
+      },
     ],
   },
 ]);
diff --git a/lineup-client/src/pages/ViewSwapRequest.tsx b/lineup-client/src/pages/ViewSwapRequest.tsx
new file mode 100644
index 0000000..4e1ee6d
--- /dev/null
+++ b/lineup-client/src/pages/ViewSwapRequest.tsx
@@ -0,0 +1,457 @@
+import { Calendar } from "@/components/Calendar";
+import { ColoredCell, FillableCell } from "@/components/CalendarCells";
+import { MousePopup } from "@/components/MousePopup";
+import { useApi } from "@/utils/api";
+import { addToasts, unauthorizedLoaderQuery } from "@/utils/db";
+import { parseTimeString } from "@/utils/time";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import React from "react";
+import { useState } from "react";
+import { useNavigate, useParams } from "react-router";
+
+const ViewSwapRequest = () => {
+  const navigate = useNavigate();
+  const { fetchWithAuth } = useApi();
+  const { swapRequestGuid, viewerGuid } = useParams();
+  const { data } = useQuery(unauthorizedLoaderQuery("/api/swap/{}", swapRequestGuid!));
+  const [focusedTime, setFocusedTime] = useState<string | null>(null);
+  const backgroundColors = Array.from({ length: 10 }, (_, i) => `hsl(${Math.round((360 / 10) * i)}, 100%, 80%)`);
+  // console.log(backgroundColors);
+
+  // console.log(data);
+
+  const [email, setEmail] = useState<string>("");
+  const [selectedCells, setSelectedCells] = useState<string[]>([]);
+  const [userId, setUserId] = useState<number | null>(null);
+  const [selectedSwapPartnerAvailabilityId, setSelectedSwapPartnerAvailabilityId] = useState<number | null>(null);
+  const [selectedSwapPartner, setSelectedSwapPartner] = useState<string | null>(null);
+
+  const confirmEmailmutation = useMutation({
+    //
+    mutationFn: async (email: string) => {
+      const res = await fetchWithAuth(`/api/schedule/${guid}/getByEmail?email=${email}`, {
+        method: "GET",
+      });
+
+      if (res.status == 406) {
+        throw new Error("Availability Not Found");
+      } else if (!res.ok) {
+        throw new Error("Failed to send Swap Request");
+      }
+      const resJson = await res.json();
+      return resJson;
+    },
+    onSuccess: (resJson) => {
+      setUserId(resJson.id);
+      // setSelectedCells(resJson.availabilitySlots); //This would make all the availiability light up at the start, but that feels confusing if others have shifts at that time.
+    },
+  });
+
+  type CreateSwapRequestProps = {
+    shiftStartTimes: string[];
+    requesterId: number;
+    recipientId: number | null;
+  };
+
+  const CreateSwapRequestMutation = useMutation({
+    //creates a SwapRequest in the DB
+    mutationFn: async (swapRequest: CreateSwapRequestProps) => {
+      if (swapRequest.recipientId == null) {
+        throw new Error("Failed to create Swap Request: Recipient not specified");
+      }
+      const res = await fetchWithAuth(`/api/schedule/${guid}/requestSwap`, {
+        method: "POST",
+        body: JSON.stringify(swapRequest),
+        headers: {
+          "Content-Type": "application/json",
+        },
+      });
+
+      // console.log(JSON.stringify(swapRequest));
+
+      if (!res.ok) {
+        throw new Error("Failed to create Swap Request");
+      }
+
+      return res;
+    },
+    onSuccess: () => {},
+  });
+
+  if (!data) return <div>Loading...</div>;
+
+  const scheduleGenerated = true;
+  const [assignmentColors, assignmentText] = mapAssignments();
+  const selectionColors = mapSelectionColors();
+
+  function mapAssignments() {
+    const colors: { [key: string]: string } = {};
+    const text: { [key: string]: string } = {};
+    const nameToColor: { [key: string]: string } = {};
+
+    if (!scheduleGenerated) {
+      return [colors, text];
+    }
+
+    for (const availability of data.Schedule.shiftAssignments) {
+      if (availability.startTime in text) {
+        text[availability.startTime] = text[availability.startTime] + ", " + availability.userName;
+      } else {
+        text[availability.startTime] = availability.userName;
+      }
+    }
+
+    let numColors = 0;
+    for (const time of Object.keys(text)) {
+      if (text[time] in nameToColor) {
+        colors[time] = nameToColor[text[time]];
+      } else {
+        nameToColor[text[time]] = backgroundColors[numColors % backgroundColors.length];
+        colors[time] = backgroundColors[numColors % backgroundColors.length];
+        numColors++;
+      }
+    }
+    return [colors, text];
+  }
+
+  function mapSelectionColors() {
+    const colors: { [key: string]: string } = {};
+
+    if (userId === null) {
+      return colors;
+    }
+
+    return colors;
+
+    /*
+    // this needs to be based on AvailDbIds instead of off of strings :D
+    for (const time of Object.keys(assignmentText)) {
+      // if it's mine make it a thing and if its another's make it diff
+      if (assignmentText[time] == ) {
+        colors[time] = `hsl(${Math.round((360 / 10) * 1)}, 100%, 80%)`;
+      } else if (assignmentText[time] == selectedSwapPartner) {
+        colors[time] = `hsl(${Math.round((360 / 10) * 2)}, 100%, 80%)`;
+      }
+
+      // if (text[time] in nameToColor) {
+      //   colors[time] = nameToColor[text[time]];
+      // } else {
+      //   nameToColor[text[time]] = backgroundColors[numColors % backgroundColors.length];
+      //   colors[time] = backgroundColors[numColors % backgroundColors.length];
+      //   numColors++;
+      // }
+    }
+    return colors;
+      //*/
+  }
+
+  const handleInputChange = (event: React.ChangeEvent<HTMLInputElement | HTMLSelectElement>) => {
+    const { value } = event.target;
+    setEmail(value);
+  };
+
+  // const respondentNames = Array.from(
+  //   new Set(
+  //     (data.shiftAssignments as { userName: string; availabilityDbId: number }[]).map((shift) => ({
+  //       userName: shift.userName,
+  //       id: shift.availabilityDbId,
+  //     })),
+  //   ),
+  // );
+
+  const respondentNames: { name: string; id: number }[] = data.shiftAssignments.reduce(
+    (nameSet: { name: string; id: number }[], assignment: any) => {
+      if (
+        nameSet.every((existingName) => existingName.id !== assignment.availabilityDbId) &&
+        assignment.availabilityDbId != userId
+      ) {
+        nameSet.push({ name: assignment.userName, id: assignment.availabilityDbId });
+      }
+      return nameSet;
+    },
+    [],
+  );
+
+  return (
+    <div className="availabilityRoot">
+      <>
+        <div className="scheduleName">
+          Schedule for <b>{data.name}</b>
+        </div>
+        {userId !== null ? (
+          <>
+            <div>
+              <em>Please select the shifts that you would like to swap.</em>
+            </div>
+            <br />
+
+            <form
+              onSubmit={(event: React.SubmitEvent<HTMLFormElement>) => {
+                event.preventDefault();
+                addToasts(
+                  CreateSwapRequestMutation.mutateAsync({
+                    shiftStartTimes: selectedCells,
+                    requesterId: userId,
+                    recipientId: selectedSwapPartnerAvailabilityId,
+                  }),
+                  undefined,
+                  "Request created! Please check your email to authenticate this request.",
+                ); //remove success message
+              }}
+            >
+              <Calendar
+                Cell={FillableCell}
+                selectedCells={selectedCells}
+                setSelectedCells={(cells) => {
+                  const next = typeof cells === "function" ? cells(selectedCells) : cells;
+                  setSelectedCells(next);
+                }}
+                minutesPerCell={data.schedulePreferences?.minutesPerSlot || 15}
+                dates={
+                  data.dateCoverage?.map((d: string) => {
+                    const [year, month, day] = d.split("-").map(Number);
+                    return new Date(year, month - 1, day);
+                  }) ?? []
+                }
+                range={{
+                  start: parseTimeString(data.startTime)!,
+                  end: parseTimeString(data.endTime)!,
+                }}
+                colors={/*selectionColors*/ assignmentColors}
+                text={assignmentText}
+                setFocusedCell={setFocusedTime}
+              />
+              <div>
+                <div className="swapPartnerLabel">
+                  <label>Swapping with:</label>
+                  {/* <label>
+                    {data.shiftAssignments.map((availabilityDbId: number, username: string) =>
+                      renderPartnerSelect(username, availabilityDbId),
+                    )}
+                  </label> */}
+                  <div className="respondentList">
+                    <ul>
+                      {respondentNames.map((shift) => (
+                        <li
+                          key={shift.id}
+                          className={selectedSwapPartnerAvailabilityId === shift.id ? "selectedRespondent" : ""}
+                          onClick={() => {
+                            setSelectedSwapPartnerAvailabilityId((prev) => {
+                              console.log(`selected name: ${shift.name}, selected id: ${shift.id}`);
+                              return prev === shift.id ? null : shift.id;
+                            });
+                            setSelectedSwapPartner((prev) => {
+                              return prev === shift.name ? null : shift.name;
+                            });
+                          }}
+                        >
+                          {shift.name}
+                        </li>
+                      ))}
+                    </ul>
+                  </div>
+                </div>
+                <button type="submit" className="scheduleBtn swapBtn">
+                  Submit
+                </button>
+              </div>
+            </form>
+          </>
+        ) : (
+          <>
+            <Calendar
+              Cell={ColoredCell}
+              minutesPerCell={data.schedulePreferences?.minutesPerSlot || 15}
+              dates={
+                data.dateCoverage?.map((d: string) => {
+                  const [year, month, day] = d.split("-").map(Number);
+                  return new Date(year, month - 1, day);
+                }) ?? []
+              }
+              range={{
+                start: parseTimeString(data.startTime)!,
+                end: parseTimeString(data.endTime)!,
+              }}
+              colors={assignmentColors}
+              text={assignmentText}
+              setFocusedCell={setFocusedTime}
+            />
+            <MousePopup isOpen={focusedTime !== null && focusedTime in assignmentText} width={250}>
+              <div className="availablePeoplePopupRoot">
+                <div className="availablePeoplePopupHeader">{focusedTime && assignmentText[focusedTime]}</div>
+                {focusedTime && (
+                  <div className="availablePeoplePopupTime">
+                    {new Intl.DateTimeFormat("en-US", {
+                      weekday: "long",
+                      hour: "2-digit",
+                      minute: "2-digit",
+                      hour12: true,
+                      timeZone: "UTC",
+                    }).format(new Date(focusedTime))}
+                  </div>
+                )}
+              </div>
+            </MousePopup>
+            <form
+              onSubmit={(event: React.SubmitEvent<HTMLFormElement>) => {
+                event.preventDefault();
+                addToasts(confirmEmailmutation.mutateAsync(email));
+              }}
+            ></form>
+          </>
+        )}
+      </>
+    </div>
+  );
+
+  // return (
+  //   <div className="availabilityRoot">
+  //     <>
+  //       <div className="scheduleName">
+  //         Schedule for <b>{data.name}</b>
+  //       </div>
+  //       {userId !== null ? (
+  //         <>
+  //           <div>
+  //             <em>Please select the shifts that you would like to swap.</em>
+  //           </div>
+  //           <br />
+
+  //           <form
+  //             onSubmit={(event: React.SubmitEvent<HTMLFormElement>) => {
+  //               event.preventDefault();
+  //               addToasts(
+  //                 CreateSwapRequestMutation.mutateAsync({
+  //                   shiftStartTimes: selectedCells,
+  //                   requesterId: userId,
+  //                   recipientId: selectedSwapPartnerAvailabilityId,
+  //                 }),
+  //                 undefined,
+  //                 "Request created! Please check your email to authenticate this request.",
+  //               ); //remove success message
+  //             }}
+  //           >
+  //             <Calendar
+  //               Cell={FillableCell}
+  //               selectedCells={selectedCells}
+  //               setSelectedCells={(cells) => {
+  //                 const next = typeof cells === "function" ? cells(selectedCells) : cells;
+  //                 setSelectedCells(next);
+  //               }}
+  //               minutesPerCell={data.schedulePreferences?.minutesPerSlot || 15}
+  //               dates={
+  //                 data.dateCoverage?.map((d: string) => {
+  //                   const [year, month, day] = d.split("-").map(Number);
+  //                   return new Date(year, month - 1, day);
+  //                 }) ?? []
+  //               }
+  //               range={{
+  //                 start: parseTimeString(data.startTime)!,
+  //                 end: parseTimeString(data.endTime)!,
+  //               }}
+  //               colors={/*selectionColors*/ assignmentColors}
+  //               text={assignmentText}
+  //               setFocusedCell={setFocusedTime}
+  //             />
+  //             <div>
+  //               <div className="swapPartnerLabel">
+  //                 <label>Swapping with:</label>
+  //                 {/* <label>
+  //                   {data.shiftAssignments.map((availabilityDbId: number, username: string) =>
+  //                     renderPartnerSelect(username, availabilityDbId),
+  //                   )}
+  //                 </label> */}
+  //                 <div className="respondentList">
+  //                   <ul>
+  //                     {respondentNames.map((shift) => (
+  //                       <li
+  //                         key={shift.id}
+  //                         className={selectedSwapPartnerAvailabilityId === shift.id ? "selectedRespondent" : ""}
+  //                         onClick={() => {
+  //                           setSelectedSwapPartnerAvailabilityId((prev) => {
+  //                             console.log(`selected name: ${shift.name}, selected id: ${shift.id}`);
+  //                             return prev === shift.id ? null : shift.id;
+  //                           });
+  //                           setSelectedSwapPartner((prev) => {
+  //                             return prev === shift.name ? null : shift.name;
+  //                           });
+  //                         }}
+  //                       >
+  //                         {shift.name}
+  //                       </li>
+  //                     ))}
+  //                   </ul>
+  //                 </div>
+  //               </div>
+  //               <button type="submit" className="scheduleBtn swapBtn">
+  //                 Submit
+  //               </button>
+  //             </div>
+  //           </form>
+  //         </>
+  //       ) : (
+  //         <>
+  //           <Calendar
+  //             Cell={ColoredCell}
+  //             minutesPerCell={data.schedulePreferences?.minutesPerSlot || 15}
+  //             dates={
+  //               data.dateCoverage?.map((d: string) => {
+  //                 const [year, month, day] = d.split("-").map(Number);
+  //                 return new Date(year, month - 1, day);
+  //               }) ?? []
+  //             }
+  //             range={{
+  //               start: parseTimeString(data.startTime)!,
+  //               end: parseTimeString(data.endTime)!,
+  //             }}
+  //             colors={assignmentColors}
+  //             text={assignmentText}
+  //             setFocusedCell={setFocusedTime}
+  //           />
+  //           <MousePopup isOpen={focusedTime !== null && focusedTime in assignmentText} width={250}>
+  //             <div className="availablePeoplePopupRoot">
+  //               <div className="availablePeoplePopupHeader">{focusedTime && assignmentText[focusedTime]}</div>
+  //               {focusedTime && (
+  //                 <div className="availablePeoplePopupTime">
+  //                   {new Intl.DateTimeFormat("en-US", {
+  //                     weekday: "long",
+  //                     hour: "2-digit",
+  //                     minute: "2-digit",
+  //                     hour12: true,
+  //                     timeZone: "UTC",
+  //                   }).format(new Date(focusedTime))}
+  //                 </div>
+  //               )}
+  //             </div>
+  //           </MousePopup>
+  //           <form
+  //             onSubmit={(event: React.SubmitEvent<HTMLFormElement>) => {
+  //               event.preventDefault();
+  //               addToasts(confirmEmailmutation.mutateAsync(email));
+  //             }}
+  //           >
+  //             <label htmlFor="email">Please input the email address you used to input your availability.</label>
+  //             <div>
+  //               <input
+  //                 className="input"
+  //                 type="email"
+  //                 id="email"
+  //                 name="email"
+  //                 value={email}
+  //                 onChange={handleInputChange}
+  //                 placeholder="name@example.com..."
+  //                 required
+  //               />
+  //               <button type="submit" className="scheduleBtn swapBtn" disabled={confirmEmailmutation.isPending}>
+  //                 Submit
+  //               </button>
+  //             </div>
+  //           </form>
+  //         </>
+  //       )}
+  //     </>
+  //   </div>
+  // );
+};
+
+export default ViewSwapRequest;