initial commit

packages/backend/.dockerignore

@@ -0,0 +1,25 @@
+**/.classpath
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/azds.yaml
+**/bin
+**/charts
+**/docker-compose*
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+LICENSE
+README.md

packages/backend/.gitignore

@@ -0,0 +1,424 @@
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+##
+## Get latest from https://github.com/github/gitignore/blob/main/VisualStudio.gitignore
+
+# User-specific files
+*.rsuser
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Mono auto generated files
+mono_crash.*
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+[Ww][Ii][Nn]32/
+[Aa][Rr][Mm]/
+[Aa][Rr][Mm]64/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+[Ll]ogs/
+
+# Visual Studio 2015/2017 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# Visual Studio 2017 auto generated files
+Generated\ Files/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUnit
+*.VisualState.xml
+TestResult.xml
+nunit-*.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# Benchmark Results
+BenchmarkDotNet.Artifacts/
+
+# .NET Core
+project.lock.json
+project.fragment.lock.json
+artifacts/
+
+# ASP.NET Scaffolding
+ScaffoldingReadMe.txt
+
+# StyleCop
+StyleCopReport.xml
+
+# Files built by Visual Studio
+*_i.c
+*_p.c
+*_h.h
+*.ilk
+*.meta
+*.obj
+*.iobj
+*.pch
+*.pdb
+*.ipdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*_wpftmp.csproj
+*.log
+*.tlog
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# Visual Studio Trace Files
+*.e2e
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# AxoCover is a Code Coverage Tool
+.axoCover/*
+!.axoCover/settings.json
+
+# Coverlet is a free, cross platform Code Coverage Tool
+coverage*.json
+coverage*.xml
+coverage*.info
+
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# Note: Comment the next line if you want to checkin your web deploy settings,
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
+# NuGet Packages
+*.nupkg
+# NuGet Symbol Packages
+*.snupkg
+# The packages folder can be ignored because of Package Restore
+**/[Pp]ackages/*
+# except build/, which is used as an MSBuild target.
+!**/[Pp]ackages/build/
+# and the packages/backend and packages/frontend folders, since they contain our source code
+!**/[Pp]ackages/backend/
+!**/[Pp]ackages/frontend/
+!**/[Pp]ackages/frontend-old/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/[Pp]ackages/repositories.config
+# NuGet v3's project.json files produces more ignorable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Windows Store app package directories and files
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+*.appx
+*.appxbundle
+*.appxupload
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!?*.[Cc]ache/
+
+# Others
+ClientBin/
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.jfm
+*.pfx
+*.publishsettings
+orleans.codegen.cs
+
+# Including strong name files can present a security risk
+# (https://github.com/github/gitignore/pull/2483#issue-259490424)
+#*.snk
+
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+ServiceFabricBackup/
+*.rptproj.bak
+
+# SQL Server files
+*.mdf
+*.ldf
+*.ndf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+*.rptproj.rsuser
+*- [Bb]ackup.rdl
+*- [Bb]ackup ([0-9]).rdl
+*- [Bb]ackup ([0-9][0-9]).rdl
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+node_modules/
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
+*.vbw
+
+# Visual Studio 6 auto-generated project file (contains which files were open etc.)
+*.vbp
+
+# Visual Studio 6 workspace and project file (working project files containing files to include in project)
+*.dsw
+*.dsp
+
+# Visual Studio 6 technical files
+*.ncb
+*.aps
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+.paket/paket.exe
+paket-files/
+
+# FAKE - F# Make
+.fake/
+
+# CodeRush personal settings
+.cr/personal
+
+# Python Tools for Visual Studio (PTVS)
+__pycache__/
+*.pyc
+
+# Cake - Uncomment if you are using it
+# tools/**
+# !tools/packages.config
+
+# Tabs Studio
+*.tss
+
+# Telerik's JustMock configuration file
+*.jmconfig
+
+# BizTalk build output
+*.btp.cs
+*.btm.cs
+*.odx.cs
+*.xsd.cs
+
+# OpenCover UI analysis results
+OpenCover/
+
+# Azure Stream Analytics local run output
+ASALocalRun/
+
+# MSBuild Binary and Structured Log
+*.binlog
+
+# NVidia Nsight GPU debugger configuration file
+*.nvuser
+
+# MFractors (Xamarin productivity tool) working folder
+.mfractor/
+
+# Local History for Visual Studio
+.localhistory/
+
+# Visual Studio History (VSHistory) files
+.vshistory/
+
+# BeatPulse healthcheck temp database
+healthchecksdb
+
+# Backup folder for Package Reference Convert tool in Visual Studio 2017
+MigrationBackup/
+
+# Ionide (cross platform F# VS Code tools) working folder
+.ionide/
+
+# Fody - auto-generated XML schema
+FodyWeavers.xsd
+
+# VS Code files for those working on multiple tools
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+*.code-workspace
+
+# Local History for Visual Studio Code
+.history/
+
+# Windows Installer files from build outputs
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# JetBrains Rider
+*.sln.iml
+
+# Frontend
+.DS_Store
+node_modules/
+/dist/
+
+# local env files
+.env.local
+.env.*.local
+
+# Log files
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Editor directories and files
+.idea
+.vscode
+*.suo
+*.ntvs*
+*.njsproj
+*.sw*

