initial gitea commit

server/.env.example

@@ -0,0 +1,12 @@
+DB_USER=username
+DB_PASS=password
+DB_NAME=portfolio
+DB_HOST=localhost
+
+AUTH0_DOMAIN=domain.auth0.com
+AUTH0_API_AUDIENCE=https://audience.auth0.com/api/v2/
+AUTH0_ISSUER=https://issuer.auth0.com/
+AUTH0_ALGORITHMS=RS256
+
+CLIENT_SECRET=secret
+CLIENT_ID=id

server/.gitignore

@@ -0,0 +1,176 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python
+# Edit at https://www.toptal.com/developers/gitignore?templates=python
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+# End of https://www.toptal.com/developers/gitignore/api/python

server/README.md

@@ -0,0 +1,28 @@
+# Backend for lucasjensen.me
+
+build with FastAPI and MySQL
+
+## Setup
+
+- create and activate virtual environment
+- install requirements
+- create database with mysql, note db name
+- create .env file with db credentials (see `.env.example`)
+- ensure mysql user has permissions to create tables
+- run `create_tables.sql` to create tables
+
+```bash
+mysql -u [username] -p [database] < create_tables.sql
+```
+
+### Run
+
+```bash
+uvicorn main:app --reload --port 8001
+```
+
+### Test
+
+```bash
+pytest -s
+```

server/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.1.22"

server/config.py

@@ -0,0 +1,27 @@
+import os
+from functools import lru_cache
+
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    auth0_domain: str
+    auth0_api_audience: str
+    auth0_issuer: str
+    auth0_algorithms: str
+
+
+@lru_cache()
+def get_settings():
+    domain = os.getenv("AUTH0_DOMAIN")
+    audience = os.getenv("AUTH0_API_AUDIENCE")
+    issuer = os.getenv("AUTH0_ISSUER")
+    algorithms = os.getenv("AUTH0_ALGORITHMS")
+    if None in [domain, audience, issuer, algorithms]:
+        raise ValueError("Missing environment variables")
+    return Settings(
+        auth0_domain=domain,  # type: ignore
+        auth0_api_audience=audience,  # type: ignore
+        auth0_issuer=issuer,  # type: ignore
+        auth0_algorithms=algorithms,  # type: ignore
+    )

server/create_tables.sql

