FastAPI migration

backend/.env.example

@@ -0,0 +1,9 @@
+COGNITO_CLIENT_ID=
+COGNITO_CLIENT_SECRET=
+COGNITO_REGION=
+COGNITO_REDIRECT_URI=http://localhost:34828/signin
+COGNITO_USER_POOL_ID=
+COGNITO_ACCESS_ID=
+COGNITO_ACCESS_KEY=
+ROOT_URL=http://localhost:34828
+DATABASE_URL=sqlite:///./homeuniteus.db

backend/.gitignore

@@ -0,0 +1,75 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Local database
+homeuniteus.db
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# 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/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*,cover
+.hypothesis/
+venv/
+.venv/
+.python-version
+.pytest_cache
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+#Ipython Notebook
+.ipynb_checkpoints
+
+# Local Setup
+.DS_Store
+.vscode
+personal.py
+.env

backend/README.md

@@ -0,0 +1,63 @@
+# Home Unite Us FastAPI Server
+
+## Overview
+
+This is the _Home Unite Us_ web API server.
+
+This server uses:
+
+- [FastAPI](https://fastapi.tiangolo.com/) - Web framework for API development
+- [SQLAlchemy](https://www.sqlalchemy.org/) - ORM for database operations
+- [Pydantic](https://docs.pydantic.dev/latest/) - Data validation and serialization
+- [Poetry](https://python-poetry.org/docs/) - Dependency management
+
+## Requirements
+
+You will need Python 3.8+ to install Poetry.
+
+Run `python -V` to check the Python version.
+
+**Note**: On some systems, you might need to use the `python3` and `pip3` commands.
+
+[Poetry](https://python-poetry.org/docs/#installation) is used to manage the project dependencies. Follow the [installation instructions](https://python-poetry.org/docs/#installation) to run the CLI globally.
+
+## Usage - Development
+
+### Getting Started
+
+#### Configuration
+
+The API configuration must be specified before running the application. Configuration variables are specified as entries within a `.env` file located within the `api-v2` directory. To get started, create a `.env` file within `/api-v2` and copy the values from `.env.example` into the new `.env` file. You may have to contact someone from the development team to get the necessary values.
+
+#### Setup and Run
+
+Once the `.env` file has been configured and Poetry is installed, run the following commands in the `api-v2` directory to install the required development dependencies and run the application.
+
+```shell
+poetry install                      # Installs all dependencies
+
+poetry shell                        # Activates the virtual environment
+
+poetry run fastapi dev app/main.py  # Runs this server in developer mode
+```
+
+Your server is now running at:
+```
+http://127.0.0.1:8000
+```
+
+And your API docs at:
+```
+http://127.0.0.1:8000/docs
+```
+
+To exit the virtual environment, within the shell run:
+```shell
+exit
+```
+
+## Conventions
+
+### API Endpoints
+
+A path segment with spaces must be replace the spaces with a hyphen `-`. For example, `https://dev.homeunite.us/api/housing-orgs`.

backend/alembic/env.py

@@ -0,0 +1,91 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+import sys
+import os
+print(os.getcwd())
+sys.path.append(os.getcwd())
+
+from app import models as db
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = db.Base.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    print("ONLINE")
+    # Check for an existing connection before creating a new engine.
+    # pytest-alembic will hook into alembic by creating a connection
+    # with the test engine configuration.
+    connectable = context.config.attributes.get("connection", None)
+    if connectable is None:
+        connectable = engine_from_config(
+            config.get_section(config.config_ini_section, {}),
+            prefix="sqlalchemy.",
+            poolclass=pool.NullPool,
+        )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, target_metadata=target_metadata
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

backend/alembic/versions/e4c8bb426528_add_user_types.py

@@ -0,0 +1,72 @@
+"""Add user types
+
+Revision ID: e4c8bb426528
+Revises: ec8b1c17739a
+Create Date: 2024-03-10 21:47:13.942845
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy import text
+from app.user_roles import UserRole
+
+# revision identifiers, used by Alembic.
+revision = 'e4c8bb426528'
+down_revision = 'ec8b1c17739a'
+branch_labels = None
+depends_on = None
+
+def upgrade() -> None:
+    '''
+    1. Add one table:
+        1. role - Store available application user roles
+    2. Prepopulate the role table with four role types: Admin, Host, Guest, Coordinator
+    3. Update the user table to add the first, middle, last name, and role_id columns.
+      * All existing users will be given the first, last name "UNKNOWN"
+      * Assign all existing users to the Guest role.
+    4. Drop the host table. 
+      * There is no way to map host users back to the user table. We would need a user id foreign 
+        key, or at least an email address.
+    '''
+    role_table = op.create_table('role',
+        sa.Column('id', sa.Integer(), nullable=False),
+        sa.Column('name', sa.String(), nullable=False),
+        sa.PrimaryKeyConstraint('id'),
+        sa.UniqueConstraint('name')
+    )
+    op.bulk_insert(role_table,
+                   [{'name': UserRole.ADMIN.value},
+                    {'name': UserRole.HOST.value},
+                    {'name': UserRole.GUEST.value},
+                    {'name': UserRole.COORDINATOR.value}])
+    op.create_index(op.f('ix_role_id'), 'role', ['id'])
+
+    conn = op.get_bind()
+    guest_role_id = conn.execute(text("SELECT id FROM role WHERE name = 'Guest'")).fetchone()[0]
+
+    with op.batch_alter_table('user', schema=None) as batch_op:
+        # Each existing user will get the first and last names "Unknown" by default
+        # and they will be assigned to the "Guest" user role.
+        batch_op.add_column(sa.Column('firstName', sa.String(length=255), nullable=False, server_default='Unknown'))
+        batch_op.add_column(sa.Column('middleName', sa.String(length=255), nullable=True))
+        batch_op.add_column(sa.Column('lastName', sa.String(length=255), nullable=True))
+        batch_op.add_column(sa.Column('role_id', sa.Integer, nullable=False, server_default=str(guest_role_id)))
+        batch_op.create_foreign_key('fk_user_role_id', 'role', ['role_id'], ['id'])
+
+    op.drop_table('host')
+
+def downgrade() -> None:
+    with op.batch_alter_table('user', schema=None) as batch_op:
+        batch_op.drop_constraint('fk_user_role_id', type_='foreignkey')
+        batch_op.drop_column('lastName')
+        batch_op.drop_column('middleName')
+        batch_op.drop_column('firstName')
+
+    op.drop_index(op.f('ix_role_id'), table_name='role')
+    op.drop_table('role')
+    op.create_table('host',
+        sa.Column('id', sa.Integer(), nullable=False),
+        sa.Column('name', sa.String(), nullable=False),
+        sa.PrimaryKeyConstraint('id')
+        )
+    op.create_index(op.f('ix_host_id'), 'host', ['id'])

backend/app/core/config.py

@@ -0,0 +1,21 @@
+from functools import lru_cache
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env")
+
+    COGNITO_CLIENT_ID: str
+    COGNITO_CLIENT_SECRET: str
+    COGNITO_REGION: str
+    COGNITO_REDIRECT_URI: str
+    COGNITO_USER_POOL_ID: str
+    COGNITO_ACCESS_ID: str
+    COGNITO_ACCESS_KEY: str
+    ROOT_URL: str
+    DATABASE_URL: str
+
+
+@lru_cache
+def get_settings():
+    return Settings()

backend/app/core/db.py

@@ -0,0 +1,32 @@
+"""Shared database components."""
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, DeclarativeBase
+
+
+_db_engine = None
+_DbSessionFactory = None
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+def init_db(engine):
+    Base.metadata.create_all(bind=engine, checkfirst=True)
+
+
+def db_engine(settings):
+    global _db_engine
+    if _db_engine is None:
+        _db_engine = create_engine(settings.DATABASE_URL,
+                                  connect_args={"check_same_thread": False})
+    return _db_engine
+
+
+def db_session_factory(engine):
+    global _DbSessionFactory
+    if _DbSessionFactory is None:
+        _DbSessionFactory = sessionmaker(autocommit=False,
+                                        autoflush=False,
+                                        bind=engine)
+    return _DbSessionFactory

backend/app/main.py

@@ -0,0 +1,20 @@
+from fastapi import FastAPI
+from contextlib import asynccontextmanager
+
+from app.modules.router import api_router
+import app.core.db as db
+import app.core.config as config
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    settings = config.get_settings()
+    engine = db.db_engine(settings)
+    import app.seed
+    db.init_db(engine)
+    yield
+
+
+app = FastAPI(lifespan=lifespan)
+
+app.include_router(api_router, prefix="/api")