packages/backend/Controllers/AuthenticationController.cs

@@ -0,0 +1,76 @@
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Authentication.Cookies;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+using Serilog;
+using System.Security.Claims;
+using YaleAccess.Models;
+
+namespace YaleAccess.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    [EnableCors]
+    [Authorize]
+    public class AuthenticationController : ControllerBase
+    {
+        private readonly Models.Options.AuthenticationOptions _authenticationOptions;
+
+        public AuthenticationController(IOptions<Models.Options.AuthenticationOptions> authenticationOptions)
+        {
+            _authenticationOptions = authenticationOptions.Value;
+        }
+
+        [HttpPost("login")]
+        [AllowAnonymous]
+        public async Task<IActionResult> Login([FromBody] string password)
+        {
+            try
+            {
+                // Check if the password is correct
+                if (password != _authenticationOptions.Password)
+                {
+                    return Unauthorized(new ApiResponse("Incorrect password."));
+                }
+
+                // Log the user in 
+                List<Claim> claims = new()
+                {
+                    new Claim(ClaimTypes.Name, "YaleAccess")
+                };
+                ClaimsIdentity claimsIdentity = new(claims, CookieAuthenticationDefaults.AuthenticationScheme);
+                ClaimsPrincipal claimsPrincipal = new(claimsIdentity);
+                 
+                await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, claimsPrincipal);
+
+                // Return the response
+                return Ok(new ApiResponse(true));
+            }
+            catch(Exception ex)
+            {
+                Log.Logger.Error(ex, "An error occurred logging in.");
+                return BadRequest(new ApiResponse("An error occurred logging in."));
+            }
+        }
+
+        [HttpPost("logout")]
+        [AllowAnonymous]
+        public async Task<IActionResult> Logout()
+        {
+            try
+            {
+                // Sign the user out
+                await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
+
+                return Ok(new ApiResponse(true));
+            }
+            catch (Exception ex)
+            {
+                Log.Logger.Error(ex, "An error occured logging out.");
+                return BadRequest(new ApiResponse("An error occured logging out."));
+            }
+        }
+    }
+}

packages/backend/Controllers/HealthController.cs

@@ -0,0 +1,22 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+using Serilog;
+
+namespace YaleAccess.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    [EnableCors]
+    [Authorize]
+    public class HealthController : ControllerBase
+    {
+        [HttpGet]
+        [AllowAnonymous]
+        public IActionResult Health()
+        {
+            Log.Logger.Information("Hit the health endpoint.");
+            return Ok("Service is healthy");
+        }        
+    }
+}

packages/backend/Controllers/PeopleController.cs

@@ -0,0 +1,84 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Serilog;
+using YaleAccess.Data;
+using YaleAccess.Models;
+
+namespace YaleAccess.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    [EnableCors]
+    [Authorize]
+    public class PeopleController : ControllerBase
+    {
+        private readonly YaleContext _context;
+
+        public PeopleController(YaleContext context)
+        {
+            _context = context;
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> GetPeople()
+        {
+            try
+            {
+                // Return all people
+                List<Person> people = await _context.People.ToListAsync();
+                return Ok(new ApiResponse(people));
+            }
+            catch (Exception ex)
+            {
+                Log.Logger.Error(ex, "An error occured retriving the people.");
+                return BadRequest(new ApiResponse("An error occured retriving the people."));
+            }
+        }
+
+        [HttpPost]
+        public async Task<IActionResult> CreatePerson([FromBody] Person person)
+        {
+            try
+            {
+                // Create a new person 
+                Person newPerson = new() { Name = person.Name, PhoneNumber = person.PhoneNumber };
+
+                // Add the person
+                await _context.AddAsync(newPerson);
+                await _context.SaveChangesAsync();
+
+                // Return the newly created person
+                return Ok(new ApiResponse(newPerson));
+            }
+            catch (Exception ex)
+            {
+                Log.Logger.Error(ex, "An error occured creating the person.");
+                return BadRequest(new ApiResponse("An error occured creating the person."));
+            }
+        }
+
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeletePerson([FromRoute] int id)
+        {
+            try
+            {
+                // Ensure the person exists
+                Person person = await _context.People.FindAsync(id) ?? throw new Exception("Person not found.");
+
+                // Remove the person
+                _context.Remove(person);
+                await _context.SaveChangesAsync();
+
+                // Return the newly removed person
+                return Ok(new ApiResponse(person));
+            }
+            catch (Exception ex)
+            {
+                Log.Logger.Error(ex, "An error occured deletiong the person.");
+                return BadRequest(new ApiResponse("An error occured deletiong the person."));
+            }
+        }
+    }
+}

packages/backend/Controllers/YaleController.cs