@@ -0,0 +1,91 @@
+DROP TABLE IF EXISTS `self`;
+CREATE TABLE `self` (
+    `id` INT(11) NOT NULL PRIMARY KEY AUTO_INCREMENT,
+    `name` VARCHAR(255) NOT NULL,
+    `email` VARCHAR(255) NOT NULL,
+    `bio` TEXT NOT NULL,
+    `github` VARCHAR(255) NOT NULL,
+    `auth0_sub` VARCHAR(255) NOT NULL,
+    `test_sub` VARCHAR(255) NOT NULL
+);
+INSERT INTO `self` (
+        `name`,
+        `email`,
+        `bio`,
+        `github`,
+        `auth0_sub`,
+        `test_sub`
+    )
+VALUES (
+        'Lucas Jensen',
+        'lucas.p.jensen10@gmail.com',
+        "I am a recent graduate from Oregon State University with a Bachelor's degree in Computer Science, driven by a passion for solving complex problems through technology. During my academic journey, I honed my skills and practical knowledge, setting a strong foundation for my career. My enthusiasm led me to a Software Engineering internship at Cvent, where I focused on Service Level Indicators (SLIs) and TypeScript. This experience allowed me to dive deep into the intricacies of backend development, gaining hands-on expertise in Python, FastAPI, Flask, Bash scripting, Linux, Nginx, and Systemd.\nMy commitment to delivering robust solutions is reflected in my proficiency in writing unit tests, ensuring the reliability and stability of the software I develop. I thrive in collaborative environments and have successfully contributed to team projects, understanding the importance of effective communication and cooperation. As I embark on my professional journey, I am excited to leverage my diverse skill set to tackle new challenges and make meaningful contributions to the field of computer science. Explore my portfolio to witness the intersection of my academic background and practical experiences that shape my identity as a dedicated and skilled computer scientist.",
+        'https://github.com/ljensen505',
+        'google-oauth2|103593642272149633528',
+        'FZdDeArr7QuX8qVmbKD2ggdLvlJZKEjE@clients'
+    );
+DROP TABLE IF EXISTS `projects`;
+CREATE TABLE `projects` (
+    `id` INT(255) NOT NULL PRIMARY KEY AUTO_INCREMENT,
+    `name` VARCHAR(255) NOT NULL,
+    `description` TEXT NOT NULL,
+    `source` VARCHAR(255),
+    `live` VARCHAR(255),
+    `is_self_hosted` BOOLEAN NOT NULL
+);
+INSERT INTO `projects` (
+        `name`,
+        `description`,
+        `source`,
+        `live`,
+        `is_self_hosted`
+    )
+VALUES (
+        'The Grapefruits Duo',
+        'An artist website for a local chamber music duo. Built with MySQL, FastAPI, and React with TypeScript.',
+        'https://github.com/ljensen505/TheGrapefruitsDuo',
+        'https://thegrapefruitsduo.com/',
+        TRUE
+    ),
+    (
+        'Portfolio Backend',
+        'A RESTful API for my portfolio website. Consumed by the portfolio frontend. Built with FastAPI and MySQL. Hosted on a Raspberry Pi in my living room.',
+        'https://github.com/ljensen505/portfolio-back',
+        'https://api.lucasjensen.me/',
+        TRUE
+    ),
+    (
+        'Portfolio Frontend',
+        'The frontend for my portfolio website (this very site!). Consumes the portfolio backend. Built with React and Typescript. Hosted on a Raspberry Pi in my living room.',
+        'https://github.com/ljensen505/portfolio-front',
+        'https://lucasjensen.me/',
+        TRUE
+    ),
+    (
+        'Portfolio CI/CD',
+        'A CI/CD pipeline for my portfolio website and used to auto build and deploy most projects listec here. Built with FastAPI and Bash, and heavily reliant upon GitHub Actions and Webhooks. Pipelines for each project vary but genarally utilize service files and systemd.',
+        'https://github.com/ljensen505/portfolio-pipeline',
+        NULL,
+        TRUE
+    ),
+    (
+        'Escape From Disco Love',
+        'An escape room game that unfolds across three environments: a dive bar, a 1970s disco club, and an upscale rooftop bar. Players face a 30-minute time limit to break free. As they explore, a variety of interactive objects and specific items become essential tools in solving puzzles.\nBuilt with Unity and C#, Escape from Disco Love is a 3D game that can be played natively on Windows or Mac OS, or through a browser using WebGL. Built for OSU Capstone Fall 2023 with Joshua Harris, Thomas McNutt, Daniel Joseph, and Jerrod Lepper.\nSource code is private but available upon request.',
+        NULL,
+        'https://efdl.lucasjensen.me/',
+        TRUE
+    ),
+    (
+        'Chess API',
+        'A RESTful API for playing chess online. Consumed by the Chess GUI.',
+        'https://github.com/ljensen505/chess-back',
+        'https://api.chess.v2.lucasjensen.me/',
+        TRUE
+    ),
+    (
+        'Chess',
+        'A webapp for playing chess online against a friend. Consumes the Chess API.',
+        'https://github.com/ljensen505/chess-front',
+        'https://chess.lucasjensen.me/',
+        FALSE
+    )

server/db.py

@@ -0,0 +1,34 @@
+import os
+
+import mysql.connector
+from dotenv import load_dotenv
+from fastapi import HTTPException, status
+
+
+def connect_db() -> mysql.connector.MySQLConnection:
+    load_dotenv()
+    host = os.getenv("DB_HOST")
+    user = os.getenv("DB_USER")
+    password = os.getenv("DB_PASS")
+    database = os.getenv("DB_NAME")
+
+    if None in (host, user, password, database):
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="err reading env vars",
+        )
+
+    try:
+        return mysql.connector.connect(
+            host=host,
+            user=user,
+            password=password,
+            database=database,
+            auth_plugin="mysql_native_password",
+        )  # type: ignore
+    except Exception as e:
+        print(f"err connecting to db: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="err connecting to db",
+        )

server/helpers.py