@@ -0,0 +1,148 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Cors;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+using Serilog;
+using YaleAccess.Models;
+using YaleAccess.Models.Options;
+using YaleAccess.Services;
+using YaleAccess.Services.Interfaces;
+
+namespace YaleAccess.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    [EnableCors]
+    [Authorize]
+    public class YaleController : ControllerBase
+    {
+        private readonly IYaleAccessor _yaleAccessor;
+        private readonly CodesOptions _codeOptions;
+        private readonly SMSService _smsService;
+
+        public YaleController(IYaleAccessor yaleAccessor, IOptions<CodesOptions> codeOptions, SMSService smsService)
+        {
+            _yaleAccessor = yaleAccessor;
+            _codeOptions = codeOptions.Value;
+            _smsService = smsService;
+        }
+
+        [HttpGet("codes")]
+        public async Task<IActionResult> GetUserCodes()
+        {
+            try
+            {
+                // Get the home code first
+                YaleUserCode homeCode = await _yaleAccessor.GetCodeInformationAsync(_codeOptions.Home);
+                homeCode.IsHome = true;
+
+                // Get the guest codes
+                List<YaleUserCode> guestCodes = new();
+                foreach (int code in Enumerable.Range(_codeOptions.GuestCodeRangeStart, _codeOptions.GuestCodeRangeCount))
+                {
+                    guestCodes.Add(await _yaleAccessor.GetCodeInformationAsync(code));
+                }
+
+                // Add the home code to the list
+                guestCodes.Add(homeCode);
+
+                // Return the codes
+                return Ok(new ApiResponse(guestCodes));
+            }
+            catch(Exception ex)
+            {
+                Log.Logger.Error(ex, "An error occurred retriving the codes.");
+                return BadRequest(new ApiResponse("An error occurred retriving the codes."));
+            }
+        }
+
+        [HttpPost("code/{id}")]
+        public async Task<IActionResult> SetUserCode([FromRoute] int id, [FromBody] string newCode)
+        {
+            try
+            {
+                // First validate the user code
+                string validCode = YaleAccessor.ValidateCode(newCode);
+                if (validCode != string.Empty)
+                {
+                    return BadRequest(new ApiResponse(validCode));
+                }
+
+                // Set the new code
+                bool result = await _yaleAccessor.SetUserCode(id, newCode);
+
+                // Return the result
+                if (result)
+                {
+                    Log.Logger.Information("Updated code for user {id} to {code}", id, newCode);
+                    return Ok(new ApiResponse(true));
+                }
+                else
+                {
+                    Log.Logger.Information("Failed to update code for user {id} to {code}", id, newCode);
+                    return BadRequest(new ApiResponse("An error occurred setting the code."));
+                }
+            }
+            catch (Exception ex)
+            {
+                Log.Logger.Error(ex, "An error occurred setting the code.");
+                return BadRequest(new ApiResponse("An error occurred setting the code."));
+            }
+        }
+
+        [HttpPost("code/{id}/status")]
+        public async Task<IActionResult> SetUserCodeStatusAsAvailable([FromRoute] int id)
+        {
+            try
+            {
+                // First validate the user code
+                string validCode = YaleAccessor.ValidateClearCode(id, _codeOptions.Home);
+                if (validCode != string.Empty)
+                {
+                    return BadRequest(new ApiResponse(validCode));
+                }
+
+                // Set the available status
+                bool result = await _yaleAccessor.SetCodeAsAvailable(id);
+
+                // Return the result
+                if (result)
+                {
+                    Log.Logger.Information("Updated code status for user {id} to available", id);
+                    return Ok(new ApiResponse(true));
+                }
+                else
+                {
+                    Log.Logger.Information("Failed to update code status for user {id} to available", id);
+                    return BadRequest(new ApiResponse("An error occurred setting the code status."));
+                }
+            }
+            catch (Exception ex)
+            {
+                Log.Logger.Error(ex, "An error occurred setting the code status.");
+                return BadRequest(new ApiResponse("An error occurred setting the code status."));
+            }
+        }
+
+        [HttpPost("code/{id}/send")]
+        public async Task<IActionResult> SendUserCode([FromRoute] int id, [FromBody] string phoneNumber)
+        {
+            try
+            {
+                // Get the user code
+                YaleUserCode userCode = await _yaleAccessor.GetCodeInformationAsync(id);
+
+                // Send the code via SMS to the phone number
+                await _smsService.SendCodeViaSMSAsync(userCode.Code, phoneNumber);
+
+                // Return success
+                return Ok(new ApiResponse(true));
+            }
+            catch (Exception ex)
+            {
+                Log.Logger.Error(ex, "An error occurred sending the code.");
+                return BadRequest(new ApiResponse("An error occurred sending the code."));
+            }
+        }
+    }
+}

packages/backend/Data/Person.cs

@@ -0,0 +1,9 @@
+namespace YaleAccess.Data
+{
+    public class Person
+    {
+        public int Id { get; set; }
+        public string Name { get; set; } = string.Empty;
+        public string PhoneNumber { get; set; } = string.Empty;
+    }
+}

packages/backend/Data/YaleContext.cs

@@ -0,0 +1,11 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace YaleAccess.Data
+{
+    public class YaleContext : DbContext
+    {
+        public YaleContext(DbContextOptions<YaleContext> options) : base(options) { }
+
+        public DbSet<Person> People { get; set; }
+    }
+}

packages/backend/Dockerfile

@@ -0,0 +1,21 @@
+FROM mcr.microsoft.com/dotnet/aspnet:7.0 AS base
+WORKDIR /app
+EXPOSE 80
+
+FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
+WORKDIR /src
+COPY ["YaleAccess.csproj", "."]
+RUN dotnet restore "./YaleAccess.csproj"
+COPY . .
+WORKDIR "/src/."
+RUN dotnet build "YaleAccess.csproj" -c Release -o /app/build
+
+FROM build AS publish
+RUN dotnet publish "YaleAccess.csproj" -c Release -o /app/publish /p:UseAppHost=false
+
+FROM base AS final
+RUN mkdir /yale-data
+ENV ConnectionStrings__YaleContext="Data Source=/yale-data/yale-access.db"
+WORKDIR /app
+COPY --from=publish /app/publish .
+ENTRYPOINT ["dotnet", "YaleAccess.dll"]

packages/backend/Migrations/20250109010459_AddedPeople.Designer.cs

@@ -0,0 +1,43 @@
+// <auto-generated />
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using YaleAccess.Data;
+
+#nullable disable
+
+namespace YaleAccess.Migrations
+{
+    [DbContext(typeof(YaleContext))]
+    [Migration("20250109010459_AddedPeople")]
+    partial class AddedPeople
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "7.0.20");
+
+            modelBuilder.Entity("YaleAccess.Data.Person", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PhoneNumber")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("People");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

packages/backend/Migrations/20250109010459_AddedPeople.cs

@@ -0,0 +1,35 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace YaleAccess.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddedPeople : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "People",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    Name = table.Column<string>(type: "TEXT", nullable: false),
+                    PhoneNumber = table.Column<string>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_People", x => x.Id);
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "People");
+        }
+    }
+}

packages/backend/Migrations/YaleContextModelSnapshot.cs