@@ -0,0 +1,46 @@
+import os
+
+from dotenv import load_dotenv
+
+origins = [
+    "http://localhost",
+    "http://localhost:3000",
+    "https://localhost:3000",
+    "https://lucasjensen.me/",
+    "https://lucasjensen.me",
+    "https://www.lucasjensen.me/",
+    "https://www.lucasjensen.me",
+]
+
+
+def get_token() -> str:
+    import http.client
+    import json
+
+    load_dotenv()
+
+    client_id = os.getenv("CLIENT_ID")
+    client_secret = os.getenv("CLIENT_SECRET")
+
+    conn = http.client.HTTPSConnection("lucasjensen.us.auth0.com")
+
+    payload = (
+        '{"client_id":"'
+        + f"{client_id}"
+        + '","client_secret":"'
+        + f"{client_secret}"
+        + '","audience":"'
+        + f"https://api.lucasjensen.me/"
+        + '","grant_type":"client_credentials"}'
+    )
+
+    headers = {"content-type": "application/json"}
+
+    conn.request("POST", "/oauth/token", payload, headers)
+
+    res = conn.getresponse()
+
+    data = res.read()
+    body = json.loads(data.decode("utf-8"))
+
+    return body["access_token"]

server/main.py

@@ -0,0 +1,133 @@
+import os
+
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException, Security, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+
+import queries
+from __version__ import __version__
+from helpers import origins
+from models import About, Project
+from utils import VerifyToken
+
+load_dotenv()
+app = FastAPI()
+auth = VerifyToken()
+
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+
+@app.get("/", status_code=status.HTTP_200_OK)
+async def root():
+    available_routes = [
+        "/",
+        "/about",
+        "/projects",
+        "/static/resume.pdf",
+        "/static/favicon.png",
+    ]
+    return {
+        "welcome": "backend api for lucasjensen.me",
+        "version": __version__,
+        "routes": available_routes,
+    }
+
+
+@app.get("/about", status_code=status.HTTP_200_OK)
+async def about() -> About:
+    try:
+        return queries.get_about()
+    except Exception as e:
+        print(f"err getting about: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"database error: {e}",
+        )
+
+
+@app.get("/projects", status_code=status.HTTP_200_OK)
+async def projects() -> list[Project]:
+    try:
+        return queries.get_projects()
+    except Exception as e:
+        print(f"err getting projects: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"database error: {e}",
+        )
+
+
+@app.get("/projects/{project_id}", status_code=status.HTTP_200_OK)
+async def project(project_id: int) -> Project:
+    project = queries.get_project(project_id)
+
+    try:
+        project = queries.get_project(project_id)
+
+    except Exception as e:
+        print(f"err getting projects: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"database error: {e}",
+        )
+    if project is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"project with id {project_id} not found",
+        )
+    return project
+
+
+@app.post("/projects", status_code=status.HTTP_201_CREATED)
+async def post_project(project: Project, auth_result=Security(auth.verify)) -> Project:
+    user_sub, test_sub = queries.get_subs().values()
+    jwt_sub = auth_result.get("sub")
+    if jwt_sub not in [user_sub, test_sub]:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="unauthorized",
+        )
+    try:
+        return queries.create_project(project)
+    except Exception as e:
+        print(f"err creating project: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"database error: {e}",
+        )
+
+
+@app.delete("/projects/{project_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_project(project_id: int, auth_result=Security(auth.verify)):
+    user_sub, test_sub = queries.get_subs().values()
+    jwt_sub = auth_result.get("sub")
+    if jwt_sub not in [user_sub, test_sub]:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="unauthorized",
+        )
+    project = queries.get_project(project_id)
+
+    if project is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"project with id {project_id} not found",
+        )
+    try:
+        return queries.delete_project(project_id)
+    except Exception as e:
+        print(f"err deleting project: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"database error: {e}",
+        )

server/models.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel
+
+
+class About(BaseModel):
+    name: str
+    email: str
+    bio: str
+    github: str
+
+
+class Project(BaseModel):
+    id: int | None = None
+    name: str
+    description: str
+    source: str | None = None
+    live: str | None = None
+    is_self_hosted: bool = False

server/queries.py