@@ -0,0 +1,40 @@
+// <auto-generated />
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using YaleAccess.Data;
+
+#nullable disable
+
+namespace YaleAccess.Migrations
+{
+    [DbContext(typeof(YaleContext))]
+    partial class YaleContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "7.0.20");
+
+            modelBuilder.Entity("YaleAccess.Data.Person", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PhoneNumber")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("People");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

packages/backend/Models/ApiResponse.cs

@@ -0,0 +1,29 @@
+namespace YaleAccess.Models
+{
+    public class ApiResponse
+    {
+        public bool Success { get; set; }
+        public string? Error { get; set; }
+        public object? Data { get; set; }
+
+        /// <summary>
+        /// If passing in data only then the resonse is successful
+        /// </summary>
+        /// <param name="data"></param>
+        public ApiResponse(object data)
+        {
+            Success = true;
+            Data = data;
+        }
+
+        /// <summary>
+        /// If passing in an error then the response is not successful
+        /// </summary>
+        /// <param name="error"></param>
+        public ApiResponse(string error)
+        {
+            Success = false;
+            Error = error;
+        }
+    }
+}

packages/backend/Models/Options/AuthenticationOptions.cs

@@ -0,0 +1,9 @@
+namespace YaleAccess.Models.Options
+{
+    public class AuthenticationOptions
+    {
+        public const string Authentication = "Authentication";
+
+        public string Password { get; set; } = string.Empty;
+    }
+}

packages/backend/Models/Options/CodesOptions.cs

@@ -0,0 +1,11 @@
+namespace YaleAccess.Models.Options
+{
+    public class CodesOptions
+    {
+        public const string Codes = "Codes";
+
+        public int Home { get; set; }
+        public int GuestCodeRangeStart { get; set; }
+        public int GuestCodeRangeCount { get; set; }
+    }
+}

packages/backend/Models/Options/DevicesOptions.cs

@@ -0,0 +1,9 @@
+namespace YaleAccess.Models.Options
+{
+    public class DevicesOptions
+    {
+        public const string Devices = "Devices";
+
+        public int YaleLockNodeId { get; set; }
+    }
+}

packages/backend/Models/Options/TwiloOptions.cs

@@ -0,0 +1,12 @@
+namespace YaleAccess.Models.Options
+{
+    public class TwiloOptions
+    {
+        public const string Twilio = "Twilio";
+
+        public string AccountSid { get; set; } = string.Empty;
+        public string AuthToken { get; set; } = string.Empty;
+        public string FromNumber { get; set; } = string.Empty;
+        public string Message { get; set; } = string.Empty;
+    }
+}

packages/backend/Models/Options/ZWaveOptions.cs

@@ -0,0 +1,10 @@
+namespace YaleAccess.Models.Options
+{
+    public class ZWaveOptions
+    {
+        public const string ZWave = "ZWave";
+
+        public string Url { get; set; } = null!;
+        public int SchemaVersion { get; set; }
+    }
+}

packages/backend/Models/YaleModels.cs

@@ -0,0 +1,45 @@
+namespace YaleAccess.Models
+{
+    public class YaleUserCode
+    { 
+        /// <summary>
+        /// The ID of the user code. When making requets to ZWave.JS API, this is the value to use.
+        /// </summary>
+        public int Id { get; set; }
+
+        /// <summary>
+        /// The code / pin number for the user code. This may be null if the user code is not set or is not in use.
+        /// Even though its a string, it is a number and appropriate validation is required.
+        /// </summary>
+        public string Code { get; set; } = string.Empty;
+
+        /// <summary>
+        /// The current status of the user code.
+        /// </summary>
+        public UserCodeStatus Status { get; set; }
+
+        /// <summary>
+        /// Is true is this is the 'home' or normal user code for daily use.
+        /// </summary>
+        public bool IsHome { get; set; }
+    }
+
+    public enum UserCodeStatus
+    {
+        /// <summary>
+        /// This means the code is not being used, and can be assigned
+        /// </summary>
+        AVAILABLE = 0,
+
+        /// <summary>
+        /// This means that the code is in used, and cannot be assigned
+        /// </summary>
+        ENABLED = 1,
+
+        /// <summary>
+        /// Not sure what this means yet, perhaps it is related to schedules?
+        /// </summary>
+        DISABLED = 2
+    }
+
+}

packages/backend/Program.cs

@@ -0,0 +1,154 @@
+using Microsoft.AspNetCore.Authentication.Cookies;
+using Microsoft.AspNetCore.HttpOverrides;
+using Microsoft.EntityFrameworkCore;
+using Serilog;
+using Serilog.Events;
+using YaleAccess.Data;
+using YaleAccess.Models.Options;
+using YaleAccess.Services;
+using YaleAccess.Services.Interfaces;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// Create the bootstraper logger
+Log.Logger = new LoggerConfiguration()
+            .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
+            .Enrich.FromLogContext()
+            .WriteTo.Console()
+            .CreateLogger();
+
+try
+{
+    // Add services to the container.
+    builder.Services.AddControllers();
+
+    // Add the database context
+    builder.Services.AddDbContext<YaleContext>(options =>
+    {
+        options.UseSqlite(builder.Configuration.GetConnectionString(nameof(YaleContext)));
+    });
+
+    // Configure the options
+    builder.Services.Configure<AuthenticationOptions>(builder.Configuration.GetSection(AuthenticationOptions.Authentication));
+    builder.Services.Configure<CodesOptions>(builder.Configuration.GetSection(CodesOptions.Codes));
+    builder.Services.Configure<DevicesOptions>(builder.Configuration.GetSection(DevicesOptions.Devices));
+    builder.Services.Configure<ZWaveOptions>(builder.Configuration.GetSection(ZWaveOptions.ZWave));
+    builder.Services.Configure<TwiloOptions>(builder.Configuration.GetSection(TwiloOptions.Twilio));
+
+    // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
+    builder.Services.AddEndpointsApiExplorer();
+    builder.Services.AddSwaggerGen();
+
+    // Get a copy of the configuration
+    IConfiguration configuration = builder.Configuration;
+    string logLocation = configuration["LogLocation"] ?? "Log.txt";
+
+    // Setup the application logger
+    Log.Logger = new LoggerConfiguration()
+                .WriteTo.Console(restrictedToMinimumLevel: LogEventLevel.Error)
+                .WriteTo.File(logLocation, rollingInterval: RollingInterval.Day)
+                .CreateLogger();
+
+    // Configure the DI services
+    builder.Services.AddScoped<SMSService>();
+
+    // If the environment is development and the mock option is set to true, use the mock service
+    if (builder.Environment.IsDevelopment() && configuration.GetValue<bool>("UseMockDevelopmentMode"))
+    {
+        builder.Services.AddSingleton<MockYaleData>();
+        builder.Services.AddScoped<IYaleAccessor, MockYaleAccessor>();
+    }
+    else
+    {
+        builder.Services.AddScoped<IYaleAccessor, YaleAccessor>();
+    }
+    
+
+    // Setup CORS
+    string[] corsAllowedOrigins = (configuration["CorsAllowedOrigins"] ?? "http://localhost:3000").Split(",") ;
+    builder.Services.AddCors(options =>
+    {
+        options.AddDefaultPolicy(policy =>
+        {
+            policy.WithOrigins(corsAllowedOrigins)
+                .AllowCredentials()
+                .AllowAnyMethod()
+                .WithHeaders("Content-Type", "Authorization");
+        });
+    });
+
+    // Setup cookie authentication scheme
+    builder.Services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
+        .AddCookie(options =>
+        {
+            // Set HTTP only to true to prevent XSS attacks
+            options.Cookie.HttpOnly = true;
+
+            // Set secure policy to always to prevent sending cookies over HTTP for production use, for development set to None
+            if (builder.Environment.IsDevelopment())
+                options.Cookie.SecurePolicy = CookieSecurePolicy.None;
+            else
+                options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
+            
+            // Ensure that the API will return a 401 Unauthorized instead of redirecting to the login page
+            options.AccessDeniedPath = string.Empty;
+            options.LoginPath = string.Empty;
+            options.Events.OnRedirectToLogin = context =>
+            {
+                context.Response.StatusCode = 401;
+                return Task.CompletedTask;
+            };
+        });
+
+    // Setup logging flow
+    builder.Host.UseSerilog();
+
+    var app = builder.Build();
+
+    // Create the database if it doesn't exist
+    using (var scope = app.Services.CreateScope())
+    {
+        var services = scope.ServiceProvider;
+        var context = services.GetRequiredService<YaleContext>();
+        context.Database.Migrate();
+    }
+
+    // Configure the forwarded headers middleware
+    app.UseForwardedHeaders(new ForwardedHeadersOptions
+    {
+        ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
+    });
+
+    // Configure the HTTP request pipeline.
+    if (app.Environment.IsDevelopment())
+    {
+        app.UseSwagger();
+        app.UseSwaggerUI();
+    }
+
+    app.UseHttpsRedirection();
+
+    app.UseCors();
+
+    app.UseAuthentication();
+
+    app.UseAuthorization();
+
+    app.MapControllers();
+
+    app.Run();
+
+}
+catch (Exception ex)
+{
+    // Ignore host aborted exceptions caused by build checks
+    if (ex is not HostAbortedException)
+    {
+        Log.Fatal(ex, "Host terminated unexpectedly");
+        throw;
+    }
+}
+finally
+{
+    Log.CloseAndFlush();
+}

packages/backend/Properties/launchSettings.json

@@ -0,0 +1,51 @@
+{
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "dotnetRunMessages": true,
+      "applicationUrl": "http://localhost:5051"
+    },
+    "https": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "dotnetRunMessages": true,
+      "applicationUrl": "https://localhost:7069;http://localhost:5051"
+    },
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "Docker": {
+      "commandName": "Docker",
+      "launchBrowser": true,
+      "launchUrl": "{Scheme}://{ServiceHost}:{ServicePort}/swagger",
+      "environmentVariables": {
+        "ASPNETCORE_URLS": "https://+:443;http://+:80"
+      },
+      "publishAllPorts": true,
+      "useSSL": true
+    }
+  },
+  "$schema": "https://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:62005",
+      "sslPort": 44335
+    }
+  }
+}

packages/backend/Services/Interfaces/IYaleAccessor.cs

@@ -0,0 +1,11 @@
+using YaleAccess.Models;
+
+namespace YaleAccess.Services.Interfaces
+{
+    public interface IYaleAccessor
+    {
+        public Task<YaleUserCode> GetCodeInformationAsync(int userCodeId);
+        public Task<bool> SetUserCode(int userCodeId, string code);
+        public Task<bool> SetCodeAsAvailable(int userCode);
+    }
+}

packages/backend/Services/MockYaleAccessor.cs

@@ -0,0 +1,30 @@
+using YaleAccess.Models;
+using YaleAccess.Services.Interfaces;
+
+namespace YaleAccess.Services
+{
+    public class MockYaleAccessor : IYaleAccessor
+    {
+        private readonly MockYaleData _data;
+
+        public MockYaleAccessor(MockYaleData data)
+        {
+            _data = data;
+        }
+
+        public Task<YaleUserCode> GetCodeInformationAsync(int userCodeId)
+        {
+            return Task.FromResult(_data.GetUserCode(userCodeId));
+        }
+
+        public Task<bool> SetCodeAsAvailable(int userCode)
+        {
+            return Task.FromResult(_data.SetUserCodeAsAvailable(userCode));
+        }
+
+        public Task<bool> SetUserCode(int userCodeId, string code)
+        {
+            return Task.FromResult(_data.SetUserCode(userCodeId, code));
+        }
+    }
+}

packages/backend/Services/MockYaleData.cs

@@ -0,0 +1,78 @@
+using YaleAccess.Models;
+
+namespace YaleAccess.Services
+{
+    public class MockYaleData
+    {
+        public List<YaleUserCode> UserCodes { get; set; } = new();
+
+        public MockYaleData()
+        {
+            // Create the home code
+            YaleUserCode homeCode = new()
+            {
+                Id = 1,
+                Code = "1234",
+                IsHome = true,
+                Status = UserCodeStatus.ENABLED
+            };
+
+            // Create 5 guest codes
+            List<YaleUserCode> guestCodes = new();
+            foreach (int code in Enumerable.Range(2, 5))
+            {
+                guestCodes.Add(new YaleUserCode()
+                {
+                    Id = code,
+                    Code = "",
+                    IsHome = false,
+                    Status = UserCodeStatus.AVAILABLE
+                });
+            }
+
+            // Add the home code to the list
+            guestCodes.Add(homeCode);
+
+            // Set the user codes
+            UserCodes = guestCodes;
+        }
+
+        public YaleUserCode GetUserCode(int id)
+        {
+            return UserCodes.First(x => x.Id == id);
+        }
+
+        public bool SetUserCode(int id, string code)
+        {
+            // Get the user code
+            YaleUserCode userCode = GetUserCode(id);
+
+            // Set the code
+            userCode.Code = code;
+
+            // Update code status
+            userCode.Status = UserCodeStatus.ENABLED;
+
+            // Update the user code in the list
+            UserCodes[UserCodes.IndexOf(userCode)] = userCode;
+
+            // Return true to indicate success
+            return true;
+        }
+
+        public bool SetUserCodeAsAvailable(int id)
+        {
+            // Get the user code
+            YaleUserCode userCode = GetUserCode(id);
+
+            // Set the code
+            userCode.Status = UserCodeStatus.AVAILABLE;
+
+            // Update the user code in the list
+            UserCodes[UserCodes.IndexOf(userCode)] = userCode;
+
+            // Return true to indicate success
+            return true;
+        }
+    }
+}

packages/backend/Services/SMSService.cs