@@ -0,0 +1,67 @@
+from db import connect_db
+from models import About, Project
+
+
+def get_projects() -> list[Project]:
+    db = connect_db()
+    cursor = db.cursor(dictionary=True)
+    cursor.execute("SELECT * FROM projects")
+    data = cursor.fetchall()
+    projects = [Project(**p) for p in data]  # type: ignore
+    db.close()
+    return projects
+
+
+def get_project(project_id: int) -> Project | None:
+    db = connect_db()
+    cursor = db.cursor(dictionary=True)
+    cursor.execute("SELECT * FROM projects WHERE id=%s", (project_id,))
+    data = cursor.fetchone()
+    db.close()
+
+    return None if data is None else Project(**data)  # type: ignore
+
+
+def create_project(project: Project) -> Project:
+    db = connect_db()
+    cursor = db.cursor(dictionary=True)
+    cursor.execute(
+        "INSERT INTO projects (name, description, source, live, is_self_hosted) VALUES (%s, %s, %s, %s, %s)",
+        (
+            project.name,
+            project.description,
+            project.source,
+            project.live,
+            project.is_self_hosted,
+        ),
+    )
+    db.commit()
+    project.id = cursor.lastrowid
+    db.close()
+    return project
+
+
+def delete_project(project_id: int) -> None:
+    db = connect_db()
+    cursor = db.cursor(dictionary=True)
+    cursor.execute("DELETE FROM projects WHERE id=%s", (project_id,))
+    db.commit()
+    db.close()
+
+
+def get_about() -> About:
+    db = connect_db()
+    cursor = db.cursor(dictionary=True)
+    cursor.execute("SELECT name, email, bio, github FROM self")
+    data = {key: val for key, val in cursor.fetchone().items()}  # type: ignore
+    db.close()
+    return About(**data)
+
+
+def get_subs() -> dict[str, str]:
+    db = connect_db()
+    cursor = db.cursor(dictionary=True)
+    cursor.execute("SELECT auth0_sub, test_sub FROM self")
+    data = {key: val for key, val in cursor.fetchone().items()}  # type: ignore
+    db.close()
+    return data

server/requirements.txt

@@ -0,0 +1,47 @@
+annotated-types==0.6.0
+anyio==4.2.0
+black==23.12.1
+certifi==2023.11.17
+cffi==1.16.0
+charset-normalizer==3.3.2
+click==8.1.7
+cryptography==41.0.7
+dotted-notation==0.11.0
+fastapi==0.108.0
+h11==0.14.0
+httpcore==1.0.2
+httptools==0.6.1
+httpx==0.26.0
+idna==3.6
+iniconfig==2.0.0
+markdown-it-py==3.0.0
+mdurl==0.1.2
+mypy-extensions==1.0.0
+mysql-connector-python==8.2.0
+packaging==23.2
+pathspec==0.12.1
+platformdirs==4.1.0
+pluggy==1.3.0
+protobuf==4.21.12
+pycparser==2.21
+pydantic==2.5.3
+pydantic-settings==2.1.0
+pydantic_core==2.14.6
+Pygments==2.17.2
+PyJWT==2.8.0
+pyparsing==3.1.1
+pytest==7.4.4
+python-dotenv==1.0.0
+PyYAML==6.0.1
+requests==2.31.0
+rich==13.7.0
+rich-click==1.7.2
+sniffio==1.3.0
+starlette==0.32.0.post1
+tomlkit==0.12.3
+typing_extensions==4.9.0
+urllib3==2.1.0
+uvicorn==0.25.0
+uvloop==0.19.0
+watchfiles==0.21.0
+websockets==12.0

server/run.py

@@ -0,0 +1,10 @@
+import os
+import uvicorn
+from main import app
+from dotenv import load_dotenv
+
+
+if __name__ == "__main__":
+    load_dotenv()
+    port = int(os.getenv("PORT", 5050))
+    uvicorn.run(app, port=port)

server/test_app.py