@@ -0,0 +1,35 @@
+using Microsoft.Extensions.Options;
+using Serilog;
+using Twilio;
+using Twilio.Rest.Api.V2010.Account;
+using YaleAccess.Models.Options;
+
+namespace YaleAccess.Services
+{
+    public class SMSService
+    {
+        private readonly TwiloOptions _twiloOptions;
+
+        public SMSService(IOptions<TwiloOptions> twiloOptions)
+        {
+            _twiloOptions = twiloOptions.Value;
+        }
+
+        public async Task SendCodeViaSMSAsync(string code, string phoneNumber)
+        {
+            // Create a Twilio client
+            TwilioClient.Init(_twiloOptions.AccountSid, _twiloOptions.AuthToken);
+
+            // Send the message
+            var message = await MessageResource.CreateAsync(
+                body: $"{_twiloOptions.Message} {code}",
+                from: new Twilio.Types.PhoneNumber(_twiloOptions.FromNumber),
+                to: new Twilio.Types.PhoneNumber(phoneNumber)
+            );
+
+            // Log the message
+            Log.Logger.Information("SMS sent to {PhoneNumber} with message SID {MessageSid}.", phoneNumber, message.Sid);
+            Log.Logger.Debug("SMS message: {MessageBody}", message.Body);
+        }
+    }
+}

packages/backend/Services/YaleAccessor.cs

@@ -0,0 +1,195 @@
+using Microsoft.Extensions.Options;
+using Newtonsoft.Json.Linq;
+using Serilog;
+using YaleAccess.Models;
+using YaleAccess.Models.Options;
+using YaleAccess.Services.Interfaces;
+using ZWaveJS.NET;
+using ZWaveOptions = YaleAccess.Models.Options.ZWaveOptions;
+
+namespace YaleAccess.Services
+{
+    public class YaleAccessor : IYaleAccessor, IDisposable
+    {
+        #region Dispose Logic
+
+        private bool disposedValue;
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!disposedValue)
+            {
+                if (disposing)
+                {
+                    driver?.Destroy();
+                }
+
+                disposedValue = true;
+                driver = null;
+            }
+        }
+
+        public void Dispose()
+        {
+            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
+            Dispose(disposing: true);
+            GC.SuppressFinalize(this);
+        }
+
+        #endregion Dispose Logic
+
+        private Driver? driver = null;
+        private readonly ZWaveNode lockNode = null!;
+
+        public YaleAccessor(IOptions<ZWaveOptions> zwave, IOptions<DevicesOptions> device)
+        {
+            // Retrive options from configuration
+            ZWaveOptions zwaveOptions = zwave.Value;
+            DevicesOptions devicesOptions = device.Value;
+
+            // Create a new driver instance
+            driver = new Driver(new Uri(zwaveOptions.Url), zwaveOptions.SchemaVersion);
+
+            // Start the driver
+            driver.Start();
+
+            // Flag to indicate if the driver is ready to use
+            bool isReady = false;
+
+            // Subscribe to the driver ready event
+            driver.DriverReady += () =>
+            {
+                isReady = true;
+            };
+
+            driver.StartUpError += (message) =>
+            {
+                throw new Exception(message);
+            };
+
+            // Wait for the driver to be ready
+            while (!isReady)
+            {
+                Thread.Sleep(100);
+            }
+
+            // Get the lock node from the driver
+            lockNode = driver.Controller.Nodes.Get(devicesOptions.YaleLockNodeId);
+        }
+
+        public async Task<YaleUserCode> GetCodeInformationAsync(int userCodeId)
+        {
+            // Setup the two tasks to get the values we need
+            CMDResult status = await lockNode.GetValue(GetUserStatusValue(userCodeId));
+            CMDResult code = await lockNode.GetValue(GetUserCodeValue(userCodeId));
+
+            // Covert the result to a YaleUserCode object
+            return new YaleUserCode()
+            {
+                Id = userCodeId,
+                Code = GetUserCodeValue(code),
+                Status = GetUserStatusValue(status),
+                IsHome = false
+            };
+        }
+
+        public async Task<bool> SetUserCode(int userCodeId, string code)
+        {
+            // Setup the set value task
+            CMDResult result = await lockNode.SetValue(GetUserCodeValue(userCodeId), code);
+
+            // If the result is not successful log the message
+            if (!result.Success)
+            {
+                Log.Logger.Error("Failed to set user code {@userCodeId} to {@code}. Error message: {message}", userCodeId, code, result.Message);
+            }
+
+            // Return the result
+            return result.Success;
+        }
+
+        public async Task<bool> SetCodeAsAvailable(int userCode)
+        {
+            // Setup the set value task
+            CMDResult result = await lockNode.SetValue(GetUserStatusValue(userCode), (int)UserCodeStatus.AVAILABLE);
+
+            // If the result is not successful log the message
+            if (!result.Success)
+            {
+                Log.Logger.Error("Failed to set user code {@userCode} to available status. Error message: {message}", userCode, result.Message);
+            }
+
+            // Return the result
+            return result.Success;
+        }
+
+        private static UserCodeStatus GetUserStatusValue(CMDResult result)
+        {
+            // Parse the payload as a JSON object
+            JObject payloadObject = (JObject)result.ResultPayload;
+
+            // Return the value property
+            return (UserCodeStatus)payloadObject.GetValue("value")!.ToObject<int>();
+        }
+
+        private static string GetUserCodeValue(CMDResult result)
+        {
+            // Parse the payload as a JSON object
+            JObject payloadObject = (JObject)result.ResultPayload;
+
+            // Return the value property
+            return payloadObject.GetValue("value")!.ToString();
+        }
+
+        private static ValueID GetUserStatusValue(int userCodeId)
+        {
+            return new ValueID()
+            {
+                commandClass = 99,
+                endpoint = 0,
+                property = "userIdStatus",
+                propertyKey = userCodeId
+            };
+        }
+
+        private static ValueID GetUserCodeValue(int userCodeId)
+        {
+            return new ValueID()
+            {
+                commandClass = 99,
+                endpoint = 0,
+                property = "userCode",
+                propertyKey = userCodeId
+            };
+        }
+
+        public static string ValidateCode(string newCode)
+        {
+            // The code must be between 4 and 6 digits
+            if (newCode.Length < 4 || newCode.Length > 6)
+            {
+                return "The code must be between 4 and 6 digits.";
+            }
+
+            // The code must be numeric
+            if (!int.TryParse(newCode, out int _))
+            {
+                return "The code must be numeric.";
+            }
+
+            // Otherwise, the code is valid, return an empty string
+            return string.Empty;
+        }
+
+        public static string ValidateClearCode(int codeId, int homeCodeId)
+        {
+            // If the code is the home code, return an error message
+            if (codeId == homeCodeId)
+            {
+                return "The home code cannot be cleared.";
+            }
+
+            return string.Empty;
+        }
+    }
+}