@@ -0,0 +1,123 @@
+from fastapi.testclient import TestClient
+
+from helpers import get_token
+from main import app
+
+client = TestClient(app)
+token = get_token()
+
+
+def test_root():
+    response = client.get("/")
+    assert response.status_code == 200
+    body: dict[str, str] = response.json()
+    welcome = body["welcome"]
+    version = body["version"]
+    major, minor, patch = version.split(".")
+    routes = body["routes"]
+    assert welcome == "backend api for lucasjensen.me"
+    for v in [major, minor, patch]:
+        assert v.isnumeric()
+    assert len(routes) >= 3
+
+
+def test_about():
+    response = client.get("/about")
+    assert response.status_code == 200
+    body = response.json()
+    vals = ["name", "email", "bio", "github"]
+    assert all([k in body for k in vals])
+
+
+def test_projects():
+    response = client.get("/projects")
+    assert response.status_code == 200
+    body = response.json()
+    assert len(body) > 0
+    vals = ["id", "name", "description"]  # remaining vals are optional
+    assert all([k in body[0] for k in vals])
+
+
+def test_project():
+    response = client.get("/projects/1")
+    assert response.status_code == 200
+    body = response.json()
+    vals = ["id", "name", "description"]  # remaining vals are optional
+    assert all([k in body for k in vals])
+
+
+def test_post_projects():
+    p_id = post_project()
+
+    client.delete(
+        f"/projects/{p_id}",
+        headers={"Authorization": f"Bearer {token}"},
+    )
+
+
+def delete_project(p_id: int):
+    response = client.delete(
+        f"/projects/{p_id}",
+        headers={"Authorization": f"Bearer {token}"},
+    )
+    assert response.status_code == 204
+
+    response = client.get("/projects")
+    assert response.status_code == 200
+    body = response.json()
+    assert not any([p.get("id") == p_id for p in body])
+
+
+def post_project() -> int:
+    project = {
+        "name": "test project",
+        "description": "test description",
+        "source": "github.com/test",
+        "live": "test.com",
+        "is_self_hosted": False,
+    }
+    response = client.post(
+        "/projects",
+        json=project,
+        headers={"Authorization": f"Bearer {token}"},
+    )
+
+    assert response.status_code == 201
+    p_id = int(response.json()["id"])
+    assert isinstance(p_id, int)
+
+    response = client.get("/projects")
+    assert response.status_code == 200
+    body = response.json()
+    assert any([p.get("id") == p_id for p in body])
+
+    response = client.get(f"/projects/{p_id}")
+    assert response.status_code == 200
+    body = response.json()
+
+    assert body["name"] == project["name"]
+    assert body["description"] == project["description"]
+    assert body["source"] == project["source"]
+    assert body["live"] == project["live"]
+    assert body["id"] == p_id
+
+    return p_id
+
+
+def test_delete_project():
+    p_id = post_project()
+    all_projects = client.get("/projects").json()
+    assert any([p.get("id") == p_id for p in all_projects])
+    delete_project(p_id)
+    all_projects = client.get("/projects").json()
+    assert not any([p.get("id") == p_id for p in all_projects])
+
+
+def test_get_static_file():
+    response = client.get("/static/resume.pdf")
+    assert response.status_code == 200
+    assert response.headers["Content-Type"] == "application/pdf"
+
+    response = client.get("/static/favicon.png")
+    assert response.status_code == 200
+    assert response.headers["Content-Type"] == "image/png"

server/utils.py

@@ -0,0 +1,70 @@
+from typing import Optional
+
+import jwt
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer, SecurityScopes
+
+from config import get_settings
+
+
+class UnauthorizedException(HTTPException):
+    def __init__(self, detail: str, **kwargs):
+        """Returns HTTP 403"""
+        super().__init__(status.HTTP_403_FORBIDDEN, detail=detail)
+
+        class UnauthenticatedException(HTTPException):
+            def __init__(self):
+                super().__init__(
+                    status_code=status.HTTP_401_UNAUTHORIZED,
+                    detail="Requires authentication",
+                )
+
+
+class UnauthenticatedException(HTTPException):
+    def __init__(self):
+        super().__init__(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Requires authentication"
+        )
+
+
+class VerifyToken:
+    """Does all the token verification using PyJWT"""
+
+    def __init__(self):
+        self.config = get_settings()
+
+        # This gets the JWKS from a given URL and does processing so you can
+        # use any of the keys available
+        jwks_url = f"https://{self.config.auth0_domain}/.well-known/jwks.json"
+        self.jwks_client = jwt.PyJWKClient(jwks_url)
+
+    async def verify(
+        self,
+        security_scopes: SecurityScopes,
+        token: Optional[HTTPAuthorizationCredentials] = Depends(HTTPBearer()),
+    ):
+        if token is None:
+            raise UnauthenticatedException
+
+        # This gets the 'kid' from the passed token
+        try:
+            signing_key = self.jwks_client.get_signing_key_from_jwt(
+                token.credentials
+            ).key
+        except jwt.exceptions.PyJWKClientError as error:
+            raise UnauthorizedException(str(error))
+        except jwt.exceptions.DecodeError as error:
+            raise UnauthorizedException(str(error))
+
+        try:
+            payload = jwt.decode(
+                token.credentials,
+                signing_key,
+                algorithms=self.config.auth0_algorithms,  # type: ignore
+                audience=self.config.auth0_api_audience,
+                issuer=self.config.auth0_issuer,
+            )
+        except Exception as error:
+            raise UnauthorizedException(str(error))
+
+        return payload