packages/backend/Templates/secrets.template.json

@@ -0,0 +1,25 @@
+{
+  "LogLocation": "<Location>/Log.txt", // Location of the log file
+  "CorsAllowedOrigins": "http://localhost:5173", // The URL of the frontend SPA
+  "Devices": {
+    "YaleLockNodeId": "?" // The yale lock node id from your ZWave Network
+  },
+  "Codes": {
+    "Home": 1, // Home user code 
+    "GuestCodeRangeStart": 2, // Guest or user codes start ID
+    "GuestCodeRangeCount": 5 // Guest or user codes count
+  },
+  "ZWave": {
+    "Url": "ws://localhost:3000", // The URL of the ZWave Server
+    "SchemaVersion": "?" // The schema version of your ZWave Network
+  },
+  "Authentication": {
+    "Password": "<Password>" // Password to access the YaleAccess Portal
+  },
+  "Twilio": {
+    "AccountSid": "<SID>",
+    "AuthToken": "<Auth>",
+    "FromNumber": "<From Number>",
+    "Message": "<Message>"
+  }
+}

packages/backend/YaleAccess.csproj

@@ -0,0 +1,51 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <UserSecretsId>83aa9238-2d6b-483c-b60d-886f32d17532</UserSecretsId>
+    <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+    <DockerfileContext>.</DockerfileContext>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="Templates\**" />
+    <Content Remove="Templates\**" />
+    <EmbeddedResource Remove="Templates\**" />
+    <None Remove="Templates\**" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="7.0.13" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.20" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="7.0.20" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="7.0.20">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.19.4" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="Semver" Version="2.3.0" />
+    <PackageReference Include="Serilog" Version="3.0.1" />
+    <PackageReference Include="Serilog.AspNetCore" Version="7.0.0" />
+    <PackageReference Include="Serilog.Sinks.Console" Version="4.1.0" />
+    <PackageReference Include="Serilog.Sinks.File" Version="5.0.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
+    <PackageReference Include="System.Reactive" Version="5.0.0" />
+    <PackageReference Include="System.Threading.Channels" Version="5.0.0" />
+    <PackageReference Include="Twilio" Version="7.8.0" />
+    <PackageReference Include="Websocket.Client" Version="4.6.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="lib\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Reference Include="ZWaveJS.NET">
+      <HintPath>lib\ZWaveJS.NET.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+
+</Project>

packages/backend/YaleAccess.sln

@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.7.34221.43
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "YaleAccess", "YaleAccess.csproj", "{BC7CD738-F262-484A-9C91-CED5BBBAD2A9}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "SolutionItems", "SolutionItems", "{A93B8970-E2F5-410D-9587-72572C991A61}"
+	ProjectSection(SolutionItems) = preProject
+		..\..\README.md = ..\..\README.md
+		Templates\secrets.template.json = Templates\secrets.template.json
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{BC7CD738-F262-484A-9C91-CED5BBBAD2A9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{BC7CD738-F262-484A-9C91-CED5BBBAD2A9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{BC7CD738-F262-484A-9C91-CED5BBBAD2A9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{BC7CD738-F262-484A-9C91-CED5BBBAD2A9}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {6CB96495-C495-41AF-BFAB-329DFC3E350C}
+	EndGlobalSection
+EndGlobal

packages/backend/appsettings.Development.json

@@ -0,0 +1,6 @@
+{
+  "UseMockDevelopmentMode": true,
+  "ConnectionStrings": {
+    "YaleContext": "Data Source=../../development/yale.db"
+  }
+}

packages/backend/appsettings.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}