feat: modernize build tooling and add CI/CD workflow

Switch to Bun for 2-5x faster frontend builds, implement cargo-chef for
reliable Rust dependency caching, and add Biome for fast code
formatting.

Build system improvements:
- Replace pnpm with Bun for frontend package management
- Add cargo-chef to Dockerfile for better Rust build layer caching
- Update all commands to use bun instead of pnpm

Developer experience:
- Add comprehensive Justfile commands (format, format-check, db)
- Implement automated PostgreSQL Docker setup with random port
allocation
- Add stricter checks (--deny warnings on clippy, --all-features flag)

Code quality:
- Add Biome formatter for 10-100x faster TypeScript/JavaScript
formatting
- Add GitHub Actions CI/CD workflow for automated checks
- Update .dockerignore with comprehensive exclusions
- Format all code with cargo fmt (Rust) and Biome (TypeScript)

All changes maintain backward compatibility and can be tested
incrementally.

.dockerignore

@@ -0,0 +1,51 @@
+# Build artifacts
+target/
+**/target/
+
+# Documentation
+README.md
+docs/
+*.md
+
+# Old Go codebase
+go/
+
+# Development configuration
+bacon.toml
+.env
+.env.*
+!.env.example
+
+# CI/CD
+.github/
+.git/
+
+# Development tools
+Justfile
+rust-toolchain.toml
+
+# Frontend build artifacts and cache
+web/node_modules/
+web/dist/
+web/.vite/
+web/.tanstack/
+web/.vscode/
+
+# IDE and editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Test coverage
+coverage/
+*.profdata
+*.profraw
+
+# SQLx offline mode (include this in builds)
+!.sqlx/

.github/workflows/ci.yml

@@ -0,0 +1,65 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+env:
+  CARGO_TERM_COLOR: always
+  RUST_BACKTRACE: 1
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+
+      - name: Cache Rust dependencies
+        uses: Swatinem/rust-cache@v2
+        with:
+          cache-on-failure: true
+
+      - name: Install frontend dependencies
+        working-directory: web
+        run: bun install --frozen-lockfile
+
+      - name: Check Rust formatting
+        run: cargo fmt --all -- --check
+
+      - name: Check TypeScript formatting
+        working-directory: web
+        run: bun run format:check
+
+      - name: TypeScript type check
+        working-directory: web
+        run: bun run typecheck
+
+      - name: ESLint
+        working-directory: web
+        run: bun run lint
+
+      - name: Clippy
+        run: cargo clippy --all-features -- --deny warnings
+
+      - name: Run tests
+        run: cargo test --all-features
+
+      - name: Build frontend
+        working-directory: web
+        run: bun run build
+
+      - name: Build backend
+        run: cargo build --release --bin banner

.gitignore

@@ -1,8 +1,5 @@
 .env
-cover.cov
-banner
-.*.go
-dumps/
-js/
-.vscode/
-*.prof
+/target
+/go/
+.cargo/config.toml
+src/scraper/README.md

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "rust-analyzer.check.command": "clippy"
+}

Cargo.toml

@@ -0,0 +1,60 @@
+[package]
+name = "banner"
+version = "0.3.4"
+edition = "2024"
+default-run = "banner"
+
+[dependencies]
+anyhow = "1.0.99"
+async-trait = "0.1"
+axum = "0.8.4"
+bitflags = { version = "2.9.4", features = ["serde"] }
+chrono = { version = "0.4.42", features = ["serde"] }
+compile-time = "0.2.0"
+cookie = "0.18.1"
+dashmap = "6.1.0"
+dotenvy = "0.15.7"
+figment = { version = "0.10.19", features = ["toml", "env"] }
+fundu = "2.0.1"
+futures = "0.3"
+http = "1.3.1"
+poise = "0.6.1"
+rand = "0.9.2"
+regex = "1.10"
+reqwest = { version = "0.12.23", features = ["json", "cookies"] }
+reqwest-middleware = { version = "0.4.2", features = ["json"] }
+serde = { version = "1.0.219", features = ["derive"] }
+serde_json = "1.0.143"
+serenity = { version = "0.12.4", features = ["rustls_backend"] }
+sqlx = { version = "0.8.6", features = [
+    "runtime-tokio-rustls",
+    "postgres",
+    "chrono",
+    "json",
+    "macros",
+] }
+thiserror = "2.0.16"
+time = "0.3.43"
+tokio = { version = "1.47.1", features = ["full"] }
+tokio-util = "0.7"
+tl = "0.7.8"
+tracing = "0.1.41"
+tracing-subscriber = { version = "0.3.20", features = ["env-filter", "json"] }
+url = "2.5"
+governor = "0.10.1"
+once_cell = "1.21.3"
+serde_path_to_error = "0.1.17"
+num-format = "0.4.4"
+tower-http = { version = "0.6.0", features = ["fs", "cors", "trace", "timeout"] }
+rust-embed = { version = "8.0", features = ["debug-embed", "include-exclude"] }
+mime_guess = "2.0"
+clap = { version = "4.5", features = ["derive"] }
+rapidhash = "4.1.0"
+yansi = "1.0.1"
+
+[dev-dependencies]
+
+# A 'release mode' profile that compiles quickly, but still 'appears' like a release build, useful for debugging
+[profile.dev-release]
+inherits = "dev"
+debug-assertions = false

Dockerfile

@@ -0,0 +1,116 @@
+# Build arguments
+ARG RUST_VERSION=1.89.0
+ARG RAILWAY_GIT_COMMIT_SHA
+
+# --- Frontend Build Stage ---
+FROM oven/bun:1 AS frontend-builder
+
+WORKDIR /app
+
+# Copy backend Cargo.toml for build-time version retrieval
+COPY ./Cargo.toml ./
+
+# Copy frontend package files
+COPY ./web/package.json ./web/bun.lock* ./
+
+# Install dependencies
+RUN bun install --frozen-lockfile
+
+# Copy frontend source code
+COPY ./web ./
+
+# Build frontend
+RUN bun run build
+
+# --- Chef Base Stage ---
+FROM lukemathwalker/cargo-chef:latest-rust-${RUST_VERSION} AS chef
+WORKDIR /app
+
+# --- Planner Stage ---
+FROM chef AS planner
+COPY Cargo.toml Cargo.lock ./
+COPY build.rs ./
+COPY src ./src
+# Migrations & .sqlx specifically left out to avoid invalidating cache
+RUN cargo chef prepare --recipe-path recipe.json --bin banner
+
+# --- Rust Build Stage ---
+FROM chef AS builder
+
+# Set build-time environment variable for Railway Git commit SHA
+ARG RAILWAY_GIT_COMMIT_SHA
+ENV RAILWAY_GIT_COMMIT_SHA=${RAILWAY_GIT_COMMIT_SHA}
+
+# Copy recipe from planner and build dependencies only
+COPY --from=planner /app/recipe.json recipe.json
+RUN cargo chef cook --release --recipe-path recipe.json --bin banner
+
+# Install build dependencies for final compilation
+RUN apt-get update && apt-get install -y \
+    pkg-config \
+    libssl-dev \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy source code and built frontend assets
+COPY Cargo.toml Cargo.lock ./
+COPY build.rs ./
+COPY .git* ./
+COPY src ./src
+COPY migrations ./migrations
+COPY --from=frontend-builder /app/dist ./web/dist
+
+# Build web app with embedded assets
+RUN cargo build --release --bin banner
+
+# Strip the binary to reduce size
+RUN strip target/release/banner
+
+# --- Runtime Stage ---
+FROM debian:12-slim
+
+ARG APP=/usr/src/app
+ARG APP_USER=appuser
+ARG UID=1000
+ARG GID=1000
+
+# Install runtime dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    tzdata \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+ARG TZ=Etc/UTC
+ENV TZ=${TZ}
+
+# Create user with specific UID/GID
+RUN addgroup --gid $GID $APP_USER \
+    && adduser --uid $UID --disabled-password --gecos "" --ingroup $APP_USER $APP_USER \
+    && mkdir -p ${APP}
+
+# Copy application binary
+COPY --from=builder --chown=$APP_USER:$APP_USER /app/target/release/banner ${APP}/banner
+
+# Set proper permissions
+RUN chmod +x ${APP}/banner
+
+USER $APP_USER
+WORKDIR ${APP}
+
+# Build-time arg for PORT, default to 8000
+ARG PORT=8000
+# Runtime environment var for PORT, default to build-time arg
+ENV PORT=${PORT}
+EXPOSE ${PORT}
+
+# Add health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD wget --no-verbose --tries=1 --spider http://localhost:${PORT}/health || exit 1
+
+# Can be explicitly overriden with different hosts & ports
+ENV HOSTS=0.0.0.0,[::]
+
+# Implicitly uses PORT environment variable
+# temporary: running without 'scraper' service
+CMD ["sh", "-c", "exec ./banner --services web,bot"]

Justfile

@@ -0,0 +1,79 @@
+default_services := "bot,web,scraper"
+
+default:
+    just --list
+
+# Run all checks (format, clippy, tests, lint)
+check:
+    cargo fmt --all -- --check
+    cargo clippy --all-features -- --deny warnings
+    cargo nextest run
+    bun run --cwd web typecheck
+    bun run --cwd web lint
+
+# Format all Rust and TypeScript code
+format:
+    cargo fmt --all
+    bun run --cwd web format
+
+# Check formatting without modifying (CI-friendly)
+format-check:
+    cargo fmt --all -- --check
+    bun run --cwd web format:check
+
+# Start PostgreSQL in Docker and update .env with connection string
+db:
+    #!/usr/bin/env bash
+    set -euo pipefail
+
+    # Find available port
+    PORT=$(shuf -i 49152-65535 -n 1)
+    while ss -tlnp 2>/dev/null | grep -q ":$PORT "; do
+        PORT=$(shuf -i 49152-65535 -n 1)
+    done
+
+    # Start PostgreSQL container
+    docker run -d \
+        --name banner-postgres \
+        -e POSTGRES_PASSWORD=banner \
+        -e POSTGRES_USER=banner \
+        -e POSTGRES_DB=banner \
+        -p "$PORT:5432" \
+        postgres:17-alpine
+
+    # Update .env file
+    DB_URL="postgresql://banner:banner@localhost:$PORT/banner"
+    if [ -f .env ]; then
+        sed -i.bak "s|^DATABASE_URL=.*|DATABASE_URL=$DB_URL|" .env
+    else
+        echo "DATABASE_URL=$DB_URL" > .env
+    fi
+
+    echo "PostgreSQL started on port $PORT"
+    echo "DATABASE_URL=$DB_URL"
+    echo "Run: sqlx migrate run"
+
+# Auto-reloading frontend server
+frontend:
+    bun run --cwd web dev
+
+# Production build of frontend
+build-frontend:
+    bun run --cwd web build
+
+# Auto-reloading backend server
+backend *ARGS:
+    bacon --headless run -- -- {{ARGS}}
+
+# Production build
+build:
+    bun run --cwd web build
+    cargo build --release --bin banner
+
+# Run auto-reloading development build with release characteristics
+dev-build *ARGS='--services web --tracing pretty': build-frontend
+    bacon --headless run -- --profile dev-release -- {{ARGS}}
+
+# Auto-reloading development build for both frontend and backend
+[parallel]
+dev *ARGS='--services web,bot': frontend (backend ARGS)

README.md

@@ -1,122 +1,51 @@
 # banner
 
-A discord bot for executing queries & searches on the Ellucian Banner instance hosting all of UTSA's class data.
+A complex multi-service system providing a Discord bot and browser-based interface to UTSA's course data.
 
-## Feature Wishlist
+## Services
 
-- Commands
-  - ICS Download (get a ICS download of your classes with location & timing perfectly - set for every class you're in)
-  - Classes Now (find classes happening)
-- Autocomplete
-  - Class Title
-  - Course Number
-  - Term/Part of Term
-  - Professor
-  - Attribute
-- Component Pagination
-- RateMyProfessor Integration (Linked/Embedded)
-- Smart term selection (i.e. Summer 2024 will be selected automatically when opened)
-- Rate Limiting (bursting with global/user limits)
-- DMs Integration (allow usage of the bot in DMs)
-- Class Change Notifications (get notified when details about a class change)
-- Multi-term Querying (currently the backend for searching is kinda weird)
-- Full Autocomplete for Every Search Option
-- Metrics, Log Query, Privileged Error Feedback
-- Search for Classes
-    - Major, Professor, Location, Name, Time of Day
-- Subscribe to Classes
-    - Availability (seat, pre-seat)
-    - Waitlist Movement
-    - Detail Changes (meta, time, location, seats, professor)
-        - `time` Start, End, Days of Week
-        - `seats` Any change in seat/waitlist data
-        - `meta` 
-- Lookup via Course Reference Number (CRN)
-- Smart Time of Day Handling
-    - "2 PM" -> Start within 2:00 PM to 2:59 PM
-    - "2-3 PM" -> Start within 2:00 PM to 3:59 PM
-    - "ends by 2 PM" -> Ends within 12:00 AM to 2:00 PM
-    - "after 2 PM" -> Start within 2:01 PM to 11:59 PM
-    - "before 2 PM" -> Ends within 12:00 AM to 1:59 PM
-- Get By Section Command
-  - CS 4393 001 =>
-  - Will require SQL to be able to search for a class by its section number
+The application consists of three modular services that can be run independently or together:
 
-## Analysis Required
+- Discord Bot ([`bot`][src-bot])
 
-Some of the features and architecture of Ellucian's Banner system are not clear.
-The follow features, JSON, and more require validation & analysis:
+  - Primary interface for course monitoring and data queries
+  - Built with [Serenity][serenity] and [Poise][poise] frameworks for robust command handling
+  - Uses slash commands with comprehensive error handling and logging
 
-- Struct Nullability
-  - Much of the responses provided by Ellucian contain nulls, and most of them are uncertain as to when and why they're null.
-  - Analysis must be conducted to be sure of when to use a string and when it should nillable (pointer).
-- Multiple Professors / Primary Indicator
-- Multiple Meeting Times
-- Meeting Schedule Types
-  - AFF vs AIN vs AHB etc.
-- Do CRNs repeat between years?
-- Check whether partOfTerm is always filled in, and it's meaning for various class results.
-- Check which API calls are affected by change in term/sessionID term select
-- SessionIDs
-  - How long does a session ID work?
-  - Do I really require a separate one per term?
-  - How many can I activate, are there any restrictions?
-  - How should session IDs be checked as 'invalid'?
-  - What action(s) keep a session ID 'active', if any?
-- Are there any courses with multiple meeting times?
-- Google Calendar link generation, as an alternative to ICS file generation
+- Web Server ([`web`][src-web])
 
-## Change Identification
+  - [Axum][axum]-based server with Vite/React-based frontend
+  - [Embeds static assets][rust-embed] at compile time with E-Tags & Cache-Control headers
 
-- Important attributes of a class will be parsed on both the old and new data.
-- These attributes will be compared and given identifiers that can be subscribed to.
-- When a user subscribes to one of these identifiers, any changes identified will be sent to the user.
+- Scraper ([`scraper`][src-scraper])
 
-## Real-time Suggestions
+  - Intelligent data collection system with priority-based queuing inside PostgreSQL via [`sqlx`][sqlx]
+  - Rate-limited scraping with burst handling to respect UTSA's systems
+  - Handles course data updates, availability changes, and metadata synchronization
 
-Various commands arguments have the ability to have suggestions appear.
+## Quick Start
 
-- They must be fast. As ephemeral suggestions that are only relevant for seconds or less, they need to be delivered in less than a second.
-- They need to be easy to acquire. With as many commands & arguments to search as I do, it is paramount that the API be easy to understand & use.
-- It cannot be complicated. I only have so much time to develop this.
-- It does not need to be persistent. Since the data is scraped and rolled periodically from the Banner system, the data used will be deleted and re-requested occasionally.
+```bash
+bun install --cwd web  # Install frontend dependencies
+cargo build  # Build the backend
 
-For these reasons, I believe SQLite to be the ideal place for this data to be stored.
-It is exceptionally fast, works well in-memory, and is less complicated compared to most other solutions.
+just dev # Runs auto-reloading dev build
+just dev --services bot,web # Runs auto-reloading dev build, running only the bot and web services
+just dev-build # Development build with release characteristics (frontend is embedded, non-auto-reloading)
 
-- Only required data about the class will be stored, along with the JSON-encoded string.
-  - For now, this would only be the CRN (and possibly the Term).
-  - Potentially, a binary encoding could be used for performance, but it is unlikely to be better.
-- Database dumping into R2 would be good to ensure that over-scraping of the Banner system does not occur.
-  - Upon a safe close requested
-    - Must be done quickly (<8 seconds)
-  - Every 30 minutes, if any scraping ocurred.
-    - May cause locking of commands.
+just build # Production build that embeds assets
+```
 
-## Scraping
+## Documentation
 
-In order to keep the in-memory database of the bot up-to-date with the Banner system, the API must be scraped.
-Scraping will be separated by major to allow for priority majors (namely, Computer Science) to be scraped more often compared to others.
-This will lower the overall load on the Banner system while ensuring that data presented by the app is still relevant.
+Comprehensive documentation is available in the [`docs/`][documentation] folder.
 
-For now, all majors will be scraped fully every 4 hours with at least 5 minutes between each one.
-- On startup, priority majors will be scraped first (if required).
-- Other majors will be scraped in arbitrary order (if required).
-- Scrape timing will be stored in Redis.
-- CRNs will be the Primary Key within SQLite
-  - If CRNs are duplicated between terms, then the primary key will be (CRN, Term)
-
-Considerations
-- Change in metadata should decrease the interval
-- The number of courses scraped should change the interval (2 hours per 500 courses involved)
-
-## Rate Limiting, Costs & Bursting
-
-Ideally, this application would implement dynamic rate limiting to ensure overload on the server does not occur.
-Better, it would also ensure that priority requests (commands) are dispatched faster than background processes (scraping), while making sure different requests are weighted differently.
-For example, a recent scrape of 350 classes should be weighted 5x more than a search for 8 classes by a user.
-Still, even if the cap does not normally allow for this request to be processed immediately, the small user search should proceed with a small bursting cap.
-
-The requirements to this hypothetical system would be:
-- Conditional Bursting: background processes or other requests deemed "low priority" are not allowed to use bursting.
-- Arbitrary Costs: rate limiting is considered in the form of the request size/speed more or less, such that small simple requests can be made more frequently, unlike large requests.
+[documentation]: docs/README.md
+[src-bot]: src/bot
+[src-web]: src/web
+[src-scraper]: src/scraper
+[serenity]: https://github.com/serenity-rs/serenity
+[poise]: https://github.com/serenity-rs/poise
+[axum]: https://github.com/tokio-rs/axum
+[rust-embed]: https://lib.rs/crates/rust-embed
+[sqlx]: https://github.com/launchbadge/sqlx

api.go

@@ -1,540 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/url"
-	"strconv"
-	"strings"
-
-	"time"
-
-	"github.com/redis/go-redis/v9"
-	"github.com/rs/zerolog/log"
-)
-
-var (
-	latestSession string = ""
-	sessionTime   time.Time
-	expiryTime    time.Duration = 25 * time.Minute
-)
-
-// ResetSessionTimer resets the session timer to the current time.
-// This is only used by the DoRequest handler when Banner API calls are detected, which would reset the session timer.
-func ResetSessionTimer() {
-	// Only reset the session time if the session is still valid
-	if time.Since(sessionTime) <= expiryTime {
-		sessionTime = time.Now()
-	}
-}
-
-// GenerateSession generates a new session ID (nonce) for use with the Banner API.
-// Don't use this function directly, use GetSession instead.
-func GenerateSession() string {
-	return RandomString(5) + Nonce()
-}
-
-// GetSession retrieves the current session ID if it's still valid.
-// If the session ID is invalid or has expired, a new one is generated and returned.
-// SessionIDs are valid for 30 minutes, but we'll be conservative and regenerate every 25 minutes.
-func GetSession() string {
-	// Check if a reset is required
-	if latestSession == "" || time.Since(sessionTime) >= expiryTime {
-		// Generate a new session identifier
-		latestSession = GenerateSession()
-
-		// Select the current term
-		term := Default(time.Now()).ToString()
-		log.Info().Str("term", term).Str("sessionID", latestSession).Msg("Setting selected term")
-		err := SelectTerm(term, latestSession)
-		if err != nil {
-			log.Fatal().Stack().Err(err).Msg("Failed to select term while generating session ID")
-		}
-
-		sessionTime = time.Now()
-	}
-
-	return latestSession
-}
-
-type Pair struct {
-	Code        string `json:"code"`
-	Description string `json:"description"`
-}
-
-type BannerTerm Pair
-type Instructor Pair
-
-// Archived returns true if the term is in it's archival state (view only)
-func (term BannerTerm) Archived() bool {
-	return strings.Contains(term.Description, "View Only")
-}
-
-// GetTerms retrieves and parses the term information for a given search term.
-// Page number must be at least 1.
-func GetTerms(search string, page int, max int) ([]BannerTerm, error) {
-	// Ensure offset is valid
-	if page <= 0 {
-		return nil, errors.New("offset must be greater than 0")
-	}
-
-	req := BuildRequest("GET", "/classSearch/getTerms", map[string]string{
-		"searchTerm": search,
-		// Page vs Offset is not a mistake here, the API uses "offset" as the page number
-		"offset": strconv.Itoa(page),
-		"max":    strconv.Itoa(max),
-		"_":      Nonce(),
-	})
-
-	if page <= 0 {
-		return nil, errors.New("Offset must be greater than 0")
-	}
-
-	res, err := DoRequest(req)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get terms: %w", err)
-	}
-
-	// Assert that the response is JSON
-	if contentType := res.Header.Get("Content-Type"); !strings.Contains(contentType, JsonContentType) {
-		return nil, &UnexpectedContentTypeError{
-			Expected: JsonContentType,
-			Actual:   contentType,
-		}
-	}
-
-	// print the response body
-	defer res.Body.Close()
-	body, err := io.ReadAll(res.Body)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read response body: %w", err)
-	}
-
-	terms := make([]BannerTerm, 0, 10)
-	json.Unmarshal(body, &terms)
-
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse terms: %w", err)
-	}
-
-	return terms, nil
-}
-
-// SelectTerm selects the given term in the Banner system.
-// This function completes the initial term selection process, which is required before any other API calls can be made with the session ID.
-func SelectTerm(term string, sessionId string) error {
-	form := url.Values{
-		"term":            {term},
-		"studyPath":       {""},
-		"studyPathText":   {""},
-		"startDatepicker": {""},
-		"endDatepicker":   {""},
-		"uniqueSessionId": {sessionId},
-	}
-
-	params := map[string]string{
-		"mode": "search",
-	}
-
-	req := BuildRequestWithBody("POST", "/term/search", params, bytes.NewBufferString(form.Encode()))
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-
-	res, err := DoRequest(req)
-	if err != nil {
-		return fmt.Errorf("failed to select term: %w", err)
-	}
-
-	// Assert that the response is JSON
-	if !ContentTypeMatch(res, "application/json") {
-		return fmt.Errorf("response was not JSON: %w", res.Header.Get("Content-Type"))
-	}
-
-	// Acquire fwdUrl
-	defer res.Body.Close()
-	body, err := io.ReadAll(res.Body)
-	if err != nil {
-		return fmt.Errorf("failed to read response body: %w", err)
-	}
-
-	var redirectResponse struct {
-		FwdUrl string `json:"fwdUrl"`
-	}
-	json.Unmarshal(body, &redirectResponse)
-
-	// Make a GET request to the fwdUrl
-	req = BuildRequest("GET", redirectResponse.FwdUrl, nil)
-	res, err = DoRequest(req)
-	if err != nil {
-		return fmt.Errorf("failed to follow redirect: %w", err)
-	}
-
-	// Assert that the response is OK (200)
-	if res.StatusCode != 200 {
-		return fmt.Errorf("redirect response was not 200: %w", res.StatusCode)
-	}
-
-	return nil
-}
-
-// GetPartOfTerms retrieves and parses the part of term information for a given term.
-// Ensure that the offset is greater than 0.
-func GetPartOfTerms(search string, term int, offset int, max int) ([]BannerTerm, error) {
-	// Ensure offset is valid
-	if offset <= 0 {
-		return nil, errors.New("offset must be greater than 0")
-	}
-
-	req := BuildRequest("GET", "/classSearch/get_partOfTerm", map[string]string{
-		"searchTerm":      search,
-		"term":            strconv.Itoa(term),
-		"offset":          strconv.Itoa(offset),
-		"max":             strconv.Itoa(max),
-		"uniqueSessionId": GetSession(),
-		"_":               Nonce(),
-	})
-
-	res, err := DoRequest(req)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get part of terms: %w", err)
-	}
-
-	// Assert that the response is JSON
-	if !ContentTypeMatch(res, "application/json") {
-		log.Panic().Stack().Str("content-type", res.Header.Get("Content-Type")).Msg("Response was not JSON")
-	}
-
-	defer res.Body.Close()
-	body, err := io.ReadAll(res.Body)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read response body: %w", err)
-	}
-
-	terms := make([]BannerTerm, 0, 10)
-	err = json.Unmarshal(body, &terms)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse part of terms: %w", err)
-	}
-
-	return terms, nil
-}
-
-// GetInstructors retrieves and parses the instructor information for a given search term.
-// In my opinion, it is unclear what providing the term does, as the results should be the same regardless of the term.
-// This function is included for completeness, but probably isn't useful.
-// Ensure that the offset is greater than 0.
-func GetInstructors(search string, term string, offset int, max int) ([]Instructor, error) {
-	// Ensure offset is valid
-	if offset <= 0 {
-		return nil, errors.New("offset must be greater than 0")
-	}
-
-	req := BuildRequest("GET", "/classSearch/get_instructor", map[string]string{
-		"searchTerm":      search,
-		"term":            term,
-		"offset":          strconv.Itoa(offset),
-		"max":             strconv.Itoa(max),
-		"uniqueSessionId": GetSession(),
-		"_":               Nonce(),
-	})
-
-	res, err := DoRequest(req)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get instructors: %w", err)
-	}
-
-	// Assert that the response is JSON
-	if !ContentTypeMatch(res, "application/json") {
-		log.Fatal().Stack().Str("content-type", res.Header.Get("Content-Type")).Msg("Response was not JSON")
-	}
-
-	defer res.Body.Close()
-	body, err := io.ReadAll(res.Body)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read response body: %w", err)
-	}
-
-	instructors := make([]Instructor, 0, 10)
-	err = json.Unmarshal(body, &instructors)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse instructors: %w", err)
-	}
-
-	return instructors, nil
-}
-
-// TODO: Finish this struct & function
-// ClassDetails represents
-type ClassDetails struct {
-}
-
-func GetCourseDetails(term int, crn int) *ClassDetails {
-	body, err := json.Marshal(map[string]string{
-		"term":                  strconv.Itoa(term),
-		"courseReferenceNumber": strconv.Itoa(crn),
-		"first":                 "first", // TODO: What is this?
-	})
-	if err != nil {
-		log.Fatal().Stack().Err(err).Msg("Failed to marshal body")
-	}
-	req := BuildRequestWithBody("GET", "/searchResults/getClassDetails", nil, bytes.NewBuffer(body))
-
-	res, err := DoRequest(req)
-	if err != nil {
-		return nil
-	}
-
-	// Assert that the response is JSON
-	if !ContentTypeMatch(res, "application/json") {
-		log.Fatal().Stack().Str("content-type", res.Header.Get("Content-Type")).Msg("Response was not JSON")
-	}
-
-	return &ClassDetails{}
-}
-
-// Search invokes a search on the Banner system with the given query and returns the results.
-func Search(query *Query, sort string, sortDescending bool) (*SearchResult, error) {
-	ResetDataForm()
-
-	params := query.Paramify()
-
-	params["txt_term"] = "202510" // TODO: Make this automatic but dynamically specifiable
-	params["uniqueSessionId"] = GetSession()
-	params["sortColumn"] = sort
-	params["sortDirection"] = "asc"
-
-	// These dates are not available for usage anywhere in the UI, but are included in every query
-	params["startDatepicker"] = ""
-	params["endDatepicker"] = ""
-
-	req := BuildRequest("GET", "/searchResults/searchResults", params)
-
-	res, err := DoRequest(req)
-	if err != nil {
-		return nil, fmt.Errorf("failed to search: %w", err)
-	}
-
-	if res.StatusCode != 200 {
-		return nil, fmt.Errorf("search failed with status code: %d", res.StatusCode)
-	}
-
-	// Assert that the response is JSON
-	if !ContentTypeMatch(res, "application/json") {
-		// for server 500 errors, parse for the error with '#dialog-message > div.message'
-		log.Error().Stack().Str("content-type", res.Header.Get("Content-Type")).Msg("Response was not JSON")
-	}
-
-	defer res.Body.Close()
-	body, err := io.ReadAll(res.Body)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read response body: %w", err)
-	}
-
-	var result SearchResult
-	err = json.Unmarshal(body, &result)
-
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse search results: %w", err)
-	}
-
-	return &result, nil
-}
-
-// GetSubjects retrieves and parses the subject information for a given search term.
-// The results of this response shouldn't change much, but technically could as new majors are developed, or old ones are removed.
-// Ensure that the offset is greater than 0.
-func GetSubjects(search string, term string, offset int, max int) ([]Pair, error) {
-	// Ensure offset is valid
-	if offset <= 0 {
-		return nil, errors.New("offset must be greater than 0")
-	}
-
-	req := BuildRequest("GET", "/classSearch/get_subject", map[string]string{
-		"searchTerm":      search,
-		"term":            term,
-		"offset":          strconv.Itoa(offset),
-		"max":             strconv.Itoa(max),
-		"uniqueSessionId": GetSession(),
-		"_":               Nonce(),
-	})
-
-	res, err := DoRequest(req)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get subjects: %w", err)
-	}
-
-	// Assert that the response is JSON
-	if !ContentTypeMatch(res, "application/json") {
-		log.Fatal().Stack().Str("content-type", res.Header.Get("Content-Type")).Msg("Response was not JSON")
-	}
-
-	defer res.Body.Close()
-	body, err := io.ReadAll(res.Body)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read response body: %w", err)
-	}
-
-	subjects := make([]Pair, 0, 10)
-	err = json.Unmarshal(body, &subjects)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse subjects: %w", err)
-	}
-
-	return subjects, nil
-}
-
-// GetCampuses retrieves and parses the campus information for a given search term.
-// In my opinion, it is unclear what providing the term does, as the results should be the same regardless of the term.
-// This function is included for completeness, but probably isn't useful.
-// Ensure that the offset is greater than 0.
-func GetCampuses(search string, term int, offset int, max int) ([]Pair, error) {
-	// Ensure offset is valid
-	if offset <= 0 {
-		return nil, errors.New("offset must be greater than 0")
-	}
-
-	req := BuildRequest("GET", "/classSearch/get_campus", map[string]string{
-		"searchTerm":      search,
-		"term":            strconv.Itoa(term),
-		"offset":          strconv.Itoa(offset),
-		"max":             strconv.Itoa(max),
-		"uniqueSessionId": GetSession(),
-		"_":               Nonce(),
-	})
-
-	res, err := DoRequest(req)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get campuses: %w", err)
-	}
-
-	// Assert that the response is JSON
-	if !ContentTypeMatch(res, "application/json") {
-		log.Fatal().Stack().Str("content-type", res.Header.Get("Content-Type")).Msg("Response was not JSON")
-	}
-
-	defer res.Body.Close()
-	body, err := io.ReadAll(res.Body)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read response body: %w", err)
-	}
-
-	campuses := make([]Pair, 0, 10)
-	err = json.Unmarshal(body, &campuses)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse campuses: %w", err)
-	}
-
-	return campuses, nil
-}
-
-// GetInstructionalMethods retrieves and parses the instructional method information for a given search term.
-// In my opinion, it is unclear what providing the term does, as the results should be the same regardless of the term.
-// This function is included for completeness, but probably isn't useful.
-// Ensure that the offset is greater than 0.
-func GetInstructionalMethods(search string, term string, offset int, max int) ([]Pair, error) {
-	// Ensure offset is valid
-	if offset <= 0 {
-		return nil, errors.New("offset must be greater than 0")
-	}
-
-	req := BuildRequest("GET", "/classSearch/get_instructionalMethod", map[string]string{
-		"searchTerm":      search,
-		"term":            term,
-		"offset":          strconv.Itoa(offset),
-		"max":             strconv.Itoa(max),
-		"uniqueSessionId": GetSession(),
-		"_":               Nonce(),
-	})
-
-	res, err := DoRequest(req)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get instructional methods: %w", err)
-	}
-
-	// Assert that the response is JSON
-	if !ContentTypeMatch(res, "application/json") {
-		log.Fatal().Stack().Str("content-type", res.Header.Get("Content-Type")).Msg("Response was not JSON")
-	}
-
-	defer res.Body.Close()
-	body, _ := io.ReadAll(res.Body)
-
-	methods := make([]Pair, 0, 10)
-	err = json.Unmarshal(body, &methods)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse instructional methods: %w", err)
-	}
-
-	return methods, nil
-}
-
-// GetCourseMeetingTime retrieves the meeting time information for a course based on the given term and course reference number (CRN).
-// It makes an HTTP GET request to the appropriate API endpoint and parses the response to extract the meeting time data.
-// The function returns a MeetingTimeResponse struct containing the extracted information.
-func GetCourseMeetingTime(term int, crn int) ([]MeetingTimeResponse, error) {
-	req := BuildRequest("GET", "/searchResults/getFacultyMeetingTimes", map[string]string{
-		"term":                  strconv.Itoa(term),
-		"courseReferenceNumber": strconv.Itoa(crn),
-	})
-
-	res, err := DoRequest(req)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get meeting time: %w", err)
-	}
-
-	// Assert that the response is JSON
-	if !ContentTypeMatch(res, "application/json") {
-		log.Fatal().Stack().Str("content-type", res.Header.Get("Content-Type")).Msg("Response was not JSON")
-	}
-
-	// Read the response body into JSON
-	defer res.Body.Close()
-	body, err := io.ReadAll(res.Body)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read response body: %w", err)
-	}
-
-	// Parse the JSON into a MeetingTimeResponse struct
-	var meetingTime struct {
-		Inner []MeetingTimeResponse `json:"fmt"`
-	}
-	err = json.Unmarshal(body, &meetingTime)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse meeting time: %w", err)
-	}
-
-	return meetingTime.Inner, nil
-}
-
-// ResetDataForm makes a POST request that needs to be made upon before new search requests can be made.
-func ResetDataForm() {
-	req := BuildRequest("POST", "/classSearch/resetDataForm", nil)
-	_, err := DoRequest(req)
-	if err != nil {
-		log.Fatal().Stack().Err(err).Msg("Failed to reset data form")
-	}
-}
-
-// GetCourse retrieves the course information.
-// This course does not retrieve directly from the API, but rather uses scraped data stored in Redis.
-func GetCourse(crn string) (*Course, error) {
-	// Retrieve raw data
-	result, err := kv.Get(ctx, fmt.Sprintf("class:%s", crn)).Result()
-	if err != nil {
-		if err == redis.Nil {
-			return nil, fmt.Errorf("course not found: %w", err)
-		}
-		return nil, fmt.Errorf("failed to get course: %w", err)
-	}
-
-	// Unmarshal the raw data
-	var course Course
-	err = json.Unmarshal([]byte(result), &course)
-	if err != nil {
-		return nil, fmt.Errorf("failed to unmarshal course: %w", err)
-	}
-
-	return &course, nil
-}

bacon.toml

@@ -0,0 +1,52 @@
+# This is a configuration file for the bacon tool
+#
+# Complete help on configuration: https://dystroy.org/bacon/config/
+# 
+# You may check the current default at
+#   https://github.com/Canop/bacon/blob/main/defaults/default-bacon.toml
+
+default_job = "check"
+env.CARGO_TERM_COLOR = "always"
+
+[jobs.check]
+command = ["cargo", "check", "--all-targets"]
+need_stdout = false
+
+[jobs.clippy]
+command = ["cargo", "clippy", "--all-targets"]
+need_stdout = false
+
+[jobs.test]
+command = [
+    "cargo", "nextest", "run",
+]
+need_stdout = true
+analyzer = "nextest"
+
+[jobs.run]
+command = [
+    "cargo", "run",
+]
+need_stdout = true
+allow_warnings = true
+background = false
+on_change_strategy = "kill_then_restart"
+# kill = ["pkill", "-TERM", "-P"]'
+
+[jobs.dev]
+command = [
+    "just", "dev"
+]
+need_stdout = true
+allow_warnings = true
+background = false
+on_change_strategy = "kill_then_restart"
+
+# You may define here keybindings that would be specific to
+# a project, for example a shortcut to launch a specific job.
+# Shortcuts to internal functions (scrolling, toggling, etc.)
+# should go in your personal global prefs.toml file instead.
+[keybindings]
+c = "job:clippy" # comment this to have 'c' run clippy on only the default target
+shift-c = "job:check"
+d = "job:dev"

build.rs

@@ -0,0 +1,36 @@
+use std::process::Command;
+
+fn main() {
+    // Try to get Git commit hash from Railway environment variable first
+    let git_hash = std::env::var("RAILWAY_GIT_COMMIT_SHA").unwrap_or_else(|_| {
+        // Fallback to git command if not on Railway
+        let output = Command::new("git").args(["rev-parse", "HEAD"]).output();
+        match output {
+            Ok(output) => {
+                if output.status.success() {
+                    String::from_utf8_lossy(&output.stdout).trim().to_string()
+                } else {
+                    "unknown".to_string()
+                }
+            }
+            Err(_) => "unknown".to_string(),
+        }
+    });
+
+    // Get the short hash (first 7 characters)
+    let short_hash = if git_hash != "unknown" && git_hash.len() >= 7 {
+        git_hash[..7].to_string()
+    } else {
+        git_hash.clone()
+    };
+
+    // Set the environment variables that will be available at compile time
+    println!("cargo:rustc-env=GIT_COMMIT_HASH={}", git_hash);
+    println!("cargo:rustc-env=GIT_COMMIT_SHORT={}", short_hash);
+
+    // Rebuild if the Git commit changes (only works when .git directory is available)
+    if std::path::Path::new(".git/HEAD").exists() {
+        println!("cargo:rerun-if-changed=.git/HEAD");
+        println!("cargo:rerun-if-changed=.git/refs/heads");
+    }
+}

commands.go

@@ -1,506 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"net/url"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/bwmarrin/discordgo"
-	"github.com/pkg/errors"
-	"github.com/rs/zerolog/log"
-	"github.com/samber/lo"
-)
-
-var (
-	commandDefinitions = []*discordgo.ApplicationCommand{TermCommandDefinition, TimeCommandDefinition, SearchCommandDefinition, IcsCommandDefinition}
-	commandHandlers    = map[string]func(s *discordgo.Session, i *discordgo.InteractionCreate) error{
-		TimeCommandDefinition.Name:   TimeCommandHandler,
-		TermCommandDefinition.Name:   TermCommandHandler,
-		SearchCommandDefinition.Name: SearchCommandHandler,
-		IcsCommandDefinition.Name:    IcsCommandHandler,
-	}
-)
-
-var SearchCommandDefinition = &discordgo.ApplicationCommand{
-	Name:        "search",
-	Description: "Search for a course",
-	Options: []*discordgo.ApplicationCommandOption{
-		{
-			Type:         discordgo.ApplicationCommandOptionString,
-			MinLength:    GetIntPointer(0),
-			MaxLength:    48,
-			Name:         "title",
-			Description:  "Course Title (exact, use autocomplete)",
-			Required:     false,
-			Autocomplete: true,
-		},
-		{
-			Type:        discordgo.ApplicationCommandOptionString,
-			Name:        "code",
-			MinLength:   GetIntPointer(4),
-			Description: "Course Code (e.g. 3743, 3000-3999, 3xxx, 3000-)",
-			Required:    false,
-		},
-		{
-			Type:        discordgo.ApplicationCommandOptionInteger,
-			Name:        "max",
-			Description: "Maximum number of results",
-			Required:    false,
-		},
-		{
-			Type:        discordgo.ApplicationCommandOptionString,
-			Name:        "keywords",
-			Description: "Keywords in Title or Description (space separated)",
-		},
-		{
-			Type:         discordgo.ApplicationCommandOptionString,
-			Name:         "instructor",
-			Description:  "Instructor Name",
-			Required:     false,
-			Autocomplete: true,
-		},
-		{
-			Type:         discordgo.ApplicationCommandOptionString,
-			Name:         "subject",
-			Description:  "Subject (e.g. Computer Science/CS, Mathematics/MAT)",
-			Required:     false,
-			Autocomplete: true,
-		},
-	},
-}
-
-func SearchCommandHandler(session *discordgo.Session, interaction *discordgo.InteractionCreate) error {
-	data := interaction.ApplicationCommandData()
-	query := NewQuery().Credits(3, 6)
-
-	for _, option := range data.Options {
-		switch option.Name {
-		case "title":
-			query.Title(option.StringValue())
-		case "code":
-			var (
-				low  = -1
-				high = -1
-			)
-			var err error
-			valueRaw := strings.TrimSpace(option.StringValue())
-
-			// Partially/fully specified range
-			if strings.Contains(valueRaw, "-") {
-				match := regexp.MustCompile(`(\d{1,4})-(\d{1,4})?`).FindSubmatch([]byte(valueRaw))
-
-				if match == nil {
-					return fmt.Errorf("invalid range format: %s", valueRaw)
-				}
-
-				// If not 2 or 3 matches, it's invalid
-				if len(match) != 3 && len(match) != 4 {
-					return fmt.Errorf("invalid range format: %s", match[0])
-				}
-
-				low, err = strconv.Atoi(string(match[1]))
-				if err != nil {
-					return errors.Wrap(err, "error parsing course code (low)")
-				}
-
-				// If there's not a high value, set it to max (open ended)
-				if len(match) == 2 || len(match[2]) == 0 {
-					high = 9999
-				} else {
-					high, err = strconv.Atoi(string(match[2]))
-					if err != nil {
-						return errors.Wrap(err, "error parsing course code (high)")
-					}
-				}
-			}
-
-			// #xxx, ##xx, ###x format (34xx -> 3400-3499)
-			if strings.Contains(valueRaw, "x") {
-				if len(valueRaw) != 4 {
-					return fmt.Errorf("code range format invalid: must be 1 or more digits followed by x's (%s)", valueRaw)
-				}
-
-				match := regexp.MustCompile(`\d{1,}([xX]{1,3})`).Match([]byte(valueRaw))
-				if !match {
-					return fmt.Errorf("code range format invalid: must be 1 or more digits followed by x's (%s)", valueRaw)
-				}
-
-				// Replace x's with 0's
-				low, err = strconv.Atoi(strings.Replace(valueRaw, "x", "0", -1))
-				if err != nil {
-					return errors.Wrap(err, "error parsing implied course code (low)")
-				}
-
-				// Replace x's with 9's
-				high, err = strconv.Atoi(strings.Replace(valueRaw, "x", "9", -1))
-				if err != nil {
-					return errors.Wrap(err, "error parsing implied course code (high)")
-				}
-			} else if len(valueRaw) == 4 {
-				// 4 digit code
-				low, err = strconv.Atoi(valueRaw)
-				if err != nil {
-					return errors.Wrap(err, "error parsing course code")
-				}
-
-				high = low
-			}
-
-			if low == -1 || high == -1 {
-				return fmt.Errorf("course code range invalid (%s)", valueRaw)
-			}
-
-			if low > high {
-				return fmt.Errorf("course code range is invalid: low is greater than high (%d > %d)", low, high)
-			}
-
-			if low < 1000 || high < 1000 || low > 9999 || high > 9999 {
-				return fmt.Errorf("course code range is invalid: must be 1000-9999 (%d-%d)", low, high)
-			}
-
-			query.CourseNumbers(low, high)
-		case "keywords":
-			query.Keywords(
-				strings.Split(option.StringValue(), " "),
-			)
-		case "max":
-			query.MaxResults(
-				min(8, int(option.IntValue())),
-			)
-		}
-	}
-
-	courses, err := Search(query, "", false)
-	if err != nil {
-		session.InteractionRespond(interaction.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Error searching for courses",
-			},
-		})
-		return err
-	}
-
-	fetch_time := time.Now()
-	fields := []*discordgo.MessageEmbedField{}
-
-	for _, course := range courses.Data {
-		displayName := course.Faculty[0].DisplayName
-		categoryLink := fmt.Sprintf("[%s](https://catalog.utsa.edu/undergraduate/coursedescriptions/%s/)", course.Subject, strings.ToLower(course.Subject))
-		classLink := fmt.Sprintf("[%s-%s](https://catalog.utsa.edu/search/?P=%s%%20%s)", course.CourseNumber, course.SequenceNumber, course.Subject, course.CourseNumber)
-		professorLink := fmt.Sprintf("[%s](https://www.ratemyprofessors.com/search/professors/1516?q=%s)", displayName, url.QueryEscape(displayName))
-
-		identifierText := fmt.Sprintf("%s %s (CRN %s)\n%s", categoryLink, classLink, course.CourseReferenceNumber, professorLink)
-		meetings := course.MeetingsFaculty[0]
-
-		fields = append(fields, &discordgo.MessageEmbedField{
-			Name:   "Identifier",
-			Value:  identifierText,
-			Inline: true,
-		}, &discordgo.MessageEmbedField{
-			Name:   "Name",
-			Value:  course.CourseTitle,
-			Inline: true,
-		}, &discordgo.MessageEmbedField{
-			Name:   "Meeting Time",
-			Value:  meetings.String(),
-			Inline: true,
-		},
-		)
-	}
-
-	// Blue if there are results, orange if there are none
-	color := 0x0073FF
-	if courses.TotalCount == 0 {
-		color = 0xFF6500
-	}
-
-	err = session.InteractionRespond(interaction.Interaction, &discordgo.InteractionResponse{
-		Type: discordgo.InteractionResponseChannelMessageWithSource,
-		Data: &discordgo.InteractionResponseData{
-			Embeds: []*discordgo.MessageEmbed{
-				{
-					Footer:      GetFetchedFooter(fetch_time),
-					Description: p.Sprintf("%d Class%s", courses.TotalCount, Plurale(courses.TotalCount)),
-					Fields:      fields[:min(25, len(fields))],
-					Color:       color,
-				},
-			},
-			AllowedMentions: &discordgo.MessageAllowedMentions{},
-		},
-	})
-
-	return err
-}
-
-var TermCommandDefinition = &discordgo.ApplicationCommand{
-	Name:        "terms",
-	Description: "Guess the current term, or search for a specific term",
-	Options: []*discordgo.ApplicationCommandOption{
-		{
-			Type:        discordgo.ApplicationCommandOptionString,
-			MinLength:   GetIntPointer(0),
-			MaxLength:   8,
-			Name:        "search",
-			Description: "Term to search for",
-			Required:    false,
-		},
-		{
-			Type:        discordgo.ApplicationCommandOptionInteger,
-			Name:        "page",
-			Description: "Page Number",
-			Required:    false,
-			MinValue:    GetFloatPointer(1),
-		},
-	},
-}
-
-func TermCommandHandler(session *discordgo.Session, interaction *discordgo.InteractionCreate) error {
-	data := interaction.ApplicationCommandData()
-
-	searchTerm := ""
-	pageNumber := 1
-
-	for _, option := range data.Options {
-		switch option.Name {
-		case "search":
-			searchTerm = option.StringValue()
-		case "page":
-			pageNumber = int(option.IntValue())
-		default:
-			log.Warn().Str("option", option.Name).Msg("Unexpected option in term command")
-		}
-	}
-
-	termResult, err := GetTerms(searchTerm, pageNumber, 25)
-
-	if err != nil {
-		RespondError(session, interaction.Interaction, "Error while fetching terms", err)
-		return err
-	}
-
-	fields := []*discordgo.MessageEmbedField{}
-
-	for _, t := range termResult {
-		fields = append(fields, &discordgo.MessageEmbedField{
-			Name:   t.Description,
-			Value:  t.Code,
-			Inline: true,
-		})
-	}
-
-	fetch_time := time.Now()
-
-	if len(fields) > 25 {
-		log.Warn().Int("count", len(fields)).Msg("Too many fields in term command (trimmed)")
-	}
-
-	err = session.InteractionRespond(interaction.Interaction, &discordgo.InteractionResponse{
-		Type: discordgo.InteractionResponseChannelMessageWithSource,
-		Data: &discordgo.InteractionResponseData{
-			Embeds: []*discordgo.MessageEmbed{
-				{
-					Footer:      GetFetchedFooter(fetch_time),
-					Description: p.Sprintf("%d of %d term%s (page %d)", len(termResult), len(terms), Plural(len(terms)), pageNumber),
-					Fields:      fields[:min(25, len(fields))],
-				},
-			},
-			AllowedMentions: &discordgo.MessageAllowedMentions{},
-		},
-	})
-
-	return err
-}
-
-var TimeCommandDefinition = &discordgo.ApplicationCommand{
-	Name:        "time",
-	Description: "Get Class Meeting Time",
-	Options: []*discordgo.ApplicationCommandOption{
-		{
-			Type:        discordgo.ApplicationCommandOptionInteger,
-			Name:        "crn",
-			Description: "Course Reference Number",
-			Required:    true,
-		},
-	},
-}
-
-func TimeCommandHandler(s *discordgo.Session, i *discordgo.InteractionCreate) error {
-	fetch_time := time.Now()
-	crn := i.ApplicationCommandData().Options[0].IntValue()
-
-	// Fix static term
-	meetingTimes, err := GetCourseMeetingTime(202510, int(crn))
-	if err != nil {
-		s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-			Type: discordgo.InteractionResponseChannelMessageWithSource,
-			Data: &discordgo.InteractionResponseData{
-				Content: "Error getting meeting time",
-			},
-		})
-		return err
-	}
-
-	meetingTime := meetingTimes[0]
-	duration := meetingTime.EndTime().Sub(meetingTime.StartTime())
-
-	s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-		Type: discordgo.InteractionResponseChannelMessageWithSource,
-		Data: &discordgo.InteractionResponseData{
-			Embeds: []*discordgo.MessageEmbed{
-				{
-					Footer:      GetFetchedFooter(fetch_time),
-					Description: "",
-					Fields: []*discordgo.MessageEmbedField{
-						{
-							Name:  "Start Date",
-							Value: meetingTime.StartDay().Format("Monday, January 2, 2006"),
-						},
-						{
-							Name:  "End Date",
-							Value: meetingTime.EndDay().Format("Monday, January 2, 2006"),
-						},
-						{
-							Name:  "Start/End Time",
-							Value: fmt.Sprintf("%s - %s (%d min)", meetingTime.StartTime().String(), meetingTime.EndTime().String(), int64(duration.Minutes())),
-						},
-						{
-							Name:  "Days of Week",
-							Value: WeekdaysToString(meetingTime.Days()),
-						},
-					},
-				},
-			},
-			AllowedMentions: &discordgo.MessageAllowedMentions{},
-		},
-	})
-	return nil
-}
-
-var IcsCommandDefinition = &discordgo.ApplicationCommand{
-	Name:        "ics",
-	Description: "Generate an ICS file for a course",
-	Options: []*discordgo.ApplicationCommandOption{
-		{
-			Type:        discordgo.ApplicationCommandOptionInteger,
-			Name:        "crn",
-			Description: "Course Reference Number",
-			Required:    true,
-		},
-	},
-}
-
-func IcsCommandHandler(s *discordgo.Session, i *discordgo.InteractionCreate) error {
-	crn := i.ApplicationCommandData().Options[0].IntValue()
-
-	course, err := GetCourse(strconv.Itoa(int(crn)))
-	if err != nil {
-		return fmt.Errorf("Error retrieving course data: %w", err)
-	}
-
-	// Fix static term
-	meetingTimes, err := GetCourseMeetingTime(202510, int(crn))
-	if err != nil {
-		return fmt.Errorf("Error requesting meeting time: %w", err)
-	}
-
-	if len(meetingTimes) == 0 {
-		return fmt.Errorf("unexpected - no meeting time data found for course")
-	}
-
-	// Check if the course has any meeting times
-	_, exists := lo.Find(meetingTimes, func(mt MeetingTimeResponse) bool {
-		switch mt.MeetingTime.MeetingType {
-		case "ID", "OA":
-			return false
-		default:
-			return true
-		}
-	})
-
-	if !exists {
-		log.Warn().Str("crn", course.CourseReferenceNumber).Msg("Non-meeting course requested for ICS file")
-		RespondError(s, i.Interaction, "The course requested does not meet at a defined moment in time.", nil)
-		return nil
-	}
-
-	events := []string{}
-	for _, meeting := range meetingTimes {
-		now := time.Now().In(CentralTimeLocation)
-		uid := fmt.Sprintf("%d-%s@ical.banner.xevion.dev", now.Unix(), meeting.CourseReferenceNumber)
-
-		startDay := meeting.StartDay()
-		startTime := meeting.StartTime()
-		endTime := meeting.EndTime()
-		dtStart := time.Date(startDay.Year(), startDay.Month(), startDay.Day(), int(startTime.Hours), int(startTime.Minutes), 0, 0, CentralTimeLocation)
-		dtEnd := time.Date(startDay.Year(), startDay.Month(), startDay.Day(), int(endTime.Hours), int(endTime.Minutes), 0, 0, CentralTimeLocation)
-
-		endDay := meeting.EndDay()
-		until := time.Date(endDay.Year(), endDay.Month(), endDay.Day(), 23, 59, 59, 0, CentralTimeLocation)
-
-		summary := fmt.Sprintf("%s %s %s", course.Subject, course.CourseNumber, course.CourseTitle)
-		description := fmt.Sprintf("Instructor: %s\nSection: %s\nCRN: %s", course.Faculty[0].DisplayName, course.SequenceNumber, meeting.CourseReferenceNumber)
-		location := meeting.PlaceString()
-
-		event := fmt.Sprintf(`BEGIN:VEVENT
-DTSTAMP:%s
-UID:%s
-DTSTART;TZID=America/Chicago:%s
-RRULE:FREQ=WEEKLY;BYDAY=%s;UNTIL=%s
-DTEND;TZID=America/Chicago:%s
-SUMMARY:%s
-DESCRIPTION:%s
-LOCATION:%s
-END:VEVENT`, now.Format(ICalTimestampFormatLocal), uid, dtStart.Format(ICalTimestampFormatLocal), meeting.ByDay(), until.Format(ICalTimestampFormatLocal), dtEnd.Format(ICalTimestampFormatLocal), summary, strings.Replace(description, "\n", `\n`, -1), location)
-
-		events = append(events, event)
-	}
-
-	// TODO: Make this dynamically requested, parsed & cached from tzurl.org
-	vTimezone := `BEGIN:VTIMEZONE
-TZID:America/Chicago
-LAST-MODIFIED:20231222T233358Z
-TZURL:https://www.tzurl.org/zoneinfo-outlook/America/Chicago
-X-LIC-LOCATION:America/Chicago
-BEGIN:DAYLIGHT
-TZNAME:CDT
-TZOFFSETFROM:-0600
-TZOFFSETTO:-0500
-DTSTART:19700308T020000
-RRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=2SU
-END:DAYLIGHT
-BEGIN:STANDARD
-TZNAME:CST
-TZOFFSETFROM:-0500
-TZOFFSETTO:-0600
-DTSTART:19701101T020000
-RRULE:FREQ=YEARLY;BYMONTH=11;BYDAY=1SU
-END:STANDARD
-END:VTIMEZONE`
-
-	ics := fmt.Sprintf(`BEGIN:VCALENDAR
-VERSION:2.0
-PRODID:-//xevion//Banner Discord Bot//EN
-CALSCALE:GREGORIAN
-%s
-%s
-END:VCALENDAR`, vTimezone, strings.Join(events, "\n"))
-
-	session.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-		Type: discordgo.InteractionResponseChannelMessageWithSource,
-		Data: &discordgo.InteractionResponseData{
-			Files: []*discordgo.File{
-				{
-					Name:        fmt.Sprintf("%s-%s-%s_%s.ics", course.Subject, course.CourseNumber, course.SequenceNumber, course.CourseReferenceNumber),
-					ContentType: "text/calendar",
-					Reader:      strings.NewReader(ics),
-				},
-			},
-			AllowedMentions: &discordgo.MessageAllowedMentions{},
-		},
-	})
-	return nil
-}

docs/ARCHITECTURE.md

@@ -0,0 +1,94 @@
+# Architecture
+
+## System Overview
+
+The Banner project is built as a multi-service application with the following components:
+
+- **Discord Bot Service**: Handles Discord interactions and commands
+- **Web Service**: Serves the React frontend and provides API endpoints
+- **Scraper Service**: Background data collection and synchronization
+- **Database Layer**: PostgreSQL for persistent storage
+
+## Technical Analysis
+
+### Banner System Integration
+
+Some of the features and architecture of Ellucian's Banner system are not clear.
+The following features, JSON, and more require validation & analysis:
+
+- Struct Nullability
+  - Much of the responses provided by Ellucian contain nulls, and most of them are uncertain as to when and why they're null.
+  - Analysis must be conducted to be sure of when to use a string and when it should nillable (pointer).
+- Multiple Professors / Primary Indicator
+- Multiple Meeting Times
+- Meeting Schedule Types
+  - AFF vs AIN vs AHB etc.
+- Do CRNs repeat between years?
+- Check whether partOfTerm is always filled in, and it's meaning for various class results.
+- Check which API calls are affected by change in term/sessionID term select
+- SessionIDs
+  - How long does a session ID work?
+  - Do I really require a separate one per term?
+  - How many can I activate, are there any restrictions?
+  - How should session IDs be checked as 'invalid'?
+  - What action(s) keep a session ID 'active', if any?
+- Are there any courses with multiple meeting times?
+- Google Calendar link generation, as an alternative to ICS file generation
+
+## Change Identification
+
+- Important attributes of a class will be parsed on both the old and new data.
+- These attributes will be compared and given identifiers that can be subscribed to.
+- When a user subscribes to one of these identifiers, any changes identified will be sent to the user.
+
+## Real-time Suggestions
+
+Various commands arguments have the ability to have suggestions appear.
+
+- They must be fast. As ephemeral suggestions that are only relevant for seconds or less, they need to be delivered in less than a second.
+- They need to be easy to acquire. With as many commands & arguments to search as I do, it is paramount that the API be easy to understand & use.
+- It cannot be complicated. I only have so much time to develop this.
+- It does not need to be persistent. Since the data is scraped and rolled periodically from the Banner system, the data used will be deleted and re-requested occasionally.
+
+For these reasons, I believe PostgreSQL to be the ideal place for this data to be stored.
+It is exceptionally fast, works well in-memory, and is less complicated compared to most other solutions.
+
+- Only required data about the class will be stored, along with the JSON-encoded string.
+  - For now, this would only be the CRN (and possibly the Term).
+  - Potentially, a binary encoding could be used for performance, but it is unlikely to be better.
+- Database dumping into R2 would be good to ensure that over-scraping of the Banner system does not occur.
+  - Upon a safe close requested
+    - Must be done quickly (<8 seconds)
+  - Every 30 minutes, if any scraping ocurred.
+    - May cause locking of commands.
+
+## Scraping System
+
+In order to keep the in-memory database of the bot up-to-date with the Banner system, the API must be scraped.
+Scraping will be separated by major to allow for priority majors (namely, Computer Science) to be scraped more often compared to others.
+This will lower the overall load on the Banner system while ensuring that data presented by the app is still relevant.
+
+For now, all majors will be scraped fully every 4 hours with at least 5 minutes between each one.
+
+- On startup, priority majors will be scraped first (if required).
+- Other majors will be scraped in arbitrary order (if required).
+- Scrape timing will be stored in database.
+- CRNs will be the Primary Key within database
+  - If CRNs are duplicated between terms, then the primary key will be (CRN, Term)
+
+Considerations
+
+- Change in metadata should decrease the interval
+- The number of courses scraped should change the interval (2 hours per 500 courses involved)
+
+## Rate Limiting, Costs & Bursting
+
+Ideally, this application would implement dynamic rate limiting to ensure overload on the server does not occur.
+Better, it would also ensure that priority requests (commands) are dispatched faster than background processes (scraping), while making sure different requests are weighted differently.
+For example, a recent scrape of 350 classes should be weighted 5x more than a search for 8 classes by a user.
+Still, even if the cap does not normally allow for this request to be processed immediately, the small user search should proceed with a small bursting cap.
+
+The requirements to this hypothetical system would be:
+
+- Conditional Bursting: background processes or other requests deemed "low priority" are not allowed to use bursting.
+- Arbitrary Costs: rate limiting is considered in the form of the request size/speed more or less, such that small simple requests can be made more frequently, unlike large requests.

docs/BANNER.md

@@ -1,29 +1,36 @@
-# Sessions
+# Banner
+
+All notes on the internal workings of the Banner system by Ellucian.
+
+## Sessions
 
 All notes on the internal workings of Sessions in the Banner system.
 
 - Sessions are generated on demand with a random string of characters.
+  - The format `{5 random characters}{milliseconds since epoch}`
+  - Example: ``
 - Sessions are invalidated after 30 minutes, but may change.
   - This delay can be found in the original HTML returned, find `meta[name="maxInactiveInterval"]` and read the `content` attribute.
-  - This is read at runtime by the javascript on initialization.
+  - This is read at runtime (in the browser, by javascript) on initialization.
 - Multiple timers exist, one is for the Inactivity Timer.
   - A dialog will appear asking the user to continue their session.
   - If they click the button, the session will be extended via the keepAliveURL (see `meta[name="keepAliveURL"]`).
   - The `keepAliveURL` does not seem to care whether the session is or was ever valid, it will always return a 200 OK with `I am Alive` as the content.
 - When searching with an invalid session (or none at all, as the case may be), the server will return 200 OK, but with an empty result response structure.
-  - ```json
-    {
-        "success": true,
-        "totalCount": 0,
-        "data": null,    // always an array, even if empty
-        "pageOffset": 0,                  //
-        "pageMaxSize": 10,
-        "sectionsFetchedCount": 0,
-        "pathMode": "registration",   // normally "search"
-        "searchResultsConfigs": null,  // normally an array
-        "ztcEncodedImage": null  // normally a static string in base64
-    }
+
+```json
+{
+  "success": true,
+  "totalCount": 0,
+  "data": null, // always an array, even if empty
+  "pageOffset": 0, //
+  "pageMaxSize": 10,
+  "sectionsFetchedCount": 0,
+  "pathMode": "registration", // normally "search"
+  "searchResultsConfigs": null, // normally an array
+  "ztcEncodedImage": null // normally a static string in base64
+}
 ```
-    
-  - This is only the handling for the search endpoint, more research is required to see how other endpoints handle invalid/expired sessions.
-  - TODO: How is `pathMode` affected by an expired session, rather than an invalid/non-existent one?
+
+- This is only the handling for the search endpoint, more research is required to see how other endpoints handle invalid/expired sessions.
+- TODO: How is `pathMode` affected by an expired session, rather than an invalid/non-existent one?

docs/FEATURES.md

@@ -0,0 +1,58 @@
+# Features
+
+## Current Features
+
+### Discord Bot Commands
+
+- **search** - Search for courses with various filters (title, course code, keywords)
+- **terms** - List available terms or search for a specific term
+- **time** - Get meeting times for a specific course (CRN)
+- **ics** - Generate ICS calendar file for a course with holiday exclusions
+- **gcal** - Generate Google Calendar link for a course
+
+### Data Pipeline
+
+- Intelligent scraping system with priority queues
+- Rate limiting and burst handling
+- Background data synchronization
+
+## Feature Wishlist
+
+### Commands
+
+- ICS Download (get a ICS download of your classes with location & timing perfectly - set for every class you're in)
+- Classes Now (find classes happening)
+- Autocomplete
+  - Class Title
+  - Course Number
+  - Term/Part of Term
+  - Professor
+  - Attribute
+- Component Pagination
+- RateMyProfessor Integration (Linked/Embedded)
+- Smart term selection (i.e. Summer 2024 will be selected automatically when opened)
+- Rate Limiting (bursting with global/user limits)
+- DMs Integration (allow usage of the bot in DMs)
+- Class Change Notifications (get notified when details about a class change)
+- Multi-term Querying (currently the backend for searching is kinda weird)
+- Full Autocomplete for Every Search Option
+- Metrics, Log Query, Privileged Error Feedback
+- Search for Classes
+  - Major, Professor, Location, Name, Time of Day
+- Subscribe to Classes
+  - Availability (seat, pre-seat)
+  - Waitlist Movement
+  - Detail Changes (meta, time, location, seats, professor)
+    - `time` Start, End, Days of Week
+    - `seats` Any change in seat/waitlist data
+    - `meta`
+- Lookup via Course Reference Number (CRN)
+- Smart Time of Day Handling
+  - "2 PM" -> Start within 2:00 PM to 2:59 PM
+  - "2-3 PM" -> Start within 2:00 PM to 3:59 PM
+  - "ends by 2 PM" -> Ends within 12:00 AM to 2:00 PM
+  - "after 2 PM" -> Start within 2:01 PM to 11:59 PM
+  - "before 2 PM" -> Ends within 12:00 AM to 1:59 PM
+- Get By Section Command
+  - CS 4393 001 =>
+  - Will require SQL to be able to search for a class by its section number

docs/README.md

@@ -0,0 +1,42 @@
+# Documentation
+
+This folder contains detailed documentation for the Banner project. This file acts as the index.
+
+## Files
+
+- [`FEATURES.md`](FEATURES.md) - Current features, implemented functionality, and future roadmap
+- [`BANNER.md`](BANNER.md) - General API documentation on the Banner system
+- [`ARCHITECTURE.md`](ARCHITECTURE.md) - Technical implementation details, system design, and analysis
+
+## Samples
+
+The `samples/` folder contains real Banner API response examples:
+
+- `search/` - Course search API responses with various filters
+  - [`searchResults.json`](samples/search/searchResults.json)
+  - [`searchResults_500.json`](samples/search/searchResults_500.json)
+  - [`searchResults_CS500.json`](samples/search/searchResults_CS500.json)
+  - [`searchResults_malware.json`](samples/search/searchResults_malware.json)
+- `meta/` - Metadata API responses (terms, subjects, instructors, etc.)
+  - [`get_attribute.json`](samples/meta/get_attribute.json)
+  - [`get_campus.json`](samples/meta/get_campus.json)
+  - [`get_instructionalMethod.json`](samples/meta/get_instructionalMethod.json)
+  - [`get_instructor.json`](samples/meta/get_instructor.json)
+  - [`get_partOfTerm.json`](samples/meta/get_partOfTerm.json)
+  - [`get_subject.json`](samples/meta/get_subject.json)
+  - [`getTerms.json`](samples/meta/getTerms.json)
+- `course/` - Course detail API responses (HTML and JSON)
+  - [`getFacultyMeetingTimes.json`](samples/course/getFacultyMeetingTimes.json)
+  - [`getClassDetails.html`](samples/course/getClassDetails.html)
+  - [`getCorequisites.html`](samples/course/getCorequisites.html)
+  - [`getCourseDescription.html`](samples/course/getCourseDescription.html)
+  - [`getEnrollmentInfo.html`](samples/course/getEnrollmentInfo.html)
+  - [`getFees.html`](samples/course/getFees.html)
+  - [`getLinkedSections.html`](samples/course/getLinkedSections.html)
+  - [`getRestrictions.html`](samples/course/getRestrictions.html)
+  - [`getSectionAttributes.html`](samples/course/getSectionAttributes.html)
+  - [`getSectionBookstoreDetails.html`](samples/course/getSectionBookstoreDetails.html)
+  - [`getSectionPrerequisites.html`](samples/course/getSectionPrerequisites.html)
+  - [`getXlistSections.html`](samples/course/getXlistSections.html)
+
+These samples are used for development, testing, and understanding the Banner API structure.

errors.go

@@ -1,12 +0,0 @@
-package main
-
-import "fmt"
-
-type UnexpectedContentTypeError struct {
-	Expected string
-	Actual   string
-}
-
-func (e *UnexpectedContentTypeError) Error() string {
-	return fmt.Sprintf("Expected content type '%s', received '%s'", e.Expected, e.Actual)
-}

go.mod

@@ -1,32 +0,0 @@
-module banner
-
-go 1.21
-
-require github.com/bwmarrin/discordgo v0.27.1
-
-require (
-	github.com/joho/godotenv v1.5.1
-	github.com/pkg/errors v0.9.1
-	github.com/redis/go-redis/v9 v9.3.1
-	github.com/rs/zerolog v1.31.0
-	github.com/samber/lo v1.39.0
-	golang.org/x/text v0.14.0
-)
-
-require (
-	github.com/arran4/golang-ical v0.2.3 // indirect
-	github.com/cespare/xxhash/v2 v2.2.0 // indirect
-	github.com/cnf/structhash v0.0.0-20201127153200-e1b16c1ebc08 // indirect
-	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
-	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-isatty v0.0.19 // indirect
-	github.com/sirupsen/logrus v1.9.3 // indirect
-	golang.org/x/exp v0.0.0-20220303212507-bbda1eaf7a17 // indirect
-)
-
-require (
-	github.com/gorilla/websocket v1.5.1 // fndirect
-	golang.org/x/crypto v0.16.0 // indirect
-	golang.org/x/net v0.19.0 // indirect
-	golang.org/x/sys v0.15.0 // indirect
-)

go.sum

@@ -1,89 +0,0 @@
-github.com/arran4/golang-ical v0.2.3 h1:C4Vj7+BjJBIrAJhHgi6Ku+XUkQVugRq4re5Cqj5QVdE=
-github.com/arran4/golang-ical v0.2.3/go.mod h1:RqMuPGmwRRwjkb07hmm+JBqcWa1vF1LvVmPtSZN2OhQ=
-github.com/bwmarrin/discordgo v0.27.0 h1:4ZK9KN+rGIxZ0fdGTmgdCcliQeW8Zhu6MnlFI92nf0Q=
-github.com/bwmarrin/discordgo v0.27.0/go.mod h1:NJZpH+1AfhIcyQsPeuBKsUtYrRnjkyu0kIVMCHkZtRY=
-github.com/bwmarrin/discordgo v0.27.1 h1:ib9AIc/dom1E/fSIulrBwnez0CToJE113ZGt4HoliGY=
-github.com/bwmarrin/discordgo v0.27.1/go.mod h1:NJZpH+1AfhIcyQsPeuBKsUtYrRnjkyu0kIVMCHkZtRY=
-github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
-github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/cnf/structhash v0.0.0-20201127153200-e1b16c1ebc08 h1:ox2F0PSMlrAAiAdknSRMDrAr8mfxPCfSZolH+/qQnyQ=
-github.com/cnf/structhash v0.0.0-20201127153200-e1b16c1ebc08/go.mod h1:pCxVEbcm3AMg7ejXyorUXi6HQCzOIBf7zEDVPtw0/U4=
-github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
-github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
-github.com/frankban/quicktest v1.2.2/go.mod h1:Qh/WofXFeiAFII1aEBu529AtJo6Zg2VHscnEsbBnJ20=
-github.com/go-redis/redis v6.15.9+incompatible h1:K0pv1D7EQUjfyoMql+r/jZqCLizCGKFlFgcHWWmHQjg=
-github.com/go-redis/redis v6.15.9+incompatible/go.mod h1:NAIEuMOZ/fxfXJIrKDQDz8wamY7mA7PouImQ2Jvg6kA=
-github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
-github.com/google/go-cmp v0.2.1-0.20190312032427-6f77996f0c42/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc=
-github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY=
-github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY=
-github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
-github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
-github.com/juju/go4 v0.0.0-20160222163258-40d72ab9641a h1:45JtCyuNYE+QN9aPuR1ID9++BQU+NMTMudHSuaK0Las=
-github.com/juju/go4 v0.0.0-20160222163258-40d72ab9641a/go.mod h1:RVHtZuvrpETIepiNUrNlih2OynoFf1eM6DGC6dloXzk=
-github.com/juju/persistent-cookiejar v1.0.0 h1:Ag7+QLzqC2m+OYXy2QQnRjb3gTkEBSZagZ6QozwT3EQ=
-github.com/juju/persistent-cookiejar v1.0.0/go.mod h1:zrbmo4nBKaiP/Ez3F67ewkMbzGYfXyMvRtbOfuAwG0w=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
-github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/redis/go-redis v6.15.9+incompatible h1:F+tnlesQSl3h9V8DdmtcYFdvkHLhbb7AgcLW6UJxnC4=
-github.com/redis/go-redis v6.15.9+incompatible/go.mod h1:ic6dLmR0d9rkHSzaa0Ab3QVRZcjopJ9hSSPCrecj/+s=
-github.com/redis/go-redis/v9 v9.3.1 h1:KqdY8U+3X6z+iACvumCNxnoluToB+9Me+TvyFa21Mds=
-github.com/redis/go-redis/v9 v9.3.1/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M=
-github.com/rogpeppe/clock v0.0.0-20190514195947-2896927a307a/go.mod h1:4r5QyqhjIWCcK8DO4KMclc5Iknq5qVBAlbYYzAbUScQ=
-github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
-github.com/rs/zerolog v1.31.0 h1:FcTR3NnLWW+NnTwwhFWiJSZr4ECLpqCm6QsEnyvbV4A=
-github.com/rs/zerolog v1.31.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
-github.com/samber/lo v1.39.0 h1:4gTz1wUhNYLhFSKl6O+8peW0v2F4BCY034GRpU9WnuA=
-github.com/samber/lo v1.39.0/go.mod h1:+m/ZKRl6ClXCE2Lgf3MsQlWfh4bn1bz6CXEOxnEXnEA=
-github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
-github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b h1:7mWr3k41Qtv8XlltBkDkl8LoP3mpSgBW8BUoxtEdbXg=
-golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
-golang.org/x/crypto v0.16.0 h1:mMMrFzRSCF0GvB7Ne27XVtVAaXLrPmgPC7/v0tkwHaY=
-golang.org/x/crypto v0.16.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
-golang.org/x/exp v0.0.0-20220303212507-bbda1eaf7a17 h1:3MTrJm4PyNL9NBqvYDSj3DHl46qQakyfqfWo4jgfaEM=
-golang.org/x/exp v0.0.0-20220303212507-bbda1eaf7a17/go.mod h1:lgLbSvA5ygNOMpwM/9anMpWVlVJ7Z+cHWq/eFuinpGE=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110 h1:qWPm9rbaAMKs8Bq/9LRpbMqxWRVUAQwMI9fVrssnTfw=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.19.0 h1:zTwKpTd2XuCqf8huc7Fo2iSy+4RHPd10s4KzeTnVr1c=
-golang.org/x/net v0.19.0/go.mod h1:CfAk/cbD4CthTvqiEl8NpboMuiuOYsAr/7NOjZJtv1U=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68 h1:nxC68pudNYkKU6jWhgrqdreuFiOQWj1Fs7T3VrH4Pjw=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
-golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/errgo.v1 v1.0.1 h1:oQFRXzZ7CkBGdm1XZm/EbQYaYNNEElNBOd09M6cqNso=
-gopkg.in/errgo.v1 v1.0.1/go.mod h1:3NjfXwocQRYAPTq4/fzX+CwUhPRcR/azYRhj8G+LqMo=
-gopkg.in/retry.v1 v1.0.3 h1:a9CArYczAVv6Qs6VGoLMio99GEs7kY9UzSF9+LD+iGs=
-gopkg.in/retry.v1 v1.0.3/go.mod h1:FJkXmWiMaAo7xB+xhvDF59zhfjDWyzmyAxiT4dB688g=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

helpers.go

@@ -1,470 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io"
-	"math/rand"
-	"net/http"
-	"net/url"
-	"os"
-	"runtime"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/bwmarrin/discordgo"
-	"github.com/pkg/errors"
-	"github.com/rs/zerolog"
-	log "github.com/rs/zerolog/log"
-	"github.com/samber/lo"
-)
-
-// BuildRequestWithBody builds a request with the given method, path, parameters, and body
-func BuildRequestWithBody(method string, path string, params map[string]string, body io.Reader) *http.Request {
-	// Builds a URL for the given path and parameters
-	requestUrl := baseURL + path
-
-	if params != nil {
-		takenFirst := false
-		for key, value := range params {
-			paramChar := "&"
-			if !takenFirst {
-				paramChar = "?"
-				takenFirst = true
-			}
-
-			requestUrl += paramChar + url.QueryEscape(key) + "=" + url.QueryEscape(value)
-		}
-	}
-
-	request, _ := http.NewRequest(method, requestUrl, body)
-	AddUserAgent(request)
-	return request
-}
-
-// BuildRequest builds a request with the given method, path, and parameters and an empty body
-func BuildRequest(method string, path string, params map[string]string) *http.Request {
-	return BuildRequestWithBody(method, path, params, nil)
-}
-
-// AddUserAgent adds a false but consistent user agent to the request
-func AddUserAgent(req *http.Request) {
-	req.Header.Add("User-Agent", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36")
-}
-
-// ContentTypeMatch checks if the response has the given content type
-func ContentTypeMatch(response *http.Response, search string) bool {
-	contentType := response.Header.Get("Content-Type")
-	if contentType == "" {
-		return search == "application/octect-stream"
-	}
-
-	return strings.HasPrefix(contentType, search)
-}
-
-const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-
-// RandomString returns a random string of length n using the letterBytes constant
-// The constant used is specifically chosen to mimic Ellucian's banner session ID generation.
-func RandomString(n int) string {
-	b := make([]byte, n)
-	for i := range b {
-		b[i] = letterBytes[rand.Intn(len(letterBytes))]
-	}
-	return string(b)
-}
-
-// DiscordGoLogger is a specialized helper function that implements discordgo's global logging interface.
-// It directs all logs to the zerolog implementation.
-func DiscordGoLogger(msgL, caller int, format string, a ...interface{}) {
-	pc, file, line, _ := runtime.Caller(caller)
-
-	files := strings.Split(file, "/")
-	file = files[len(files)-1]
-
-	name := runtime.FuncForPC(pc).Name()
-	fns := strings.Split(name, ".")
-	name = fns[len(fns)-1]
-
-	msg := fmt.Sprintf(format, a...)
-
-	var event *zerolog.Event
-	switch msgL {
-	case 0:
-		event = log.Debug()
-	case 1:
-		event = log.Info()
-	case 2:
-		event = log.Warn()
-	case 3:
-		event = log.Error()
-	default:
-		event = log.Info()
-	}
-
-	event.Str("file", file).Int("line", line).Str("function", name).Msg(msg)
-}
-
-// Nonce returns a string made up of the current time in milliseconds, Unix epoch/UTC
-// This is typically used as a query parameter to prevent request caching in the browser.
-func Nonce() string {
-	return strconv.Itoa(int(time.Now().UnixMilli()))
-}
-
-// DoRequest performs & logs the request, logging and returning the response
-func DoRequest(req *http.Request) (*http.Response, error) {
-	headerSize := 0
-	for key, values := range req.Header {
-		for _, value := range values {
-			headerSize += len(key)
-			headerSize += len(value)
-		}
-	}
-
-	bodySize := int64(0)
-	if req.Body != nil {
-		bodySize, _ = io.Copy(io.Discard, req.Body)
-	}
-
-	size := zerolog.Dict().Int64("body", bodySize).Int("header", headerSize).Int("url", len(req.URL.String()))
-
-	log.Debug().
-		Dict("size", size).
-		Str("method", strings.TrimRight(req.Method, " ")).
-		Str("url", req.URL.String()).
-		Str("query", req.URL.RawQuery).
-		Str("content-type", req.Header.Get("Content-Type")).
-		Msg("Request")
-
-	res, err := client.Do(req)
-
-	if err != nil {
-		log.Err(err).Stack().Str("method", req.Method).Msg("Request Failed")
-	} else {
-		contentLengthHeader := res.Header.Get("Content-Length")
-		contentLength := int64(-1)
-
-		// If this request was a Banner API request, reset the session timer
-		if strings.HasPrefix(req.URL.Path, "StudentRegistrationSsb/ssb/classSearch/") {
-			ResetSessionTimer()
-		}
-
-		// Get the content length
-		if contentLengthHeader != "" {
-			contentLength, err = strconv.ParseInt(contentLengthHeader, 10, 64)
-			if err != nil {
-				contentLength = -1
-			}
-		}
-
-		log.Debug().Int("status", res.StatusCode).Int64("content-length", contentLength).Strs("content-type", res.Header["Content-Type"]).Msg("Response")
-	}
-	return res, err
-}
-
-// Plural is a simple helper function that returns an empty string if n is 1, and "s" otherwise.
-func Plural(n int) string {
-	if n == 1 {
-		return ""
-	}
-	return "s"
-}
-
-// Plurale is a simple helper function that returns an empty string if n is 1, and "ess" otherwise.
-// This is for words that end in "es" when plural.
-func Plurale(n int) string {
-	if n == 1 {
-		return ""
-	}
-	return "es"
-}
-
-func WeekdaysToString(days map[time.Weekday]bool) string {
-	// If no days are present
-	numDays := len(days)
-	if numDays == 0 {
-		return "None"
-	}
-
-	// If all days are present
-	if numDays == 7 {
-		return "Everyday"
-	}
-
-	str := ""
-
-	if days[time.Monday] {
-		str += "M"
-	}
-
-	if days[time.Tuesday] {
-		str += "Tu"
-	}
-
-	if days[time.Wednesday] {
-		str += "W"
-	}
-
-	if days[time.Thursday] {
-		str += "Th"
-	}
-
-	if days[time.Friday] {
-		str += "F"
-	}
-
-	if days[time.Saturday] {
-		str += "Sa"
-	}
-
-	if days[time.Sunday] {
-		str += "Su"
-	}
-
-	return str
-}
-
-type NaiveTime struct {
-	Hours   uint
-	Minutes uint
-}
-
-func (nt *NaiveTime) Sub(other *NaiveTime) time.Duration {
-	return time.Hour*time.Duration(nt.Hours-other.Hours) + time.Minute*time.Duration(nt.Minutes-other.Minutes)
-}
-
-func ParseNaiveTime(integer uint64) *NaiveTime {
-	minutes := uint(integer % 100)
-	hours := uint(integer / 100)
-
-	return &NaiveTime{Hours: hours, Minutes: minutes}
-}
-
-func (nt NaiveTime) String() string {
-	meridiem := "AM"
-	hour := nt.Hours
-	if nt.Hours >= 12 {
-		meridiem = "PM"
-		if nt.Hours > 12 {
-			hour -= 12
-		}
-	}
-	return fmt.Sprintf("%d:%02d%s", hour, nt.Minutes, meridiem)
-}
-
-func GetFirstEnv(key ...string) string {
-	for _, k := range key {
-		if v := os.Getenv(k); v != "" {
-			return v
-		}
-	}
-	return ""
-}
-
-// GetIntPointer returns a pointer to the given value.
-// This function is useful for discordgo, which inexplicably requires pointers to integers for minLength arguments.
-func GetIntPointer(value int) *int {
-	return &value
-}
-
-// GetFloatPointer returns a pointer to the given value.
-// This function is useful for discordgo, which inexplicably requires pointers to floats for minLength arguments.
-func GetFloatPointer(value float64) *float64 {
-	return &value
-}
-
-var extensionMap = map[string]string{
-	"text/plain":               "txt",
-	"application/json":         "json",
-	"text/html":                "html",
-	"text/css":                 "css",
-	"text/csv":                 "csv",
-	"text/calendar":            "ics",
-	"text/markdown":            "md",
-	"text/xml":                 "xml",
-	"text/yaml":                "yaml",
-	"text/javascript":          "js",
-	"text/vtt":                 "vtt",
-	"image/jpeg":               "jpg",
-	"image/png":                "png",
-	"image/gif":                "gif",
-	"image/webp":               "webp",
-	"image/tiff":               "tiff",
-	"image/svg+xml":            "svg",
-	"image/bmp":                "bmp",
-	"image/vnd.microsoft.icon": "ico",
-	"image/x-icon":             "ico",
-	"image/x-xbitmap":          "xbm",
-	"image/x-xpixmap":          "xpm",
-	"image/x-xwindowdump":      "xwd",
-	"image/avif":               "avif",
-	"image/apng":               "apng",
-	"image/jxl":                "jxl",
-}
-
-func GuessExtension(contentType string) string {
-	ext, ok := extensionMap[strings.ToLower(contentType)]
-	if !ok {
-		return ""
-	}
-	return ext
-}
-
-// DumpResponse dumps a response body to a file for debugging purposes
-func DumpResponse(res *http.Response) {
-	contentType := res.Header.Get("Content-Type")
-	ext := GuessExtension(contentType)
-
-	// Use current time as filename + /dumps/ prefix
-	filename := fmt.Sprintf("dumps/%d.%s", time.Now().Unix(), ext)
-	file, err := os.Create(filename)
-
-	if err != nil {
-		log.Err(err).Stack().Msg("Error creating file")
-		return
-	}
-	defer file.Close()
-
-	_, err = io.Copy(file, res.Body)
-	if err != nil {
-		log.Err(err).Stack().Msg("Error copying response body")
-		return
-	}
-
-	log.Info().Str("filename", filename).Str("content-type", contentType).Msg("Dumped response body")
-}
-
-// ResponseError responds to an interaction with an error message
-// TODO: Improve with a proper embed and colors
-func RespondError(session *discordgo.Session, interaction *discordgo.Interaction, message string, err error) error {
-	// Optional: log the error
-	if err != nil {
-		log.Err(err).Stack().Msg(message)
-	}
-
-	return session.InteractionRespond(interaction, &discordgo.InteractionResponse{
-		Type: discordgo.InteractionResponseChannelMessageWithSource,
-		Data: &discordgo.InteractionResponseData{
-			Embeds: []*discordgo.MessageEmbed{
-				{
-					Footer: &discordgo.MessageEmbedFooter{
-						Text: fmt.Sprintf("Occurred at %s", time.Now().Format("Monday, January 2, 2006 at 3:04:05PM")),
-					},
-					Description: message,
-					Color:       0xff0000,
-				},
-			},
-			AllowedMentions: &discordgo.MessageAllowedMentions{},
-		},
-	})
-}
-
-func GetFetchedFooter(time time.Time) *discordgo.MessageEmbedFooter {
-	return &discordgo.MessageEmbedFooter{
-		Text: fmt.Sprintf("Fetched at %s", time.In(CentralTimeLocation).Format("Monday, January 2, 2006 at 3:04:05PM")),
-	}
-}
-
-// GetUser returns the user from the interaction.
-// This helper method is useful as depending on where the message was sent (guild or DM), the user is in a different field.
-func GetUser(interaction *discordgo.InteractionCreate) *discordgo.User {
-	// If the interaction is in a guild, the user is kept in the Member field
-	if interaction.Member != nil {
-		return interaction.Member.User
-	}
-
-	// If the interaction is in a DM, the user is kept in the User field
-	return interaction.User
-}
-
-// Encode encodes the values into “URL encoded” form
-// ("bar=baz&foo=quux") sorted by key.
-func EncodeParams(params map[string]*[]string) string {
-	// Escape hatch for nil
-	if params == nil {
-		return ""
-	}
-
-	// Sort the keys
-	keys := make([]string, 0, len(params))
-	for k := range params {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-
-	var buf strings.Builder
-	for _, k := range keys {
-		// Multiple values are allowed, so extract the slice & prepare the key
-		values := params[k]
-		keyEscaped := url.QueryEscape(k)
-
-		for _, v := range *values {
-			// If any parameters have been written, add the ampersand
-			if buf.Len() > 0 {
-				buf.WriteByte('&')
-			}
-
-			// Write the key and value
-			buf.WriteString(keyEscaped)
-			buf.WriteByte('=')
-			buf.WriteString(url.QueryEscape(v))
-		}
-	}
-
-	return buf.String()
-}
-
-var terms []BannerTerm
-var lastTermUpdate time.Time
-
-// TryReloadTerms attempts to reload the terms if they are not loaded or the last update was more than 24 hours ago
-func TryReloadTerms() error {
-	if len(terms) > 0 && time.Since(lastTermUpdate) < 24*time.Hour {
-		return nil
-	}
-
-	// Load the terms
-	var err error
-	terms, err = GetTerms("", 1, 100)
-	if err != nil {
-		return errors.Wrap(err, "failed to load terms")
-	}
-
-	lastTermUpdate = time.Now()
-	return nil
-}
-
-// IsTermArchived checks if the given term is archived
-// TODO: Add error, switch missing term logic to error
-func IsTermArchived(term string) bool {
-	// Ensure the terms are loaded
-	err := TryReloadTerms()
-	if err != nil {
-		log.Err(err).Stack().Msg("Failed to reload terms")
-		return true
-	}
-
-	// Check if the term is in the list of terms
-	bannerTerm, exists := lo.Find(terms, func(t BannerTerm) bool {
-		return t.Code == term
-	})
-
-	if !exists {
-		log.Warn().Str("term", term).Msg("Term does not exist")
-		return true
-	}
-
-	return bannerTerm.Archived()
-}
-
-// Point represents a point in 2D space
-type Point struct {
-	X, Y float64
-}
-
-func Slope(p1 Point, p2 Point, x float64) Point {
-	slope := (p2.Y - p1.Y) / (p2.X - p1.X)
-	newY := slope*(x-p1.X) + p1.Y
-	return Point{X: x, Y: newY}
-}

logs.go

@@ -1,35 +0,0 @@
-package main
-
-import (
-	"io"
-	"os"
-
-	"github.com/rs/zerolog"
-)
-
-const timeFormat = "2006-01-02 15:04:05"
-
-var (
-	stdConsole = zerolog.ConsoleWriter{Out: os.Stdout, TimeFormat: timeFormat}
-	errConsole = zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: timeFormat}
-)
-
-// logSplitter implements zerolog.LevelWriter
-type logSplitter struct {
-	std io.Writer
-	err io.Writer
-}
-
-// Write should not be called
-func (l logSplitter) Write(p []byte) (n int, err error) {
-	return l.std.Write(p)
-}
-
-// WriteLevel write to the appropriate output
-func (l logSplitter) WriteLevel(level zerolog.Level, p []byte) (n int, err error) {
-	if level <= zerolog.WarnLevel {
-		return l.std.Write(p)
-	} else {
-		return l.err.Write(p)
-	}
-}

main.go

@@ -1,335 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"net/http"
-	"net/http/cookiejar"
-	_ "net/http/pprof"
-	"os"
-	"os/signal"
-	"strings"
-	"syscall"
-	"time"
-	_ "time/tzdata"
-
-	"github.com/bwmarrin/discordgo"
-	"github.com/joho/godotenv"
-	"github.com/redis/go-redis/v9"
-	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
-	"github.com/rs/zerolog/pkgerrors"
-	"github.com/samber/lo"
-	"golang.org/x/text/message"
-)
-
-var (
-	ctx                 context.Context
-	kv                  *redis.Client
-	session             *discordgo.Session
-	client              http.Client
-	cookies             http.CookieJar
-	isDevelopment       bool
-	baseURL             string // Base URL for all requests to the banner system
-	environment         string
-	p                   *message.Printer = message.NewPrinter(message.MatchLanguage("en"))
-	CentralTimeLocation *time.Location
-	isClosing           bool = false
-)
-
-const (
-	ICalTimestampFormatUtc   = "20060102T150405Z"
-	ICalTimestampFormatLocal = "20060102T150405"
-	CentralTimezoneName      = "America/Chicago"
-)
-
-func init() {
-	// Load environment variables
-	if err := godotenv.Load(); err != nil {
-		log.Debug().Err(err).Msg("Error loading .env file")
-	}
-
-	ctx = context.Background()
-
-	var err error
-	CentralTimeLocation, err = time.LoadLocation(CentralTimezoneName)
-	if err != nil {
-		panic(err)
-	}
-
-	// Set zerolog's timestamp function to use the central timezone
-	zerolog.TimestampFunc = func() time.Time {
-		return time.Now().In(CentralTimeLocation)
-	}
-
-	zerolog.ErrorStackMarshaler = pkgerrors.MarshalStack
-
-	// Try to grab the environment variable, or default to development
-	environment = GetFirstEnv("ENVIRONMENT", "RAILWAY_ENVIRONMENT")
-	if environment == "" {
-		environment = "development"
-	}
-
-	// Use the custom console writer if we're in development
-	isDevelopment = environment == "development"
-	if isDevelopment {
-		log.Logger = zerolog.New(logSplitter{std: stdConsole, err: errConsole}).With().Timestamp().Logger()
-	} else {
-		log.Logger = zerolog.New(logSplitter{std: os.Stdout, err: os.Stderr}).With().Timestamp().Logger()
-	}
-	log.Debug().Str("environment", environment).Msg("Loggers Setup")
-
-	// Set discordgo's logger to use zerolog
-	discordgo.Logger = DiscordGoLogger
-
-	baseURL = os.Getenv("BANNER_BASE_URL")
-}
-
-func initRedis() {
-	// Setup redis
-	redisUrl := GetFirstEnv("REDIS_URL", "REDIS_PRIVATE_URL")
-	if redisUrl == "" {
-		log.Fatal().Stack().Msg("REDIS_URL/REDIS_PRIVATE_URL not set")
-	}
-
-	// Parse URL and create client
-	options, err := redis.ParseURL(redisUrl)
-	if err != nil {
-		log.Fatal().Stack().Err(err).Msg("Cannot parse redis url")
-	}
-	kv = redis.NewClient(options)
-
-	var lastPingErr error
-	pingCount := 0  // Nth ping being attempted
-	totalPings := 5 // Total pings to attempt
-
-	// Wait for private networking to kick in (production only)
-	if !isDevelopment {
-		time.Sleep(250 * time.Millisecond)
-	}
-
-	// Test the redis instance, try to ping every 2 seconds 5 times, otherwise panic
-	for {
-		pingCount++
-		if pingCount > totalPings {
-			log.Fatal().Stack().Err(lastPingErr).Msg("Reached ping limit while trying to connect")
-		}
-
-		// Ping redis
-		pong, err := kv.Ping(ctx).Result()
-
-		// Failed; log error and wait 2 seconds
-		if err != nil {
-			lastPingErr = err
-			log.Warn().Err(err).Int("pings", pingCount).Int("remaining", totalPings-pingCount).Msg("Cannot ping redis")
-			time.Sleep(2 * time.Second)
-
-			continue
-		}
-
-		log.Debug().Str("ping", pong).Msg("Redis connection successful")
-		break
-	}
-}
-
-func main() {
-	flag.Parse()
-
-	initRedis()
-
-	if strings.EqualFold(os.Getenv("PPROF_ENABLE"), "true") {
-		// Start pprof server
-		go func() {
-			port := os.Getenv("PORT")
-			log.Info().Str("port", port).Msg("Starting pprof server")
-			err := http.ListenAndServe(":"+port, nil)
-
-			if err != nil {
-				log.Fatal().Stack().Err(err).Msg("Cannot start pprof server")
-			}
-		}()
-	}
-
-	// Create cookie jar
-	var err error
-	cookies, err = cookiejar.New(nil)
-	if err != nil {
-		log.Err(err).Msg("Cannot create cookie jar")
-	}
-
-	// Create client, setup session (acquire cookies)
-	client = http.Client{Jar: cookies}
-	setup()
-
-	// Create discord session
-	session, err = discordgo.New("Bot " + os.Getenv("BOT_TOKEN"))
-	if err != nil {
-		log.Err(err).Msg("Invalid bot parameters")
-	}
-
-	// Open discord session
-	session.AddHandler(func(s *discordgo.Session, r *discordgo.Ready) {
-		log.Info().Str("username", r.User.Username).Str("discriminator", r.User.Discriminator).Str("id", r.User.ID).Str("session", s.State.SessionID).Msg("Bot is logged in")
-	})
-	err = session.Open()
-	if err != nil {
-		log.Fatal().Stack().Err(err).Msg("Cannot open the session")
-	}
-
-	// Setup command handlers
-	session.AddHandler(func(internalSession *discordgo.Session, interaction *discordgo.InteractionCreate) {
-		// Handle commands during restart (highly unlikely, but just in case)
-		if isClosing {
-			err := RespondError(internalSession, interaction.Interaction, "Bot is currently restarting, try again later.", nil)
-			if err != nil {
-				log.Error().Err(err).Msg("Failed to respond with restart error feedback")
-			}
-			return
-		}
-
-		name := interaction.ApplicationCommandData().Name
-		if handler, ok := commandHandlers[name]; ok {
-			// Build dict of options for the log
-			options := zerolog.Dict()
-			for _, option := range interaction.ApplicationCommandData().Options {
-				options.Str(option.Name, fmt.Sprintf("%v", option.Value))
-			}
-
-			event := log.Info().Str("name", name).Str("user", GetUser(interaction).Username).Dict("options", options)
-
-			// If the command was invoked in a guild, add guild & channel info to the log
-			if interaction.Member != nil {
-				guild := zerolog.Dict()
-				guild.Str("id", interaction.GuildID)
-				guild.Str("name", GetGuildName(interaction.GuildID))
-				event.Dict("guild", guild)
-
-				channel := zerolog.Dict()
-				channel.Str("id", interaction.ChannelID)
-				guild.Str("name", GetChannelName(interaction.ChannelID))
-				event.Dict("channel", channel)
-			} else {
-				// If the command was invoked in a DM, add the user info to the log
-				user := zerolog.Dict()
-				user.Str("id", interaction.User.ID)
-				user.Str("name", interaction.User.Username)
-				event.Dict("user", user)
-			}
-
-			// Log command invocation
-			event.Msg("Command Invoked")
-
-			// Prepare to recover
-			defer func() {
-				if err := recover(); err != nil {
-					log.Error().Stack().Str("commandName", name).Interface("detail", err).Msg("Command Handler Panic")
-
-					// Respond with error
-					err := RespondError(internalSession, interaction.Interaction, "Unexpected Error: command handler panic", nil)
-					if err != nil {
-						log.Error().Stack().Str("commandName", name).Err(err).Msg("Failed to respond with panic error feedback")
-					}
-				}
-			}()
-
-			// Call handler
-			err := handler(internalSession, interaction)
-
-			// Log & respond error
-			if err != nil {
-				// TODO: Find a way to merge the response with the handler's error
-				log.Error().Str("commandName", name).Err(err).Msg("Command Handler Error")
-
-				// Respond with error
-				err = RespondError(internalSession, interaction.Interaction, fmt.Sprintf("Unexpected Error: %s", err.Error()), nil)
-				if err != nil {
-					log.Error().Stack().Str("commandName", name).Err(err).Msg("Failed to respond with error feedback")
-				}
-			}
-
-		} else {
-			log.Error().Stack().Str("commandName", name).Msg("Command Interaction Has No Handler")
-
-			// Respond with error
-			RespondError(internalSession, interaction.Interaction, "Unexpected Error: interaction has no handler", nil)
-		}
-	})
-
-	// Register commands with discord
-	arr := zerolog.Arr()
-	lo.ForEach(commandDefinitions, func(cmd *discordgo.ApplicationCommand, _ int) {
-		arr.Str(cmd.Name)
-	})
-	log.Info().Array("commands", arr).Msg("Registering commands")
-
-	// In development, use test server, otherwise empty (global) for command registration
-	guildTarget := ""
-	if isDevelopment {
-		guildTarget = os.Getenv("BOT_TARGET_GUILD")
-	}
-
-	// Register commands
-	existingCommands, err := session.ApplicationCommands(session.State.User.ID, guildTarget)
-	if err != nil {
-		log.Fatal().Stack().Err(err).Msg("Cannot get existing commands")
-	}
-	newCommands, err := session.ApplicationCommandBulkOverwrite(session.State.User.ID, guildTarget, commandDefinitions)
-	if err != nil {
-		log.Fatal().Stack().Err(err).Msg("Cannot register commands")
-	}
-
-	// Compare existing commands with new commands
-	for _, newCommand := range newCommands {
-		existingCommand, found := lo.Find(existingCommands, func(cmd *discordgo.ApplicationCommand) bool {
-			return cmd.Name == newCommand.Name
-		})
-
-		// New command
-		if !found {
-			log.Info().Str("commandName", newCommand.Name).Msg("Registered new command")
-			continue
-		}
-
-		// Compare versions
-		if newCommand.Version != existingCommand.Version {
-			log.Info().Str("commandName", newCommand.Name).
-				Str("oldVersion", existingCommand.Version).Str("newVersion", newCommand.Version).
-				Msg("Command Updated")
-		}
-	}
-
-	// Fetch terms on startup
-	err = TryReloadTerms()
-	if err != nil {
-		log.Fatal().Stack().Err(err).Msg("Cannot fetch terms on startup")
-	}
-
-	// Launch a goroutine to scrape the banner system periodically
-	go func() {
-		for {
-			err := Scrape()
-			if err != nil {
-				log.Err(err).Stack().Msg("Periodic Scrape Failed")
-			}
-
-			time.Sleep(3 * time.Minute)
-		}
-	}()
-
-	// Close session, ensure http client closes idle connections
-	defer session.Close()
-	defer client.CloseIdleConnections()
-
-	// Setup signal handler channel
-	stop := make(chan os.Signal, 1)
-	signal.Notify(stop, os.Interrupt)    // Ctrl+C signal
-	signal.Notify(stop, syscall.SIGTERM) // Container stop signal
-
-	// Wait for signal (indefinite)
-	closingSignal := <-stop
-	isClosing = true // TODO: Switch to atomic lock with forced close after 10 seconds
-
-	// Defers are called after this
-	log.Warn().Str("signal", closingSignal.String()).Msg("Gracefully shutting down")
-}

meta.go

@@ -1,76 +0,0 @@
-package main
-
-import (
-	"time"
-
-	"github.com/redis/go-redis/v9"
-	log "github.com/rs/zerolog/log"
-)
-
-// GetGuildName returns the name of the guild with the given ID, utilizing Redis to cache the value
-func GetGuildName(guildID string) string {
-	// Check Redis for the guild name
-	guildName, err := kv.Get(ctx, "guild:"+guildID+":name").Result()
-	if err != nil && err != redis.Nil {
-		log.Error().Stack().Err(err).Msg("Error getting guild name from Redis")
-		return "err"
-	}
-
-	// If the guild name is invalid (1 character long), then return "unknown"
-	if len(guildName) == 1 {
-		return "unknown"
-	}
-
-	// If the guild name isn't in Redis, get it from Discord and cache it
-	guild, err := session.Guild(guildID)
-	if err != nil {
-		log.Error().Stack().Err(err).Msg("Error getting guild name")
-
-		// Store an invalid value in Redis so we  don't keep trying to get the guild name
-		_, err := kv.Set(ctx, "guild:"+guildID+":name", "x", time.Minute*5).Result()
-		if err != nil {
-			log.Error().Stack().Err(err).Msg("Error setting false guild name in Redis")
-		}
-
-		return "unknown"
-	}
-
-	// Cache the guild name in Redis
-	kv.Set(ctx, "guild:"+guildID+":name", guild.Name, time.Hour*3)
-
-	return guild.Name
-}
-
-// GetChannelName returns the name of the channel with the given ID, utilizing Redis to cache the value
-func GetChannelName(channelID string) string {
-	// Check Redis for the channel name
-	channelName, err := kv.Get(ctx, "channel:"+channelID+":name").Result()
-	if err != nil && err != redis.Nil {
-		log.Error().Stack().Err(err).Msg("Error getting channel name from Redis")
-		return "err"
-	}
-
-	// If the channel name is invalid (1 character long), then return "unknown"
-	if len(channelName) == 1 {
-		return "unknown"
-	}
-
-	// If the channel name isn't in Redis, get it from Discord and cache it
-	channel, err := session.Channel(channelID)
-	if err != nil {
-		log.Error().Stack().Err(err).Msg("Error getting channel name")
-
-		// Store an invalid value in Redis so we  don't keep trying to get the channel name
-		_, err := kv.Set(ctx, "channel:"+channelID+":name", "x", time.Minute*5).Result()
-		if err != nil {
-			log.Error().Stack().Err(err).Msg("Error setting false channel name in Redis")
-		}
-
-		return "unknown"
-	}
-
-	// Cache the channel name in Redis
-	kv.Set(ctx, "channel:"+channelID+":name", channel.Name, time.Hour*3)
-
-	return channel.Name
-}

migrations/20250829175305_initial_schema.sql

@@ -0,0 +1,56 @@
+-- Drop all old tables
+DROP TABLE IF EXISTS scrape_jobs;
+DROP TABLE IF EXISTS course_metrics;
+DROP TABLE IF EXISTS course_audits;
+DROP TABLE IF EXISTS courses;
+
+-- Enums for scrape_jobs
+CREATE TYPE scrape_priority AS ENUM ('Low', 'Medium', 'High', 'Critical');
+CREATE TYPE target_type AS ENUM ('Subject', 'CourseRange', 'CrnList', 'SingleCrn');
+
+-- Main course data table
+CREATE TABLE courses (
+    id SERIAL PRIMARY KEY,
+    crn VARCHAR NOT NULL,
+    subject VARCHAR NOT NULL,
+    course_number VARCHAR NOT NULL,
+    title VARCHAR NOT NULL,
+    term_code VARCHAR NOT NULL,
+    enrollment INTEGER NOT NULL,
+    max_enrollment INTEGER NOT NULL,
+    wait_count INTEGER NOT NULL,
+    wait_capacity INTEGER NOT NULL,
+    last_scraped_at TIMESTAMPTZ NOT NULL,
+    UNIQUE(crn, term_code)
+);
+
+-- Time-series data for course enrollment
+CREATE TABLE course_metrics (
+    id SERIAL PRIMARY KEY,
+    course_id INTEGER NOT NULL REFERENCES courses(id) ON DELETE CASCADE,
+    timestamp TIMESTAMPTZ NOT NULL,
+    enrollment INTEGER NOT NULL,
+    wait_count INTEGER NOT NULL,
+    seats_available INTEGER NOT NULL
+);
+
+-- Audit trail for changes to course data
+CREATE TABLE course_audits (
+    id SERIAL PRIMARY KEY,
+    course_id INTEGER NOT NULL REFERENCES courses(id) ON DELETE CASCADE,
+    timestamp TIMESTAMPTZ NOT NULL,
+    field_changed VARCHAR NOT NULL,
+    old_value TEXT NOT NULL,
+    new_value TEXT NOT NULL
+);
+
+-- Job queue for the scraper
+CREATE TABLE scrape_jobs (
+    id SERIAL PRIMARY KEY,
+    target_type target_type NOT NULL,
+    target_payload JSONB NOT NULL,
+    priority scrape_priority NOT NULL,
+    execute_at TIMESTAMPTZ NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    locked_at TIMESTAMPTZ
+);

migrations/20251103093649_add_retry_tracking.sql

@@ -0,0 +1,3 @@
+-- Add retry tracking columns to scrape_jobs table
+ALTER TABLE scrape_jobs ADD COLUMN retry_count INTEGER NOT NULL DEFAULT 0 CHECK (retry_count >= 0);
+ALTER TABLE scrape_jobs ADD COLUMN max_retries INTEGER NOT NULL DEFAULT 5 CHECK (max_retries >= 0);

migrations/20251103104300_add_performance_indexes.sql

@@ -0,0 +1,45 @@
+-- Performance optimization indexes
+
+-- Index for term-based queries (most common access pattern)
+CREATE INDEX IF NOT EXISTS idx_courses_term_code ON courses(term_code);
+
+-- Index for subject-based filtering
+CREATE INDEX IF NOT EXISTS idx_courses_subject ON courses(subject);
+
+-- Composite index for subject + term queries
+CREATE INDEX IF NOT EXISTS idx_courses_subject_term ON courses(subject, term_code);
+
+-- Index for course number lookups
+CREATE INDEX IF NOT EXISTS idx_courses_course_number ON courses(course_number);
+
+-- Index for last scraped timestamp (useful for finding stale data)
+CREATE INDEX IF NOT EXISTS idx_courses_last_scraped ON courses(last_scraped_at);
+
+-- Index for course metrics time-series queries
+-- BRIN index is optimal for time-series data
+CREATE INDEX IF NOT EXISTS idx_course_metrics_timestamp ON course_metrics USING BRIN(timestamp);
+
+-- B-tree index for specific course metric lookups
+CREATE INDEX IF NOT EXISTS idx_course_metrics_course_timestamp
+    ON course_metrics(course_id, timestamp DESC);
+
+-- Partial index for pending scrape jobs (only unlocked jobs)
+CREATE INDEX IF NOT EXISTS idx_scrape_jobs_pending
+    ON scrape_jobs(execute_at ASC)
+    WHERE locked_at IS NULL;
+
+-- Index for high-priority job processing
+CREATE INDEX IF NOT EXISTS idx_scrape_jobs_priority_pending
+    ON scrape_jobs(priority DESC, execute_at ASC)
+    WHERE locked_at IS NULL;
+
+-- Index for retry tracking
+CREATE INDEX IF NOT EXISTS idx_scrape_jobs_retry_count
+    ON scrape_jobs(retry_count)
+    WHERE retry_count > 0 AND locked_at IS NULL;
+
+-- Analyze tables to update statistics
+ANALYZE courses;
+ANALYZE course_metrics;
+ANALYZE course_audits;
+ANALYZE scrape_jobs;

migrations/20251103104400_optimize_indexes.sql

@@ -0,0 +1,53 @@
+-- Index Optimization Follow-up Migration
+
+-- Reason: Redundant with composite index idx_courses_subject_term
+DROP INDEX IF EXISTS idx_courses_subject;
+
+-- Remove: idx_scrape_jobs_retry_count
+DROP INDEX IF EXISTS idx_scrape_jobs_retry_count;
+
+-- Purpose: Optimize the scheduler's frequent query (runs every 60 seconds)
+CREATE INDEX IF NOT EXISTS idx_scrape_jobs_scheduler_lookup
+    ON scrape_jobs(target_type, target_payload)
+    WHERE locked_at IS NULL;
+
+-- Note: We use (target_type, target_payload) instead of including locked_at
+-- in the index columns because:
+-- 1. The WHERE clause filters locked_at IS NULL (partial index optimization)
+-- 2. target_payload is JSONB and already large; keeping it as an indexed column
+--    allows PostgreSQL to use index-only scans for the SELECT target_payload query
+-- 3. This design minimizes index size while maximizing query performance
+
+
+-- Purpose: Enable efficient audit trail queries by course
+CREATE INDEX IF NOT EXISTS idx_course_audits_course_timestamp
+    ON course_audits(course_id, timestamp DESC);
+
+-- Purpose: Enable queries like "Show all changes in the last 24 hours"
+CREATE INDEX IF NOT EXISTS idx_course_audits_timestamp
+    ON course_audits(timestamp DESC);
+
+
+-- The BRIN index on course_metrics(timestamp) assumes data is inserted in
+-- chronological order. BRIN indexes are only effective when data is physically
+-- ordered on disk. If you perform:
+-- - Backfills of historical data
+-- - Out-of-order inserts
+-- - Frequent UPDATEs that move rows
+--
+-- Then the BRIN index effectiveness will degrade. Monitor with:
+--   SELECT * FROM brin_page_items(get_raw_page('idx_course_metrics_timestamp', 1));
+--
+-- If you see poor selectivity, consider:
+-- 1. REINDEX to rebuild after bulk loads
+-- 2. Switch to B-tree if inserts are not time-ordered
+-- 3. Use CLUSTER to physically reorder the table (requires downtime)
+
+COMMENT ON INDEX idx_course_metrics_timestamp IS
+    'BRIN index - requires chronologically ordered inserts for efficiency. Monitor selectivity.';
+
+-- Update statistics for query planner
+ANALYZE courses;
+ANALYZE course_metrics;
+ANALYZE course_audits;
+ANALYZE scrape_jobs;

scrape.go

@@ -1,219 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"math/rand"
-	"time"
-
-	"github.com/rs/zerolog/log"
-	"github.com/samber/lo"
-)
-
-const (
-	MaxPageSize = 500
-)
-
-var (
-	// PriorityMajors is a list of majors that are considered to be high priority for scraping. This list is used to determine which majors to scrape first/most often.
-	PriorityMajors = []string{"CS", "CPE", "MAT", "EE", "IS"}
-	// AncillaryMajors is a list of majors that are considered to be low priority for scraping. This list will not contain any majors that are in PriorityMajors.
-	AncillaryMajors []string
-	// AllMajors is a list of all majors that are available in the Banner system.
-	AllMajors []string
-)
-
-// Scrape is the general scraping invocation (best called within/as a goroutine) that should be called regularly to initiate scraping of the Banner system.
-func Scrape() error {
-	// Populate AllMajors if it is empty
-	if len(AncillaryMajors) == 0 {
-		term := Default(time.Now()).ToString()
-		subjects, err := GetSubjects("", term, 1, 99)
-		if err != nil {
-			return fmt.Errorf("failed to get subjects: %w", err)
-		}
-
-		// Ensure subjects were found
-		if len(subjects) == 0 {
-			return fmt.Errorf("no subjects found")
-		}
-
-		// Extract major code name
-		for _, subject := range subjects {
-			// Add to AncillaryMajors if not in PriorityMajors
-			if !lo.Contains(PriorityMajors, subject.Code) {
-				AncillaryMajors = append(AncillaryMajors, subject.Code)
-			}
-		}
-
-		AllMajors = lo.Flatten([][]string{PriorityMajors, AncillaryMajors})
-	}
-
-	expiredSubjects, err := GetExpiredSubjects()
-	if err != nil {
-		return fmt.Errorf("failed to get scrapable majors: %w", err)
-	}
-
-	log.Info().Strs("majors", expiredSubjects).Msg("Scraping majors")
-	for _, subject := range expiredSubjects {
-		err := ScrapeMajor(subject)
-		if err != nil {
-			return fmt.Errorf("failed to scrape major %s: %w", subject, err)
-		}
-	}
-
-	return nil
-}
-
-// GetExpiredSubjects returns a list of subjects that are expired and should be scraped.
-func GetExpiredSubjects() ([]string, error) {
-	term := Default(time.Now()).ToString()
-	subjects := make([]string, 0)
-
-	// Get all subjects
-	values, err := kv.MGet(ctx, lo.Map(AllMajors, func(major string, _ int) string {
-		return fmt.Sprintf("scraped:%s:%s", major, term)
-	})...).Result()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get all subjects: %w", err)
-	}
-
-	// Extract expired subjects
-	for i, value := range values {
-		subject := AllMajors[i]
-
-		// If the value is nil or "0", then the subject is expired
-		if value == nil || value == "0" {
-			subjects = append(subjects, subject)
-		}
-	}
-
-	log.Debug().Strs("majors", subjects).Msg("Expired Subjects")
-
-	return subjects, nil
-}
-
-// ScrapeMajor is the scraping invocation for a specific major.
-// This function does not check whether scraping is required at this time, it is assumed that the caller has already done so.
-func ScrapeMajor(subject string) error {
-	offset := 0
-	totalClassCount := 0
-
-	for {
-		// Build & execute the query
-		query := NewQuery().Offset(offset).MaxResults(MaxPageSize * 2).Subject(subject)
-		result, err := Search(query, "subjectDescription", false)
-		if err != nil {
-			return fmt.Errorf("search failed: %w (%s)", err, query.String())
-		}
-
-		// Isn't it bullshit that they decided not to leave an actual 'reason' field for the failure?
-		if !result.Success {
-			return fmt.Errorf("result marked unsuccessful when searching for classes (%s)", query.String())
-		}
-
-		classCount := len(result.Data)
-		totalClassCount += classCount
-		log.Debug().Str("subject", subject).Int("count", classCount).Int("offset", offset).Msg("Placing classes in Redis")
-
-		// Process each class and store it in Redis
-		for _, course := range result.Data {
-			// Store class in Redis
-			err := IntakeCourse(course)
-			if err != nil {
-				log.Error().Err(err).Msg("failed to store class in Redis")
-			}
-		}
-
-		// Increment and continue if the results are full
-		if classCount >= MaxPageSize {
-			// This is unlikely to happen, but log it just in case
-			if classCount > MaxPageSize {
-				log.Warn().Int("page", offset).Int("count", classCount).Msg("Results exceed MaxPageSize")
-			}
-
-			offset += MaxPageSize
-
-			// TODO: Replace sleep with smarter rate limiting
-			log.Debug().Str("subject", subject).Int("nextOffset", offset).Msg("Sleeping before next page")
-			time.Sleep(time.Second * 3)
-			continue
-		} else {
-			// Log the number of classes scraped
-			log.Info().Str("subject", subject).Int("total", totalClassCount).Msgf("Subject %s Scraped", subject)
-			break
-		}
-	}
-
-	term := Default(time.Now()).ToString()
-
-	// Calculate the expiry time for the scrape (1 hour for every 200 classes, random +-15%) with a minimum of 1 hour
-	var scrapeExpiry time.Duration
-	if totalClassCount == 0 {
-		scrapeExpiry = time.Hour * 12
-	} else {
-		scrapeExpiry = CalculateExpiry(term, totalClassCount, lo.Contains(PriorityMajors, subject))
-	}
-
-	// Mark the major as scraped
-	if totalClassCount == 0 {
-		totalClassCount = -1
-	}
-	err := kv.Set(ctx, fmt.Sprintf("scraped:%s:%s", subject, term), totalClassCount, scrapeExpiry).Err()
-	if err != nil {
-		log.Error().Err(err).Msg("failed to mark major as scraped")
-	}
-
-	return nil
-}
-
-// CalculateExpiry calculates the expiry time until the next scrape for a major.
-// term is the term for which the relevant course is occurring within.
-// count is the number of courses that were scraped.
-// priority is a boolean indicating whether the major is a priority major.
-func CalculateExpiry(term string, count int, priority bool) time.Duration {
-	// An hour for every 100 classes
-	baseExpiry := time.Hour * time.Duration(count/100)
-
-	// Subjects with less than 50 classes have a reversed expiry (less classes, longer interval)
-	// 1 class => 12 hours, 49 classes => 1 hour
-	if count < 50 {
-		hours := Slope(Point{1, 12}, Point{49, 1}, float64(count)).Y
-		baseExpiry = time.Duration(hours * float64(time.Hour))
-	}
-
-	// If the subject is a priority, then the expiry is halved without variance
-	if priority {
-		return baseExpiry / 3
-	}
-
-	// If the term is considered "view only" or "archived", then the expiry is multiplied by 5
-	var expiry = baseExpiry
-	if IsTermArchived(term) {
-		expiry *= 5
-	}
-
-	// Add minor variance to the expiry
-	expiryVariance := baseExpiry.Seconds() * (rand.Float64() * 0.15) // Between 0 and 15% of the total
-	if rand.Intn(2) == 0 {
-		expiry -= time.Duration(expiryVariance) * time.Second
-	} else {
-		expiry += time.Duration(expiryVariance) * time.Second
-	}
-
-	// Ensure the expiry is at least 1 hour with up to 15 extra minutes
-	if expiry < time.Hour {
-		baseExpiry = time.Hour + time.Duration(rand.Intn(60*15))*time.Second
-	}
-
-	return baseExpiry
-}
-
-// IntakeCourse stores a course in Redis.
-// This function is mostly a stub for now, but will be used to handle change identification, notifications, and SQLite upserts in the future.
-func IntakeCourse(course Course) error {
-	err := kv.Set(ctx, fmt.Sprintf("class:%s", course.CourseReferenceNumber), course, 0).Err()
-	if err != nil {
-		return fmt.Errorf("failed to store class in Redis: %w", err)
-	}
-	return nil
-}

search.go

@@ -1,336 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/samber/lo"
-)
-
-const (
-	paramSubject           = "txt_subject"
-	paramTitle             = "txt_courseTitle"
-	paramKeywords          = "txt_keywordlike"
-	paramOpenOnly          = "chk_open_only"
-	paramTermPart          = "txt_partOfTerm"
-	paramCampus            = "txt_campus"
-	paramAttributes        = "txt_attribute"
-	paramInstructor        = "txt_instructor"
-	paramStartTimeHour     = "select_start_hour"
-	paramStartTimeMinute   = "select_start_min"
-	paramStartTimeMeridiem = "select_start_ampm"
-	paramEndTimeHour       = "select_end_hour"
-	paramEndTimeMinute     = "select_end_min"
-	paramEndTimeMeridiem   = "select_end_ampm"
-	paramMinCredits        = "txt_credithourlow"
-	paramMaxCredits        = "txt_credithourhigh"
-	paramCourseNumberLow   = "txt_course_number_range"
-	paramCourseNumberHigh  = "txt_course_number_range_to"
-	paramOffset            = "pageOffset"
-	paramMaxResults        = "pageMaxSize"
-)
-
-type Query struct {
-	subject             *string
-	title               *string
-	keywords            *[]string
-	openOnly            *bool
-	termPart            *[]string // e.g. [1, B6, 8, J]
-	campus              *[]string // e.g. [9, 1DT, 1LR]
-	instructionalMethod *[]string // e.g. [HB]
-	attributes          *[]string // e.g. [060, 010]
-	instructor          *[]uint64 // e.g. [27957, 27961]
-	startTime           *time.Duration
-	endTime             *time.Duration
-	minCredits          *int
-	maxCredits          *int
-	offset              int
-	maxResults          int
-	courseNumberRange   *Range
-}
-
-func NewQuery() *Query {
-	return &Query{maxResults: 8, offset: 0}
-}
-
-// Subject sets the subject for the query
-func (q *Query) Subject(subject string) *Query {
-	q.subject = &subject
-	return q
-}
-
-// Title sets the title for the query
-func (q *Query) Title(title string) *Query {
-	q.title = &title
-	return q
-}
-
-// Keywords sets the keywords for the query
-func (q *Query) Keywords(keywords []string) *Query {
-	q.keywords = &keywords
-	return q
-}
-
-// Keyword adds a keyword to the query
-func (q *Query) Keyword(keyword string) *Query {
-	if q.keywords == nil {
-		q.keywords = &[]string{keyword}
-	} else {
-		*q.keywords = append(*q.keywords, keyword)
-	}
-	return q
-}
-
-// OpenOnly sets the open only flag for the query
-func (q *Query) OpenOnly(openOnly bool) *Query {
-	q.openOnly = &openOnly
-	return q
-}
-
-// TermPart sets the term part for the query
-func (q *Query) TermPart(termPart []string) *Query {
-	q.termPart = &termPart
-	return q
-}
-
-func (q *Query) Campus(campus []string) *Query {
-	q.campus = &campus
-	return q
-}
-
-func (q *Query) InstructionalMethod(instructionalMethod []string) *Query {
-	q.instructionalMethod = &instructionalMethod
-	return q
-}
-
-func (q *Query) Attributes(attributes []string) *Query {
-	q.attributes = &attributes
-	return q
-}
-
-func (q *Query) Instructor(instructor []uint64) *Query {
-	q.instructor = &instructor
-	return q
-}
-
-func (q *Query) StartTime(startTime time.Duration) *Query {
-	q.startTime = &startTime
-	return q
-}
-
-func (q *Query) EndTime(endTime time.Duration) *Query {
-	q.endTime = &endTime
-	return q
-}
-
-func (q *Query) Credits(low int, high int) *Query {
-	q.minCredits = &low
-	q.maxCredits = &high
-	return q
-}
-
-func (q *Query) MinCredits(value int) *Query {
-	q.minCredits = &value
-	return q
-}
-
-func (q *Query) MaxCredits(value int) *Query {
-	q.maxCredits = &value
-	return q
-}
-
-func (q *Query) CourseNumbers(low int, high int) *Query {
-	q.courseNumberRange = &Range{low, high}
-	return q
-}
-
-// Offset sets the offset for the query, allowing for pagination
-func (q *Query) Offset(offset int) *Query {
-	q.offset = offset
-	return q
-}
-
-// MaxResults sets the maximum number of results for the query
-func (q *Query) MaxResults(maxResults int) *Query {
-	q.maxResults = maxResults
-	return q
-}
-
-type Range struct {
-	Low  int
-	High int
-}
-
-// FormatTimeParameter formats a time.Duration into a tuple of strings
-// This is mostly a private helper to keep the parameter formatting for both the start and end time consistent together
-func FormatTimeParameter(d time.Duration) (string, string, string) {
-	hourParameter, minuteParameter, meridiemParameter := "", "", ""
-
-	hours := int64(d.Hours())
-	minutes := int64(d.Minutes()) % 60
-
-	minuteParameter = strconv.FormatInt(minutes, 10)
-
-	if hours >= 12 {
-		hourParameter = "PM"
-
-		// Exceptional case: 12PM = 12, 1PM = 1, 2PM = 2
-		if hours >= 13 {
-			hourParameter = strconv.FormatInt(hours-12, 10) // 13 - 12 = 1, 14 - 12 = 2
-		} else {
-			hourParameter = strconv.FormatInt(hours, 10)
-		}
-	} else {
-		meridiemParameter = "AM"
-		hourParameter = strconv.FormatInt(hours, 10)
-	}
-
-	return hourParameter, minuteParameter, meridiemParameter
-}
-
-// Paramify converts a Query into a map of parameters that can be used in a POST request
-// This function assumes each query key only appears once.
-func (q *Query) Paramify() map[string]string {
-	params := map[string]string{}
-
-	if q.subject != nil {
-		params[paramSubject] = *q.subject
-	}
-
-	if q.title != nil {
-		// Whitespace can prevent valid queries from succeeding
-		params[paramTitle] = strings.TrimSpace(*q.title)
-	}
-
-	if q.keywords != nil {
-		params[paramKeywords] = strings.Join(*q.keywords, " ")
-	}
-
-	if q.openOnly != nil {
-		params[paramOpenOnly] = "true"
-	}
-
-	if q.termPart != nil {
-		params[paramTermPart] = strings.Join(*q.termPart, ",")
-	}
-
-	if q.campus != nil {
-		params[paramCampus] = strings.Join(*q.campus, ",")
-	}
-
-	if q.attributes != nil {
-		params[paramAttributes] = strings.Join(*q.attributes, ",")
-	}
-
-	if q.instructor != nil {
-		params[paramInstructor] = strings.Join(lo.Map(*q.instructor, func(i uint64, _ int) string {
-			return strconv.FormatUint(i, 10)
-		}), ",")
-	}
-
-	if q.startTime != nil {
-		hour, minute, meridiem := FormatTimeParameter(*q.startTime)
-		params[paramStartTimeHour] = hour
-		params[paramStartTimeMinute] = minute
-		params[paramStartTimeMeridiem] = meridiem
-	}
-
-	if q.endTime != nil {
-		hour, minute, meridiem := FormatTimeParameter(*q.endTime)
-		params[paramEndTimeHour] = hour
-		params[paramEndTimeMinute] = minute
-		params[paramEndTimeMeridiem] = meridiem
-	}
-
-	if q.minCredits != nil {
-		params[paramMinCredits] = strconv.Itoa(*q.minCredits)
-	}
-
-	if q.maxCredits != nil {
-		params[paramMaxCredits] = strconv.Itoa(*q.maxCredits)
-	}
-
-	if q.courseNumberRange != nil {
-		params[paramCourseNumberLow] = strconv.Itoa(q.courseNumberRange.Low)
-		params[paramCourseNumberHigh] = strconv.Itoa(q.courseNumberRange.High)
-	}
-
-	params[paramOffset] = strconv.Itoa(q.offset)
-	params[paramMaxResults] = strconv.Itoa(q.maxResults)
-
-	return params
-}
-
-// String returns a string representation of the query, ideal for debugging & logging.
-func (q *Query) String() string {
-	var sb strings.Builder
-
-	if q.subject != nil {
-		fmt.Fprintf(&sb, "subject=%s, ", *q.subject)
-	}
-
-	if q.title != nil {
-		// Whitespace can prevent valid queries from succeeding
-		fmt.Fprintf(&sb, "title=%s, ", strings.TrimSpace(*q.title))
-	}
-
-	if q.keywords != nil {
-		fmt.Fprintf(&sb, "keywords=%s, ", strings.Join(*q.keywords, " "))
-	}
-
-	if q.openOnly != nil {
-		fmt.Fprintf(&sb, "openOnly=%t, ", *q.openOnly)
-	}
-
-	if q.termPart != nil {
-		fmt.Fprintf(&sb, "termPart=%s, ", strings.Join(*q.termPart, ","))
-	}
-
-	if q.campus != nil {
-		fmt.Fprintf(&sb, "campus=%s, ", strings.Join(*q.campus, ","))
-	}
-
-	if q.attributes != nil {
-		fmt.Fprintf(&sb, "attributes=%s, ", strings.Join(*q.attributes, ","))
-	}
-
-	if q.instructor != nil {
-		fmt.Fprintf(&sb, "instructor=%s, ", strings.Join(lo.Map(*q.instructor, func(i uint64, _ int) string {
-			return strconv.FormatUint(i, 10)
-		}), ","))
-	}
-
-	if q.startTime != nil {
-		hour, minute, meridiem := FormatTimeParameter(*q.startTime)
-		fmt.Fprintf(&sb, "startTime=%s:%s%s, ", hour, minute, meridiem)
-	}
-
-	if q.endTime != nil {
-		hour, minute, meridiem := FormatTimeParameter(*q.endTime)
-		fmt.Fprintf(&sb, "endTime=%s:%s%s, ", hour, minute, meridiem)
-	}
-
-	if q.minCredits != nil {
-		fmt.Fprintf(&sb, "minCredits=%d, ", *q.minCredits)
-	}
-
-	if q.maxCredits != nil {
-		fmt.Fprintf(&sb, "maxCredits=%d, ", *q.maxCredits)
-	}
-
-	if q.courseNumberRange != nil {
-		fmt.Fprintf(&sb, "courseNumberRange=%d-%d, ", q.courseNumberRange.Low, q.courseNumberRange.High)
-	}
-
-	fmt.Fprintf(&sb, "offset=%d, ", q.offset)
-	fmt.Fprintf(&sb, "maxResults=%d", q.maxResults)
-
-	return sb.String()
-}
-
-// Dict returns a map representation of the query, ideal for debugging & logging.
-// This dict is represented with zerolog's Event type.
-// func (q *Query) Dict() *zerolog.Event {
-// }

session.go

@@ -1,52 +0,0 @@
-package main
-
-import (
-	"net/url"
-
-	log "github.com/rs/zerolog/log"
-)
-
-func setup() {
-	// Makes the initial requests that sets up the session cookies for the rest of the application
-	log.Info().Msg("Setting up session...")
-
-	request_queue := []string{
-		"/registration/registration",
-		"/selfServiceMenu/data",
-	}
-
-	for _, path := range request_queue {
-		req := BuildRequest("GET", path, nil)
-		DoRequest(req)
-	}
-
-	// Validate that cookies were set
-	baseUrlParsed, err := url.Parse(baseURL)
-	if err != nil {
-		log.Fatal().Stack().Str("baseURL", baseURL).Err(err).Msg("Failed to parse baseURL")
-	}
-
-	current_cookies := client.Jar.Cookies(baseUrlParsed)
-	required_cookies := map[string]bool{
-		"JSESSIONID": false,
-		"SSB_COOKIE": false,
-	}
-
-	for _, cookie := range current_cookies {
-		_, present := required_cookies[cookie.Name]
-		// Check if this cookie is required
-		if present {
-			required_cookies[cookie.Name] = true
-		}
-	}
-
-	// Check if all required cookies were set
-	for cookieName, cookie_set := range required_cookies {
-		if !cookie_set {
-			log.Warn().Str("cookieName", cookieName).Msg("Required cookie not set")
-		}
-	}
-	log.Debug().Msg("All required cookies set, session setup complete")
-
-	// TODO: Validate that the session allows access to termSelection
-}

src/app.rs

@@ -0,0 +1,168 @@
+use crate::banner::BannerApi;
+use crate::cli::ServiceName;
+use crate::config::Config;
+use crate::scraper::ScraperService;
+use crate::services::bot::BotService;
+use crate::services::manager::ServiceManager;
+use crate::services::web::WebService;
+use crate::state::AppState;
+use crate::web::routes::BannerState;
+use figment::value::UncasedStr;
+use figment::{Figment, providers::Env};
+use sqlx::postgres::PgPoolOptions;
+use std::process::ExitCode;
+use std::sync::Arc;
+use std::time::Duration;
+use tracing::{error, info};
+
+/// Main application struct containing all necessary components
+pub struct App {
+    config: Config,
+    db_pool: sqlx::PgPool,
+    banner_api: Arc<BannerApi>,
+    app_state: AppState,
+    banner_state: BannerState,
+    service_manager: ServiceManager,
+}
+
+impl App {
+    /// Create a new App instance with all necessary components initialized
+    pub async fn new() -> Result<Self, anyhow::Error> {
+        // Load configuration
+        let config: Config = Figment::new()
+            .merge(Env::raw().map(|k| {
+                if k == UncasedStr::new("RAILWAY_DEPLOYMENT_DRAINING_SECONDS") {
+                    "SHUTDOWN_TIMEOUT".into()
+                } else {
+                    k.into()
+                }
+            }))
+            .extract()
+            .expect("Failed to load config");
+
+        // Check if the database URL is via private networking
+        let is_private = config.database_url.contains("railway.internal");
+        let slow_threshold = Duration::from_millis(if is_private { 200 } else { 500 });
+
+        // Create database connection pool
+        let db_pool = PgPoolOptions::new()
+            .min_connections(0)
+            .max_connections(4)
+            .acquire_slow_threshold(slow_threshold)
+            .acquire_timeout(Duration::from_secs(4))
+            .idle_timeout(Duration::from_secs(60 * 2))
+            .max_lifetime(Duration::from_secs(60 * 30))
+            .connect(&config.database_url)
+            .await
+            .expect("Failed to create database pool");
+
+        info!(
+            is_private = is_private,
+            slow_threshold = format!("{:.2?}", slow_threshold),
+            "database pool established"
+        );
+
+        // Run database migrations
+        info!("Running database migrations...");
+        sqlx::migrate!("./migrations")
+            .run(&db_pool)
+            .await
+            .expect("Failed to run database migrations");
+        info!("Database migrations completed successfully");
+
+        // Create BannerApi and AppState
+        let banner_api = BannerApi::new_with_config(
+            config.banner_base_url.clone(),
+            config.rate_limiting.clone().into(),
+        )
+        .expect("Failed to create BannerApi");
+
+        let banner_api_arc = Arc::new(banner_api);
+        let app_state = AppState::new(banner_api_arc.clone(), db_pool.clone());
+
+        // Create BannerState for web service
+        let banner_state = BannerState {};
+
+        Ok(App {
+            config,
+            db_pool,
+            banner_api: banner_api_arc,
+            app_state,
+            banner_state,
+            service_manager: ServiceManager::new(),
+        })
+    }
+
+    /// Setup and register services based on enabled service list
+    pub fn setup_services(&mut self, services: &[ServiceName]) -> Result<(), anyhow::Error> {
+        // Register enabled services with the manager
+        if services.contains(&ServiceName::Web) {
+            let web_service =
+                Box::new(WebService::new(self.config.port, self.banner_state.clone()));
+            self.service_manager
+                .register_service(ServiceName::Web.as_str(), web_service);
+        }
+
+        if services.contains(&ServiceName::Scraper) {
+            let scraper_service = Box::new(ScraperService::new(
+                self.db_pool.clone(),
+                self.banner_api.clone(),
+            ));
+            self.service_manager
+                .register_service(ServiceName::Scraper.as_str(), scraper_service);
+        }
+
+        // Check if any services are enabled
+        if !self.service_manager.has_services() && !services.contains(&ServiceName::Bot) {
+            error!("No services enabled. Cannot start application.");
+            return Err(anyhow::anyhow!("No services enabled"));
+        }
+
+        Ok(())
+    }
+
+    /// Setup bot service if enabled
+    pub async fn setup_bot_service(&mut self) -> Result<(), anyhow::Error> {
+        use std::sync::Arc;
+        use tokio::sync::{Mutex, broadcast};
+
+        // Create shutdown channel for status update task
+        let (status_shutdown_tx, status_shutdown_rx) = broadcast::channel(1);
+        let status_task_handle = Arc::new(Mutex::new(None));
+
+        let client = BotService::create_client(
+            &self.config,
+            self.app_state.clone(),
+            status_task_handle.clone(),
+            status_shutdown_rx,
+        )
+        .await
+        .expect("Failed to create Discord client");
+
+        let bot_service = Box::new(BotService::new(
+            client,
+            status_task_handle,
+            status_shutdown_tx,
+        ));
+
+        self.service_manager
+            .register_service(ServiceName::Bot.as_str(), bot_service);
+        Ok(())
+    }
+
+    /// Start all registered services
+    pub fn start_services(&mut self) {
+        self.service_manager.spawn_all();
+    }
+
+    /// Run the application and handle shutdown signals
+    pub async fn run(self) -> ExitCode {
+        use crate::signals::handle_shutdown_signals;
+        handle_shutdown_signals(self.service_manager, self.config.shutdown_timeout).await
+    }
+
+    /// Get a reference to the configuration
+    pub fn config(&self) -> &Config {
+        &self.config
+    }
+}

src/banner/api.rs

@@ -0,0 +1,386 @@
+//! Main Banner API client implementation.
+
+use std::{
+    collections::{HashMap, VecDeque},
+    sync::{Arc, Mutex},
+    time::Instant,
+};
+
+use crate::banner::{
+    BannerSession, SessionPool, create_shared_rate_limiter,
+    errors::BannerApiError,
+    json::parse_json_with_context,
+    middleware::TransparentMiddleware,
+    models::*,
+    nonce,
+    query::SearchQuery,
+    rate_limit_middleware::RateLimitMiddleware,
+    rate_limiter::{RateLimitConfig, SharedRateLimiter},
+    util::user_agent,
+};
+use anyhow::{Context, Result, anyhow};
+use cookie::Cookie;
+use dashmap::DashMap;
+use http::HeaderValue;
+use reqwest::{Client, Request, Response};
+use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};
+use serde_json;
+use tl;
+use tracing::{Level, Metadata, Span, debug, error, field::ValueSet, info, span, trace, warn};
+
+/// Main Banner API client.
+pub struct BannerApi {
+    pub sessions: SessionPool,
+    http: ClientWithMiddleware,
+    base_url: String,
+}
+
+#[allow(dead_code)]
+impl BannerApi {
+    /// Creates a new Banner API client.
+    pub fn new(base_url: String) -> Result<Self> {
+        Self::new_with_config(base_url, RateLimitConfig::default())
+    }
+
+    /// Creates a new Banner API client with custom rate limiting configuration.
+    pub fn new_with_config(base_url: String, rate_limit_config: RateLimitConfig) -> Result<Self> {
+        let rate_limiter = create_shared_rate_limiter(Some(rate_limit_config));
+
+        let http = ClientBuilder::new(
+            Client::builder()
+                .cookie_store(false)
+                .user_agent(user_agent())
+                .tcp_keepalive(Some(std::time::Duration::from_secs(60 * 5)))
+                .read_timeout(std::time::Duration::from_secs(10))
+                .connect_timeout(std::time::Duration::from_secs(10))
+                .timeout(std::time::Duration::from_secs(30))
+                .build()
+                .context("Failed to create HTTP client")?,
+        )
+        .with(TransparentMiddleware)
+        .with(RateLimitMiddleware::new(rate_limiter.clone()))
+        .build();
+
+        Ok(Self {
+            sessions: SessionPool::new(http.clone(), base_url.clone()),
+            http,
+            base_url,
+        })
+    }
+    /// Validates offset parameter for search methods.
+    fn validate_offset(offset: i32) -> Result<()> {
+        if offset <= 0 {
+            Err(anyhow::anyhow!("Offset must be greater than 0"))
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Builds common search parameters for list endpoints.
+    fn build_list_params(
+        &self,
+        search: &str,
+        term: &str,
+        offset: i32,
+        max_results: i32,
+        session_id: &str,
+    ) -> Vec<(&str, String)> {
+        vec![
+            ("searchTerm", search.to_string()),
+            ("term", term.to_string()),
+            ("offset", offset.to_string()),
+            ("max", max_results.to_string()),
+            ("uniqueSessionId", session_id.to_string()),
+            ("_", nonce()),
+        ]
+    }
+
+    /// Makes a GET request to a list endpoint and parses JSON response.
+    async fn get_list_endpoint<T>(
+        &self,
+        endpoint: &str,
+        search: &str,
+        term: &str,
+        offset: i32,
+        max_results: i32,
+    ) -> Result<Vec<T>>
+    where
+        T: for<'de> serde::Deserialize<'de>,
+    {
+        Self::validate_offset(offset)?;
+
+        let session = self.sessions.acquire(term.parse()?).await?;
+        let url = format!("{}/classSearch/{}", self.base_url, endpoint);
+        let params = self.build_list_params(search, term, offset, max_results, &session.id());
+
+        let response = self
+            .http
+            .get(&url)
+            .query(&params)
+            .send()
+            .await
+            .with_context(|| format!("Failed to get {}", endpoint))?;
+
+        let data: Vec<T> = response
+            .json()
+            .await
+            .with_context(|| format!("Failed to parse {} response", endpoint))?;
+
+        Ok(data)
+    }
+
+    /// Builds search parameters for course search methods.
+    fn build_search_params(
+        &self,
+        query: &SearchQuery,
+        term: &str,
+        session_id: &str,
+        sort: &str,
+        sort_descending: bool,
+    ) -> HashMap<String, String> {
+        let mut params = query.to_params();
+        params.insert("txt_term".to_string(), term.to_string());
+        params.insert("uniqueSessionId".to_string(), session_id.to_string());
+        params.insert("sortColumn".to_string(), sort.to_string());
+        params.insert(
+            "sortDirection".to_string(),
+            if sort_descending { "desc" } else { "asc" }.to_string(),
+        );
+        params.insert("startDatepicker".to_string(), String::new());
+        params.insert("endDatepicker".to_string(), String::new());
+        params
+    }
+
+    /// Performs a course search and handles common response processing.
+    #[tracing::instrument(
+        skip(self, query),
+        fields(
+            term = %term,
+            subject = %query.get_subject().unwrap_or(&"all".to_string())
+        )
+    )]
+    async fn perform_search(
+        &self,
+        term: &str,
+        query: &SearchQuery,
+        sort: &str,
+        sort_descending: bool,
+    ) -> Result<SearchResult, BannerApiError> {
+        let mut session = self.sessions.acquire(term.parse()?).await?;
+
+        if session.been_used() {
+            self.http
+                .post(format!("{}/classSearch/resetDataForm", self.base_url))
+                .header("Cookie", session.cookie())
+                .send()
+                .await
+                .map_err(|e| BannerApiError::RequestFailed(e.into()))?;
+        }
+
+        session.touch();
+
+        let params = self.build_search_params(query, term, &session.id(), sort, sort_descending);
+
+        debug!(
+            term = term,
+            subject = query.get_subject().map(|s| s.as_str()).unwrap_or("all"),
+            max_results = query.get_max_results(),
+            "Searching for courses"
+        );
+
+        let response = self
+            .http
+            .get(format!("{}/searchResults/searchResults", self.base_url))
+            .header("Cookie", session.cookie())
+            .query(&params)
+            .send()
+            .await
+            .context("Failed to search courses")?;
+
+        let status = response.status();
+        let url = response.url().clone();
+        let body = response
+            .text()
+            .await
+            .with_context(|| format!("Failed to read body (status={status})"))?;
+
+        let search_result: SearchResult = parse_json_with_context(&body).map_err(|e| {
+            BannerApiError::RequestFailed(anyhow!(
+                "Failed to parse search response (status={status}, url={url}): {e}"
+            ))
+        })?;
+
+        // Check for signs of an invalid session
+        if search_result.path_mode.is_none() {
+            return Err(BannerApiError::InvalidSession(
+                "Search result path mode is none".to_string(),
+            ));
+        } else if search_result.data.is_none() {
+            return Err(BannerApiError::InvalidSession(
+                "Search result data is none".to_string(),
+            ));
+        }
+
+        if !search_result.success {
+            return Err(BannerApiError::RequestFailed(anyhow!(
+                "Search marked as unsuccessful by Banner API"
+            )));
+        }
+
+        Ok(search_result)
+    }
+
+    /// Retrieves a list of subjects from the Banner API.
+    pub async fn get_subjects(
+        &self,
+        search: &str,
+        term: &str,
+        offset: i32,
+        max_results: i32,
+    ) -> Result<Vec<Pair>> {
+        self.get_list_endpoint("get_subject", search, term, offset, max_results)
+            .await
+    }
+
+    /// Retrieves a list of instructors from the Banner API.
+    pub async fn get_instructors(
+        &self,
+        search: &str,
+        term: &str,
+        offset: i32,
+        max_results: i32,
+    ) -> Result<Vec<Instructor>> {
+        self.get_list_endpoint("get_instructor", search, term, offset, max_results)
+            .await
+    }
+
+    /// Retrieves a list of campuses from the Banner API.
+    pub async fn get_campuses(
+        &self,
+        search: &str,
+        term: &str,
+        offset: i32,
+        max_results: i32,
+    ) -> Result<Vec<Pair>> {
+        self.get_list_endpoint("get_campus", search, term, offset, max_results)
+            .await
+    }
+
+    /// Retrieves meeting time information for a course.
+    pub async fn get_course_meeting_time(
+        &self,
+        term: &str,
+        crn: &str,
+    ) -> Result<Vec<MeetingScheduleInfo>> {
+        let url = format!("{}/searchResults/getFacultyMeetingTimes", self.base_url);
+        let params = [("term", term), ("courseReferenceNumber", crn)];
+
+        let response = self
+            .http
+            .get(&url)
+            .query(&params)
+            .send()
+            .await
+            .context("Failed to get meeting times")?;
+
+        if !response.status().is_success() {
+            return Err(anyhow::anyhow!(
+                "Failed to get meeting times: {}",
+                response.status()
+            ));
+        } else if !response
+            .headers()
+            .get("Content-Type")
+            .unwrap_or(&HeaderValue::from_static(""))
+            .to_str()
+            .unwrap_or("")
+            .starts_with("application/json")
+        {
+            return Err(anyhow::anyhow!(
+                "Unexpected content type: {:?}",
+                response
+                    .headers()
+                    .get("Content-Type")
+                    .unwrap_or(&HeaderValue::from_static("(empty)"))
+                    .to_str()
+                    .unwrap_or("(non-ascii)")
+            ));
+        }
+
+        let response: MeetingTimesApiResponse =
+            response.json().await.context("Failed to parse response")?;
+
+        Ok(response
+            .fmt
+            .into_iter()
+            .map(|m| m.schedule_info())
+            .collect())
+    }
+
+    /// Performs a search for courses.
+    pub async fn search(
+        &self,
+        term: &str,
+        query: &SearchQuery,
+        sort: &str,
+        sort_descending: bool,
+    ) -> Result<SearchResult, BannerApiError> {
+        self.perform_search(term, query, sort, sort_descending)
+            .await
+    }
+
+    /// Retrieves a single course by CRN by issuing a minimal search
+    pub async fn get_course_by_crn(
+        &self,
+        term: &str,
+        crn: &str,
+    ) -> Result<Option<Course>, BannerApiError> {
+        debug!(term = term, crn = crn, "Looking up course by CRN");
+
+        let query = SearchQuery::new()
+            .course_reference_number(crn)
+            .max_results(1);
+
+        let search_result = self
+            .perform_search(term, &query, "subjectDescription", false)
+            .await?;
+
+        // Additional validation for CRN search
+        if search_result.path_mode == Some("registration".to_string())
+            && search_result.data.is_none()
+        {
+            return Err(BannerApiError::InvalidSession(
+                "Search result path mode is registration and data is none".to_string(),
+            ));
+        }
+
+        Ok(search_result
+            .data
+            .and_then(|courses| courses.into_iter().next()))
+    }
+
+    /// Gets course details (placeholder - needs implementation).
+    pub async fn get_course_details(&self, term: &str, crn: &str) -> Result<ClassDetails> {
+        let body = serde_json::json!({
+            "term": term,
+            "courseReferenceNumber": crn,
+            "first": "first"
+        });
+
+        let url = format!("{}/searchResults/getClassDetails", self.base_url);
+        let response = self
+            .http
+            .post(&url)
+            .json(&body)
+            .send()
+            .await
+            .context("Failed to get course details")?;
+
+        let details: ClassDetails = response
+            .json()
+            .await
+            .context("Failed to parse course details response")?;
+
+        Ok(details)
+    }
+}

src/banner/errors.rs

@@ -0,0 +1,11 @@
+//! Error types for the Banner API client.
+
+use thiserror::Error;
+
+#[derive(Debug, thiserror::Error)]
+pub enum BannerApiError {
+    #[error("Banner session is invalid or expired: {0}")]
+    InvalidSession(String),
+    #[error(transparent)]
+    RequestFailed(#[from] anyhow::Error),
+}

src/banner/json.rs

@@ -0,0 +1,415 @@
+//! JSON parsing utilities for the Banner API client.
+
+use anyhow::Result;
+use serde_json::{self, Value};
+
+/// Attempt to parse JSON and, on failure, include a contextual snippet of the
+/// line where the error occurred.
+///
+/// In debug builds, this provides detailed context including the full JSON object
+/// containing the error and type mismatch information. In release builds, it shows
+/// a minimal snippet to prevent dumping huge JSON bodies to production logs.
+pub fn parse_json_with_context<T: serde::de::DeserializeOwned>(body: &str) -> Result<T> {
+    let jd = &mut serde_json::Deserializer::from_str(body);
+    match serde_path_to_error::deserialize(jd) {
+        Ok(value) => Ok(value),
+        Err(err) => {
+            let inner_err = err.inner();
+            let (line, column) = (inner_err.line(), inner_err.column());
+            let path = err.path().to_string();
+
+            let msg = inner_err.to_string();
+            let loc = format!(" at line {line} column {column}");
+            let msg_without_loc = msg.strip_suffix(&loc).unwrap_or(&msg).to_string();
+
+            // Build error message differently for debug vs release builds
+            let final_err = if cfg!(debug_assertions) {
+                // Debug mode: provide detailed context
+                let type_info = parse_type_mismatch(&msg_without_loc);
+                let context = extract_json_object_at_path(body, err.path(), line, column);
+
+                let mut err_msg = String::new();
+                if !path.is_empty() && path != "." {
+                    err_msg.push_str(&format!("for path '{}'\n", path));
+                }
+                err_msg.push_str(&format!(
+                    "({}) at line {} column {}\n\n",
+                    type_info, line, column
+                ));
+                err_msg.push_str(&context);
+
+                err_msg
+            } else {
+                // Release mode: minimal snippet to keep logs concise
+                let snippet = build_error_snippet(body, line, column, 20);
+
+                let mut err_msg = String::new();
+                if !path.is_empty() && path != "." {
+                    err_msg.push_str(&format!("for path '{}' ", path));
+                }
+                err_msg.push_str(&format!(
+                    "({}) at line {} column {}",
+                    msg_without_loc, line, column
+                ));
+                err_msg.push_str(&format!("\n{}", snippet));
+
+                err_msg
+            };
+
+            Err(anyhow::anyhow!(final_err))
+        }
+    }
+}
+
+/// Extract type mismatch information from a serde error message.
+///
+/// Parses error messages like "invalid type: null, expected a string" to extract
+/// the expected and actual types for clearer error reporting.
+///
+/// Returns a formatted string like "(expected a string, got null)" or the original
+/// message if parsing fails.
+fn parse_type_mismatch(error_msg: &str) -> String {
+    // Try to parse "invalid type: X, expected Y" format
+    if let Some(invalid_start) = error_msg.find("invalid type: ") {
+        let after_prefix = &error_msg[invalid_start + "invalid type: ".len()..];
+
+        if let Some(comma_pos) = after_prefix.find(", expected ") {
+            let actual_type = &after_prefix[..comma_pos];
+            let expected_part = &after_prefix[comma_pos + ", expected ".len()..];
+
+            // Clean up expected part (remove " at line X column Y" if present)
+            let expected_type = expected_part
+                .split(" at line ")
+                .next()
+                .unwrap_or(expected_part)
+                .trim();
+
+            return format!("expected {}, got {}", expected_type, actual_type);
+        }
+    }
+
+    // Try to parse "expected X at line Y" format
+    if error_msg.starts_with("expected ")
+        && let Some(expected_part) = error_msg.split(" at line ").next()
+    {
+        return expected_part.to_string();
+    }
+
+    // Fallback: return original message without location info
+    error_msg.to_string()
+}
+
+/// Extract and pretty-print the JSON object/array containing the parse error.
+///
+/// This function navigates to the error location using the serde path and extracts
+/// the parent object or array to provide better context for debugging.
+///
+/// # Arguments
+/// * `body` - The raw JSON string
+/// * `path` - The serde path to the error (e.g., "data[0].faculty[0].displayName")
+/// * `line` - Line number of the error (for fallback)
+/// * `column` - Column number of the error (for fallback)
+///
+/// # Returns
+/// A formatted string containing the JSON object with the error, or a fallback snippet
+fn extract_json_object_at_path(
+    body: &str,
+    path: &serde_path_to_error::Path,
+    line: usize,
+    column: usize,
+) -> String {
+    // Try to parse the entire JSON structure
+    let root_value: Value = match serde_json::from_str(body) {
+        Ok(v) => v,
+        Err(_) => {
+            // If we can't parse the JSON at all, fall back to line snippet
+            return build_error_snippet(body, line, column, 20);
+        }
+    };
+
+    // Navigate to the error location using the path
+    let path_str = path.to_string();
+    let segments = parse_path_segments(&path_str);
+
+    let (context_value, context_name) = navigate_to_context(&root_value, &segments);
+
+    // Pretty-print the context value with limited depth to avoid huge output
+    match serde_json::to_string_pretty(&context_value) {
+        Ok(pretty) => {
+            // Limit output to ~50 lines to prevent log spam
+            let lines: Vec<&str> = pretty.lines().collect();
+            let truncated = if lines.len() > 50 {
+                let mut result = lines[..47].join("\n");
+                result.push_str("\n  ... (truncated, ");
+                result.push_str(&(lines.len() - 47).to_string());
+                result.push_str(" more lines)");
+                result
+            } else {
+                pretty
+            };
+
+            format!("{} at '{}':\n{}", context_name, path_str, truncated)
+        }
+        Err(_) => {
+            // Fallback to simple snippet if pretty-print fails
+            build_error_snippet(body, line, column, 20)
+        }
+    }
+}
+
+/// Parse a JSON path string into segments for navigation.
+///
+/// Converts paths like "data[0].faculty[1].displayName" into a sequence of
+/// object keys and array indices.
+fn parse_path_segments(path: &str) -> Vec<PathSegment> {
+    let mut segments = Vec::new();
+    let mut current = String::new();
+    let mut in_bracket = false;
+
+    for ch in path.chars() {
+        match ch {
+            '.' if !in_bracket => {
+                if !current.is_empty() {
+                    segments.push(PathSegment::Key(current.clone()));
+                    current.clear();
+                }
+            }
+            '[' => {
+                if !current.is_empty() {
+                    segments.push(PathSegment::Key(current.clone()));
+                    current.clear();
+                }
+                in_bracket = true;
+            }
+            ']' => {
+                if in_bracket && !current.is_empty() {
+                    if let Ok(index) = current.parse::<usize>() {
+                        segments.push(PathSegment::Index(index));
+                    }
+                    current.clear();
+                }
+                in_bracket = false;
+            }
+            _ => current.push(ch),
+        }
+    }
+
+    if !current.is_empty() {
+        segments.push(PathSegment::Key(current));
+    }
+
+    segments
+}
+
+/// Represents a segment in a JSON path (either an object key or array index).
+#[derive(Debug)]
+enum PathSegment {
+    Key(String),
+    Index(usize),
+}
+
+/// Navigate through a JSON value using path segments and return the appropriate context.
+///
+/// This function walks the JSON structure and returns the parent object/array that
+/// contains the error, providing meaningful context for debugging.
+///
+/// # Returns
+/// A tuple of (context_value, description) where context_value is the JSON to display
+/// and description is a human-readable name for what we're showing.
+fn navigate_to_context<'a>(
+    mut current: &'a Value,
+    segments: &[PathSegment],
+) -> (&'a Value, &'static str) {
+    // If path is empty or just root, return the whole value
+    if segments.is_empty() {
+        return (current, "Root object");
+    }
+
+    // Try to navigate to the parent of the error location
+    // We want to show the containing object/array, not just the failing field
+    let parent_depth = segments.len().saturating_sub(1);
+
+    for (i, segment) in segments.iter().enumerate() {
+        // Stop one level before the end to show the parent context
+        if i >= parent_depth {
+            break;
+        }
+
+        match segment {
+            PathSegment::Key(key) => {
+                if let Some(next) = current.get(key) {
+                    current = next;
+                } else {
+                    // Can't navigate further, return what we have
+                    return (current, "Partial context (navigation stopped)");
+                }
+            }
+            PathSegment::Index(idx) => {
+                if let Some(next) = current.get(idx) {
+                    current = next;
+                } else {
+                    return (current, "Partial context (index out of bounds)");
+                }
+            }
+        }
+    }
+
+    (current, "Object containing error")
+}
+
+fn build_error_snippet(body: &str, line: usize, column: usize, context_len: usize) -> String {
+    let target_line = body.lines().nth(line.saturating_sub(1)).unwrap_or("");
+    if target_line.is_empty() {
+        return "(empty line)".to_string();
+    }
+
+    // column is 1-based, convert to 0-based for slicing
+    let error_idx = column.saturating_sub(1);
+
+    let half_len = context_len / 2;
+    let start = error_idx.saturating_sub(half_len);
+    let end = (error_idx + half_len).min(target_line.len());
+
+    let slice = &target_line[start..end];
+    let indicator_pos = error_idx - start;
+
+    let indicator = " ".repeat(indicator_pos) + "^";
+
+    format!("...{slice}...\n   {indicator}")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde::Deserialize;
+
+    #[test]
+    fn test_parse_type_mismatch_invalid_type() {
+        let msg = "invalid type: null, expected a string at line 45 column 29";
+        let result = parse_type_mismatch(msg);
+        assert_eq!(result, "expected a string, got null");
+    }
+
+    #[test]
+    fn test_parse_type_mismatch_expected() {
+        let msg = "expected value at line 1 column 1";
+        let result = parse_type_mismatch(msg);
+        assert_eq!(result, "expected value");
+    }
+
+    #[test]
+    fn test_parse_path_segments_simple() {
+        let segments = parse_path_segments("data.name");
+        assert_eq!(segments.len(), 2);
+        match &segments[0] {
+            PathSegment::Key(k) => assert_eq!(k, "data"),
+            _ => panic!("Expected Key segment"),
+        }
+    }
+
+    #[test]
+    fn test_parse_path_segments_with_array() {
+        let segments = parse_path_segments("data[0].faculty[1].displayName");
+        assert_eq!(segments.len(), 5);
+        match &segments[0] {
+            PathSegment::Key(k) => assert_eq!(k, "data"),
+            _ => panic!("Expected Key segment"),
+        }
+        match &segments[1] {
+            PathSegment::Index(i) => assert_eq!(*i, 0),
+            _ => panic!("Expected Index segment"),
+        }
+    }
+
+    #[test]
+    fn test_parse_json_with_context_null_value() {
+        #[derive(Debug, Deserialize)]
+        struct TestStruct {
+            name: String,
+        }
+
+        let json = r#"{"name": null}"#;
+        let result: Result<TestStruct> = parse_json_with_context(json);
+
+        assert!(result.is_err());
+        let err_msg = result.unwrap_err().to_string();
+
+        // Should contain path info
+        assert!(err_msg.contains("name"));
+
+        // In debug mode, should contain detailed context
+        if cfg!(debug_assertions) {
+            assert!(err_msg.contains("expected"));
+        }
+    }
+
+    #[test]
+    fn test_navigate_to_context() {
+        let json = r#"{"data": [{"faculty": [{"name": "John"}]}]}"#;
+        let value: Value = serde_json::from_str(json).unwrap();
+
+        let segments = parse_path_segments("data[0].faculty[0].name");
+        let (context, _) = navigate_to_context(&value, &segments);
+
+        // Should return the faculty[0] object (parent of 'name')
+        assert!(context.is_object());
+        assert!(context.get("name").is_some());
+    }
+
+    #[test]
+    fn test_realistic_banner_error() {
+        #[derive(Debug, Deserialize)]
+        struct Course {
+            #[allow(dead_code)]
+            #[serde(rename = "courseTitle")]
+            course_title: String,
+            faculty: Vec<Faculty>,
+        }
+
+        #[derive(Debug, Deserialize)]
+        struct Faculty {
+            #[serde(rename = "displayName")]
+            display_name: String,
+            #[allow(dead_code)]
+            email: String,
+        }
+
+        #[derive(Debug, Deserialize)]
+        struct SearchResult {
+            data: Vec<Course>,
+        }
+
+        // Simulate Banner API response with null faculty displayName
+        // This mimics the actual error from SPN subject scrape
+        let json = r#"{
+            "data": [
+                {
+                    "courseTitle": "Spanish Conversation",
+                    "faculty": [
+                        {
+                            "displayName": null,
+                            "email": "instructor@utsa.edu"
+                        }
+                    ]
+                }
+            ]
+        }"#;
+
+        let result: Result<SearchResult> = parse_json_with_context(json);
+        assert!(result.is_err());
+
+        let err_msg = result.unwrap_err().to_string();
+        println!("\n=== Error output in debug mode ===\n{}\n", err_msg);
+
+        // Verify error contains key information
+        assert!(err_msg.contains("data[0].faculty[0].displayName"));
+
+        // In debug mode, should show detailed context
+        if cfg!(debug_assertions) {
+            // Should show type mismatch info
+            assert!(err_msg.contains("expected") && err_msg.contains("got"));
+            // Should show surrounding JSON context with the faculty object
+            assert!(err_msg.contains("email"));
+        }
+    }
+}

src/banner/middleware.rs

@@ -0,0 +1,75 @@
+//! HTTP middleware for the Banner API client.
+
+use http::Extensions;
+use reqwest::{Request, Response};
+use reqwest_middleware::{Middleware, Next};
+use tracing::{debug, trace, warn};
+
+pub struct TransparentMiddleware;
+
+/// Threshold for logging slow requests at DEBUG level (in milliseconds)
+const SLOW_REQUEST_THRESHOLD_MS: u128 = 1000;
+
+#[async_trait::async_trait]
+impl Middleware for TransparentMiddleware {
+    async fn handle(
+        &self,
+        req: Request,
+        extensions: &mut Extensions,
+        next: Next<'_>,
+    ) -> std::result::Result<Response, reqwest_middleware::Error> {
+        let method = req.method().to_string();
+        let path = req.url().path().to_string();
+
+        let start = std::time::Instant::now();
+        let response_result = next.run(req, extensions).await;
+        let duration = start.elapsed();
+
+        match response_result {
+            Ok(response) => {
+                if response.status().is_success() {
+                    let duration_ms = duration.as_millis();
+                    if duration_ms >= SLOW_REQUEST_THRESHOLD_MS {
+                        debug!(
+                            method = method,
+                            path = path,
+                            status = response.status().as_u16(),
+                            duration_ms = duration_ms,
+                            "Request completed (slow)"
+                        );
+                    } else {
+                        trace!(
+                            method = method,
+                            path = path,
+                            status = response.status().as_u16(),
+                            duration_ms = duration_ms,
+                            "Request completed"
+                        );
+                    }
+                    Ok(response)
+                } else {
+                    let e = response.error_for_status_ref().unwrap_err();
+                    warn!(
+                        method = method,
+                        path = path,
+                        error = ?e,
+                        status = response.status().as_u16(),
+                        duration_ms = duration.as_millis(),
+                        "Request failed"
+                    );
+                    Ok(response)
+                }
+            }
+            Err(error) => {
+                warn!(
+                    method = method,
+                    path = path,
+                    error = ?error,
+                    duration_ms = duration.as_millis(),
+                    "Request failed"
+                );
+                Err(error)
+            }
+        }
+    }
+}

src/banner/mod.rs

@@ -0,0 +1,26 @@
+#![allow(unused_imports)]
+
+//! Banner API module for interacting with Ellucian Banner systems.
+//!
+//! This module provides functionality to:
+//! - Search for courses and retrieve course information
+//! - Manage Banner API sessions and authentication
+//! - Generate ICS files and calendar links
+
+pub mod api;
+pub mod errors;
+pub mod json;
+pub mod middleware;
+pub mod models;
+pub mod query;
+pub mod rate_limit_middleware;
+pub mod rate_limiter;
+pub mod session;
+pub mod util;
+
+pub use api::*;
+pub use errors::*;
+pub use models::*;
+pub use query::*;
+pub use rate_limiter::*;
+pub use session::*;

src/banner/models/common.rs

@@ -0,0 +1,21 @@
+use serde::{Deserialize, Serialize};
+
+/// Represents a key-value pair from the Banner API
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Pair {
+    pub code: String,
+    pub description: String,
+}
+
+/// Represents a term in the Banner system
+pub type BannerTerm = Pair;
+
+/// Represents an instructor in the Banner system
+pub type Instructor = Pair;
+
+impl BannerTerm {
+    /// Returns true if the term is in an archival (view-only) state
+    pub fn is_archived(&self) -> bool {
+        self.description.contains("View Only")
+    }
+}

src/banner/models/courses.rs

@@ -0,0 +1,84 @@
+use serde::{Deserialize, Serialize};
+
+use super::meetings::FacultyItem;
+use super::meetings::MeetingTimeResponse;
+
+/// Course section attribute
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SectionAttribute {
+    pub class: String,
+    pub course_reference_number: String,
+    pub code: String,
+    pub description: String,
+    pub term_code: String,
+    #[serde(rename = "isZTCAttribute")]
+    pub is_ztc_attribute: bool,
+}
+
+/// Represents a single course returned from a search
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Course {
+    pub id: i32,
+    pub term: String,
+    pub term_desc: String,
+    pub course_reference_number: String,
+    pub part_of_term: String,
+    pub course_number: String,
+    pub subject: String,
+    pub subject_description: String,
+    pub sequence_number: String,
+    pub campus_description: String,
+    pub schedule_type_description: String,
+    pub course_title: String,
+    pub credit_hours: Option<i32>,
+    pub maximum_enrollment: i32,
+    pub enrollment: i32,
+    pub seats_available: i32,
+    pub wait_capacity: i32,
+    pub wait_count: i32,
+    pub cross_list: Option<String>,
+    pub cross_list_capacity: Option<i32>,
+    pub cross_list_count: Option<i32>,
+    pub cross_list_available: Option<i32>,
+    pub credit_hour_high: Option<i32>,
+    pub credit_hour_low: Option<i32>,
+    pub credit_hour_indicator: Option<String>,
+    pub open_section: bool,
+    pub link_identifier: Option<String>,
+    pub is_section_linked: bool,
+    pub subject_course: String,
+    pub reserved_seat_summary: Option<String>,
+    pub instructional_method: String,
+    pub instructional_method_description: String,
+    pub section_attributes: Vec<SectionAttribute>,
+    #[serde(default)]
+    pub faculty: Vec<FacultyItem>,
+    #[serde(default)]
+    pub meetings_faculty: Vec<MeetingTimeResponse>,
+}
+
+impl Course {
+    /// Returns the course title in the format "SUBJ #### - Course Title"
+    pub fn display_title(&self) -> String {
+        format!(
+            "{} {} - {}",
+            self.subject, self.course_number, self.course_title
+        )
+    }
+
+    /// Returns the name of the primary instructor, or "Unknown" if not available
+    pub fn primary_instructor_name(&self) -> &str {
+        self.faculty
+            .first()
+            .map(|f| f.display_name.as_str())
+            .unwrap_or("Unknown")
+    }
+}
+
+/// Class details (to be implemented)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ClassDetails {
+    // TODO: Implement based on Banner API response
+}

src/banner/models/meetings.rs

@@ -0,0 +1,574 @@
+use bitflags::{Flags, bitflags};
+use chrono::{DateTime, NaiveDate, NaiveTime, Timelike, Utc};
+use serde::{Deserialize, Deserializer, Serialize};
+use std::{cmp::Ordering, collections::HashSet, fmt::Display, str::FromStr};
+
+use super::terms::Term;
+
+/// Deserialize a string field into a u32
+fn deserialize_string_to_u32<'de, D>(deserializer: D) -> Result<u32, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let s: String = Deserialize::deserialize(deserializer)?;
+    s.parse::<u32>().map_err(serde::de::Error::custom)
+}
+
+/// Deserialize a string field into a Term
+fn deserialize_string_to_term<'de, D>(deserializer: D) -> Result<Term, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let s: String = Deserialize::deserialize(deserializer)?;
+    Term::from_str(&s).map_err(serde::de::Error::custom)
+}
+
+/// Represents a faculty member associated with a course
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FacultyItem {
+    pub banner_id: String,        // e.g "@01647907" (can contain @ symbol)
+    pub category: Option<String>, // zero-padded digits
+    pub class: String,            // internal class name
+    #[serde(deserialize_with = "deserialize_string_to_u32")]
+    pub course_reference_number: u32, // CRN, e.g 27294
+    pub display_name: String,     // "LastName, FirstName"
+    pub email_address: Option<String>, // e.g. FirstName.LastName@utsaedu
+    pub primary_indicator: bool,
+    pub term: String, // e.g "202420"
+}
+
+/// Meeting time information for a course
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MeetingTime {
+    pub start_date: String,         // MM/DD/YYYY, e.g 08/26/2025
+    pub end_date: String,           // MM/DD/YYYY, e.g 08/26/2025
+    pub begin_time: Option<String>, // HHMM, e.g 1000
+    pub end_time: Option<String>,   // HHMM, e.g 1100
+    pub category: String,           // unknown meaning, e.g. 01, 02, etc
+    pub class: String, // internal class name, e.g. net.hedtech.banner.general.overallMeetingTimeDecorator
+    pub monday: bool,  // true if the meeting time occurs on Monday
+    pub tuesday: bool, // true if the meeting time occurs on Tuesday
+    pub wednesday: bool, // true if the meeting time occurs on Wednesday
+    pub thursday: bool, // true if the meeting time occurs on Thursday
+    pub friday: bool,  // true if the meeting time occurs on Friday
+    pub saturday: bool, // true if the meeting time occurs on Saturday
+    pub sunday: bool,  // true if the meeting time occurs on Sunday
+    pub room: Option<String>, // e.g. 1.238
+    #[serde(deserialize_with = "deserialize_string_to_term")]
+    pub term: Term, // e.g 202510
+    pub building: Option<String>, // e.g NPB
+    pub building_description: Option<String>, // e.g North Paseo Building
+    pub campus: Option<String>, // campus code, e.g 11
+    pub campus_description: Option<String>, // name of campus, e.g Main Campus
+    pub course_reference_number: String, // CRN, e.g 27294
+    pub credit_hour_session: Option<f64>, // e.g. 30
+    pub hours_week: f64, // e.g. 30
+    pub meeting_schedule_type: String, // e.g AFF
+    pub meeting_type: String, // e.g HB, H2, H1, OS, OA, OH, ID, FF
+    pub meeting_type_description: String,
+}
+
+bitflags! {
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+    pub struct MeetingDays: u8 {
+        const Monday = 1 << 0;
+        const Tuesday = 1 << 1;
+        const Wednesday = 1 << 2;
+        const Thursday = 1 << 3;
+        const Friday = 1 << 4;
+        const Saturday = 1 << 5;
+        const Sunday = 1 << 6;
+    }
+}
+
+impl MeetingDays {
+    /// Convert from the boolean flags in the raw API response
+    pub fn from_meeting_time(meeting_time: &MeetingTime) -> MeetingDays {
+        let mut days = MeetingDays::empty();
+
+        if meeting_time.monday {
+            days.insert(MeetingDays::Monday);
+        }
+        if meeting_time.tuesday {
+            days.insert(MeetingDays::Tuesday);
+        }
+        if meeting_time.wednesday {
+            days.insert(MeetingDays::Wednesday);
+        }
+        if meeting_time.thursday {
+            days.insert(MeetingDays::Thursday);
+        }
+        if meeting_time.friday {
+            days.insert(MeetingDays::Friday);
+        }
+        if meeting_time.saturday {
+            days.insert(MeetingDays::Saturday);
+        }
+        if meeting_time.sunday {
+            days.insert(MeetingDays::Sunday);
+        }
+
+        days
+    }
+}
+
+impl PartialOrd for MeetingDays {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.bits().cmp(&other.bits()))
+    }
+}
+
+impl From<DayOfWeek> for MeetingDays {
+    fn from(day: DayOfWeek) -> Self {
+        match day {
+            DayOfWeek::Monday => MeetingDays::Monday,
+            DayOfWeek::Tuesday => MeetingDays::Tuesday,
+            DayOfWeek::Wednesday => MeetingDays::Wednesday,
+            DayOfWeek::Thursday => MeetingDays::Thursday,
+            DayOfWeek::Friday => MeetingDays::Friday,
+            DayOfWeek::Saturday => MeetingDays::Saturday,
+            DayOfWeek::Sunday => MeetingDays::Sunday,
+        }
+    }
+}
+
+/// Days of the week for meeting schedules
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum DayOfWeek {
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+    Sunday,
+}
+
+impl DayOfWeek {
+    /// Convert to short string representation
+    ///
+    /// Do not change these, these are used for ICS generation. Casing does not matter though.
+    pub fn to_short_string(self) -> &'static str {
+        match self {
+            DayOfWeek::Monday => "Mo",
+            DayOfWeek::Tuesday => "Tu",
+            DayOfWeek::Wednesday => "We",
+            DayOfWeek::Thursday => "Th",
+            DayOfWeek::Friday => "Fr",
+            DayOfWeek::Saturday => "Sa",
+            DayOfWeek::Sunday => "Su",
+        }
+    }
+
+    /// Convert to full string representation
+    pub fn to_full_string(self) -> &'static str {
+        match self {
+            DayOfWeek::Monday => "Monday",
+            DayOfWeek::Tuesday => "Tuesday",
+            DayOfWeek::Wednesday => "Wednesday",
+            DayOfWeek::Thursday => "Thursday",
+            DayOfWeek::Friday => "Friday",
+            DayOfWeek::Saturday => "Saturday",
+            DayOfWeek::Sunday => "Sunday",
+        }
+    }
+}
+
+impl TryFrom<MeetingDays> for DayOfWeek {
+    type Error = anyhow::Error;
+
+    fn try_from(days: MeetingDays) -> Result<Self, Self::Error> {
+        if days.contains_unknown_bits() {
+            return Err(anyhow::anyhow!("Unknown days: {:?}", days));
+        }
+
+        let count = days.into_iter().count();
+        if count == 1 {
+            return Ok(match days {
+                MeetingDays::Monday => DayOfWeek::Monday,
+                MeetingDays::Tuesday => DayOfWeek::Tuesday,
+                MeetingDays::Wednesday => DayOfWeek::Wednesday,
+                MeetingDays::Thursday => DayOfWeek::Thursday,
+                MeetingDays::Friday => DayOfWeek::Friday,
+                MeetingDays::Saturday => DayOfWeek::Saturday,
+                MeetingDays::Sunday => DayOfWeek::Sunday,
+                _ => unreachable!(),
+            });
+        }
+
+        Err(anyhow::anyhow!(
+            "Cannot convert multiple days to a single day: {days:?}"
+        ))
+    }
+}
+
+/// Time range for meetings
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct TimeRange {
+    pub start: NaiveTime,
+    pub end: NaiveTime,
+}
+
+impl TimeRange {
+    /// Parse time range from HHMM format strings
+    pub fn from_hhmm(start: &str, end: &str) -> Option<Self> {
+        let start_time = Self::parse_hhmm(start)?;
+        let end_time = Self::parse_hhmm(end)?;
+
+        Some(TimeRange {
+            start: start_time,
+            end: end_time,
+        })
+    }
+
+    /// Parse HHMM format string to NaiveTime
+    fn parse_hhmm(time_str: &str) -> Option<NaiveTime> {
+        if time_str.len() != 4 {
+            return None;
+        }
+
+        let hours = time_str[..2].parse::<u32>().ok()?;
+        let minutes = time_str[2..].parse::<u32>().ok()?;
+
+        if hours > 23 || minutes > 59 {
+            return None;
+        }
+
+        NaiveTime::from_hms_opt(hours, minutes, 0)
+    }
+
+    /// Format time in 12-hour format
+    pub fn format_12hr(&self) -> String {
+        format!(
+            "{}-{}",
+            Self::format_time_12hr(self.start),
+            Self::format_time_12hr(self.end)
+        )
+    }
+
+    /// Format a single time in 12-hour format
+    fn format_time_12hr(time: NaiveTime) -> String {
+        let hour = time.hour();
+        let minute = time.minute();
+
+        let meridiem = if hour < 12 { "AM" } else { "PM" };
+        format!("{hour}:{minute:02}{meridiem}")
+    }
+
+    /// Get duration in minutes
+    #[allow(dead_code)]
+    pub fn duration_minutes(&self) -> i64 {
+        let start_minutes = self.start.hour() as i64 * 60 + self.start.minute() as i64;
+        let end_minutes = self.end.hour() as i64 * 60 + self.end.minute() as i64;
+        end_minutes - start_minutes
+    }
+}
+
+impl PartialOrd for TimeRange {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.start.cmp(&other.start))
+    }
+}
+
+/// Date range for meetings
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DateRange {
+    pub start: NaiveDate,
+    pub end: NaiveDate,
+}
+
+impl DateRange {
+    /// Parse date range from MM/DD/YYYY format strings
+    pub fn from_mm_dd_yyyy(start: &str, end: &str) -> Option<Self> {
+        let start_date = Self::parse_mm_dd_yyyy(start)?;
+        let end_date = Self::parse_mm_dd_yyyy(end)?;
+
+        Some(DateRange {
+            start: start_date,
+            end: end_date,
+        })
+    }
+
+    /// Parse MM/DD/YYYY format string to NaiveDate
+    fn parse_mm_dd_yyyy(date_str: &str) -> Option<NaiveDate> {
+        NaiveDate::parse_from_str(date_str, "%m/%d/%Y").ok()
+    }
+
+    /// Get the number of weeks between start and end dates
+    pub fn weeks_duration(&self) -> u32 {
+        let duration = self.end.signed_duration_since(self.start);
+        duration.num_weeks() as u32
+    }
+
+    /// Check if a specific date falls within this range
+    #[allow(dead_code)]
+    pub fn contains_date(&self, date: NaiveDate) -> bool {
+        date >= self.start && date <= self.end
+    }
+}
+
+/// Meeting schedule type enum
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum MeetingType {
+    HybridBlended,      // HB, H2, H1
+    OnlineSynchronous,  // OS
+    OnlineAsynchronous, // OA
+    OnlineHybrid,       // OH
+    IndependentStudy,   // ID
+    FaceToFace,         // FF
+    Unknown(String),
+}
+
+impl MeetingType {
+    /// Parse from the meeting type string
+    pub fn from_string(s: &str) -> Self {
+        match s {
+            "HB" | "H2" | "H1" => MeetingType::HybridBlended,
+            "OS" => MeetingType::OnlineSynchronous,
+            "OA" => MeetingType::OnlineAsynchronous,
+            "OH" => MeetingType::OnlineHybrid,
+            "ID" => MeetingType::IndependentStudy,
+            "FF" => MeetingType::FaceToFace,
+            other => MeetingType::Unknown(other.to_string()),
+        }
+    }
+
+    /// Get description for the meeting type
+    pub fn description(&self) -> &'static str {
+        match self {
+            MeetingType::HybridBlended => "Hybrid",
+            MeetingType::OnlineSynchronous => "Online Only",
+            MeetingType::OnlineAsynchronous => "Online Asynchronous",
+            MeetingType::OnlineHybrid => "Online Partial",
+            MeetingType::IndependentStudy => "To Be Arranged",
+            MeetingType::FaceToFace => "Face to Face",
+            MeetingType::Unknown(_) => "Unknown",
+        }
+    }
+}
+
+/// Meeting location information
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum MeetingLocation {
+    Online,
+    InPerson {
+        campus: String,
+        campus_description: String,
+        building: String,
+        building_description: String,
+        room: String,
+    },
+}
+
+impl MeetingLocation {
+    /// Create from raw MeetingTime data
+    pub fn from_meeting_time(meeting_time: &MeetingTime) -> Self {
+        if meeting_time.campus.is_none()
+            || meeting_time.building.is_none()
+            || meeting_time.building_description.is_none()
+            || meeting_time.room.is_none()
+            || meeting_time.campus_description.is_none()
+            || meeting_time
+                .campus_description
+                .eq(&Some("Internet".to_string()))
+        {
+            return MeetingLocation::Online;
+        }
+
+        MeetingLocation::InPerson {
+            campus: meeting_time.campus.as_ref().unwrap().clone(),
+            campus_description: meeting_time.campus_description.as_ref().unwrap().clone(),
+            building: meeting_time.building.as_ref().unwrap().clone(),
+            building_description: meeting_time.building_description.as_ref().unwrap().clone(),
+            room: meeting_time.room.as_ref().unwrap().clone(),
+        }
+    }
+}
+
+impl Display for MeetingLocation {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            MeetingLocation::Online => write!(f, "Online"),
+            MeetingLocation::InPerson {
+                campus,
+                building,
+                building_description,
+                room,
+                ..
+            } => write!(
+                f,
+                "{campus} | {building_name} | {building_code} {room}",
+                building_name = building_description,
+                building_code = building,
+            ),
+        }
+    }
+}
+
+/// Clean, parsed meeting schedule information
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MeetingScheduleInfo {
+    pub days: MeetingDays,
+    pub time_range: Option<TimeRange>,
+    pub date_range: DateRange,
+    pub meeting_type: MeetingType,
+    pub location: MeetingLocation,
+    pub duration_weeks: u32,
+}
+
+impl MeetingScheduleInfo {
+    /// Create from raw MeetingTime data
+    pub fn from_meeting_time(meeting_time: &MeetingTime) -> Self {
+        let days = MeetingDays::from_meeting_time(meeting_time);
+        let time_range = match (&meeting_time.begin_time, &meeting_time.end_time) {
+            (Some(begin), Some(end)) => TimeRange::from_hhmm(begin, end),
+            _ => None,
+        };
+
+        let date_range =
+            DateRange::from_mm_dd_yyyy(&meeting_time.start_date, &meeting_time.end_date)
+                .unwrap_or_else(|| {
+                    // Fallback to current date if parsing fails
+                    let now = chrono::Utc::now().naive_utc().date();
+                    DateRange {
+                        start: now,
+                        end: now,
+                    }
+                });
+        let meeting_type = MeetingType::from_string(&meeting_time.meeting_type);
+        let location = MeetingLocation::from_meeting_time(meeting_time);
+        let duration_weeks = date_range.weeks_duration();
+
+        MeetingScheduleInfo {
+            days,
+            time_range,
+            date_range,
+            meeting_type,
+            location,
+            duration_weeks,
+        }
+    }
+
+    /// Convert the meeting days bitset to a enum vector
+    pub fn days_of_week(&self) -> Vec<DayOfWeek> {
+        self.days
+            .iter()
+            .map(|day| <MeetingDays as TryInto<DayOfWeek>>::try_into(day).unwrap())
+            .collect()
+    }
+
+    /// Get formatted days string
+    pub fn days_string(&self) -> Option<String> {
+        if self.days.is_empty() {
+            return None;
+        }
+        if self.days.is_all() {
+            return Some("Everyday".to_string());
+        }
+
+        let days_of_week = self.days_of_week();
+        if days_of_week.len() == 1 {
+            return Some(days_of_week[0].to_full_string().to_string());
+        }
+
+        // Mapper function to get the short string representation of the day of week
+        let mapper = {
+            let ambiguous = self.days.intersects(
+                MeetingDays::Tuesday
+                    | MeetingDays::Thursday
+                    | MeetingDays::Saturday
+                    | MeetingDays::Sunday,
+            );
+
+            if ambiguous {
+                |day: &DayOfWeek| day.to_short_string().to_string()
+            } else {
+                |day: &DayOfWeek| day.to_short_string().chars().next().unwrap().to_string()
+            }
+        };
+
+        Some(days_of_week.iter().map(mapper).collect::<String>())
+    }
+
+    /// Returns a formatted string representing the location of the meeting
+    pub fn place_string(&self) -> String {
+        match &self.location {
+            MeetingLocation::Online => "Online".to_string(),
+            MeetingLocation::InPerson {
+                campus,
+                building,
+                building_description,
+                room,
+                ..
+            } => format!(
+                "{} | {} | {} {}",
+                campus, building_description, building, room
+            ),
+        }
+    }
+
+    /// Get the start and end date times for the meeting
+    ///
+    /// Uses the start and end times of the meeting if available, otherwise defaults to midnight (00:00:00.000).
+    ///
+    /// The returned times are in UTC.
+    pub fn datetime_range(&self) -> (DateTime<Utc>, DateTime<Utc>) {
+        let (start, end) = if let Some(time_range) = &self.time_range {
+            let start = self.date_range.start.and_time(time_range.start);
+            let end = self.date_range.end.and_time(time_range.end);
+            (start, end)
+        } else {
+            (
+                self.date_range.start.and_hms_opt(0, 0, 0).unwrap(),
+                self.date_range.end.and_hms_opt(0, 0, 0).unwrap(),
+            )
+        };
+
+        (start.and_utc(), end.and_utc())
+    }
+}
+
+impl PartialEq for MeetingScheduleInfo {
+    fn eq(&self, other: &Self) -> bool {
+        self.days == other.days && self.time_range == other.time_range
+    }
+}
+
+impl PartialOrd for MeetingScheduleInfo {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match (&self.time_range, &other.time_range) {
+            (Some(self_time), Some(other_time)) => self_time.partial_cmp(other_time),
+            (None, None) => Some(self.days.partial_cmp(&other.days).unwrap()),
+            (Some(_), None) => Some(Ordering::Less),
+            (None, Some(_)) => Some(Ordering::Greater),
+        }
+    }
+}
+
+/// API response wrapper for meeting times
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MeetingTimesApiResponse {
+    pub fmt: Vec<MeetingTimeResponse>,
+}
+
+/// Meeting time response wrapper
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MeetingTimeResponse {
+    pub category: Option<String>,
+    pub class: String,
+    pub course_reference_number: String,
+    #[serde(default)]
+    pub faculty: Vec<FacultyItem>,
+    pub meeting_time: MeetingTime,
+    pub term: String,
+}
+
+impl MeetingTimeResponse {
+    /// Get parsed meeting schedule information
+    pub fn schedule_info(&self) -> MeetingScheduleInfo {
+        MeetingScheduleInfo::from_meeting_time(&self.meeting_time)
+    }
+}

src/banner/models/mod.rs

@@ -0,0 +1,14 @@
+//! Data models for the Banner API.
+
+pub mod common;
+pub mod courses;
+pub mod meetings;
+pub mod search;
+pub mod terms;
+
+// Re-export commonly used types
+pub use common::*;
+pub use courses::*;
+pub use meetings::*;
+pub use search::*;
+pub use terms::*;

src/banner/models/search.rs

@@ -0,0 +1,23 @@
+use serde::{Deserialize, Serialize};
+
+use super::courses::Course;
+
+/// Search result wrapper
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SearchResult {
+    pub success: bool,
+    pub total_count: i32,
+    pub page_offset: i32,
+    pub page_max_size: i32,
+    pub path_mode: Option<String>,
+    pub search_results_config: Option<Vec<SearchResultConfig>>,
+    pub data: Option<Vec<Course>>,
+}
+
+/// Search result configuration
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SearchResultConfig {
+    pub config: String,
+    pub display: String,
+}

src/banner/models/terms.rs

@@ -0,0 +1,242 @@
+use std::{ops::RangeInclusive, str::FromStr};
+
+use anyhow::Context;
+use chrono::{Datelike, Local, NaiveDate};
+use serde::{Deserialize, Serialize};
+
+/// The current year at the time of compilation
+const CURRENT_YEAR: u32 = compile_time::date!().year() as u32;
+
+/// The valid years for terms
+/// We set a semi-static upper limit to avoid having to update this value while also keeping a tight bound
+/// TODO: Recheck the lower bound, it's just a guess right now.
+const VALID_YEARS: RangeInclusive<u32> = 2007..=(CURRENT_YEAR + 10);
+
+/// Represents a term in the Banner system
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub struct Term {
+    pub year: u32, // 2024, 2025, etc
+    pub season: Season,
+}
+
+/// Represents the term status at a specific point in time
+#[derive(Debug, Clone)]
+pub enum TermPoint {
+    /// Currently in a term
+    InTerm { current: Term },
+    /// Between terms, with the next term specified
+    BetweenTerms { next: Term },
+}
+
+/// Represents a season within a term
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub enum Season {
+    Fall,
+    Spring,
+    Summer,
+}
+
+impl Term {
+    /// Returns the current term status - either currently in a term or between terms
+    pub fn get_current() -> TermPoint {
+        let now = Local::now().naive_local();
+        Self::get_status_for_date(now.date())
+    }
+
+    /// Returns the current term status for a specific date
+    pub fn get_status_for_date(date: NaiveDate) -> TermPoint {
+        let literal_year = date.year() as u32;
+        let day_of_year = date.ordinal();
+        let ranges = Self::get_season_ranges(literal_year);
+
+        // If we're past the end of the summer term, we're 'in' the next school year.
+        let term_year = if day_of_year > ranges.summer.end {
+            literal_year + 1
+        } else {
+            literal_year
+        };
+
+        if (day_of_year < ranges.spring.start) || (day_of_year >= ranges.fall.end) {
+            // Fall over, Spring not yet begun
+            TermPoint::BetweenTerms {
+                next: Term {
+                    year: term_year,
+                    season: Season::Spring,
+                },
+            }
+        } else if (day_of_year >= ranges.spring.start) && (day_of_year < ranges.spring.end) {
+            // Spring
+            TermPoint::InTerm {
+                current: Term {
+                    year: term_year,
+                    season: Season::Spring,
+                },
+            }
+        } else if day_of_year < ranges.summer.start {
+            // Spring over, Summer not yet begun
+            TermPoint::BetweenTerms {
+                next: Term {
+                    year: term_year,
+                    season: Season::Summer,
+                },
+            }
+        } else if (day_of_year >= ranges.summer.start) && (day_of_year < ranges.summer.end) {
+            // Summer
+            TermPoint::InTerm {
+                current: Term {
+                    year: term_year,
+                    season: Season::Summer,
+                },
+            }
+        } else if day_of_year < ranges.fall.start {
+            // Summer over, Fall not yet begun
+            TermPoint::BetweenTerms {
+                next: Term {
+                    year: term_year,
+                    season: Season::Fall,
+                },
+            }
+        } else if (day_of_year >= ranges.fall.start) && (day_of_year < ranges.fall.end) {
+            // Fall
+            TermPoint::InTerm {
+                current: Term {
+                    year: term_year,
+                    season: Season::Fall,
+                },
+            }
+        } else {
+            // This should never happen, but Rust requires exhaustive matching
+            panic!("Impossible code reached (dayOfYear: {})", day_of_year);
+        }
+    }
+
+    /// Returns the start and end day of each term for the given year.
+    /// The ranges are inclusive of the start day and exclusive of the end day.
+    fn get_season_ranges(year: u32) -> SeasonRanges {
+        let spring_start = NaiveDate::from_ymd_opt(year as i32, 1, 14)
+            .unwrap()
+            .ordinal();
+        let spring_end = NaiveDate::from_ymd_opt(year as i32, 5, 1)
+            .unwrap()
+            .ordinal();
+        let summer_start = NaiveDate::from_ymd_opt(year as i32, 5, 25)
+            .unwrap()
+            .ordinal();
+        let summer_end = NaiveDate::from_ymd_opt(year as i32, 8, 15)
+            .unwrap()
+            .ordinal();
+        let fall_start = NaiveDate::from_ymd_opt(year as i32, 8, 18)
+            .unwrap()
+            .ordinal();
+        let fall_end = NaiveDate::from_ymd_opt(year as i32, 12, 10)
+            .unwrap()
+            .ordinal();
+
+        SeasonRanges {
+            spring: YearDayRange {
+                start: spring_start,
+                end: spring_end,
+            },
+            summer: YearDayRange {
+                start: summer_start,
+                end: summer_end,
+            },
+            fall: YearDayRange {
+                start: fall_start,
+                end: fall_end,
+            },
+        }
+    }
+}
+
+impl TermPoint {
+    /// Returns the inner Term regardless of the status
+    pub fn inner(&self) -> &Term {
+        match self {
+            TermPoint::InTerm { current } => current,
+            TermPoint::BetweenTerms { next } => next,
+        }
+    }
+}
+
+/// Represents the start and end day of each term within a year
+#[derive(Debug, Clone)]
+struct SeasonRanges {
+    spring: YearDayRange,
+    summer: YearDayRange,
+    fall: YearDayRange,
+}
+
+/// Represents the start and end day of a term within a year
+#[derive(Debug, Clone)]
+struct YearDayRange {
+    start: u32,
+    end: u32,
+}
+
+impl std::fmt::Display for Term {
+    /// Returns the term in the format YYYYXX, where YYYY is the year and XX is the season code
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{year}{season}",
+            year = self.year,
+            season = self.season.to_str()
+        )
+    }
+}
+
+impl Season {
+    /// Returns the season code as a string
+    fn to_str(self) -> &'static str {
+        match self {
+            Season::Fall => "10",
+            Season::Spring => "20",
+            Season::Summer => "30",
+        }
+    }
+}
+
+impl std::fmt::Display for Season {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Season::Fall => write!(f, "Fall"),
+            Season::Spring => write!(f, "Spring"),
+            Season::Summer => write!(f, "Summer"),
+        }
+    }
+}
+
+impl FromStr for Season {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let season = match s {
+            "10" => Season::Fall,
+            "20" => Season::Spring,
+            "30" => Season::Summer,
+            _ => return Err(anyhow::anyhow!("Invalid season: {s}")),
+        };
+        Ok(season)
+    }
+}
+
+impl FromStr for Term {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s.len() != 6 {
+            return Err(anyhow::anyhow!("Term string must be 6 characters"));
+        }
+
+        let year = s[0..4].parse::<u32>().context("Failed to parse year")?;
+        if !VALID_YEARS.contains(&year) {
+            return Err(anyhow::anyhow!("Year out of range"));
+        }
+
+        let season =
+            Season::from_str(&s[4..6]).map_err(|e| anyhow::anyhow!("Invalid season: {}", e))?;
+
+        Ok(Term { year, season })
+    }
+}

src/banner/query.rs

@@ -0,0 +1,335 @@
+//! Query builder for Banner API course searches.
+
+use std::collections::HashMap;
+use std::time::Duration;
+
+/// Range of two integers
+#[derive(Debug, Clone)]
+pub struct Range {
+    pub low: i32,
+    pub high: i32,
+}
+
+/// Builder for constructing Banner API search queries
+#[derive(Debug, Clone, Default)]
+pub struct SearchQuery {
+    subject: Option<String>,
+    title: Option<String>,
+    keywords: Option<Vec<String>>,
+    course_reference_number: Option<String>,
+    open_only: Option<bool>,
+    term_part: Option<Vec<String>>,
+    campus: Option<Vec<String>>,
+    instructional_method: Option<Vec<String>>,
+    attributes: Option<Vec<String>>,
+    instructor: Option<Vec<u64>>,
+    start_time: Option<Duration>,
+    end_time: Option<Duration>,
+    min_credits: Option<i32>,
+    max_credits: Option<i32>,
+    offset: i32,
+    max_results: i32,
+    course_number_range: Option<Range>,
+}
+
+#[allow(dead_code)]
+impl SearchQuery {
+    /// Creates a new SearchQuery with default values
+    pub fn new() -> Self {
+        Self {
+            max_results: 8,
+            offset: 0,
+            ..Default::default()
+        }
+    }
+
+    /// Sets the subject for the query
+    pub fn subject<S: Into<String>>(mut self, subject: S) -> Self {
+        self.subject = Some(subject.into());
+        self
+    }
+
+    /// Sets the title for the query
+    pub fn title<S: Into<String>>(mut self, title: S) -> Self {
+        self.title = Some(title.into());
+        self
+    }
+
+    /// Sets the course reference number (CRN) for the query
+    pub fn course_reference_number<S: Into<String>>(mut self, crn: S) -> Self {
+        self.course_reference_number = Some(crn.into());
+        self
+    }
+
+    /// Sets the keywords for the query
+    pub fn keywords(mut self, keywords: Vec<String>) -> Self {
+        self.keywords = Some(keywords);
+        self
+    }
+
+    /// Adds a keyword to the query
+    pub fn keyword<S: Into<String>>(mut self, keyword: S) -> Self {
+        match &mut self.keywords {
+            Some(keywords) => keywords.push(keyword.into()),
+            None => self.keywords = Some(vec![keyword.into()]),
+        }
+        self
+    }
+
+    /// Sets whether to search for open courses only
+    pub fn open_only(mut self, open_only: bool) -> Self {
+        self.open_only = Some(open_only);
+        self
+    }
+
+    /// Sets the term part for the query
+    pub fn term_part(mut self, term_part: Vec<String>) -> Self {
+        self.term_part = Some(term_part);
+        self
+    }
+
+    /// Sets the campuses for the query
+    pub fn campus(mut self, campus: Vec<String>) -> Self {
+        self.campus = Some(campus);
+        self
+    }
+
+    /// Sets the instructional methods for the query
+    pub fn instructional_method(mut self, instructional_method: Vec<String>) -> Self {
+        self.instructional_method = Some(instructional_method);
+        self
+    }
+
+    /// Sets the attributes for the query
+    pub fn attributes(mut self, attributes: Vec<String>) -> Self {
+        self.attributes = Some(attributes);
+        self
+    }
+
+    /// Sets the instructors for the query
+    pub fn instructor(mut self, instructor: Vec<u64>) -> Self {
+        self.instructor = Some(instructor);
+        self
+    }
+
+    /// Sets the start time for the query
+    pub fn start_time(mut self, start_time: Duration) -> Self {
+        self.start_time = Some(start_time);
+        self
+    }
+
+    /// Sets the end time for the query
+    pub fn end_time(mut self, end_time: Duration) -> Self {
+        self.end_time = Some(end_time);
+        self
+    }
+
+    /// Sets the credit range for the query
+    pub fn credits(mut self, low: i32, high: i32) -> Self {
+        self.min_credits = Some(low);
+        self.max_credits = Some(high);
+        self
+    }
+
+    /// Sets the minimum credits for the query
+    pub fn min_credits(mut self, value: i32) -> Self {
+        self.min_credits = Some(value);
+        self
+    }
+
+    /// Sets the maximum credits for the query
+    pub fn max_credits(mut self, value: i32) -> Self {
+        self.max_credits = Some(value);
+        self
+    }
+
+    /// Sets the course number range for the query
+    pub fn course_numbers(mut self, low: i32, high: i32) -> Self {
+        self.course_number_range = Some(Range { low, high });
+        self
+    }
+
+    /// Sets the offset for pagination
+    pub fn offset(mut self, offset: i32) -> Self {
+        self.offset = offset;
+        self
+    }
+
+    /// Sets the maximum number of results to return
+    pub fn max_results(mut self, max_results: i32) -> Self {
+        self.max_results = max_results;
+        self
+    }
+
+    /// Gets the subject field
+    pub fn get_subject(&self) -> Option<&String> {
+        self.subject.as_ref()
+    }
+
+    /// Gets the max_results field
+    pub fn get_max_results(&self) -> i32 {
+        self.max_results
+    }
+
+    /// Converts the query into URL parameters for the Banner API
+    pub fn to_params(&self) -> HashMap<String, String> {
+        let mut params = HashMap::new();
+
+        if let Some(ref subject) = self.subject {
+            params.insert("txt_subject".to_string(), subject.clone());
+        }
+
+        if let Some(ref title) = self.title {
+            params.insert("txt_courseTitle".to_string(), title.trim().to_string());
+        }
+
+        if let Some(ref crn) = self.course_reference_number {
+            params.insert("txt_courseReferenceNumber".to_string(), crn.clone());
+        }
+
+        if let Some(ref keywords) = self.keywords {
+            params.insert("txt_keywordlike".to_string(), keywords.join(" "));
+        }
+
+        if self.open_only.is_some() {
+            params.insert("chk_open_only".to_string(), "true".to_string());
+        }
+
+        if let Some(ref term_part) = self.term_part {
+            params.insert("txt_partOfTerm".to_string(), term_part.join(","));
+        }
+
+        if let Some(ref campus) = self.campus {
+            params.insert("txt_campus".to_string(), campus.join(","));
+        }
+
+        if let Some(ref attributes) = self.attributes {
+            params.insert("txt_attribute".to_string(), attributes.join(","));
+        }
+
+        if let Some(ref instructor) = self.instructor {
+            let instructor_str = instructor
+                .iter()
+                .map(|i| i.to_string())
+                .collect::<Vec<_>>()
+                .join(",");
+            params.insert("txt_instructor".to_string(), instructor_str);
+        }
+
+        if let Some(start_time) = self.start_time {
+            let (hour, minute, meridiem) = format_time_parameter(start_time);
+            params.insert("select_start_hour".to_string(), hour);
+            params.insert("select_start_min".to_string(), minute);
+            params.insert("select_start_ampm".to_string(), meridiem);
+        }
+
+        if let Some(end_time) = self.end_time {
+            let (hour, minute, meridiem) = format_time_parameter(end_time);
+            params.insert("select_end_hour".to_string(), hour);
+            params.insert("select_end_min".to_string(), minute);
+            params.insert("select_end_ampm".to_string(), meridiem);
+        }
+
+        if let Some(min_credits) = self.min_credits {
+            params.insert("txt_credithourlow".to_string(), min_credits.to_string());
+        }
+
+        if let Some(max_credits) = self.max_credits {
+            params.insert("txt_credithourhigh".to_string(), max_credits.to_string());
+        }
+
+        if let Some(ref range) = self.course_number_range {
+            params.insert("txt_course_number_range".to_string(), range.low.to_string());
+            params.insert(
+                "txt_course_number_range_to".to_string(),
+                range.high.to_string(),
+            );
+        }
+
+        params.insert("pageOffset".to_string(), self.offset.to_string());
+        params.insert("pageMaxSize".to_string(), self.max_results.to_string());
+
+        params
+    }
+}
+
+/// Formats a Duration into hour, minute, and meridiem strings for Banner API
+fn format_time_parameter(duration: Duration) -> (String, String, String) {
+    let total_minutes = duration.as_secs() / 60;
+    let hours = total_minutes / 60;
+    let minutes = total_minutes % 60;
+
+    let minute_str = minutes.to_string();
+
+    if hours >= 12 {
+        let meridiem = "PM".to_string();
+        let hour_str = if hours >= 13 {
+            (hours - 12).to_string()
+        } else {
+            hours.to_string()
+        };
+        (hour_str, minute_str, meridiem)
+    } else {
+        let meridiem = "AM".to_string();
+        let hour_str = hours.to_string();
+        (hour_str, minute_str, meridiem)
+    }
+}
+
+impl std::fmt::Display for SearchQuery {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut parts = Vec::new();
+
+        if let Some(ref subject) = self.subject {
+            parts.push(format!("subject={subject}"));
+        }
+        if let Some(ref title) = self.title {
+            parts.push(format!("title={}", title.trim()));
+        }
+        if let Some(ref keywords) = self.keywords {
+            parts.push(format!("keywords={}", keywords.join(" ")));
+        }
+        if self.open_only.is_some() {
+            parts.push("openOnly=true".to_string());
+        }
+        if let Some(ref term_part) = self.term_part {
+            parts.push(format!("termPart={}", term_part.join(",")));
+        }
+        if let Some(ref campus) = self.campus {
+            parts.push(format!("campus={}", campus.join(",")));
+        }
+        if let Some(ref attributes) = self.attributes {
+            parts.push(format!("attributes={}", attributes.join(",")));
+        }
+        if let Some(ref instructor) = self.instructor {
+            let instructor_str = instructor
+                .iter()
+                .map(|i| i.to_string())
+                .collect::<Vec<_>>()
+                .join(",");
+            parts.push(format!("instructor={instructor_str}"));
+        }
+        if let Some(start_time) = self.start_time {
+            let (hour, minute, meridiem) = format_time_parameter(start_time);
+            parts.push(format!("startTime={hour}:{minute}:{meridiem}"));
+        }
+        if let Some(end_time) = self.end_time {
+            let (hour, minute, meridiem) = format_time_parameter(end_time);
+            parts.push(format!("endTime={hour}:{minute}:{meridiem}"));
+        }
+        if let Some(min_credits) = self.min_credits {
+            parts.push(format!("minCredits={min_credits}"));
+        }
+        if let Some(max_credits) = self.max_credits {
+            parts.push(format!("maxCredits={max_credits}"));
+        }
+        if let Some(ref range) = self.course_number_range {
+            parts.push(format!("courseNumberRange={}-{}", range.low, range.high));
+        }
+
+        parts.push(format!("offset={}", self.offset));
+        parts.push(format!("maxResults={}", self.max_results));
+
+        write!(f, "{}", parts.join(", "))
+    }
+}

src/banner/rate_limit_middleware.rs

@@ -0,0 +1,84 @@
+//! HTTP middleware that enforces rate limiting for Banner API requests.
+
+use crate::banner::rate_limiter::{RequestType, SharedRateLimiter};
+use http::Extensions;
+use reqwest::{Request, Response};
+use reqwest_middleware::{Middleware, Next};
+use tracing::debug;
+use url::Url;
+
+/// Middleware that enforces rate limiting based on request URL patterns
+pub struct RateLimitMiddleware {
+    rate_limiter: SharedRateLimiter,
+}
+
+impl RateLimitMiddleware {
+    /// Creates a new rate limiting middleware
+    pub fn new(rate_limiter: SharedRateLimiter) -> Self {
+        Self { rate_limiter }
+    }
+
+    /// Returns a human-readable description of the rate limit for a request type
+    fn get_rate_limit_description(request_type: RequestType) -> &'static str {
+        match request_type {
+            RequestType::Session => "6 rpm (~10s interval)",
+            RequestType::Search => "30 rpm (~2s interval)",
+            RequestType::Metadata => "20 rpm (~3s interval)",
+            RequestType::Reset => "10 rpm (~6s interval)",
+        }
+    }
+
+    /// Determines the request type based on the URL path
+    fn get_request_type(url: &Url) -> RequestType {
+        let path = url.path();
+
+        if path.contains("/registration")
+            || path.contains("/selfServiceMenu")
+            || path.contains("/term/termSelection")
+        {
+            RequestType::Session
+        } else if path.contains("/searchResults") || path.contains("/classSearch") {
+            RequestType::Search
+        } else if path.contains("/getTerms")
+            || path.contains("/getSubjects")
+            || path.contains("/getCampuses")
+        {
+            RequestType::Metadata
+        } else if path.contains("/resetDataForm") {
+            RequestType::Reset
+        } else {
+            // Default to search for unknown endpoints
+            RequestType::Search
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl Middleware for RateLimitMiddleware {
+    async fn handle(
+        &self,
+        req: Request,
+        extensions: &mut Extensions,
+        next: Next<'_>,
+    ) -> std::result::Result<Response, reqwest_middleware::Error> {
+        let request_type = Self::get_request_type(req.url());
+
+        let start = std::time::Instant::now();
+        self.rate_limiter.wait_for_permission(request_type).await;
+        let wait_duration = start.elapsed();
+
+        // Only log if rate limiting caused significant delay (>= 500ms)
+        if wait_duration.as_millis() >= 500 {
+            let limit_desc = Self::get_rate_limit_description(request_type);
+            debug!(
+                request_type = ?request_type,
+                wait_ms = wait_duration.as_millis(),
+                rate_limit = limit_desc,
+                "Rate limit caused delay"
+            );
+        }
+
+        // Make the actual request
+        next.run(req, extensions).await
+    }
+}

src/banner/rate_limiter.rs

@@ -0,0 +1,131 @@
+//! Rate limiting for Banner API requests to prevent overwhelming the server.
+
+use governor::{
+    Quota, RateLimiter,
+    clock::DefaultClock,
+    state::{InMemoryState, NotKeyed},
+};
+use std::num::NonZeroU32;
+use std::sync::Arc;
+use std::time::Duration;
+
+/// Different types of Banner API requests with different rate limits
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum RequestType {
+    /// Session creation and management (very conservative)
+    Session,
+    /// Course search requests (moderate)
+    Search,
+    /// Term and metadata requests (moderate)
+    Metadata,
+    /// Data form resets (low priority)
+    Reset,
+}
+
+/// Rate limiter configuration for different request types
+#[derive(Debug, Clone)]
+pub struct RateLimitConfig {
+    /// Requests per minute for session operations
+    pub session_rpm: u32,
+    /// Requests per minute for search operations
+    pub search_rpm: u32,
+    /// Requests per minute for metadata operations
+    pub metadata_rpm: u32,
+    /// Requests per minute for reset operations
+    pub reset_rpm: u32,
+    /// Burst allowance (extra requests allowed in short bursts)
+    pub burst_allowance: u32,
+}
+
+impl Default for RateLimitConfig {
+    fn default() -> Self {
+        Self {
+            // Very conservative for session creation
+            session_rpm: 6, // 1 every 10 seconds
+            // Moderate for search operations
+            search_rpm: 30, // 1 every 2 seconds
+            // Moderate for metadata
+            metadata_rpm: 20, // 1 every 3 seconds
+            // Low for resets
+            reset_rpm: 10, // 1 every 6 seconds
+            // Allow small bursts
+            burst_allowance: 3,
+        }
+    }
+}
+
+/// A rate limiter that manages different request types with different limits
+pub struct BannerRateLimiter {
+    session_limiter: RateLimiter<NotKeyed, InMemoryState, DefaultClock>,
+    search_limiter: RateLimiter<NotKeyed, InMemoryState, DefaultClock>,
+    metadata_limiter: RateLimiter<NotKeyed, InMemoryState, DefaultClock>,
+    reset_limiter: RateLimiter<NotKeyed, InMemoryState, DefaultClock>,
+}
+
+impl BannerRateLimiter {
+    /// Creates a new rate limiter with the given configuration
+    pub fn new(config: RateLimitConfig) -> Self {
+        let session_quota = Quota::with_period(Duration::from_secs(60) / config.session_rpm)
+            .unwrap()
+            .allow_burst(NonZeroU32::new(config.burst_allowance).unwrap());
+
+        let search_quota = Quota::with_period(Duration::from_secs(60) / config.search_rpm)
+            .unwrap()
+            .allow_burst(NonZeroU32::new(config.burst_allowance).unwrap());
+
+        let metadata_quota = Quota::with_period(Duration::from_secs(60) / config.metadata_rpm)
+            .unwrap()
+            .allow_burst(NonZeroU32::new(config.burst_allowance).unwrap());
+
+        let reset_quota = Quota::with_period(Duration::from_secs(60) / config.reset_rpm)
+            .unwrap()
+            .allow_burst(NonZeroU32::new(config.burst_allowance).unwrap());
+
+        Self {
+            session_limiter: RateLimiter::direct(session_quota),
+            search_limiter: RateLimiter::direct(search_quota),
+            metadata_limiter: RateLimiter::direct(metadata_quota),
+            reset_limiter: RateLimiter::direct(reset_quota),
+        }
+    }
+
+    /// Waits for permission to make a request of the given type
+    pub async fn wait_for_permission(&self, request_type: RequestType) {
+        let limiter = match request_type {
+            RequestType::Session => &self.session_limiter,
+            RequestType::Search => &self.search_limiter,
+            RequestType::Metadata => &self.metadata_limiter,
+            RequestType::Reset => &self.reset_limiter,
+        };
+
+        // Wait until we can make the request (logging handled by middleware)
+        limiter.until_ready().await;
+    }
+}
+
+impl Default for BannerRateLimiter {
+    fn default() -> Self {
+        Self::new(RateLimitConfig::default())
+    }
+}
+
+/// A shared rate limiter instance
+pub type SharedRateLimiter = Arc<BannerRateLimiter>;
+
+/// Creates a new shared rate limiter with custom configuration
+pub fn create_shared_rate_limiter(config: Option<RateLimitConfig>) -> SharedRateLimiter {
+    Arc::new(BannerRateLimiter::new(config.unwrap_or_default()))
+}
+
+/// Conversion from config module's RateLimitingConfig to this module's RateLimitConfig
+impl From<crate::config::RateLimitingConfig> for RateLimitConfig {
+    fn from(config: crate::config::RateLimitingConfig) -> Self {
+        Self {
+            session_rpm: config.session_rpm,
+            search_rpm: config.search_rpm,
+            metadata_rpm: config.metadata_rpm,
+            reset_rpm: config.reset_rpm,
+            burst_allowance: config.burst_allowance,
+        }
+    }
+}

src/banner/session.rs

@@ -0,0 +1,478 @@
+//! Session management for Banner API.
+
+use crate::banner::BannerTerm;
+use crate::banner::models::Term;
+use anyhow::{Context, Result};
+use cookie::Cookie;
+use dashmap::DashMap;
+use governor::state::InMemoryState;
+use governor::{Quota, RateLimiter};
+use once_cell::sync::Lazy;
+use rand::distr::{Alphanumeric, SampleString};
+use reqwest_middleware::ClientWithMiddleware;
+use std::collections::{HashMap, VecDeque};
+use std::num::NonZeroU32;
+use std::ops::{Deref, DerefMut};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tokio::sync::{Mutex, Notify};
+use tracing::{debug, info, trace};
+use url::Url;
+
+const SESSION_EXPIRY: Duration = Duration::from_secs(25 * 60); // 25 minutes
+
+// A global rate limiter to ensure we only try to create one new session every 10 seconds,
+// preventing us from overwhelming the server with session creation requests.
+static SESSION_CREATION_RATE_LIMITER: Lazy<
+    RateLimiter<governor::state::direct::NotKeyed, InMemoryState, governor::clock::DefaultClock>,
+> = Lazy::new(|| RateLimiter::direct(Quota::with_period(Duration::from_secs(10)).unwrap()));
+
+/// Represents an active anonymous session within the Banner API.
+/// Identified by multiple persistent cookies, as well as a client-generated "unique session ID".
+#[derive(Debug, Clone)]
+pub struct BannerSession {
+    // Randomly generated
+    pub unique_session_id: String,
+    // Timestamp of creation
+    created_at: Instant,
+    // Timestamp of last activity
+    last_activity: Option<Instant>,
+    // Cookie values from initial registration page
+    jsessionid: String,
+    ssb_cookie: String,
+}
+
+/// Generates a new session ID mimicking Banner's format
+fn generate_session_id() -> String {
+    let random_part = Alphanumeric.sample_string(&mut rand::rng(), 5);
+    let timestamp = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_millis();
+    format!("{}{}", random_part, timestamp)
+}
+
+/// Generates a timestamp-based nonce
+pub fn nonce() -> String {
+    std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_millis()
+        .to_string()
+}
+
+impl BannerSession {
+    /// Creates a new session
+    pub async fn new(unique_session_id: &str, jsessionid: &str, ssb_cookie: &str) -> Result<Self> {
+        let now = Instant::now();
+
+        Ok(Self {
+            created_at: now,
+            last_activity: None,
+            unique_session_id: unique_session_id.to_string(),
+            jsessionid: jsessionid.to_string(),
+            ssb_cookie: ssb_cookie.to_string(),
+        })
+    }
+
+    /// Returns the unique session ID
+    pub fn id(&self) -> String {
+        self.unique_session_id.clone()
+    }
+
+    /// Updates the last activity timestamp
+    pub fn touch(&mut self) {
+        self.last_activity = Some(Instant::now());
+    }
+
+    /// Returns true if the session is expired
+    pub fn is_expired(&self) -> bool {
+        self.last_activity.unwrap_or(self.created_at).elapsed() > SESSION_EXPIRY
+    }
+
+    /// Returns a string used to for the "Cookie" header
+    pub fn cookie(&self) -> String {
+        format!(
+            "JSESSIONID={}; SSB_COOKIE={}",
+            self.jsessionid, self.ssb_cookie
+        )
+    }
+
+    pub fn been_used(&self) -> bool {
+        self.last_activity.is_some()
+    }
+}
+
+/// A smart pointer that returns a BannerSession to the pool when dropped.
+pub struct PooledSession {
+    session: Option<BannerSession>,
+    // This Arc points directly to the term-specific pool.
+    pool: Arc<TermPool>,
+}
+
+impl PooledSession {
+    pub fn been_used(&self) -> bool {
+        self.session.as_ref().unwrap().been_used()
+    }
+}
+
+impl Deref for PooledSession {
+    type Target = BannerSession;
+    fn deref(&self) -> &Self::Target {
+        // The option is only ever None after drop is called, so this is safe.
+        self.session.as_ref().unwrap()
+    }
+}
+
+impl DerefMut for PooledSession {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.session.as_mut().unwrap()
+    }
+}
+
+/// The magic happens here: when the guard goes out of scope, this is called.
+impl Drop for PooledSession {
+    fn drop(&mut self) {
+        if let Some(session) = self.session.take() {
+            let pool = self.pool.clone();
+            // Since drop() cannot be async, we spawn a task to return the session.
+            tokio::spawn(async move {
+                pool.release(session).await;
+            });
+        }
+    }
+}
+
+pub struct TermPool {
+    sessions: Mutex<VecDeque<BannerSession>>,
+    notifier: Notify,
+    is_creating: Mutex<bool>,
+}
+
+impl TermPool {
+    fn new() -> Self {
+        Self {
+            sessions: Mutex::new(VecDeque::new()),
+            notifier: Notify::new(),
+            is_creating: Mutex::new(false),
+        }
+    }
+
+    async fn release(&self, session: BannerSession) {
+        let id = session.unique_session_id.clone();
+        if session.is_expired() {
+            debug!(id = id, "Session expired, dropping");
+            // Wake up a waiter, as it might need to create a new session
+            // if this was the last one.
+            self.notifier.notify_one();
+            return;
+        }
+
+        let mut queue = self.sessions.lock().await;
+        queue.push_back(session);
+        drop(queue); // Release lock before notifying
+
+        self.notifier.notify_one();
+    }
+}
+
+pub struct SessionPool {
+    sessions: DashMap<Term, Arc<TermPool>>,
+    http: ClientWithMiddleware,
+    base_url: String,
+}
+
+impl SessionPool {
+    pub fn new(http: ClientWithMiddleware, base_url: String) -> Self {
+        Self {
+            sessions: DashMap::new(),
+            http,
+            base_url,
+        }
+    }
+
+    /// Acquires a session from the pool.
+    /// If no sessions are available, a new one is created on demand,
+    /// respecting the global rate limit.
+    pub async fn acquire(&self, term: Term) -> Result<PooledSession> {
+        let term_pool = self
+            .sessions
+            .entry(term)
+            .or_insert_with(|| Arc::new(TermPool::new()))
+            .clone();
+
+        let start = Instant::now();
+        let mut waited_for_creation = false;
+
+        loop {
+            // Fast path: Try to get an existing, non-expired session.
+            {
+                let mut queue = term_pool.sessions.lock().await;
+                if let Some(session) = queue.pop_front() {
+                    if !session.is_expired() {
+                        return Ok(PooledSession {
+                            session: Some(session),
+                            pool: Arc::clone(&term_pool),
+                        });
+                    } else {
+                        debug!(id = session.unique_session_id, "Discarded expired session");
+                    }
+                }
+            } // MutexGuard is dropped, lock is released.
+
+            // Slow path: No sessions available. We must either wait or become the creator.
+            let mut is_creating_guard = term_pool.is_creating.lock().await;
+            if *is_creating_guard {
+                // Another task is already creating a session. Release the lock and wait.
+                drop(is_creating_guard);
+                if !waited_for_creation {
+                    trace!("Waiting for another task to create session");
+                    waited_for_creation = true;
+                }
+                term_pool.notifier.notified().await;
+                // Loop back to the top to try the fast path again.
+                continue;
+            }
+
+            // This task is now the designated creator.
+            *is_creating_guard = true;
+            drop(is_creating_guard);
+
+            // Race: wait for a session to be returned OR for the rate limiter to allow a new one.
+            trace!("Pool empty, creating new session");
+            tokio::select! {
+                _ = term_pool.notifier.notified() => {
+                    // A session was returned while we were waiting!
+                    // We are no longer the creator. Reset the flag and loop to race for the new session.
+                    let mut guard = term_pool.is_creating.lock().await;
+                    *guard = false;
+                    drop(guard);
+                    continue;
+                }
+                _ = SESSION_CREATION_RATE_LIMITER.until_ready() => {
+                    // The rate limit has elapsed. It's our job to create the session.
+                    let new_session_result = self.create_session(&term).await;
+
+                    // After creation, we are no longer the creator. Reset the flag
+                    // and notify all other waiting tasks.
+                    let mut guard = term_pool.is_creating.lock().await;
+                    *guard = false;
+                    drop(guard);
+                    term_pool.notifier.notify_waiters();
+
+                    match new_session_result {
+                        Ok(new_session) => {
+                            let elapsed = start.elapsed();
+                            debug!(
+                                id = new_session.unique_session_id,
+                                elapsed_ms = elapsed.as_millis(),
+                                "Created new session"
+                            );
+                            return Ok(PooledSession {
+                                session: Some(new_session),
+                                pool: term_pool,
+                            });
+                        }
+                        Err(e) => {
+                            // Propagate the error if session creation failed.
+                            return Err(e.context("Failed to create new session in pool"));
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /// Sets up initial session cookies by making required Banner API requests
+    pub async fn create_session(&self, term: &Term) -> Result<BannerSession> {
+        info!(term = %term, "setting up banner session");
+
+        // The 'register' or 'search' registration page
+        let initial_registration = self
+            .http
+            .get(format!("{}/registration", self.base_url))
+            .send()
+            .await?;
+        // TODO: Validate success
+
+        let cookies = initial_registration
+            .headers()
+            .get_all("Set-Cookie")
+            .iter()
+            .filter_map(|header_value| {
+                if let Ok(cookie_str) = header_value.to_str() {
+                    if let Ok(cookie) = Cookie::parse(cookie_str) {
+                        Some((cookie.name().to_string(), cookie.value().to_string()))
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            })
+            .collect::<HashMap<String, String>>();
+
+        if !cookies.contains_key("JSESSIONID") || !cookies.contains_key("SSB_COOKIE") {
+            return Err(anyhow::anyhow!("Failed to get cookies"));
+        }
+
+        let jsessionid = cookies
+            .get("JSESSIONID")
+            .ok_or_else(|| anyhow::anyhow!("JSESSIONID cookie missing after validation"))?;
+        let ssb_cookie = cookies
+            .get("SSB_COOKIE")
+            .ok_or_else(|| anyhow::anyhow!("SSB_COOKIE cookie missing after validation"))?;
+        let cookie_header = format!("JSESSIONID={}; SSB_COOKIE={}", jsessionid, ssb_cookie);
+
+        self.http
+            .get(format!("{}/selfServiceMenu/data", self.base_url))
+            .header("Cookie", &cookie_header)
+            .send()
+            .await?
+            .error_for_status()
+            .context("Failed to get data page")?;
+
+        self.http
+            .get(format!("{}/term/termSelection", self.base_url))
+            .header("Cookie", &cookie_header)
+            .query(&[("mode", "search")])
+            .send()
+            .await?
+            .error_for_status()
+            .context("Failed to get term selection page")?;
+        // TOOD: Validate success
+
+        let terms = self.get_terms("", 1, 10).await?;
+        if !terms.iter().any(|t| t.code == term.to_string()) {
+            return Err(anyhow::anyhow!("Failed to get term search response"));
+        }
+
+        let specific_term_search_response = self.get_terms(&term.to_string(), 1, 10).await?;
+        if !specific_term_search_response
+            .iter()
+            .any(|t| t.code == term.to_string())
+        {
+            return Err(anyhow::anyhow!("Failed to get term search response"));
+        }
+
+        let unique_session_id = generate_session_id();
+        self.select_term(&term.to_string(), &unique_session_id, &cookie_header)
+            .await?;
+
+        BannerSession::new(&unique_session_id, jsessionid, ssb_cookie).await
+    }
+
+    /// Retrieves a list of terms from the Banner API.
+    pub async fn get_terms(
+        &self,
+        search: &str,
+        page: i32,
+        max_results: i32,
+    ) -> Result<Vec<BannerTerm>> {
+        if page <= 0 {
+            return Err(anyhow::anyhow!("Page must be greater than 0"));
+        }
+
+        let url = format!("{}/classSearch/getTerms", self.base_url);
+        let params = [
+            ("searchTerm", search),
+            ("offset", &page.to_string()),
+            ("max", &max_results.to_string()),
+            ("_", &nonce()),
+        ];
+
+        let response = self
+            .http
+            .get(&url)
+            .query(&params)
+            .send()
+            .await
+            .with_context(|| "Failed to get terms".to_string())?;
+
+        let terms: Vec<BannerTerm> = response
+            .json()
+            .await
+            .context("Failed to parse terms response")?;
+
+        Ok(terms)
+    }
+
+    /// Selects a term for the current session
+    pub async fn select_term(
+        &self,
+        term: &str,
+        unique_session_id: &str,
+        cookie_header: &str,
+    ) -> Result<()> {
+        let form_data = [
+            ("term", term),
+            ("studyPath", ""),
+            ("studyPathText", ""),
+            ("startDatepicker", ""),
+            ("endDatepicker", ""),
+            ("uniqueSessionId", unique_session_id),
+        ];
+
+        let url = format!("{}/term/search", self.base_url);
+        let response = self
+            .http
+            .post(&url)
+            .header("Cookie", cookie_header)
+            .query(&[("mode", "search")])
+            .form(&form_data)
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            return Err(anyhow::anyhow!(
+                "Failed to select term {}: {}",
+                term,
+                response.status()
+            ));
+        }
+
+        #[derive(serde::Deserialize)]
+        struct RedirectResponse {
+            #[serde(rename = "fwdURL")]
+            fwd_url: String,
+        }
+
+        let redirect: RedirectResponse = response.json().await?;
+
+        let base_url_path = self
+            .base_url
+            .parse::<Url>()
+            .context("Failed to parse base URL")?
+            .path()
+            .to_string();
+        let non_overlap_redirect =
+            redirect
+                .fwd_url
+                .strip_prefix(&base_url_path)
+                .ok_or_else(|| {
+                    anyhow::anyhow!(
+                        "Redirect URL '{}' does not start with expected prefix '{}'",
+                        redirect.fwd_url,
+                        base_url_path
+                    )
+                })?;
+
+        // Follow the redirect
+        let redirect_url = format!("{}{}", self.base_url, non_overlap_redirect);
+        let redirect_response = self
+            .http
+            .get(&redirect_url)
+            .header("Cookie", cookie_header)
+            .send()
+            .await?;
+
+        if !redirect_response.status().is_success() {
+            return Err(anyhow::anyhow!(
+                "Failed to follow redirect: {}",
+                redirect_response.status()
+            ));
+        }
+
+        Ok(())
+    }
+}

src/banner/util.rs

@@ -0,0 +1,6 @@
+//! Utility functions for the Banner module.
+
+/// Returns a browser-like user agent string.
+pub fn user_agent() -> &'static str {
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36"
+}

src/bin/search.rs

@@ -0,0 +1,132 @@
+use banner::banner::{BannerApi, SearchQuery, Term};
+use banner::config::Config;
+use banner::error::Result;
+use figment::{Figment, providers::Env};
+use futures::future;
+use tracing::{error, info};
+use tracing_subscriber::{EnvFilter, FmtSubscriber};
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    // Configure logging
+    let filter = EnvFilter::try_from_default_env()
+        .unwrap_or_else(|_| EnvFilter::new("info,banner=trace,reqwest=debug,hyper=info"));
+    let subscriber = FmtSubscriber::builder()
+        .with_env_filter(filter)
+        .with_target(true)
+        .finish();
+    tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
+
+    info!("Starting Banner search test");
+
+    dotenvy::dotenv().ok();
+
+    // Load configuration
+    let config: Config = Figment::new()
+        .merge(Env::raw())
+        .extract()
+        .expect("Failed to load config");
+
+    info!(
+        banner_base_url = config.banner_base_url,
+        "Configuration loaded"
+    );
+
+    // Create Banner API client
+    let banner_api =
+        BannerApi::new_with_config(config.banner_base_url, config.rate_limiting.into())
+            .expect("Failed to create BannerApi");
+
+    // Get current term
+    let term = Term::get_current().inner().to_string();
+    info!(term = term, "Using current term");
+
+    // Define multiple search queries
+    let queries = vec![
+        (
+            "CS Courses",
+            SearchQuery::new().subject("CS").max_results(10),
+        ),
+        (
+            "Math Courses",
+            SearchQuery::new().subject("MAT").max_results(10),
+        ),
+        (
+            "3000-level CS",
+            SearchQuery::new()
+                .subject("CS")
+                .course_numbers(3000, 3999)
+                .max_results(8),
+        ),
+        (
+            "High Credit Courses",
+            SearchQuery::new().credits(4, 6).max_results(8),
+        ),
+        (
+            "Programming Courses",
+            SearchQuery::new().keyword("programming").max_results(6),
+        ),
+    ];
+
+    info!(query_count = queries.len(), "Executing concurrent searches");
+
+    // Execute all searches concurrently
+    let search_futures = queries.into_iter().map(|(label, query)| {
+        info!(label = %label, "Starting search");
+        let banner_api = &banner_api;
+        let term = &term;
+        async move {
+            let result = banner_api
+                .search(term, &query, "subjectDescription", false)
+                .await;
+            (label, result)
+        }
+    });
+
+    // Wait for all searches to complete
+    let search_results = future::join_all(search_futures)
+        .await
+        .into_iter()
+        .filter_map(|(label, result)| match result {
+            Ok(search_result) => {
+                info!(
+                    label = label,
+                    success = search_result.success,
+                    total_count = search_result.total_count,
+                    "Search completed successfully"
+                );
+                Some((label, search_result))
+            }
+            Err(e) => {
+                error!(label = label, error = ?e, "Search failed");
+                None
+            }
+        })
+        .collect::<Vec<_>>();
+
+    // Process and display results
+    for (label, search_result) in search_results {
+        println!("\n=== {} ===", label);
+        if let Some(courses) = &search_result.data {
+            if courses.is_empty() {
+                println!("  No courses found");
+            } else {
+                println!("  Found {} courses:", courses.len());
+                for course in courses {
+                    println!(
+                        "    {} {} - {} (CRN: {})",
+                        course.subject,
+                        course.course_number,
+                        course.course_title,
+                        course.course_reference_number
+                    );
+                }
+            }
+        } else {
+            println!("  No courses found");
+        }
+    }
+
+    info!("Search test completed");
+    Ok(())
+}

src/bot/commands/gcal.rs

@@ -0,0 +1,151 @@
+//! Google Calendar command implementation.
+
+use crate::banner::{Course, DayOfWeek, MeetingScheduleInfo};
+use crate::bot::{Context, Error, utils};
+use chrono::NaiveDate;
+use std::collections::HashMap;
+use tracing::info;
+use url::Url;
+
+/// Generate a link to create a Google Calendar event for a course
+#[poise::command(slash_command)]
+pub async fn gcal(
+    ctx: Context<'_>,
+    #[description = "Course Reference Number (CRN)"] crn: i32,
+) -> Result<(), Error> {
+    let user = ctx.author();
+    info!(source = user.name, target = crn, "gcal command invoked");
+
+    ctx.defer().await?;
+
+    let course = utils::get_course_by_crn(&ctx, crn).await?;
+    let term = course.term.clone();
+
+    // Get meeting times
+    let meeting_times = ctx
+        .data()
+        .app_state
+        .banner_api
+        .get_course_meeting_time(&term, &crn.to_string())
+        .await?;
+
+    struct LinkDetail {
+        link: String,
+        detail: String,
+    }
+
+    let response: Vec<LinkDetail> = match meeting_times.len() {
+        0 => Err(anyhow::anyhow!("No meeting times found for this course.")),
+        1.. => {
+            // Sort meeting times by start time of their TimeRange
+            let mut sorted_meeting_times = meeting_times.to_vec();
+            sorted_meeting_times.sort_unstable_by(|a, b| {
+                // Primary sort: by start time
+                match (&a.time_range, &b.time_range) {
+                    (Some(a_time), Some(b_time)) => a_time.start.cmp(&b_time.start),
+                    (Some(_), None) => std::cmp::Ordering::Less,
+                    (None, Some(_)) => std::cmp::Ordering::Greater,
+                    (None, None) => a.days.bits().cmp(&b.days.bits()),
+                }
+            });
+
+            let links = sorted_meeting_times
+                .iter()
+                .map(|m| {
+                    let link = generate_gcal_url(&course, m)?;
+                    let detail = match &m.time_range {
+                        Some(range) => {
+                            format!("{} {}", m.days_string().unwrap(), range.format_12hr())
+                        }
+                        None => m.days_string().unwrap(),
+                    };
+                    Ok(LinkDetail { link, detail })
+                })
+                .collect::<Result<Vec<LinkDetail>, anyhow::Error>>()?;
+            Ok(links)
+        }
+    }?;
+
+    ctx.say(
+        response
+            .iter()
+            .map(|LinkDetail { link, detail }| {
+                format!("[Add to Google Calendar](<{link}>) ({detail})")
+            })
+            .collect::<Vec<String>>()
+            .join("\n"),
+    )
+    .await?;
+
+    info!(crn = %crn, "gcal command completed");
+    Ok(())
+}
+
+/// Generate Google Calendar URL for a course
+fn generate_gcal_url(
+    course: &Course,
+    meeting_time: &MeetingScheduleInfo,
+) -> Result<String, anyhow::Error> {
+    let course_text = course.display_title();
+
+    let dates_text = {
+        let (start, end) = meeting_time.datetime_range();
+        format!(
+            "{}/{}",
+            start.format("%Y%m%dT%H%M%S"),
+            end.format("%Y%m%dT%H%M%S")
+        )
+    };
+
+    // Get instructor name
+    let instructor_name = course.primary_instructor_name();
+
+    // The event description
+    let details_text = format!(
+        "CRN: {}\nInstructor: {}\nDays: {}",
+        course.course_reference_number,
+        instructor_name,
+        meeting_time.days_string().unwrap()
+    );
+
+    // The event location
+    let location_text = meeting_time.place_string();
+
+    // The event recurrence rule
+    let recur_text = generate_rrule(meeting_time, meeting_time.date_range.end);
+
+    let mut params = HashMap::new();
+    params.insert("action", "TEMPLATE");
+    params.insert("text", &course_text);
+    params.insert("dates", &dates_text);
+    params.insert("details", &details_text);
+    params.insert("location", &location_text);
+    params.insert("trp", "true");
+    params.insert("ctz", "America/Chicago");
+    params.insert("recur", &recur_text);
+
+    Ok(Url::parse_with_params("https://calendar.google.com/calendar/render", &params)?.to_string())
+}
+
+/// Generate RRULE for recurrence
+fn generate_rrule(meeting_time: &MeetingScheduleInfo, end_date: NaiveDate) -> String {
+    let days_of_week = meeting_time.days_of_week();
+    let by_day = days_of_week
+        .iter()
+        .map(|day| match day {
+            DayOfWeek::Monday => "MO",
+            DayOfWeek::Tuesday => "TU",
+            DayOfWeek::Wednesday => "WE",
+            DayOfWeek::Thursday => "TH",
+            DayOfWeek::Friday => "FR",
+            DayOfWeek::Saturday => "SA",
+            DayOfWeek::Sunday => "SU",
+        })
+        .collect::<Vec<&str>>()
+        .join(",");
+
+    // Format end date for RRULE (YYYYMMDD format)
+    let until = end_date.format("%Y%m%dT000000Z").to_string();
+
+    format!("RRULE:FREQ=WEEKLY;BYDAY={by_day};UNTIL={until}")
+}

src/bot/commands/ics.rs

@@ -0,0 +1,436 @@
+//! ICS command implementation for generating calendar files.
+
+use crate::banner::{Course, MeetingScheduleInfo};
+use crate::bot::{Context, Error, utils};
+use chrono::{Datelike, NaiveDate, Utc};
+use serenity::all::CreateAttachment;
+use tracing::info;
+
+/// Represents a holiday or special day that should be excluded from class schedules
+#[derive(Debug, Clone)]
+enum Holiday {
+    /// A single-day holiday
+    Single { month: u32, day: u32 },
+    /// A multi-day holiday range
+    Range {
+        month: u32,
+        start_day: u32,
+        end_day: u32,
+    },
+}
+
+impl Holiday {
+    /// Check if a specific date falls within this holiday
+    fn contains_date(&self, date: NaiveDate) -> bool {
+        match self {
+            Holiday::Single { month, day, .. } => date.month() == *month && date.day() == *day,
+            Holiday::Range {
+                month,
+                start_day,
+                end_day,
+                ..
+            } => date.month() == *month && date.day() >= *start_day && date.day() <= *end_day,
+        }
+    }
+
+    /// Get all dates in this holiday for a given year
+    fn get_dates_for_year(&self, year: i32) -> Vec<NaiveDate> {
+        match self {
+            Holiday::Single { month, day, .. } => {
+                if let Some(date) = NaiveDate::from_ymd_opt(year, *month, *day) {
+                    vec![date]
+                } else {
+                    Vec::new()
+                }
+            }
+            Holiday::Range {
+                month,
+                start_day,
+                end_day,
+                ..
+            } => {
+                let mut dates = Vec::new();
+                for day in *start_day..=*end_day {
+                    if let Some(date) = NaiveDate::from_ymd_opt(year, *month, day) {
+                        dates.push(date);
+                    }
+                }
+                dates
+            }
+        }
+    }
+}
+
+/// University holidays that should be excluded from class schedules
+const UNIVERSITY_HOLIDAYS: &[(&str, Holiday)] = &[
+    ("Labor Day", Holiday::Single { month: 9, day: 1 }),
+    (
+        "Fall Break",
+        Holiday::Range {
+            month: 10,
+            start_day: 13,
+            end_day: 14,
+        },
+    ),
+    (
+        "Unspecified Holiday",
+        Holiday::Single { month: 11, day: 26 },
+    ),
+    (
+        "Thanksgiving",
+        Holiday::Range {
+            month: 11,
+            start_day: 28,
+            end_day: 29,
+        },
+    ),
+    ("Student Study Day", Holiday::Single { month: 12, day: 5 }),
+    (
+        "Winter Holiday",
+        Holiday::Range {
+            month: 12,
+            start_day: 23,
+            end_day: 31,
+        },
+    ),
+    ("New Year's Day", Holiday::Single { month: 1, day: 1 }),
+    ("MLK Day", Holiday::Single { month: 1, day: 20 }),
+    (
+        "Spring Break",
+        Holiday::Range {
+            month: 3,
+            start_day: 10,
+            end_day: 15,
+        },
+    ),
+    ("Student Study Day", Holiday::Single { month: 5, day: 9 }),
+];
+
+/// Generate an ICS file for a course
+#[poise::command(slash_command, prefix_command)]
+pub async fn ics(
+    ctx: Context<'_>,
+    #[description = "Course Reference Number (CRN)"] crn: i32,
+) -> Result<(), Error> {
+    ctx.defer().await?;
+
+    let course = utils::get_course_by_crn(&ctx, crn).await?;
+    let term = course.term.clone();
+
+    // Get meeting times
+    let meeting_times = ctx
+        .data()
+        .app_state
+        .banner_api
+        .get_course_meeting_time(&term, &crn.to_string())
+        .await?;
+
+    if meeting_times.is_empty() {
+        ctx.say("No meeting times found for this course.").await?;
+        return Ok(());
+    }
+
+    // Sort meeting times by start time
+    let mut sorted_meeting_times = meeting_times.to_vec();
+    sorted_meeting_times.sort_unstable_by(|a, b| match (&a.time_range, &b.time_range) {
+        (Some(a_time), Some(b_time)) => a_time.start.cmp(&b_time.start),
+        (Some(_), None) => std::cmp::Ordering::Less,
+        (None, Some(_)) => std::cmp::Ordering::Greater,
+        (None, None) => a.days.bits().cmp(&b.days.bits()),
+    });
+
+    // Generate ICS content
+    let (ics_content, excluded_holidays) =
+        generate_ics_content(&course, &term, &sorted_meeting_times)?;
+
+    // Create file attachment
+    let filename = format!(
+        "{subject}_{number}_{section}.ics",
+        subject = course.subject.replace(" ", "_"),
+        number = course.course_number,
+        section = course.sequence_number,
+    );
+
+    let file = CreateAttachment::bytes(ics_content.into_bytes(), filename.clone());
+
+    // Build response content
+    let mut response_content = format!(
+        "📅 Generated ICS calendar for **{}**\n\n**Meeting Times:**\n{}",
+        course.display_title(),
+        sorted_meeting_times
+            .iter()
+            .enumerate()
+            .map(|(i, m)| {
+                let time_info = match &m.time_range {
+                    Some(range) => format!(
+                        "{} {}",
+                        m.days_string().unwrap_or("TBA".to_string()),
+                        range.format_12hr()
+                    ),
+                    None => m.days_string().unwrap_or("TBA".to_string()),
+                };
+                format!("{}. {}", i + 1, time_info)
+            })
+            .collect::<Vec<_>>()
+            .join("\n")
+    );
+
+    // Add holiday exclusion information
+    if !excluded_holidays.is_empty() {
+        let count = excluded_holidays.len();
+        let count_text = if count == 1 {
+            "1 date was".to_string()
+        } else {
+            format!("{} dates were", count)
+        };
+        response_content.push_str(&format!("\n\n{} excluded from the ICS file:\n", count_text));
+        response_content.push_str(
+            &excluded_holidays
+                .iter()
+                .map(|s| format!("- {}", s))
+                .collect::<Vec<_>>()
+                .join("\n"),
+        );
+    }
+
+    ctx.send(
+        poise::CreateReply::default()
+            .content(response_content)
+            .attachment(file),
+    )
+    .await?;
+
+    info!(crn = %crn, "ics command completed");
+    Ok(())
+}
+
+/// Generate ICS content for a course and its meeting times
+fn generate_ics_content(
+    course: &Course,
+    term: &str,
+    meeting_times: &[MeetingScheduleInfo],
+) -> Result<(String, Vec<String>), anyhow::Error> {
+    let mut ics_content = String::new();
+    let mut excluded_holidays = Vec::new();
+
+    // ICS header
+    ics_content.push_str("BEGIN:VCALENDAR\r\n");
+    ics_content.push_str("VERSION:2.0\r\n");
+    ics_content.push_str("PRODID:-//Banner Bot//Course Calendar//EN\r\n");
+    ics_content.push_str("CALSCALE:GREGORIAN\r\n");
+    ics_content.push_str("METHOD:PUBLISH\r\n");
+
+    // Calendar name
+    ics_content.push_str(&format!(
+        "X-WR-CALNAME:{} - {}\r\n",
+        course.display_title(),
+        term
+    ));
+
+    // Generate events for each meeting time
+    for (index, meeting_time) in meeting_times.iter().enumerate() {
+        let (event_content, holidays) = generate_event_content(course, meeting_time, index)?;
+        ics_content.push_str(&event_content);
+        excluded_holidays.extend(holidays);
+    }
+
+    // ICS footer
+    ics_content.push_str("END:VCALENDAR\r\n");
+
+    Ok((ics_content, excluded_holidays))
+}
+
+/// Generate ICS event content for a single meeting time
+fn generate_event_content(
+    course: &Course,
+    meeting_time: &MeetingScheduleInfo,
+    index: usize,
+) -> Result<(String, Vec<String>), anyhow::Error> {
+    let course_title = course.display_title();
+    let instructor_name = course.primary_instructor_name();
+    let location = meeting_time.place_string();
+
+    // Create event title with meeting index if multiple meetings
+    let event_title = if index > 0 {
+        format!("{} (Meeting {})", course_title, index + 1)
+    } else {
+        course_title
+    };
+
+    // Create event description
+    let description = format!(
+        "CRN: {}\\nInstructor: {}\\nDays: {}\\nMeeting Type: {}",
+        course.course_reference_number,
+        instructor_name,
+        meeting_time.days_string().unwrap_or("TBA".to_string()),
+        meeting_time.meeting_type.description()
+    );
+
+    // Get start and end times
+    let (start_dt, end_dt) = meeting_time.datetime_range();
+
+    // Format datetimes for ICS (UTC format)
+    let start_utc = start_dt.with_timezone(&Utc);
+    let end_utc = end_dt.with_timezone(&Utc);
+
+    let start_str = start_utc.format("%Y%m%dT%H%M%SZ").to_string();
+    let end_str = end_utc.format("%Y%m%dT%H%M%SZ").to_string();
+
+    // Generate unique ID for the event
+    let uid = format!(
+        "{}-{}-{}@banner-bot.local",
+        course.course_reference_number,
+        index,
+        start_utc.timestamp()
+    );
+
+    let mut event_content = String::new();
+
+    // Event header
+    event_content.push_str("BEGIN:VEVENT\r\n");
+    event_content.push_str(&format!("UID:{}\r\n", uid));
+    event_content.push_str(&format!("DTSTART:{}\r\n", start_str));
+    event_content.push_str(&format!("DTEND:{}\r\n", end_str));
+    event_content.push_str(&format!("SUMMARY:{}\r\n", escape_ics_text(&event_title)));
+    event_content.push_str(&format!(
+        "DESCRIPTION:{}\r\n",
+        escape_ics_text(&description)
+    ));
+    event_content.push_str(&format!("LOCATION:{}\r\n", escape_ics_text(&location)));
+
+    // Add recurrence rule if there are specific days and times
+    if !meeting_time.days.is_empty() && meeting_time.time_range.is_some() {
+        let days_of_week = meeting_time.days_of_week();
+        let by_day: Vec<String> = days_of_week
+            .iter()
+            .map(|day| day.to_short_string().to_uppercase())
+            .collect();
+
+        if !by_day.is_empty() {
+            let until_date = meeting_time
+                .date_range
+                .end
+                .format("%Y%m%dT000000Z")
+                .to_string();
+
+            event_content.push_str(&format!(
+                "RRULE:FREQ=WEEKLY;BYDAY={};UNTIL={}\r\n",
+                by_day.join(","),
+                until_date
+            ));
+
+            // Add holiday exceptions (EXDATE) if the class would meet on holiday dates
+            let holiday_exceptions = get_holiday_exceptions(meeting_time);
+            if let Some(exdate_property) = generate_exdate_property(&holiday_exceptions, start_utc)
+            {
+                event_content.push_str(&format!("{}\r\n", exdate_property));
+            }
+
+            // Collect holiday names for reporting
+            let mut holiday_names = Vec::new();
+            for (holiday_name, holiday) in UNIVERSITY_HOLIDAYS {
+                for &exception_date in &holiday_exceptions {
+                    if holiday.contains_date(exception_date) {
+                        holiday_names.push(format!(
+                            "{} ({})",
+                            holiday_name,
+                            exception_date.format("%a, %b %d")
+                        ));
+                    }
+                }
+            }
+            holiday_names.sort();
+            holiday_names.dedup();
+
+            return Ok((event_content, holiday_names));
+        }
+    }
+
+    // Event footer
+    event_content.push_str("END:VEVENT\r\n");
+
+    Ok((event_content, Vec::new()))
+}
+
+/// Convert chrono::Weekday to the custom DayOfWeek enum
+fn chrono_weekday_to_day_of_week(weekday: chrono::Weekday) -> crate::banner::meetings::DayOfWeek {
+    use crate::banner::meetings::DayOfWeek;
+    match weekday {
+        chrono::Weekday::Mon => DayOfWeek::Monday,
+        chrono::Weekday::Tue => DayOfWeek::Tuesday,
+        chrono::Weekday::Wed => DayOfWeek::Wednesday,
+        chrono::Weekday::Thu => DayOfWeek::Thursday,
+        chrono::Weekday::Fri => DayOfWeek::Friday,
+        chrono::Weekday::Sat => DayOfWeek::Saturday,
+        chrono::Weekday::Sun => DayOfWeek::Sunday,
+    }
+}
+
+/// Check if a class meets on a specific date based on its meeting days
+fn class_meets_on_date(meeting_time: &MeetingScheduleInfo, date: NaiveDate) -> bool {
+    let weekday = chrono_weekday_to_day_of_week(date.weekday());
+    let meeting_days = meeting_time.days_of_week();
+
+    meeting_days.contains(&weekday)
+}
+
+/// Get holiday dates that fall within the course date range and would conflict with class meetings
+fn get_holiday_exceptions(meeting_time: &MeetingScheduleInfo) -> Vec<NaiveDate> {
+    let mut exceptions = Vec::new();
+
+    // Get the year range from the course date range
+    let start_year = meeting_time.date_range.start.year();
+    let end_year = meeting_time.date_range.end.year();
+
+    for (_, holiday) in UNIVERSITY_HOLIDAYS {
+        // Check for the holiday in each year of the course
+        for year in start_year..=end_year {
+            let holiday_dates = holiday.get_dates_for_year(year);
+
+            for holiday_date in holiday_dates {
+                // Check if the holiday falls within the course date range
+                if holiday_date >= meeting_time.date_range.start
+                    && holiday_date <= meeting_time.date_range.end
+                {
+                    // Check if the class would actually meet on this day
+                    if class_meets_on_date(meeting_time, holiday_date) {
+                        exceptions.push(holiday_date);
+                    }
+                }
+            }
+        }
+    }
+
+    exceptions
+}
+
+/// Generate EXDATE property for holiday exceptions
+fn generate_exdate_property(
+    exceptions: &[NaiveDate],
+    start_time: chrono::DateTime<Utc>,
+) -> Option<String> {
+    if exceptions.is_empty() {
+        return None;
+    }
+
+    let mut exdate_values = Vec::new();
+
+    for &exception_date in exceptions {
+        // Create a datetime for the exception using the same time as the start time
+        let exception_datetime = exception_date.and_time(start_time.time()).and_utc();
+
+        let exdate_str = exception_datetime.format("%Y%m%dT%H%M%SZ").to_string();
+        exdate_values.push(exdate_str);
+    }
+
+    Some(format!("EXDATE:{}", exdate_values.join(",")))
+}
+
+/// Escape text for ICS format
+fn escape_ics_text(text: &str) -> String {
+    text.replace("\\", "\\\\")
+        .replace(";", "\\;")
+        .replace(",", "\\,")
+        .replace("\n", "\\n")
+        .replace("\r", "")
+}

src/bot/commands/mod.rs

@@ -0,0 +1,13 @@
+//! Bot commands module.
+
+pub mod gcal;
+pub mod ics;
+pub mod search;
+pub mod terms;
+pub mod time;
+
+pub use gcal::gcal;
+pub use ics::ics;
+pub use search::search;
+pub use terms::terms;
+pub use time::time;

src/bot/commands/search.rs

@@ -0,0 +1,140 @@
+//! Course search command implementation.
+
+use crate::banner::{SearchQuery, Term};
+use crate::bot::{Context, Error};
+use anyhow::anyhow;
+use regex::Regex;
+use tracing::info;
+
+/// Search for courses with various filters
+#[poise::command(slash_command, prefix_command)]
+pub async fn search(
+    ctx: Context<'_>,
+    #[description = "Course title (exact, use autocomplete)"] title: Option<String>,
+    #[description = "Course code (e.g. 3743, 3000-3999, 3xxx, 3000-)"] code: Option<String>,
+    #[description = "Maximum number of results"] max: Option<i32>,
+    #[description = "Keywords in title or description (space separated)"] keywords: Option<String>,
+    // #[description = "Instructor name"] instructor: Option<String>,
+    // #[description = "Subject (e.g Computer Science/CS, Mathematics/MAT)"] subject: Option<String>,
+) -> Result<(), Error> {
+    // Defer the response since this might take a while
+    ctx.defer().await?;
+
+    // Build the search query
+    let mut query = SearchQuery::new().credits(3, 6);
+
+    if let Some(title) = title {
+        query = query.title(title);
+    }
+
+    if let Some(code) = code {
+        let (low, high) = parse_course_code(&code)?;
+        query = query.course_numbers(low, high);
+    }
+
+    if let Some(keywords) = keywords {
+        let keyword_list: Vec<String> =
+            keywords.split_whitespace().map(|s| s.to_string()).collect();
+        query = query.keywords(keyword_list);
+    }
+
+    if let Some(max_results) = max {
+        query = query.max_results(max_results.min(25)); // Cap at 25
+    }
+
+    let term = Term::get_current().inner().to_string();
+    let search_result = ctx
+        .data()
+        .app_state
+        .banner_api
+        .search(&term, &query, "subjectDescription", false)
+        .await?;
+
+    let response = if let Some(courses) = search_result.data {
+        if courses.is_empty() {
+            "No courses found with the specified criteria.".to_string()
+        } else {
+            courses
+                .iter()
+                .map(|course| {
+                    format!(
+                        "**{}**: {} ({})",
+                        course.display_title(),
+                        course.primary_instructor_name(),
+                        course.course_reference_number
+                    )
+                })
+                .collect::<Vec<_>>()
+                .join("\n")
+        }
+    } else {
+        "No courses found with the specified criteria.".to_string()
+    };
+
+    ctx.say(response).await?;
+    info!("search command completed");
+    Ok(())
+}
+
+/// Parse course code input (e.g, "3743", "3000-3999", "3xxx", "3000-")
+fn parse_course_code(input: &str) -> Result<(i32, i32), Error> {
+    let input = input.trim();
+
+    // Handle range format (e.g, "3000-3999")
+    if input.contains('-') {
+        let re = Regex::new(r"(\d{1,4})-(\d{1,4})?").unwrap();
+        if let Some(captures) = re.captures(input) {
+            let low: i32 = captures[1].parse()?;
+            let high = if captures.get(2).is_some() {
+                captures[2].parse()?
+            } else {
+                9999 // Open-ended range
+            };
+
+            if low > high {
+                return Err(anyhow!("Invalid range: low value greater than high value"));
+            }
+
+            if low < 1000 || high > 9999 {
+                return Err(anyhow!("Course codes must be between 1000 and 9999"));
+            }
+
+            return Ok((low, high));
+        }
+        return Err(anyhow!("Invalid range format"));
+    }
+
+    // Handle wildcard format (e.g, "34xx")
+    if input.contains('x') {
+        if input.len() != 4 {
+            return Err(anyhow!("Wildcard format must be exactly 4 characters"));
+        }
+
+        let re = Regex::new(r"(\d+)(x+)").unwrap();
+        if let Some(captures) = re.captures(input) {
+            let prefix: i32 = captures[1].parse()?;
+            let x_count = captures[2].len();
+
+            let low = prefix * 10_i32.pow(x_count as u32);
+            let high = low + 10_i32.pow(x_count as u32) - 1;
+
+            if low < 1000 || high > 9999 {
+                return Err(anyhow!("Course codes must be between 1000 and 9999"));
+            }
+
+            return Ok((low, high));
+        }
+        return Err(anyhow!("Invalid wildcard format"));
+    }
+
+    // Handle single course code
+    if input.len() == 4 {
+        let code: i32 = input.parse()?;
+        if !(1000..=9999).contains(&code) {
+            return Err(anyhow!("Course codes must be between 1000 and 9999"));
+        }
+        return Ok((code, code));
+    }
+
+    Err(anyhow!("Invalid course code format"))
+}

src/bot/commands/terms.rs

@@ -0,0 +1,59 @@
+//! Terms command implementation.
+
+use crate::banner::{BannerTerm, Term};
+use crate::bot::{Context, Error};
+use tracing::info;
+
+/// List available terms or search for a specific term
+#[poise::command(slash_command, prefix_command)]
+pub async fn terms(
+    ctx: Context<'_>,
+    #[description = "Term to search for"] search: Option<String>,
+    #[description = "Page number"] page: Option<i32>,
+) -> Result<(), Error> {
+    ctx.defer().await?;
+
+    let search_term = search.unwrap_or_default();
+    let page_number = page.unwrap_or(1).max(1);
+    let max_results = 10;
+
+    let terms = ctx
+        .data()
+        .app_state
+        .banner_api
+        .sessions
+        .get_terms(&search_term, page_number, max_results)
+        .await?;
+
+    let response = if terms.is_empty() {
+        "No terms found.".to_string()
+    } else {
+        let current_term_code = Term::get_current().inner().to_string();
+        terms
+            .iter()
+            .map(|term| format_term(term, &current_term_code))
+            .collect::<Vec<_>>()
+            .join("\n")
+    };
+
+    ctx.say(response).await?;
+    info!("terms command completed");
+    Ok(())
+}
+
+fn format_term(term: &BannerTerm, current_term_code: &str) -> String {
+    let is_current = if term.code == current_term_code {
+        " (current)"
+    } else {
+        ""
+    };
+    let is_archived = if term.is_archived() {
+        " (archived)"
+    } else {
+        ""
+    };
+    format!(
+        "- `{}`: {}{}{}",
+        term.code, term.description, is_current, is_archived
+    )
+}

src/bot/commands/time.rs

@@ -0,0 +1,25 @@
+//! Time command implementation for course meeting times.
+
+use crate::bot::{Context, Error, utils};
+use tracing::info;
+
+/// Get meeting times for a specific course
+#[poise::command(slash_command, prefix_command)]
+pub async fn time(
+    ctx: Context<'_>,
+    #[description = "Course Reference Number (CRN)"] crn: i32,
+) -> Result<(), Error> {
+    ctx.defer().await?;
+
+    let course = utils::get_course_by_crn(&ctx, crn).await?;
+
+    // TODO: Implement actual meeting time retrieval and display
+    ctx.say(format!(
+        "Meeting time display for '{}' is not yet implemented.",
+        course.display_title()
+    ))
+    .await?;
+
+    info!(crn = %crn, "time command completed");
+    Ok(())
+}

src/bot/mod.rs

@@ -0,0 +1,21 @@
+use crate::error::Error;
+use crate::state::AppState;
+
+pub mod commands;
+pub mod utils;
+
+pub struct Data {
+    pub app_state: AppState,
+} // User data, which is stored and accessible in all command invocations
+pub type Context<'a> = poise::Context<'a, Data, Error>;
+
+/// Get all available commands
+pub fn get_commands() -> Vec<poise::Command<Data, Error>> {
+    vec![
+        commands::search(),
+        commands::terms(),
+        commands::time(),
+        commands::ics(),
+        commands::gcal(),
+    ]
+}

src/bot/utils.rs

@@ -0,0 +1,24 @@
+//! Bot command utilities.
+
+use crate::banner::{Course, Term};
+use crate::bot::Context;
+use crate::error::Result;
+use tracing::error;
+
+/// Gets a course by its CRN for the current term.
+pub async fn get_course_by_crn(ctx: &Context<'_>, crn: i32) -> Result<Course> {
+    let app_state = &ctx.data().app_state;
+
+    // Get current term dynamically
+    let current_term_status = Term::get_current();
+    let term = current_term_status.inner();
+
+    // Fetch live course data from database via AppState
+    app_state
+        .get_course_or_fetch(&term.to_string(), &crn.to_string())
+        .await
+        .map_err(|e| {
+            error!(error = %e, crn = %crn, "failed to fetch course data");
+            e
+        })
+}

src/cli.rs

@@ -0,0 +1,104 @@
+use clap::Parser;
+
+/// Banner Discord Bot - Course availability monitoring
+///
+/// This application runs multiple services that can be controlled via CLI arguments:
+/// - bot: Discord bot for course monitoring commands
+/// - web: HTTP server for web interface and API
+/// - scraper: Background service for scraping course data
+///
+/// Use --services to specify which services to run, or --disable-services to exclude specific services.
+#[derive(Parser, Debug)]
+#[command(author, version, about, long_about = None)]
+pub struct Args {
+    /// Log formatter to use
+    #[arg(long, value_enum, default_value_t = default_tracing_format())]
+    pub tracing: TracingFormat,
+
+    /// Services to run (comma-separated). Default: all services
+    ///
+    /// Examples:
+    ///   --services bot,web    # Run only bot and web services
+    ///   --services scraper    # Run only the scraper service
+    #[arg(long, value_delimiter = ',', conflicts_with = "disable_services")]
+    pub services: Option<Vec<ServiceName>>,
+
+    /// Services to disable (comma-separated)
+    ///
+    /// Examples:
+    ///   --disable-services bot        # Run web and scraper only
+    ///   --disable-services bot,web    # Run only the scraper service
+    #[arg(long, value_delimiter = ',', conflicts_with = "services")]
+    pub disable_services: Option<Vec<ServiceName>>,
+}
+
+#[derive(clap::ValueEnum, Clone, Debug)]
+pub enum TracingFormat {
+    /// Use pretty formatter (default in debug mode)
+    Pretty,
+    /// Use JSON formatter (default in release mode)
+    Json,
+}
+
+#[derive(clap::ValueEnum, Clone, Debug, PartialEq)]
+pub enum ServiceName {
+    /// Discord bot for course monitoring commands
+    Bot,
+    /// HTTP server for web interface and API
+    Web,
+    /// Background service for scraping course data
+    Scraper,
+}
+
+impl ServiceName {
+    /// Get all available services
+    pub fn all() -> Vec<ServiceName> {
+        vec![ServiceName::Bot, ServiceName::Web, ServiceName::Scraper]
+    }
+
+    /// Convert to string for service registration
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            ServiceName::Bot => "bot",
+            ServiceName::Web => "web",
+            ServiceName::Scraper => "scraper",
+        }
+    }
+}
+
+/// Determine which services should be enabled based on CLI arguments
+pub fn determine_enabled_services(args: &Args) -> Result<Vec<ServiceName>, anyhow::Error> {
+    match (&args.services, &args.disable_services) {
+        (Some(services), None) => {
+            // User specified which services to run
+            Ok(services.clone())
+        }
+        (None, Some(disabled)) => {
+            // User specified which services to disable
+            let enabled: Vec<ServiceName> = ServiceName::all()
+                .into_iter()
+                .filter(|s| !disabled.contains(s))
+                .collect();
+            Ok(enabled)
+        }
+        (None, None) => {
+            // Default: run all services
+            Ok(ServiceName::all())
+        }
+        (Some(_), Some(_)) => {
+            // This should be prevented by clap's conflicts_with, but just in case
+            Err(anyhow::anyhow!(
+                "Cannot specify both --services and --disable-services"
+            ))
+        }
+    }
+}
+
+#[cfg(debug_assertions)]
+const DEFAULT_TRACING_FORMAT: TracingFormat = TracingFormat::Pretty;
+#[cfg(not(debug_assertions))]
+const DEFAULT_TRACING_FORMAT: TracingFormat = TracingFormat::Json;
+
+fn default_tracing_format() -> TracingFormat {
+    DEFAULT_TRACING_FORMAT
+}

src/config/mod.rs

@@ -0,0 +1,211 @@
+//! Configuration module for the banner application.
+//!
+//! This module handles loading and parsing configuration from environment variables
+//! using the figment crate. It supports flexible duration parsing that accepts both
+//! numeric values (interpreted as seconds) and duration strings with units.
+
+use fundu::{DurationParser, TimeUnit};
+use serde::{Deserialize, Deserializer};
+use std::time::Duration;
+
+/// Main application configuration containing all sub-configurations
+#[derive(Deserialize)]
+pub struct Config {
+    /// Log level for the application
+    ///
+    /// This value is used to set the log level for this application's target specifically.
+    /// e.g. "debug" would be similar to "warn,banner=debug,..."
+    ///
+    /// Valid values are: "trace", "debug", "info", "warn", "error"
+    /// Defaults to "info" if not specified
+    #[serde(default = "default_log_level")]
+    pub log_level: String,
+    /// Port for the web server (default: 8080)
+    #[serde(default = "default_port")]
+    pub port: u16,
+    /// Database connection URL
+    pub database_url: String,
+    /// Graceful shutdown timeout duration
+    ///
+    /// Accepts both numeric values (seconds) and duration strings
+    /// Defaults to 8 seconds if not specified
+    #[serde(
+        default = "default_shutdown_timeout",
+        deserialize_with = "deserialize_duration"
+    )]
+    pub shutdown_timeout: Duration,
+    /// Discord bot token for authentication
+    pub bot_token: String,
+    /// Target Discord guild ID where the bot operates
+    pub bot_target_guild: u64,
+
+    /// Base URL for banner generation service
+    ///
+    /// Defaults to "https://ssbprod.utsa.edu/StudentRegistrationSsb/ssb" if not specified
+    #[serde(default = "default_banner_base_url")]
+    pub banner_base_url: String,
+    /// Rate limiting configuration for Banner API requests
+    #[serde(default = "default_rate_limiting")]
+    pub rate_limiting: RateLimitingConfig,
+}
+
+/// Default log level of "info"
+fn default_log_level() -> String {
+    "info".to_string()
+}
+
+/// Default port of 8080
+fn default_port() -> u16 {
+    8080
+}
+
+/// Default shutdown timeout of 8 seconds
+fn default_shutdown_timeout() -> Duration {
+    Duration::from_secs(8)
+}
+
+/// Default banner base URL
+fn default_banner_base_url() -> String {
+    "https://ssbprod.utsa.edu/StudentRegistrationSsb/ssb".to_string()
+}
+
+/// Rate limiting configuration for Banner API requests
+#[derive(Deserialize, Clone, Debug)]
+pub struct RateLimitingConfig {
+    /// Requests per minute for session operations (very conservative)
+    #[serde(default = "default_session_rpm")]
+    pub session_rpm: u32,
+    /// Requests per minute for search operations (moderate)
+    #[serde(default = "default_search_rpm")]
+    pub search_rpm: u32,
+    /// Requests per minute for metadata operations (moderate)
+    #[serde(default = "default_metadata_rpm")]
+    pub metadata_rpm: u32,
+    /// Requests per minute for reset operations (low priority)
+    #[serde(default = "default_reset_rpm")]
+    pub reset_rpm: u32,
+    /// Burst allowance (extra requests allowed in short bursts)
+    #[serde(default = "default_burst_allowance")]
+    pub burst_allowance: u32,
+}
+
+/// Default rate limiting configuration
+fn default_rate_limiting() -> RateLimitingConfig {
+    RateLimitingConfig {
+        session_rpm: default_session_rpm(),
+        search_rpm: default_search_rpm(),
+        metadata_rpm: default_metadata_rpm(),
+        reset_rpm: default_reset_rpm(),
+        burst_allowance: default_burst_allowance(),
+    }
+}
+
+/// Default session requests per minute (6 = 1 every 10 seconds)
+fn default_session_rpm() -> u32 {
+    6
+}
+
+/// Default search requests per minute (30 = 1 every 2 seconds)
+fn default_search_rpm() -> u32 {
+    30
+}
+
+/// Default metadata requests per minute (20 = 1 every 3 seconds)
+fn default_metadata_rpm() -> u32 {
+    20
+}
+
+/// Default reset requests per minute (10 = 1 every 6 seconds)
+fn default_reset_rpm() -> u32 {
+    10
+}
+
+/// Default burst allowance (3 extra requests)
+fn default_burst_allowance() -> u32 {
+    3
+}
+
+/// Duration parser configured to handle various time units with seconds as default
+///
+/// Supports:
+/// - Seconds (s) - default unit
+/// - Milliseconds (ms)
+/// - Minutes (m)
+/// - Hours (h)
+///
+/// Does not support fractions, exponents, or infinity values
+/// Allows for whitespace between the number and the time unit
+/// Allows for multiple time units to be specified (summed together, e.g "10s 2m" = 120 + 10 = 130 seconds)
+const DURATION_PARSER: DurationParser<'static> = DurationParser::builder()
+    .time_units(&[TimeUnit::Second, TimeUnit::MilliSecond, TimeUnit::Minute])
+    .parse_multiple(None)
+    .allow_time_unit_delimiter()
+    .disable_infinity()
+    .disable_fraction()
+    .disable_exponent()
+    .default_unit(TimeUnit::Second)
+    .build();
+
+/// Custom deserializer for duration fields that accepts both numeric and string values
+///
+/// This deserializer handles the flexible duration parsing by accepting:
+/// - Unsigned integers (interpreted as seconds)
+/// - Signed integers (interpreted as seconds, must be non-negative)
+/// - Strings (parsed using the fundu duration parser)
+///
+/// # Examples
+///
+/// - `1` -> 1 second
+/// - `"30s"` -> 30 seconds  
+/// - `"2 m"` -> 2 minutes
+/// - `"1500ms"` -> 15 seconds
+fn deserialize_duration<'de, D>(deserializer: D) -> Result<Duration, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    use serde::de::Visitor;
+
+    struct DurationVisitor;
+
+    impl<'de> Visitor<'de> for DurationVisitor {
+        type Value = Duration;
+
+        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+            formatter.write_str("a duration string or number")
+        }
+
+        fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            DURATION_PARSER.parse(value)
+                .map_err(|e| {
+                    serde::de::Error::custom(format!(
+                        "Invalid duration format '{}': {}. Examples: '5' (5 seconds), '3500ms', '30s', '2m', '1.5h'", 
+                        value, e
+                    ))
+                })?
+                .try_into()
+                .map_err(|e| serde::de::Error::custom(format!("Duration conversion error: {}", e)))
+        }
+
+        fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            Ok(Duration::from_secs(value))
+        }
+
+        fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            if value < 0 {
+                return Err(serde::de::Error::custom("Duration cannot be negative"));
+            }
+            Ok(Duration::from_secs(value as u64))
+        }
+    }
+
+    deserializer.deserialize_any(DurationVisitor)
+}

src/data/batch.rs

@@ -0,0 +1,135 @@
+//! Batch database operations for improved performance.
+
+use crate::banner::Course;
+use crate::error::Result;
+use sqlx::PgPool;
+use std::time::Instant;
+use tracing::info;
+
+/// Batch upsert courses in a single database query.
+///
+/// This function performs a bulk INSERT...ON CONFLICT DO UPDATE for all courses
+/// in a single round-trip to the database, significantly reducing overhead compared
+/// to individual inserts.
+///
+/// # Performance
+/// - Reduces N database round-trips to 1
+/// - Typical usage: 50-200 courses per batch
+/// - PostgreSQL parameter limit: 65,535 (we use ~10 per course)
+///
+/// # Arguments
+/// * `courses` - Slice of Course structs from the Banner API
+/// * `db_pool` - PostgreSQL connection pool
+///
+/// # Returns
+/// * `Ok(())` on success
+/// * `Err(_)` if the database operation fails
+///
+/// # Example
+/// ```no_run
+/// use banner::data::batch::batch_upsert_courses;
+/// use banner::banner::Course;
+/// use sqlx::PgPool;
+///
+/// async fn example(courses: &[Course], pool: &PgPool) -> anyhow::Result<()> {
+///     batch_upsert_courses(courses, pool).await?;
+///     Ok(())
+/// }
+/// ```
+pub async fn batch_upsert_courses(courses: &[Course], db_pool: &PgPool) -> Result<()> {
+    // Early return for empty batches
+    if courses.is_empty() {
+        info!("No courses to upsert, skipping batch operation");
+        return Ok(());
+    }
+
+    let start = Instant::now();
+    let course_count = courses.len();
+
+    // Extract course fields into vectors for UNNEST
+    let crns: Vec<&str> = courses
+        .iter()
+        .map(|c| c.course_reference_number.as_str())
+        .collect();
+
+    let subjects: Vec<&str> = courses.iter().map(|c| c.subject.as_str()).collect();
+
+    let course_numbers: Vec<&str> = courses.iter().map(|c| c.course_number.as_str()).collect();
+
+    let titles: Vec<&str> = courses.iter().map(|c| c.course_title.as_str()).collect();
+
+    let term_codes: Vec<&str> = courses.iter().map(|c| c.term.as_str()).collect();
+
+    let enrollments: Vec<i32> = courses.iter().map(|c| c.enrollment).collect();
+
+    let max_enrollments: Vec<i32> = courses.iter().map(|c| c.maximum_enrollment).collect();
+
+    let wait_counts: Vec<i32> = courses.iter().map(|c| c.wait_count).collect();
+
+    let wait_capacities: Vec<i32> = courses.iter().map(|c| c.wait_capacity).collect();
+
+    // Perform batch upsert using UNNEST for efficient bulk insertion
+    let result = sqlx::query(
+        r#"
+        INSERT INTO courses (
+            crn, subject, course_number, title, term_code,
+            enrollment, max_enrollment, wait_count, wait_capacity, last_scraped_at
+        )
+        SELECT * FROM UNNEST(
+            $1::text[], $2::text[], $3::text[], $4::text[], $5::text[],
+            $6::int4[], $7::int4[], $8::int4[], $9::int4[],
+            array_fill(NOW()::timestamptz, ARRAY[$10])
+        ) AS t(
+            crn, subject, course_number, title, term_code,
+            enrollment, max_enrollment, wait_count, wait_capacity, last_scraped_at
+        )
+        ON CONFLICT (crn, term_code)
+        DO UPDATE SET
+            subject = EXCLUDED.subject,
+            course_number = EXCLUDED.course_number,
+            title = EXCLUDED.title,
+            enrollment = EXCLUDED.enrollment,
+            max_enrollment = EXCLUDED.max_enrollment,
+            wait_count = EXCLUDED.wait_count,
+            wait_capacity = EXCLUDED.wait_capacity,
+            last_scraped_at = EXCLUDED.last_scraped_at
+        "#,
+    )
+    .bind(&crns)
+    .bind(&subjects)
+    .bind(&course_numbers)
+    .bind(&titles)
+    .bind(&term_codes)
+    .bind(&enrollments)
+    .bind(&max_enrollments)
+    .bind(&wait_counts)
+    .bind(&wait_capacities)
+    .bind(course_count as i32)
+    .execute(db_pool)
+    .await
+    .map_err(|e| anyhow::anyhow!("Failed to batch upsert courses: {}", e))?;
+
+    let duration = start.elapsed();
+
+    info!(
+        courses_count = course_count,
+        rows_affected = result.rows_affected(),
+        duration_ms = duration.as_millis(),
+        "Batch upserted courses"
+    );
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_empty_batch_returns_ok() {
+        // This is a basic compile-time test
+        // Runtime tests would require sqlx::test macro and a test database
+        let courses: Vec<Course> = vec![];
+        assert_eq!(courses.len(), 0);
+    }
+}

src/data/mod.rs

@@ -0,0 +1,4 @@
+//! Database models and schema.
+
+pub mod batch;
+pub mod models;

src/data/models.rs

@@ -0,0 +1,79 @@
+//! `sqlx` models for the database schema.
+
+use chrono::{DateTime, Utc};
+use serde_json::Value;
+
+#[allow(dead_code)]
+#[derive(sqlx::FromRow, Debug, Clone)]
+pub struct Course {
+    pub id: i32,
+    pub crn: String,
+    pub subject: String,
+    pub course_number: String,
+    pub title: String,
+    pub term_code: String,
+    pub enrollment: i32,
+    pub max_enrollment: i32,
+    pub wait_count: i32,
+    pub wait_capacity: i32,
+    pub last_scraped_at: DateTime<Utc>,
+}
+
+#[allow(dead_code)]
+#[derive(sqlx::FromRow, Debug, Clone)]
+pub struct CourseMetric {
+    pub id: i32,
+    pub course_id: i32,
+    pub timestamp: DateTime<Utc>,
+    pub enrollment: i32,
+    pub wait_count: i32,
+    pub seats_available: i32,
+}
+
+#[allow(dead_code)]
+#[derive(sqlx::FromRow, Debug, Clone)]
+pub struct CourseAudit {
+    pub id: i32,
+    pub course_id: i32,
+    pub timestamp: DateTime<Utc>,
+    pub field_changed: String,
+    pub old_value: String,
+    pub new_value: String,
+}
+
+/// The priority level of a scrape job.
+#[derive(sqlx::Type, Copy, Debug, Clone)]
+#[sqlx(type_name = "scrape_priority", rename_all = "PascalCase")]
+pub enum ScrapePriority {
+    Low,
+    Medium,
+    High,
+    Critical,
+}
+
+/// The type of target for a scrape job, determining how the payload is interpreted.
+#[derive(sqlx::Type, Copy, Debug, Clone)]
+#[sqlx(type_name = "target_type", rename_all = "PascalCase")]
+pub enum TargetType {
+    Subject,
+    CourseRange,
+    CrnList,
+    SingleCrn,
+}
+
+/// Represents a queryable job from the database.
+#[allow(dead_code)]
+#[derive(sqlx::FromRow, Debug, Clone)]
+pub struct ScrapeJob {
+    pub id: i32,
+    pub target_type: TargetType,
+    pub target_payload: Value,
+    pub priority: ScrapePriority,
+    pub execute_at: DateTime<Utc>,
+    pub created_at: DateTime<Utc>,
+    pub locked_at: Option<DateTime<Utc>>,
+    /// Number of retry attempts for this job (non-negative, enforced by CHECK constraint)
+    pub retry_count: i32,
+    /// Maximum number of retry attempts allowed (non-negative, enforced by CHECK constraint)
+    pub max_retries: i32,
+}

src/error.rs

@@ -0,0 +1,4 @@
+//! Application-specific error types.
+
+pub type Error = anyhow::Error;
+pub type Result<T, E = Error> = anyhow::Result<T, E>;

src/formatter.rs

@@ -0,0 +1,275 @@
+//! Custom tracing formatter
+
+use serde::Serialize;
+use serde_json::{Map, Value};
+use std::fmt;
+use time::macros::format_description;
+use time::{OffsetDateTime, format_description::FormatItem};
+use tracing::field::{Field, Visit};
+use tracing::{Event, Level, Subscriber};
+use tracing_subscriber::fmt::format::Writer;
+use tracing_subscriber::fmt::{FmtContext, FormatEvent, FormatFields, FormattedFields};
+use tracing_subscriber::registry::LookupSpan;
+use yansi::Paint;
+
+/// Cached format description for timestamps
+/// Uses 3 subsecond digits on Emscripten, 5 otherwise for better performance
+#[cfg(target_os = "emscripten")]
+const TIMESTAMP_FORMAT: &[FormatItem<'static>] =
+    format_description!("[hour]:[minute]:[second].[subsecond digits:3]");
+
+#[cfg(not(target_os = "emscripten"))]
+const TIMESTAMP_FORMAT: &[FormatItem<'static>] =
+    format_description!("[hour]:[minute]:[second].[subsecond digits:5]");
+
+/// A custom formatter with enhanced timestamp formatting
+///
+/// Re-implementation of the Full formatter with improved timestamp display.
+pub struct CustomPrettyFormatter;
+
+impl<S, N> FormatEvent<S, N> for CustomPrettyFormatter
+where
+    S: Subscriber + for<'a> LookupSpan<'a>,
+    N: for<'a> FormatFields<'a> + 'static,
+{
+    fn format_event(
+        &self,
+        ctx: &FmtContext<'_, S, N>,
+        mut writer: Writer<'_>,
+        event: &Event<'_>,
+    ) -> fmt::Result {
+        let meta = event.metadata();
+
+        // 1) Timestamp (dimmed when ANSI)
+        let now = OffsetDateTime::now_utc();
+        let formatted_time = now.format(&TIMESTAMP_FORMAT).map_err(|e| {
+            eprintln!("Failed to format timestamp: {}", e);
+            fmt::Error
+        })?;
+        write_dimmed(&mut writer, formatted_time)?;
+        writer.write_char(' ')?;
+
+        // 2) Colored 5-char level like Full
+        write_colored_level(&mut writer, meta.level())?;
+        writer.write_char(' ')?;
+
+        // 3) Span scope chain (bold names, fields in braces, dimmed ':')
+        if let Some(scope) = ctx.event_scope() {
+            let mut saw_any = false;
+            for span in scope.from_root() {
+                write_bold(&mut writer, span.metadata().name())?;
+                saw_any = true;
+
+                write_dimmed(&mut writer, ":")?;
+
+                let ext = span.extensions();
+                if let Some(fields) = &ext.get::<FormattedFields<N>>()
+                    && !fields.fields.is_empty()
+                {
+                    write_bold(&mut writer, "{")?;
+                    writer.write_str(fields.fields.as_str())?;
+                    write_bold(&mut writer, "}")?;
+                }
+                write_dimmed(&mut writer, ":")?;
+            }
+
+            if saw_any {
+                writer.write_char(' ')?;
+            }
+        }
+
+        // 4) Target (dimmed), then a space
+        if writer.has_ansi_escapes() {
+            write!(writer, "{}: ", Paint::new(meta.target()).dim())?;
+        } else {
+            write!(writer, "{}: ", meta.target())?;
+        }
+
+        // 5) Event fields
+        ctx.format_fields(writer.by_ref(), event)?;
+
+        // 6) Newline
+        writeln!(writer)
+    }
+}
+
+/// A custom JSON formatter that flattens fields to root level
+///
+/// Outputs logs in the format: { "message": "...", "level": "...", "customAttribute": "..." }
+pub struct CustomJsonFormatter;
+
+impl<S, N> FormatEvent<S, N> for CustomJsonFormatter
+where
+    S: Subscriber + for<'a> LookupSpan<'a>,
+    N: for<'a> FormatFields<'a> + 'static,
+{
+    fn format_event(
+        &self,
+        ctx: &FmtContext<'_, S, N>,
+        mut writer: Writer<'_>,
+        event: &Event<'_>,
+    ) -> fmt::Result {
+        let meta = event.metadata();
+
+        #[derive(Serialize)]
+        struct EventFields {
+            message: String,
+            level: String,
+            target: String,
+            #[serde(flatten)]
+            spans: Map<String, Value>,
+            #[serde(flatten)]
+            fields: Map<String, Value>,
+        }
+
+        let (message, fields, spans) = {
+            let mut message: Option<String> = None;
+            let mut fields: Map<String, Value> = Map::new();
+            let mut spans: Map<String, Value> = Map::new();
+
+            struct FieldVisitor<'a> {
+                message: &'a mut Option<String>,
+                fields: &'a mut Map<String, Value>,
+            }
+
+            impl<'a> Visit for FieldVisitor<'a> {
+                fn record_debug(&mut self, field: &Field, value: &dyn std::fmt::Debug) {
+                    let key = field.name();
+                    if key == "message" {
+                        *self.message = Some(format!("{:?}", value));
+                    } else {
+                        // Use typed methods for better performance
+                        self.fields
+                            .insert(key.to_string(), Value::String(format!("{:?}", value)));
+                    }
+                }
+
+                fn record_str(&mut self, field: &Field, value: &str) {
+                    let key = field.name();
+                    if key == "message" {
+                        *self.message = Some(value.to_string());
+                    } else {
+                        self.fields
+                            .insert(key.to_string(), Value::String(value.to_string()));
+                    }
+                }
+
+                fn record_i64(&mut self, field: &Field, value: i64) {
+                    let key = field.name();
+                    if key != "message" {
+                        self.fields.insert(
+                            key.to_string(),
+                            Value::Number(serde_json::Number::from(value)),
+                        );
+                    }
+                }
+
+                fn record_u64(&mut self, field: &Field, value: u64) {
+                    let key = field.name();
+                    if key != "message" {
+                        self.fields.insert(
+                            key.to_string(),
+                            Value::Number(serde_json::Number::from(value)),
+                        );
+                    }
+                }
+
+                fn record_bool(&mut self, field: &Field, value: bool) {
+                    let key = field.name();
+                    if key != "message" {
+                        self.fields.insert(key.to_string(), Value::Bool(value));
+                    }
+                }
+            }
+
+            let mut visitor = FieldVisitor {
+                message: &mut message,
+                fields: &mut fields,
+            };
+            event.record(&mut visitor);
+
+            // Collect span information from the span hierarchy
+            if let Some(scope) = ctx.event_scope() {
+                for span in scope.from_root() {
+                    let span_name = span.metadata().name().to_string();
+                    let mut span_fields: Map<String, Value> = Map::new();
+
+                    // Try to extract fields from FormattedFields
+                    let ext = span.extensions();
+                    if let Some(formatted_fields) = ext.get::<FormattedFields<N>>() {
+                        // Try to parse as JSON first
+                        if let Ok(json_fields) = serde_json::from_str::<Map<String, Value>>(
+                            formatted_fields.fields.as_str(),
+                        ) {
+                            span_fields.extend(json_fields);
+                        } else {
+                            // If not valid JSON, treat the entire field string as a single field
+                            span_fields.insert(
+                                "raw".to_string(),
+                                Value::String(formatted_fields.fields.as_str().to_string()),
+                            );
+                        }
+                    }
+
+                    // Insert span as a nested object directly into the spans map
+                    spans.insert(span_name, Value::Object(span_fields));
+                }
+            }
+
+            (message, fields, spans)
+        };
+
+        let json = EventFields {
+            message: message.unwrap_or_default(),
+            level: meta.level().to_string(),
+            target: meta.target().to_string(),
+            spans,
+            fields,
+        };
+
+        writeln!(
+            writer,
+            "{}",
+            serde_json::to_string(&json).unwrap_or_else(|_| "{}".to_string())
+        )
+    }
+}
+
+/// Write the verbosity level with the same coloring/alignment as the Full formatter.
+fn write_colored_level(writer: &mut Writer<'_>, level: &Level) -> fmt::Result {
+    if writer.has_ansi_escapes() {
+        let paint = match *level {
+            Level::TRACE => Paint::new("TRACE").magenta(),
+            Level::DEBUG => Paint::new("DEBUG").blue(),
+            Level::INFO => Paint::new(" INFO").green(),
+            Level::WARN => Paint::new(" WARN").yellow(),
+            Level::ERROR => Paint::new("ERROR").red(),
+        };
+        write!(writer, "{}", paint)
+    } else {
+        // Right-pad to width 5 like Full's non-ANSI mode
+        match *level {
+            Level::TRACE => write!(writer, "{:>5}", "TRACE"),
+            Level::DEBUG => write!(writer, "{:>5}", "DEBUG"),
+            Level::INFO => write!(writer, "{:>5}", " INFO"),
+            Level::WARN => write!(writer, "{:>5}", " WARN"),
+            Level::ERROR => write!(writer, "{:>5}", "ERROR"),
+        }
+    }
+}
+
+fn write_dimmed(writer: &mut Writer<'_>, s: impl fmt::Display) -> fmt::Result {
+    if writer.has_ansi_escapes() {
+        write!(writer, "{}", Paint::new(s).dim())
+    } else {
+        write!(writer, "{}", s)
+    }
+}
+
+fn write_bold(writer: &mut Writer<'_>, s: impl fmt::Display) -> fmt::Result {
+    if writer.has_ansi_escapes() {
+        write!(writer, "{}", Paint::new(s).bold())
+    } else {
+        write!(writer, "{}", s)
+    }
+}

src/lib.rs

@@ -0,0 +1,15 @@
+pub mod app;
+pub mod banner;
+pub mod bot;
+pub mod cli;
+pub mod config;
+pub mod data;
+pub mod error;
+pub mod formatter;
+pub mod logging;
+pub mod scraper;
+pub mod services;
+pub mod signals;
+pub mod state;
+pub mod utils;
+pub mod web;

src/logging.rs

@@ -0,0 +1,47 @@
+use crate::cli::TracingFormat;
+use crate::config::Config;
+use crate::formatter;
+use tracing_subscriber::fmt::format::JsonFields;
+use tracing_subscriber::{EnvFilter, FmtSubscriber};
+
+/// Configure and initialize logging for the application
+pub fn setup_logging(config: &Config, tracing_format: TracingFormat) {
+    // Configure logging based on config
+    // Note: Even when base_level is trace or debug, we suppress trace logs from noisy
+    // infrastructure modules to keep output readable. These modules use debug for important
+    // events and trace only for very detailed debugging.
+    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| {
+        let base_level = &config.log_level;
+        EnvFilter::new(format!(
+            "warn,banner={},banner::rate_limiter=warn,banner::session=debug,banner::rate_limit_middleware=warn,banner::middleware=debug",
+            base_level
+        ))
+    });
+
+    // Select formatter based on CLI args
+    let use_pretty = match tracing_format {
+        TracingFormat::Pretty => true,
+        TracingFormat::Json => false,
+    };
+
+    let subscriber: Box<dyn tracing::Subscriber + Send + Sync> = if use_pretty {
+        Box::new(
+            FmtSubscriber::builder()
+                .with_target(true)
+                .event_format(formatter::CustomPrettyFormatter)
+                .with_env_filter(filter)
+                .finish(),
+        )
+    } else {
+        Box::new(
+            FmtSubscriber::builder()
+                .with_target(true)
+                .event_format(formatter::CustomJsonFormatter)
+                .fmt_fields(JsonFields::new())
+                .with_env_filter(filter)
+                .finish(),
+        )
+    };
+
+    tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
+}

src/main.rs

@@ -0,0 +1,70 @@
+use crate::app::App;
+use crate::cli::{Args, ServiceName, determine_enabled_services};
+use crate::logging::setup_logging;
+use clap::Parser;
+use std::process::ExitCode;
+use tracing::info;
+
+mod app;
+mod banner;
+mod bot;
+mod cli;
+mod config;
+mod data;
+mod error;
+mod formatter;
+mod logging;
+mod scraper;
+mod services;
+mod signals;
+mod state;
+mod web;
+
+#[tokio::main]
+async fn main() -> ExitCode {
+    dotenvy::dotenv().ok();
+
+    // Parse CLI arguments
+    let args = Args::parse();
+
+    // Determine which services should be enabled
+    let enabled_services: Vec<ServiceName> =
+        determine_enabled_services(&args).expect("Failed to determine enabled services");
+
+    info!(
+        enabled_services = ?enabled_services,
+        "services configuration loaded"
+    );
+
+    // Create and initialize the application
+    let mut app = App::new().await.expect("Failed to initialize application");
+
+    // Setup logging
+    setup_logging(app.config(), args.tracing);
+
+    // Log application startup context
+    info!(
+        version = env!("CARGO_PKG_VERSION"),
+        environment = if cfg!(debug_assertions) {
+            "development"
+        } else {
+            "production"
+        },
+        "starting banner"
+    );
+
+    // Setup services (web, scraper)
+    app.setup_services(&enabled_services)
+        .expect("Failed to setup services");
+
+    // Setup bot service if enabled
+    if enabled_services.contains(&ServiceName::Bot) {
+        app.setup_bot_service()
+            .await
+            .expect("Failed to setup bot service");
+    }
+
+    // Start all services and run the application
+    app.start_services();
+    app.run().await
+}

src/scraper/jobs/mod.rs

@@ -0,0 +1,104 @@
+pub mod subject;
+
+use crate::banner::BannerApi;
+use crate::data::models::TargetType;
+use crate::error::Result;
+use serde::{Deserialize, Serialize};
+use sqlx::PgPool;
+use std::fmt;
+
+/// Errors that can occur during job parsing
+#[derive(Debug)]
+pub enum JobParseError {
+    InvalidJson(serde_json::Error),
+    UnsupportedTargetType(TargetType),
+}
+
+impl fmt::Display for JobParseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            JobParseError::InvalidJson(e) => write!(f, "Invalid JSON in job payload: {}", e),
+            JobParseError::UnsupportedTargetType(t) => {
+                write!(f, "Unsupported target type: {:?}", t)
+            }
+        }
+    }
+}
+
+impl std::error::Error for JobParseError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            JobParseError::InvalidJson(e) => Some(e),
+            _ => None,
+        }
+    }
+}
+
+/// Errors that can occur during job processing
+#[derive(Debug)]
+pub enum JobError {
+    Recoverable(anyhow::Error),   // API failures, network issues
+    Unrecoverable(anyhow::Error), // Parse errors, corrupted data
+}
+
+impl fmt::Display for JobError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            JobError::Recoverable(e) => write!(f, "Recoverable error: {}", e),
+            JobError::Unrecoverable(e) => write!(f, "Unrecoverable error: {}", e),
+        }
+    }
+}
+
+impl std::error::Error for JobError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            JobError::Recoverable(e) => e.source(),
+            JobError::Unrecoverable(e) => e.source(),
+        }
+    }
+}
+
+/// Common trait interface for all job types
+#[async_trait::async_trait]
+pub trait Job: Send + Sync {
+    /// The target type this job handles
+    #[allow(dead_code)]
+    fn target_type(&self) -> TargetType;
+
+    /// Process the job with the given API client and database pool
+    async fn process(&self, banner_api: &BannerApi, db_pool: &PgPool) -> Result<()>;
+
+    /// Get a human-readable description of the job
+    fn description(&self) -> String;
+}
+
+/// Main job enum that dispatches to specific job implementations
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum JobType {
+    Subject(subject::SubjectJob),
+}
+
+impl JobType {
+    /// Create a job from the target type and payload
+    pub fn from_target_type_and_payload(
+        target_type: TargetType,
+        payload: serde_json::Value,
+    ) -> Result<Self, JobParseError> {
+        match target_type {
+            TargetType::Subject => {
+                let subject_job: subject::SubjectJob =
+                    serde_json::from_value(payload).map_err(JobParseError::InvalidJson)?;
+                Ok(JobType::Subject(subject_job))
+            }
+            _ => Err(JobParseError::UnsupportedTargetType(target_type)),
+        }
+    }
+
+    /// Convert to a Job trait object
+    pub fn boxed(self) -> Box<dyn Job> {
+        match self {
+            JobType::Subject(job) => Box::new(job),
+        }
+    }
+}

src/scraper/jobs/subject.rs

@@ -0,0 +1,56 @@
+use super::Job;
+use crate::banner::{BannerApi, SearchQuery, Term};
+use crate::data::batch::batch_upsert_courses;
+use crate::data::models::TargetType;
+use crate::error::Result;
+use serde::{Deserialize, Serialize};
+use sqlx::PgPool;
+use tracing::{debug, info};
+
+/// Job implementation for scraping subject data
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SubjectJob {
+    pub subject: String,
+}
+
+impl SubjectJob {
+    pub fn new(subject: String) -> Self {
+        Self { subject }
+    }
+}
+
+#[async_trait::async_trait]
+impl Job for SubjectJob {
+    fn target_type(&self) -> TargetType {
+        TargetType::Subject
+    }
+
+    #[tracing::instrument(skip(self, banner_api, db_pool), fields(subject = %self.subject))]
+    async fn process(&self, banner_api: &BannerApi, db_pool: &PgPool) -> Result<()> {
+        let subject_code = &self.subject;
+
+        // Get the current term
+        let term = Term::get_current().inner().to_string();
+        let query = SearchQuery::new().subject(subject_code).max_results(500);
+
+        let search_result = banner_api
+            .search(&term, &query, "subjectDescription", false)
+            .await?;
+
+        if let Some(courses_from_api) = search_result.data {
+            info!(
+                subject = subject_code,
+                count = courses_from_api.len(),
+                "Found courses"
+            );
+            batch_upsert_courses(&courses_from_api, db_pool).await?;
+        }
+
+        debug!(subject = subject_code, "Subject job completed");
+        Ok(())
+    }
+
+    fn description(&self) -> String {
+        format!("Scrape subject: {}", self.subject)
+    }
+}

src/scraper/mod.rs

@@ -0,0 +1,116 @@
+pub mod jobs;
+pub mod scheduler;
+pub mod worker;
+
+use crate::banner::BannerApi;
+use crate::services::Service;
+use sqlx::PgPool;
+use std::sync::Arc;
+use tokio::sync::broadcast;
+use tokio::task::JoinHandle;
+use tracing::{info, warn};
+
+use self::scheduler::Scheduler;
+use self::worker::Worker;
+
+/// The main service that will be managed by the application's `ServiceManager`.
+///
+/// It holds the shared resources (database pool, API client) and manages the
+/// lifecycle of the Scheduler and Worker tasks.
+pub struct ScraperService {
+    db_pool: PgPool,
+    banner_api: Arc<BannerApi>,
+    scheduler_handle: Option<JoinHandle<()>>,
+    worker_handles: Vec<JoinHandle<()>>,
+    shutdown_tx: Option<broadcast::Sender<()>>,
+}
+
+impl ScraperService {
+    /// Creates a new `ScraperService`.
+    pub fn new(db_pool: PgPool, banner_api: Arc<BannerApi>) -> Self {
+        Self {
+            db_pool,
+            banner_api,
+            scheduler_handle: None,
+            worker_handles: Vec::new(),
+            shutdown_tx: None,
+        }
+    }
+
+    /// Starts the scheduler and a pool of workers.
+    pub fn start(&mut self) {
+        info!("ScraperService starting");
+
+        // Create shutdown channel
+        let (shutdown_tx, _) = broadcast::channel(1);
+        self.shutdown_tx = Some(shutdown_tx.clone());
+
+        let scheduler = Scheduler::new(self.db_pool.clone(), self.banner_api.clone());
+        let shutdown_rx = shutdown_tx.subscribe();
+        let scheduler_handle = tokio::spawn(async move {
+            scheduler.run(shutdown_rx).await;
+        });
+        self.scheduler_handle = Some(scheduler_handle);
+        info!("Scheduler task spawned");
+
+        let worker_count = 4; // This could be configurable
+        for i in 0..worker_count {
+            let worker = Worker::new(i, self.db_pool.clone(), self.banner_api.clone());
+            let shutdown_rx = shutdown_tx.subscribe();
+            let worker_handle = tokio::spawn(async move {
+                worker.run(shutdown_rx).await;
+            });
+            self.worker_handles.push(worker_handle);
+        }
+        info!(
+            worker_count = self.worker_handles.len(),
+            "Spawned worker tasks"
+        );
+    }
+}
+
+#[async_trait::async_trait]
+impl Service for ScraperService {
+    fn name(&self) -> &'static str {
+        "scraper"
+    }
+
+    async fn run(&mut self) -> Result<(), anyhow::Error> {
+        self.start();
+        std::future::pending::<()>().await;
+        Ok(())
+    }
+
+    async fn shutdown(&mut self) -> Result<(), anyhow::Error> {
+        info!("Shutting down scraper service");
+
+        // Send shutdown signal to all tasks
+        if let Some(shutdown_tx) = self.shutdown_tx.take() {
+            let _ = shutdown_tx.send(());
+        } else {
+            warn!("No shutdown channel found for scraper service");
+            return Err(anyhow::anyhow!("No shutdown channel available"));
+        }
+
+        // Collect all handles
+        let mut all_handles = Vec::new();
+        if let Some(handle) = self.scheduler_handle.take() {
+            all_handles.push(handle);
+        }
+        all_handles.append(&mut self.worker_handles);
+
+        // Wait for all tasks to complete (no internal timeout - let ServiceManager handle it)
+        let results = futures::future::join_all(all_handles).await;
+        let failed = results.iter().filter(|r| r.is_err()).count();
+        if failed > 0 {
+            warn!(
+                failed_count = failed,
+                "Some scraper tasks panicked during shutdown"
+            );
+            return Err(anyhow::anyhow!("{} task(s) panicked", failed));
+        }
+
+        info!("All scraper tasks shutdown gracefully");
+        Ok(())
+    }
+}

src/scraper/scheduler.rs

@@ -0,0 +1,188 @@
+use crate::banner::{BannerApi, Term};
+use crate::data::models::{ScrapePriority, TargetType};
+use crate::error::Result;
+use crate::scraper::jobs::subject::SubjectJob;
+use serde_json::json;
+use sqlx::PgPool;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::broadcast;
+use tokio::time;
+use tokio_util::sync::CancellationToken;
+use tracing::{debug, error, info, warn};
+
+/// Periodically analyzes data and enqueues prioritized scrape jobs.
+pub struct Scheduler {
+    db_pool: PgPool,
+    banner_api: Arc<BannerApi>,
+}
+
+impl Scheduler {
+    pub fn new(db_pool: PgPool, banner_api: Arc<BannerApi>) -> Self {
+        Self {
+            db_pool,
+            banner_api,
+        }
+    }
+
+    /// Runs the scheduler's main loop with graceful shutdown support.
+    ///
+    /// The scheduler wakes up every 60 seconds to analyze data and enqueue jobs.
+    /// When a shutdown signal is received:
+    /// 1. Any in-progress scheduling work is gracefully cancelled via CancellationToken
+    /// 2. The scheduler waits up to 5 seconds for work to complete
+    /// 3. If timeout occurs, the task is abandoned (it will be aborted when dropped)
+    ///
+    /// This ensures that shutdown is responsive even if scheduling work is blocked.
+    pub async fn run(&self, mut shutdown_rx: broadcast::Receiver<()>) {
+        info!("Scheduler service started");
+
+        let work_interval = Duration::from_secs(60);
+        let mut next_run = time::Instant::now();
+        let mut current_work: Option<(tokio::task::JoinHandle<()>, CancellationToken)> = None;
+
+        loop {
+            tokio::select! {
+                _ = time::sleep_until(next_run) => {
+                    let cancel_token = CancellationToken::new();
+
+                    // Spawn work in separate task to allow graceful cancellation during shutdown.
+                    // Without this, shutdown would have to wait for the full scheduling cycle.
+                    let work_handle = tokio::spawn({
+                        let db_pool = self.db_pool.clone();
+                        let banner_api = self.banner_api.clone();
+                        let cancel_token = cancel_token.clone();
+
+                        async move {
+                            tokio::select! {
+                                result = Self::schedule_jobs_impl(&db_pool, &banner_api) => {
+                                    if let Err(e) = result {
+                                        error!(error = ?e, "Failed to schedule jobs");
+                                    }
+                                }
+                                _ = cancel_token.cancelled() => {
+                                    debug!("Scheduling work cancelled gracefully");
+                                }
+                            }
+                        }
+                    });
+
+                    current_work = Some((work_handle, cancel_token));
+                    next_run = time::Instant::now() + work_interval;
+                }
+                _ = shutdown_rx.recv() => {
+                    info!("Scheduler received shutdown signal");
+
+                    if let Some((handle, cancel_token)) = current_work.take() {
+                        cancel_token.cancel();
+
+                        // Wait briefly for graceful completion
+                        if tokio::time::timeout(Duration::from_secs(5), handle).await.is_err() {
+                            warn!("Scheduling work did not complete within 5s, abandoning");
+                        } else {
+                            debug!("Scheduling work completed gracefully");
+                        }
+                    }
+
+                    info!("Scheduler exiting gracefully");
+                    break;
+                }
+            }
+        }
+    }
+
+    /// Core scheduling logic that analyzes data and creates scrape jobs.
+    ///
+    /// Strategy:
+    /// 1. Fetch all subjects for the current term from Banner API
+    /// 2. Query existing jobs in a single batch query
+    /// 3. Create jobs only for subjects that don't have pending jobs
+    ///
+    /// This is a static method (not &self) to allow it to be called from spawned tasks.
+    #[tracing::instrument(skip_all, fields(term))]
+    async fn schedule_jobs_impl(db_pool: &PgPool, banner_api: &BannerApi) -> Result<()> {
+        // For now, we will implement a simple baseline scheduling strategy:
+        // 1. Get a list of all subjects from the Banner API.
+        // 2. Query existing jobs for all subjects in a single query.
+        // 3. Create new jobs only for subjects that don't have existing jobs.
+        let term = Term::get_current().inner().to_string();
+
+        tracing::Span::current().record("term", term.as_str());
+        debug!(term = term, "Enqueuing subject jobs");
+
+        let subjects = banner_api.get_subjects("", &term, 1, 500).await?;
+        debug!(
+            subject_count = subjects.len(),
+            "Retrieved subjects from API"
+        );
+
+        // Create payloads for all subjects
+        let subject_payloads: Vec<_> = subjects
+            .iter()
+            .map(|subject| json!({ "subject": subject.code }))
+            .collect();
+
+        // Query existing jobs for all subjects in a single query
+        let existing_jobs: Vec<(serde_json::Value,)> = sqlx::query_as(
+            "SELECT target_payload FROM scrape_jobs
+             WHERE target_type = $1 AND target_payload = ANY($2) AND locked_at IS NULL",
+        )
+        .bind(TargetType::Subject)
+        .bind(&subject_payloads)
+        .fetch_all(db_pool)
+        .await?;
+
+        // Convert to a HashSet for efficient lookup
+        let existing_payloads: std::collections::HashSet<String> = existing_jobs
+            .into_iter()
+            .map(|(payload,)| payload.to_string())
+            .collect();
+
+        // Filter out subjects that already have jobs and prepare new jobs
+        let mut skipped_count = 0;
+        let new_jobs: Vec<_> = subjects
+            .into_iter()
+            .filter_map(|subject| {
+                let job = SubjectJob::new(subject.code.clone());
+                let payload = serde_json::to_value(&job).unwrap();
+                let payload_str = payload.to_string();
+
+                if existing_payloads.contains(&payload_str) {
+                    skipped_count += 1;
+                    None
+                } else {
+                    Some((payload, subject.code))
+                }
+            })
+            .collect();
+
+        if skipped_count > 0 {
+            debug!(count = skipped_count, "Skipped subjects with existing jobs");
+        }
+
+        // Insert all new jobs in a single batch
+        if !new_jobs.is_empty() {
+            let now = chrono::Utc::now();
+            let mut tx = db_pool.begin().await?;
+
+            for (payload, subject_code) in new_jobs {
+                sqlx::query(
+                    "INSERT INTO scrape_jobs (target_type, target_payload, priority, execute_at) VALUES ($1, $2, $3, $4)"
+                )
+                .bind(TargetType::Subject)
+                .bind(&payload)
+                .bind(ScrapePriority::Low)
+                .bind(now)
+                .execute(&mut *tx)
+                .await?;
+
+                debug!(subject = subject_code, "New job enqueued for subject");
+            }
+
+            tx.commit().await?;
+        }
+
+        debug!("Job scheduling complete");
+        Ok(())
+    }
+}

src/scraper/worker.rs

@@ -0,0 +1,300 @@
+use crate::banner::{BannerApi, BannerApiError};
+use crate::data::models::ScrapeJob;
+use crate::error::Result;
+use crate::scraper::jobs::{JobError, JobType};
+use sqlx::PgPool;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::broadcast;
+use tokio::time;
+use tracing::{Instrument, debug, error, info, trace, warn};
+
+/// A single worker instance.
+///
+/// Each worker runs in its own asynchronous task and continuously polls the
+/// database for scrape jobs to execute.
+pub struct Worker {
+    id: usize, // For logging purposes
+    db_pool: PgPool,
+    banner_api: Arc<BannerApi>,
+}
+
+impl Worker {
+    pub fn new(id: usize, db_pool: PgPool, banner_api: Arc<BannerApi>) -> Self {
+        Self {
+            id,
+            db_pool,
+            banner_api,
+        }
+    }
+
+    /// Runs the worker's main loop.
+    pub async fn run(&self, mut shutdown_rx: broadcast::Receiver<()>) {
+        info!(worker_id = self.id, "Worker started");
+
+        loop {
+            // Fetch and lock a job, racing against shutdown signal
+            let job = tokio::select! {
+                _ = shutdown_rx.recv() => {
+                    info!(worker_id = self.id, "Worker received shutdown signal, exiting gracefully");
+                    break;
+                }
+                result = self.fetch_and_lock_job() => {
+                    match result {
+                        Ok(Some(job)) => job,
+                        Ok(None) => {
+                            trace!(worker_id = self.id, "No jobs available, waiting");
+                            time::sleep(Duration::from_secs(5)).await;
+                            continue;
+                        }
+                        Err(e) => {
+                            warn!(worker_id = self.id, error = ?e, "Failed to fetch job, waiting");
+                            time::sleep(Duration::from_secs(10)).await;
+                            continue;
+                        }
+                    }
+                }
+            };
+
+            let job_id = job.id;
+            let retry_count = job.retry_count;
+            let max_retries = job.max_retries;
+            let start = std::time::Instant::now();
+
+            // Process the job, racing against shutdown signal
+            let process_result = tokio::select! {
+                _ = shutdown_rx.recv() => {
+                    self.handle_shutdown_during_processing(job_id).await;
+                    break;
+                }
+                result = self.process_job(job) => result
+            };
+
+            let duration = start.elapsed();
+
+            // Handle the job processing result
+            self.handle_job_result(job_id, retry_count, max_retries, process_result, duration)
+                .await;
+        }
+    }
+
+    /// Atomically fetches a job from the queue, locking it for processing.
+    ///
+    /// This uses a `FOR UPDATE SKIP LOCKED` query to ensure that multiple
+    /// workers can poll the queue concurrently without conflicts.
+    async fn fetch_and_lock_job(&self) -> Result<Option<ScrapeJob>> {
+        let mut tx = self.db_pool.begin().await?;
+
+        let job = sqlx::query_as::<_, ScrapeJob>(
+            "SELECT * FROM scrape_jobs WHERE locked_at IS NULL AND execute_at <= NOW() ORDER BY priority DESC, execute_at ASC LIMIT 1 FOR UPDATE SKIP LOCKED"
+        )
+        .fetch_optional(&mut *tx)
+        .await?;
+
+        if let Some(ref job) = job {
+            sqlx::query("UPDATE scrape_jobs SET locked_at = NOW() WHERE id = $1")
+                .bind(job.id)
+                .execute(&mut *tx)
+                .await?;
+        }
+
+        tx.commit().await?;
+
+        Ok(job)
+    }
+
+    async fn process_job(&self, job: ScrapeJob) -> Result<(), JobError> {
+        // Convert the database job to our job type
+        let job_type = JobType::from_target_type_and_payload(job.target_type, job.target_payload)
+            .map_err(|e| JobError::Unrecoverable(anyhow::anyhow!(e)))?; // Parse errors are unrecoverable
+
+        // Get the job implementation
+        let job_impl = job_type.boxed();
+
+        // Create span with job context
+        let span = tracing::debug_span!(
+            "process_job",
+            job_id = job.id,
+            job_type = job_impl.description()
+        );
+
+        async move {
+            debug!(
+                worker_id = self.id,
+                job_id = job.id,
+                description = job_impl.description(),
+                "Processing job"
+            );
+
+            // Process the job - API errors are recoverable
+            job_impl
+                .process(&self.banner_api, &self.db_pool)
+                .await
+                .map_err(JobError::Recoverable)?;
+
+            Ok(())
+        }
+        .instrument(span)
+        .await
+    }
+
+    async fn delete_job(&self, job_id: i32) -> Result<()> {
+        sqlx::query("DELETE FROM scrape_jobs WHERE id = $1")
+            .bind(job_id)
+            .execute(&self.db_pool)
+            .await?;
+        Ok(())
+    }
+
+    async fn unlock_job(&self, job_id: i32) -> Result<()> {
+        sqlx::query("UPDATE scrape_jobs SET locked_at = NULL WHERE id = $1")
+            .bind(job_id)
+            .execute(&self.db_pool)
+            .await?;
+        Ok(())
+    }
+
+    async fn unlock_and_increment_retry(&self, job_id: i32, max_retries: i32) -> Result<bool> {
+        let result = sqlx::query_scalar::<_, Option<i32>>(
+            "UPDATE scrape_jobs
+             SET locked_at = NULL, retry_count = retry_count + 1
+             WHERE id = $1
+             RETURNING CASE WHEN retry_count + 1 < $2 THEN retry_count + 1 ELSE NULL END",
+        )
+        .bind(job_id)
+        .bind(max_retries)
+        .fetch_one(&self.db_pool)
+        .await?;
+
+        Ok(result.is_some())
+    }
+
+    /// Handle shutdown signal received during job processing
+    async fn handle_shutdown_during_processing(&self, job_id: i32) {
+        info!(
+            worker_id = self.id,
+            job_id, "Shutdown received during job processing"
+        );
+
+        if let Err(e) = self.unlock_job(job_id).await {
+            warn!(
+                worker_id = self.id,
+                job_id,
+                error = ?e,
+                "Failed to unlock job during shutdown"
+            );
+        } else {
+            debug!(worker_id = self.id, job_id, "Job unlocked during shutdown");
+        }
+
+        info!(worker_id = self.id, "Worker exiting gracefully");
+    }
+
+    /// Handle the result of job processing
+    async fn handle_job_result(
+        &self,
+        job_id: i32,
+        retry_count: i32,
+        max_retries: i32,
+        result: Result<(), JobError>,
+        duration: std::time::Duration,
+    ) {
+        match result {
+            Ok(()) => {
+                debug!(
+                    worker_id = self.id,
+                    job_id,
+                    duration_ms = duration.as_millis(),
+                    "Job completed successfully"
+                );
+                if let Err(e) = self.delete_job(job_id).await {
+                    error!(worker_id = self.id, job_id, error = ?e, "Failed to delete completed job");
+                }
+            }
+            Err(JobError::Recoverable(e)) => {
+                self.handle_recoverable_error(job_id, retry_count, max_retries, e, duration)
+                    .await;
+            }
+            Err(JobError::Unrecoverable(e)) => {
+                error!(
+                    worker_id = self.id,
+                    job_id,
+                    duration_ms = duration.as_millis(),
+                    error = ?e,
+                    "Job corrupted, deleting"
+                );
+                if let Err(e) = self.delete_job(job_id).await {
+                    error!(worker_id = self.id, job_id, error = ?e, "Failed to delete corrupted job");
+                }
+            }
+        }
+    }
+
+    /// Handle recoverable errors by logging appropriately and unlocking the job
+    async fn handle_recoverable_error(
+        &self,
+        job_id: i32,
+        retry_count: i32,
+        max_retries: i32,
+        e: anyhow::Error,
+        duration: std::time::Duration,
+    ) {
+        let next_attempt = retry_count.saturating_add(1);
+        let remaining_retries = max_retries.saturating_sub(next_attempt);
+
+        // Log the error appropriately based on type
+        if let Some(BannerApiError::InvalidSession(_)) = e.downcast_ref::<BannerApiError>() {
+            warn!(
+                worker_id = self.id,
+                job_id,
+                duration_ms = duration.as_millis(),
+                retry_attempt = next_attempt,
+                max_retries = max_retries,
+                remaining_retries = remaining_retries,
+                "Invalid session detected, will retry"
+            );
+        } else {
+            error!(
+                worker_id = self.id,
+                job_id,
+                duration_ms = duration.as_millis(),
+                retry_attempt = next_attempt,
+                max_retries = max_retries,
+                remaining_retries = remaining_retries,
+                error = ?e,
+                "Failed to process job, will retry"
+            );
+        }
+
+        // Atomically unlock and increment retry count, checking if retry is allowed
+        match self.unlock_and_increment_retry(job_id, max_retries).await {
+            Ok(can_retry) if can_retry => {
+                info!(
+                    worker_id = self.id,
+                    job_id,
+                    retry_attempt = next_attempt,
+                    remaining_retries = remaining_retries,
+                    "Job unlocked for retry"
+                );
+            }
+            Ok(_) => {
+                // Max retries exceeded (detected atomically)
+                error!(
+                    worker_id = self.id,
+                    job_id,
+                    duration_ms = duration.as_millis(),
+                    retry_count = next_attempt,
+                    max_retries = max_retries,
+                    error = ?e,
+                    "Job failed permanently (max retries exceeded), deleting"
+                );
+                if let Err(e) = self.delete_job(job_id).await {
+                    error!(worker_id = self.id, job_id, error = ?e, "Failed to delete failed job");
+                }
+            }
+            Err(e) => {
+                error!(worker_id = self.id, job_id, error = ?e, "Failed to unlock and increment retry count");
+            }
+        }
+    }
+}

src/services/bot.rs

@@ -0,0 +1,240 @@
+use super::Service;
+use crate::bot::{Data, get_commands};
+use crate::config::Config;
+use crate::state::AppState;
+use num_format::{Locale, ToFormattedString};
+use serenity::Client;
+use serenity::all::{ActivityData, ClientBuilder, GatewayIntents};
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::{Mutex, broadcast};
+use tokio::task::JoinHandle;
+use tracing::{debug, error, info, warn};
+
+/// Discord bot service implementation
+pub struct BotService {
+    client: Client,
+    shard_manager: Arc<serenity::gateway::ShardManager>,
+    status_task_handle: Arc<Mutex<Option<JoinHandle<()>>>>,
+    status_shutdown_tx: Option<broadcast::Sender<()>>,
+}
+
+impl BotService {
+    /// Create a new Discord bot client with full configuration
+    pub async fn create_client(
+        config: &Config,
+        app_state: AppState,
+        status_task_handle: Arc<Mutex<Option<JoinHandle<()>>>>,
+        status_shutdown_rx: broadcast::Receiver<()>,
+    ) -> Result<Client, anyhow::Error> {
+        let intents = GatewayIntents::non_privileged();
+        let bot_target_guild = config.bot_target_guild;
+
+        let framework = poise::Framework::builder()
+            .options(poise::FrameworkOptions {
+                commands: get_commands(),
+                pre_command: |ctx| {
+                    Box::pin(async move {
+                        let content = match ctx {
+                            poise::Context::Application(_) => ctx.invocation_string(),
+                            poise::Context::Prefix(prefix) => prefix.msg.content.to_string(),
+                        };
+                        let channel_name = ctx
+                            .channel_id()
+                            .name(ctx.http())
+                            .await
+                            .unwrap_or("unknown".to_string());
+
+                        let span = tracing::Span::current();
+                        span.record("command_name", ctx.command().qualified_name.as_str());
+                        span.record("invocation", ctx.invocation_string());
+                        span.record("msg.content", content.as_str());
+                        span.record("msg.author", ctx.author().tag().as_str());
+                        span.record("msg.id", ctx.id());
+                        span.record("msg.channel_id", ctx.channel_id().get());
+                        span.record("msg.channel", channel_name.as_str());
+
+                        tracing::info!(
+                            command_name = ctx.command().qualified_name.as_str(),
+                            invocation = ctx.invocation_string(),
+                            msg.content = %content,
+                            msg.author = %ctx.author().tag(),
+                            msg.author_id = %ctx.author().id,
+                            msg.id = %ctx.id(),
+                            msg.channel = %channel_name.as_str(),
+                            msg.channel_id = %ctx.channel_id(),
+                            "{} invoked by {}",
+                            ctx.command().name,
+                            ctx.author().tag()
+                        );
+                    })
+                },
+                on_error: |error| {
+                    Box::pin(async move {
+                        if let Err(e) = poise::builtins::on_error(error).await {
+                            tracing::error!(error = %e, "Fatal error while sending error message");
+                        }
+                    })
+                },
+                ..Default::default()
+            })
+            .setup(move |ctx, _ready, framework| {
+                let app_state = app_state.clone();
+                let status_task_handle = status_task_handle.clone();
+                Box::pin(async move {
+                    poise::builtins::register_in_guild(
+                        ctx,
+                        &framework.options().commands,
+                        bot_target_guild.into(),
+                    )
+                    .await?;
+                    poise::builtins::register_globally(ctx, &framework.options().commands).await?;
+
+                    // Start status update task with shutdown support
+                    let handle = Self::start_status_update_task(
+                        ctx.clone(),
+                        app_state.clone(),
+                        status_shutdown_rx,
+                    );
+                    *status_task_handle.lock().await = Some(handle);
+
+                    Ok(Data { app_state })
+                })
+            })
+            .build();
+
+        Ok(ClientBuilder::new(config.bot_token.clone(), intents)
+            .framework(framework)
+            .await?)
+    }
+
+    /// Start the status update task for the Discord bot with graceful shutdown support
+    fn start_status_update_task(
+        ctx: serenity::client::Context,
+        app_state: AppState,
+        mut shutdown_rx: broadcast::Receiver<()>,
+    ) -> JoinHandle<()> {
+        tokio::spawn(async move {
+            let max_interval = Duration::from_secs(300); // 5 minutes
+            let base_interval = Duration::from_secs(30);
+            let mut interval = tokio::time::interval(base_interval);
+            let mut previous_course_count: Option<i64> = None;
+
+            // This runs once immediately on startup, then with adaptive intervals
+            loop {
+                tokio::select! {
+                    _ = interval.tick() => {
+                        // Get the course count, update the activity if it has changed/hasn't been set this session
+                        let course_count = app_state.get_course_count().await.unwrap();
+                        if previous_course_count.is_none() || previous_course_count != Some(course_count) {
+                            ctx.set_activity(Some(ActivityData::playing(format!(
+                                "Querying {:} classes",
+                                course_count.to_formatted_string(&Locale::en)
+                            ))));
+                        }
+
+                        // Increase or reset the interval
+                        interval = tokio::time::interval(
+                            // Avoid logging the first 'change'
+                            if course_count != previous_course_count.unwrap_or(0) {
+                                if previous_course_count.is_some() {
+                                    debug!(
+                                        new_course_count = course_count,
+                                        last_interval = interval.period().as_secs(),
+                                        "Course count changed, resetting interval"
+                                    );
+                                }
+
+                                // Record the new course count
+                                previous_course_count = Some(course_count);
+
+                                // Reset to base interval
+                                base_interval
+                            } else {
+                                // Increase interval by 10% (up to maximum)
+                                let new_interval = interval.period().mul_f32(1.1).min(max_interval);
+                                debug!(
+                                    current_course_count = course_count,
+                                    last_interval = interval.period().as_secs(),
+                                    new_interval = new_interval.as_secs(),
+                                    "Course count unchanged, increasing interval"
+                                );
+
+                                new_interval
+                            },
+                        );
+
+                        // Reset the interval, otherwise it will tick again immediately
+                        interval.reset();
+                    }
+                    _ = shutdown_rx.recv() => {
+                        info!("Status update task received shutdown signal");
+                        break;
+                    }
+                }
+            }
+        })
+    }
+
+    pub fn new(
+        client: Client,
+        status_task_handle: Arc<Mutex<Option<JoinHandle<()>>>>,
+        status_shutdown_tx: broadcast::Sender<()>,
+    ) -> Self {
+        let shard_manager = client.shard_manager.clone();
+
+        Self {
+            client,
+            shard_manager,
+            status_task_handle,
+            status_shutdown_tx: Some(status_shutdown_tx),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl Service for BotService {
+    fn name(&self) -> &'static str {
+        "bot"
+    }
+
+    async fn run(&mut self) -> Result<(), anyhow::Error> {
+        match self.client.start().await {
+            Ok(()) => {
+                warn!(service = "bot", "stopped early");
+                Err(anyhow::anyhow!("bot stopped early"))
+            }
+            Err(e) => {
+                error!(service = "bot", "error: {e:?}");
+                Err(e.into())
+            }
+        }
+    }
+
+    async fn shutdown(&mut self) -> Result<(), anyhow::Error> {
+        // Signal status update task to stop
+        if let Some(status_shutdown_tx) = self.status_shutdown_tx.take() {
+            let _ = status_shutdown_tx.send(());
+        }
+
+        // Wait for status update task to complete (with timeout)
+        let handle = self.status_task_handle.lock().await.take();
+        if let Some(handle) = handle {
+            match tokio::time::timeout(Duration::from_secs(2), handle).await {
+                Ok(Ok(())) => {
+                    debug!("Status update task completed gracefully");
+                }
+                Ok(Err(e)) => {
+                    warn!(error = ?e, "Status update task panicked");
+                }
+                Err(_) => {
+                    warn!("Status update task did not complete within 2s timeout");
+                }
+            }
+        }
+
+        // Shutdown Discord shards
+        self.shard_manager.shutdown_all().await;
+        Ok(())
+    }
+}

src/services/manager.rs

@@ -0,0 +1,220 @@
+use std::collections::HashMap;
+use std::time::Duration;
+use tokio::sync::{broadcast, mpsc};
+use tracing::{debug, info, trace, warn};
+
+use crate::services::{Service, ServiceResult, run_service};
+
+/// Manages multiple services and their lifecycle
+pub struct ServiceManager {
+    registered_services: HashMap<String, Box<dyn Service>>,
+    service_handles: HashMap<String, tokio::task::AbortHandle>,
+    completion_rx: Option<mpsc::UnboundedReceiver<(String, ServiceResult)>>,
+    completion_tx: mpsc::UnboundedSender<(String, ServiceResult)>,
+    shutdown_tx: broadcast::Sender<()>,
+}
+
+impl Default for ServiceManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ServiceManager {
+    pub fn new() -> Self {
+        let (shutdown_tx, _) = broadcast::channel(1);
+        let (completion_tx, completion_rx) = mpsc::unbounded_channel();
+
+        Self {
+            registered_services: HashMap::new(),
+            service_handles: HashMap::new(),
+            completion_rx: Some(completion_rx),
+            completion_tx,
+            shutdown_tx,
+        }
+    }
+
+    /// Register a service to be managed (not yet spawned)
+    pub fn register_service(&mut self, name: &str, service: Box<dyn Service>) {
+        self.registered_services.insert(name.to_string(), service);
+    }
+
+    /// Check if there are any registered services
+    pub fn has_services(&self) -> bool {
+        !self.registered_services.is_empty()
+    }
+
+    /// Spawn all registered services
+    pub fn spawn_all(&mut self) {
+        let service_count = self.registered_services.len();
+        let service_names: Vec<_> = self.registered_services.keys().cloned().collect();
+
+        for (name, service) in self.registered_services.drain() {
+            let shutdown_rx = self.shutdown_tx.subscribe();
+            let completion_tx = self.completion_tx.clone();
+            let name_clone = name.clone();
+
+            // Spawn service task
+            let handle = tokio::spawn(async move {
+                let result = run_service(service, shutdown_rx).await;
+                // Send completion notification
+                let _ = completion_tx.send((name_clone, result));
+            });
+
+            // Store abort handle for shutdown control
+            self.service_handles
+                .insert(name.clone(), handle.abort_handle());
+            debug!(service = name, id = ?handle.id(), "service spawned");
+        }
+
+        info!(
+            service_count,
+            services = ?service_names,
+            "spawned {} services",
+            service_count
+        );
+    }
+
+    /// Run all services until one completes or fails
+    /// Returns the first service that completes and its result
+    pub async fn run(&mut self) -> (String, ServiceResult) {
+        if self.service_handles.is_empty() {
+            return (
+                "none".to_string(),
+                ServiceResult::Error(anyhow::anyhow!("No services to run")),
+            );
+        }
+
+        info!(
+            "servicemanager running {} services",
+            self.service_handles.len()
+        );
+
+        // Wait for any service to complete via the channel
+        let completion_rx = self
+            .completion_rx
+            .as_mut()
+            .expect("completion_rx should be available");
+
+        completion_rx
+            .recv()
+            .await
+            .map(|(name, result)| {
+                self.service_handles.remove(&name);
+                (name, result)
+            })
+            .unwrap_or_else(|| {
+                (
+                    "channel_closed".to_string(),
+                    ServiceResult::Error(anyhow::anyhow!("Completion channel closed")),
+                )
+            })
+    }
+
+    /// Shutdown all services gracefully with a timeout.
+    ///
+    /// All services receive the shutdown signal simultaneously and shut down in parallel.
+    /// Each service gets the full timeout duration (they don't share/consume from a budget).
+    /// If any service fails to shutdown within the timeout, it will be aborted.
+    ///
+    /// Returns the elapsed time if all succeed, or a list of failed service names.
+    pub async fn shutdown(&mut self, timeout: Duration) -> Result<Duration, Vec<String>> {
+        let service_count = self.service_handles.len();
+        let service_names: Vec<_> = self.service_handles.keys().cloned().collect();
+
+        info!(
+            service_count,
+            services = ?service_names,
+            timeout = format!("{:.2?}", timeout),
+            "shutting down {} services in parallel with {:?} timeout each",
+            service_count,
+            timeout
+        );
+
+        if service_count == 0 {
+            return Ok(Duration::ZERO);
+        }
+
+        // Send shutdown signal to all services simultaneously
+        let _ = self.shutdown_tx.send(());
+
+        let start_time = std::time::Instant::now();
+
+        // Collect results from all services with timeout
+        let completion_rx = self
+            .completion_rx
+            .as_mut()
+            .expect("completion_rx should be available");
+
+        // Collect all completion results with a single timeout
+        let collect_future = async {
+            let mut collected: Vec<Option<(String, ServiceResult)>> = Vec::new();
+            for _ in 0..service_count {
+                if let Some(result) = completion_rx.recv().await {
+                    collected.push(Some(result));
+                } else {
+                    collected.push(None);
+                }
+            }
+            collected
+        };
+
+        let results = match tokio::time::timeout(timeout, collect_future).await {
+            Ok(results) => results,
+            Err(_) => {
+                // Timeout exceeded - abort all remaining services
+                warn!(
+                    timeout = format!("{:.2?}", timeout),
+                    "shutdown timeout exceeded - aborting all remaining services"
+                );
+
+                let failed: Vec<String> = self.service_handles.keys().cloned().collect();
+                for handle in self.service_handles.values() {
+                    handle.abort();
+                }
+                self.service_handles.clear();
+
+                return Err(failed);
+            }
+        };
+
+        // Process results and identify failures
+        let mut failed_services = Vec::new();
+        for (name, service_result) in results.into_iter().flatten() {
+            self.service_handles.remove(&name);
+
+            if matches!(service_result, ServiceResult::GracefulShutdown) {
+                trace!(service = name, "service shutdown completed");
+            } else {
+                warn!(
+                    service = name,
+                    result = ?service_result,
+                    "service shutdown with non-graceful result"
+                );
+                failed_services.push(name);
+            }
+        }
+
+        let elapsed = start_time.elapsed();
+
+        if failed_services.is_empty() {
+            info!(
+                service_count,
+                elapsed = format!("{:.2?}", elapsed),
+                "all services shutdown successfully: {}",
+                service_names.join(", ")
+            );
+            Ok(elapsed)
+        } else {
+            warn!(
+                failed_count = failed_services.len(),
+                failed_services = ?failed_services,
+                elapsed = format!("{:.2?}", elapsed),
+                "{} service(s) failed to shutdown gracefully: {}",
+                failed_services.len(),
+                failed_services.join(", ")
+            );
+            Err(failed_services)
+        }
+    }
+}

src/services/mod.rs

@@ -0,0 +1,75 @@
+use tokio::sync::broadcast;
+use tracing::{error, info, warn};
+
+pub mod bot;
+pub mod manager;
+pub mod web;
+
+#[derive(Debug)]
+pub enum ServiceResult {
+    GracefulShutdown,
+    NormalCompletion,
+    Error(anyhow::Error),
+}
+
+/// Common trait for all services in the application
+#[async_trait::async_trait]
+pub trait Service: Send + Sync {
+    /// The name of the service for logging
+    fn name(&self) -> &'static str;
+
+    /// Run the service's main work loop
+    async fn run(&mut self) -> Result<(), anyhow::Error>;
+
+    /// Gracefully shutdown the service
+    ///
+    /// Implementations should initiate shutdown and MAY wait for completion.
+    /// Services are expected to respond to this call and begin cleanup promptly.
+    /// When managed by ServiceManager, the configured timeout (default 8s) applies to
+    /// ALL services combined, not per-service. Services should complete shutdown as
+    /// quickly as possible to avoid timeout.
+    async fn shutdown(&mut self) -> Result<(), anyhow::Error>;
+}
+
+/// Generic service runner that handles the lifecycle
+pub async fn run_service(
+    mut service: Box<dyn Service>,
+    mut shutdown_rx: broadcast::Receiver<()>,
+) -> ServiceResult {
+    let name = service.name();
+    info!(service = name, "service started");
+
+    let work = async {
+        match service.run().await {
+            Ok(()) => {
+                warn!(service = name, "service completed unexpectedly");
+                ServiceResult::NormalCompletion
+            }
+            Err(e) => {
+                error!(service = name, "service failed: {e}");
+                ServiceResult::Error(e)
+            }
+        }
+    };
+
+    tokio::select! {
+        result = work => result,
+        _ = shutdown_rx.recv() => {
+            info!(service = name, "shutting down...");
+            let start_time = std::time::Instant::now();
+
+            match service.shutdown().await {
+                Ok(()) => {
+                    let elapsed = start_time.elapsed();
+                    info!(service = name, "shutdown completed in {elapsed:.2?}");
+                    ServiceResult::GracefulShutdown
+                }
+                Err(e) => {
+                    let elapsed = start_time.elapsed();
+                    error!(service = name, "shutdown failed after {elapsed:.2?}: {e}");
+                    ServiceResult::Error(e)
+                }
+            }
+        }
+    }
+}

src/services/web.rs

@@ -0,0 +1,78 @@
+use super::Service;
+use crate::web::{BannerState, create_router};
+use std::net::SocketAddr;
+use tokio::net::TcpListener;
+use tokio::sync::broadcast;
+use tracing::{info, trace, warn};
+
+/// Web server service implementation
+pub struct WebService {
+    port: u16,
+    banner_state: BannerState,
+    shutdown_tx: Option<broadcast::Sender<()>>,
+}
+
+impl WebService {
+    pub fn new(port: u16, banner_state: BannerState) -> Self {
+        Self {
+            port,
+            banner_state,
+            shutdown_tx: None,
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl Service for WebService {
+    fn name(&self) -> &'static str {
+        "web"
+    }
+
+    async fn run(&mut self) -> Result<(), anyhow::Error> {
+        // Create the main router with Banner API routes
+        let app = create_router(self.banner_state.clone());
+
+        let addr = SocketAddr::from(([0, 0, 0, 0], self.port));
+
+        let listener = TcpListener::bind(addr).await?;
+        info!(
+            service = "web",
+            address = %addr,
+            link = format!("http://localhost:{}", addr.port()),
+            "web server listening"
+        );
+
+        // Create internal shutdown channel for axum graceful shutdown
+        let (shutdown_tx, mut shutdown_rx) = broadcast::channel(1);
+        self.shutdown_tx = Some(shutdown_tx);
+
+        // Use axum's graceful shutdown with the internal shutdown signal
+        axum::serve(listener, app)
+            .with_graceful_shutdown(async move {
+                let _ = shutdown_rx.recv().await;
+                trace!(
+                    service = "web",
+                    "received shutdown signal, starting graceful shutdown"
+                );
+            })
+            .await?;
+
+        trace!(service = "web", "graceful shutdown completed");
+        info!(service = "web", "web server stopped");
+
+        Ok(())
+    }
+
+    async fn shutdown(&mut self) -> Result<(), anyhow::Error> {
+        if let Some(shutdown_tx) = self.shutdown_tx.take() {
+            let _ = shutdown_tx.send(());
+            trace!(service = "web", "sent shutdown signal to axum");
+        } else {
+            warn!(
+                service = "web",
+                "no shutdown channel found, cannot trigger graceful shutdown"
+            );
+        }
+        Ok(())
+    }
+}

src/signals.rs

@@ -0,0 +1,106 @@
+use crate::services::ServiceResult;
+use crate::services::manager::ServiceManager;
+use std::process::ExitCode;
+use std::time::Duration;
+use tokio::signal;
+use tracing::{error, info, warn};
+
+/// Handle application shutdown signals and graceful shutdown
+pub async fn handle_shutdown_signals(
+    mut service_manager: ServiceManager,
+    shutdown_timeout: Duration,
+) -> ExitCode {
+    // Set up signal handling for both SIGINT (Ctrl+C) and SIGTERM
+    let ctrl_c = async {
+        signal::ctrl_c()
+            .await
+            .expect("Failed to install CTRL+C signal handler");
+        info!("received ctrl+c, gracefully shutting down...");
+    };
+
+    #[cfg(unix)]
+    let sigterm = async {
+        use tokio::signal::unix::{SignalKind, signal};
+        let mut sigterm_stream =
+            signal(SignalKind::terminate()).expect("Failed to install SIGTERM signal handler");
+        sigterm_stream.recv().await;
+        info!("received SIGTERM, gracefully shutting down...");
+    };
+
+    #[cfg(not(unix))]
+    let sigterm = async {
+        // On non-Unix systems, create a future that never completes
+        // This ensures the select! macro works correctly
+        std::future::pending::<()>().await;
+    };
+
+    // Main application loop - wait for services or signals
+    let mut exit_code = ExitCode::SUCCESS;
+
+    tokio::select! {
+        (service_name, result) = service_manager.run() => {
+            // A service completed unexpectedly
+            match result {
+                ServiceResult::GracefulShutdown => {
+                    info!(service = service_name, "service completed gracefully");
+                }
+                ServiceResult::NormalCompletion => {
+                    warn!(service = service_name, "service completed unexpectedly");
+                    exit_code = ExitCode::FAILURE;
+                }
+                ServiceResult::Error(e) => {
+                    error!(service = service_name, error = ?e, "service failed");
+                    exit_code = ExitCode::FAILURE;
+                }
+            }
+
+            // Shutdown remaining services
+            exit_code = handle_graceful_shutdown(service_manager, shutdown_timeout, exit_code).await;
+        }
+        _ = ctrl_c => {
+            // User requested shutdown via Ctrl+C
+            info!("user requested shutdown via ctrl+c");
+            exit_code = handle_graceful_shutdown(service_manager, shutdown_timeout, ExitCode::SUCCESS).await;
+        }
+        _ = sigterm => {
+            // System requested shutdown via SIGTERM
+            info!("system requested shutdown via SIGTERM");
+            exit_code = handle_graceful_shutdown(service_manager, shutdown_timeout, ExitCode::SUCCESS).await;
+        }
+    }
+
+    info!(exit_code = ?exit_code, "application shutdown complete");
+    exit_code
+}
+
+/// Handle graceful shutdown of remaining services
+async fn handle_graceful_shutdown(
+    mut service_manager: ServiceManager,
+    shutdown_timeout: Duration,
+    current_exit_code: ExitCode,
+) -> ExitCode {
+    match service_manager.shutdown(shutdown_timeout).await {
+        Ok(elapsed) => {
+            info!(
+                remaining = format!("{:.2?}", shutdown_timeout - elapsed),
+                "graceful shutdown complete"
+            );
+            current_exit_code
+        }
+        Err(pending_services) => {
+            warn!(
+                pending_count = pending_services.len(),
+                pending_services = ?pending_services,
+                "graceful shutdown elapsed - {} service(s) did not complete",
+                pending_services.len()
+            );
+
+            // Non-zero exit code, default to FAILURE if not set
+            if current_exit_code == ExitCode::SUCCESS {
+                ExitCode::FAILURE
+            } else {
+                current_exit_code
+            }
+        }
+    }
+}

src/state.rs

@@ -0,0 +1,38 @@
+//! Application state shared across components (bot, web, scheduler).
+
+use crate::banner::BannerApi;
+use crate::banner::Course;
+use anyhow::Result;
+use sqlx::PgPool;
+use std::sync::Arc;
+
+#[derive(Clone)]
+pub struct AppState {
+    pub banner_api: Arc<BannerApi>,
+    pub db_pool: PgPool,
+}
+
+impl AppState {
+    pub fn new(banner_api: Arc<BannerApi>, db_pool: PgPool) -> Self {
+        Self {
+            banner_api,
+            db_pool,
+        }
+    }
+
+    /// Get a course by CRN directly from Banner API
+    pub async fn get_course_or_fetch(&self, term: &str, crn: &str) -> Result<Course> {
+        self.banner_api
+            .get_course_by_crn(term, crn)
+            .await?
+            .ok_or_else(|| anyhow::anyhow!("Course not found for CRN {crn}"))
+    }
+
+    /// Get the total number of courses in the database
+    pub async fn get_course_count(&self) -> Result<i64> {
+        let count: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM courses")
+            .fetch_one(&self.db_pool)
+            .await?;
+        Ok(count.0)
+    }
+}

src/utils/mod.rs

@@ -0,0 +1 @@
+pub mod shutdown;

src/utils/shutdown.rs

@@ -0,0 +1,32 @@
+use tokio::task::JoinHandle;
+use tracing::warn;
+
+/// Helper for joining multiple task handles with proper error handling.
+///
+/// This function waits for all tasks to complete and reports any that panicked.
+/// Returns an error if any task panicked, otherwise returns Ok.
+pub async fn join_tasks(handles: Vec<JoinHandle<()>>) -> Result<(), anyhow::Error> {
+    let results = futures::future::join_all(handles).await;
+
+    let failed = results.iter().filter(|r| r.is_err()).count();
+    if failed > 0 {
+        warn!(failed_count = failed, "Some tasks panicked during shutdown");
+        Err(anyhow::anyhow!("{} task(s) panicked", failed))
+    } else {
+        Ok(())
+    }
+}
+
+/// Helper for joining multiple task handles with a timeout.
+///
+/// Waits for all tasks to complete within the specified timeout.
+/// If timeout occurs, remaining tasks are aborted.
+pub async fn join_tasks_with_timeout(
+    handles: Vec<JoinHandle<()>>,
+    timeout: std::time::Duration,
+) -> Result<(), anyhow::Error> {
+    match tokio::time::timeout(timeout, join_tasks(handles)).await {
+        Ok(result) => result,
+        Err(_) => Err(anyhow::anyhow!("Task join timed out after {:?}", timeout)),
+    }
+}

src/web/assets.rs

@@ -0,0 +1,96 @@
+//! Embedded assets for the web frontend
+//!
+//! This module handles serving static assets that are embedded into the binary
+//! at compile time using rust-embed.
+
+use dashmap::DashMap;
+use once_cell::sync::Lazy;
+use rapidhash::v3::rapidhash_v3;
+use rust_embed::RustEmbed;
+use std::fmt;
+
+/// Embedded web assets from the dist directory
+#[derive(RustEmbed)]
+#[folder = "web/dist/"]
+#[include = "*"]
+#[exclude = "*.map"]
+pub struct WebAssets;
+
+/// RapidHash hash type for asset content (u64 native output size)
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct AssetHash(u64);
+
+impl AssetHash {
+    /// Create a new AssetHash from u64 value
+    pub fn new(hash: u64) -> Self {
+        Self(hash)
+    }
+
+    /// Get the hash as a hex string
+    pub fn to_hex(&self) -> String {
+        format!("{:016x}", self.0)
+    }
+
+    /// Get the hash as a quoted hex string
+    pub fn quoted(&self) -> String {
+        format!("\"{}\"", self.to_hex())
+    }
+}
+
+impl fmt::Display for AssetHash {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.to_hex())
+    }
+}
+
+/// Metadata for an asset including MIME type and RapidHash hash
+#[derive(Debug, Clone)]
+pub struct AssetMetadata {
+    pub mime_type: Option<String>,
+    pub hash: AssetHash,
+}
+
+impl AssetMetadata {
+    /// Check if the etag matches the asset hash
+    pub fn etag_matches(&self, etag: &str) -> bool {
+        // Remove quotes if present (ETags are typically quoted)
+        let etag = etag.trim_matches('"');
+
+        // ETags generated from u64 hex should be 16 characters
+        etag.len() == 16
+        // Parse the hexadecimal, compare if it matches
+            && etag.parse::<u64>()
+                .map(|parsed| parsed == self.hash.0)
+                .unwrap_or(false)
+    }
+}
+
+/// Global cache for asset metadata to avoid repeated calculations
+static ASSET_CACHE: Lazy<DashMap<String, AssetMetadata>> = Lazy::new(DashMap::new);
+
+/// Get cached asset metadata for a file path, caching on-demand
+/// Returns AssetMetadata containing MIME type and RapidHash hash
+pub fn get_asset_metadata_cached(path: &str, content: &[u8]) -> AssetMetadata {
+    // Check cache first
+    if let Some(cached) = ASSET_CACHE.get(path) {
+        return cached.value().clone();
+    }
+
+    // Calculate MIME type
+    let mime_type = mime_guess::from_path(path)
+        .first()
+        .map(|mime| mime.to_string());
+
+    // Calculate RapidHash hash (using u64 native output size)
+    let hash_value = rapidhash_v3(content);
+    let hash = AssetHash::new(hash_value);
+
+    let metadata = AssetMetadata { mime_type, hash };
+
+    // Only cache if we haven't exceeded the limit
+    if ASSET_CACHE.len() < 1000 {
+        ASSET_CACHE.insert(path.to_string(), metadata.clone());
+    }
+
+    metadata
+}

src/web/mod.rs

@@ -0,0 +1,6 @@
+//! Web API module for the banner application.
+
+pub mod assets;
+pub mod routes;
+
+pub use routes::*;

src/web/routes.rs

@@ -0,0 +1,296 @@
+//! Web API endpoints for Banner bot monitoring and metrics.
+
+use axum::{
+    Router,
+    body::Body,
+    extract::{Request, State},
+    http::{HeaderMap, HeaderValue, StatusCode, Uri},
+    response::{Html, IntoResponse, Json, Response},
+    routing::get,
+};
+use http::header;
+use serde::Serialize;
+use serde_json::{Value, json};
+use std::{collections::BTreeMap, time::Duration};
+use tower_http::timeout::TimeoutLayer;
+use tower_http::{
+    classify::ServerErrorsFailureClass,
+    cors::{Any, CorsLayer},
+    trace::TraceLayer,
+};
+use tracing::{Span, debug, info, warn};
+
+use crate::web::assets::{WebAssets, get_asset_metadata_cached};
+
+/// Set appropriate caching headers based on asset type
+fn set_caching_headers(response: &mut Response, path: &str, etag: &str) {
+    let headers = response.headers_mut();
+
+    // Set ETag
+    if let Ok(etag_value) = HeaderValue::from_str(etag) {
+        headers.insert(header::ETAG, etag_value);
+    }
+
+    // Set Cache-Control based on asset type
+    let cache_control = if path.starts_with("assets/") {
+        // Static assets with hashed filenames - long-term cache
+        "public, max-age=31536000, immutable"
+    } else if path == "index.html" {
+        // HTML files - short-term cache
+        "public, max-age=300"
+    } else {
+        match path.split_once('.').map(|(_, extension)| extension) {
+            Some(ext) => match ext {
+                // CSS/JS files - medium-term cache
+                "css" | "js" => "public, max-age=86400",
+                // Images - long-term cache
+                "png" | "jpg" | "jpeg" | "gif" | "svg" | "ico" => "public, max-age=2592000",
+                // Default for other files
+                _ => "public, max-age=3600",
+            },
+            // Default for files without an extension
+            None => "public, max-age=3600",
+        }
+    };
+
+    if let Ok(cache_control_value) = HeaderValue::from_str(cache_control) {
+        headers.insert(header::CACHE_CONTROL, cache_control_value);
+    }
+}
+
+/// Shared application state for web server
+#[derive(Clone)]
+pub struct BannerState {}
+
+/// Creates the web server router
+pub fn create_router(state: BannerState) -> Router {
+    let api_router = Router::new()
+        .route("/health", get(health))
+        .route("/status", get(status))
+        .route("/metrics", get(metrics))
+        .with_state(state);
+
+    let mut router = Router::new().nest("/api", api_router);
+
+    if cfg!(debug_assertions) {
+        router = router.layer(
+            CorsLayer::new()
+                .allow_origin(Any)
+                .allow_methods(Any)
+                .allow_headers(Any),
+        )
+    } else {
+        router = router.fallback(fallback);
+    }
+
+    router.layer((
+        TraceLayer::new_for_http()
+            .make_span_with(|request: &Request<Body>| {
+                tracing::debug_span!("request", path = request.uri().path())
+            })
+            .on_request(())
+            .on_body_chunk(())
+            .on_eos(())
+            .on_response(
+                |response: &Response<Body>, latency: Duration, _span: &Span| {
+                    let latency_threshold = if cfg!(debug_assertions) {
+                        Duration::from_millis(100)
+                    } else {
+                        Duration::from_millis(1000)
+                    };
+
+                    // Format latency, status, and code
+                    let (latency_str, status) = (
+                        format!("{latency:.2?}"),
+                        format!(
+                            "{} {}",
+                            response.status().as_u16(),
+                            response.status().canonical_reason().unwrap_or("??")
+                        ),
+                    );
+
+                    // Log in warn if latency is above threshold, otherwise debug
+                    if latency > latency_threshold {
+                        warn!(latency = latency_str, status = status, "Response");
+                    } else {
+                        debug!(latency = latency_str, status = status, "Response");
+                    }
+                },
+            )
+            .on_failure(
+                |error: ServerErrorsFailureClass, latency: Duration, _span: &Span| {
+                    warn!(
+                        error = ?error,
+                        latency = format!("{latency:.2?}"),
+                        "Request failed"
+                    );
+                },
+            ),
+        TimeoutLayer::new(Duration::from_secs(10)),
+    ))
+}
+
+/// Handler that extracts request information for caching
+async fn fallback(request: Request) -> Response {
+    let uri = request.uri().clone();
+    let headers = request.headers().clone();
+    handle_spa_fallback_with_headers(uri, headers).await
+}
+
+/// Handles SPA routing by serving index.html for non-API, non-asset requests
+/// This version includes HTTP caching headers and ETag support
+async fn handle_spa_fallback_with_headers(uri: Uri, request_headers: HeaderMap) -> Response {
+    let path = uri.path().trim_start_matches('/');
+
+    if let Some(content) = WebAssets::get(path) {
+        // Get asset metadata (MIME type and hash) with caching
+        let metadata = get_asset_metadata_cached(path, &content.data);
+
+        // Check if client has a matching ETag (conditional request)
+        if let Some(etag) = request_headers.get(header::IF_NONE_MATCH)
+            && metadata.etag_matches(etag.to_str().unwrap())
+        {
+            return StatusCode::NOT_MODIFIED.into_response();
+        }
+
+        // Use cached MIME type, only set Content-Type if we have a valid MIME type
+        let mut response = (
+            [(
+                header::CONTENT_TYPE,
+                // For unknown types, set to application/octet-stream
+                metadata
+                    .mime_type
+                    .unwrap_or("application/octet-stream".to_string()),
+            )],
+            content.data,
+        )
+            .into_response();
+
+        // Set caching headers
+        set_caching_headers(&mut response, path, &metadata.hash.quoted());
+
+        return response;
+    } else {
+        // Any assets that are not found should be treated as a 404, not falling back to the SPA index.html
+        if path.starts_with("assets/") {
+            return (StatusCode::NOT_FOUND, "Asset not found").into_response();
+        }
+    }
+
+    // Fall back to the SPA index.html
+    match WebAssets::get("index.html") {
+        Some(content) => {
+            let metadata = get_asset_metadata_cached("index.html", &content.data);
+
+            // Check if client has a matching ETag for index.html
+            if let Some(etag) = request_headers.get(header::IF_NONE_MATCH)
+                && metadata.etag_matches(etag.to_str().unwrap())
+            {
+                return StatusCode::NOT_MODIFIED.into_response();
+            }
+
+            let mut response = Html(content.data).into_response();
+            set_caching_headers(&mut response, "index.html", &metadata.hash.quoted());
+            response
+        }
+        None => (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            "Failed to load index.html",
+        )
+            .into_response(),
+    }
+}
+
+/// Health check endpoint
+async fn health() -> Json<Value> {
+    info!("health check requested");
+    Json(json!({
+        "status": "healthy",
+        "timestamp": chrono::Utc::now().to_rfc3339()
+    }))
+}
+
+#[derive(Serialize)]
+enum Status {
+    Disabled,
+    Connected,
+    Active,
+    Healthy,
+    Error,
+}
+
+#[derive(Serialize)]
+struct ServiceInfo {
+    name: String,
+    status: Status,
+}
+
+#[derive(Serialize)]
+struct StatusResponse {
+    status: Status,
+    version: String,
+    commit: String,
+    services: BTreeMap<String, ServiceInfo>,
+}
+
+/// Status endpoint showing bot and system status
+async fn status(State(_state): State<BannerState>) -> Json<StatusResponse> {
+    let mut services = BTreeMap::new();
+
+    // Bot service status - hardcoded as disabled for now
+    services.insert(
+        "bot".to_string(),
+        ServiceInfo {
+            name: "Bot".to_string(),
+            status: Status::Disabled,
+        },
+    );
+
+    // Banner API status - always connected for now
+    services.insert(
+        "banner".to_string(),
+        ServiceInfo {
+            name: "Banner".to_string(),
+            status: Status::Connected,
+        },
+    );
+
+    // Discord status - hardcoded as disabled for now
+    services.insert(
+        "discord".to_string(),
+        ServiceInfo {
+            name: "Discord".to_string(),
+            status: Status::Disabled,
+        },
+    );
+
+    let overall_status = if services.values().any(|s| matches!(s.status, Status::Error)) {
+        Status::Error
+    } else if services
+        .values()
+        .all(|s| matches!(s.status, Status::Active | Status::Connected))
+    {
+        Status::Active
+    } else {
+        // If we have any Disabled services but no errors, show as Healthy
+        Status::Healthy
+    };
+
+    Json(StatusResponse {
+        status: overall_status,
+        version: env!("CARGO_PKG_VERSION").to_string(),
+        commit: env!("GIT_COMMIT_HASH").to_string(),
+        services,
+    })
+}
+
+/// Metrics endpoint for monitoring
+async fn metrics(State(_state): State<BannerState>) -> Json<Value> {
+    // For now, return basic metrics structure
+    Json(json!({
+        "banner_api": {
+            "status": "connected"
+        },
+        "timestamp": chrono::Utc::now().to_rfc3339()
+    }))
+}

term.go

@@ -1,145 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"strconv"
-	"time"
-
-	"github.com/rs/zerolog/log"
-)
-
-// Term selection should yield smart results based on the current time, as well as the input provided.
-// Fall 2024, "spring" => Spring 2025
-// Fall 2024, "fall" => Fall 2025
-// Summer 2024, "fall" => Fall 2024
-
-const (
-	Spring = iota
-	Summer
-	Fall
-)
-
-type Term struct {
-	Year   uint16
-	Season uint8
-}
-
-var (
-	SpringRange, SummerRange, FallRange YearDayRange
-)
-
-func init() {
-	SpringRange, SummerRange, FallRange = GetYearDayRange(uint16(time.Now().Year()))
-
-	currentTerm, nextTerm := GetCurrentTerm(time.Now())
-	log.Debug().Str("CurrentTerm", fmt.Sprintf("%+v", currentTerm)).Str("NextTerm", fmt.Sprintf("%+v", nextTerm)).Msg("GetCurrentTerm")
-}
-
-type YearDayRange struct {
-	Start uint16
-	End   uint16
-}
-
-// GetYearDayRange returns the start and end day of each term for the given year.
-// This could technically introduce race conditions, but it's more likely confusion from UTC will be a greater issue.
-// Spring: January 14th to May
-// Summer: May 25th - August 15th
-// Fall: August 18th - December 10th
-func GetYearDayRange(year uint16) (YearDayRange, YearDayRange, YearDayRange) {
-	springStart := time.Date(int(year), time.January, 14, 0, 0, 0, 0, CentralTimeLocation).YearDay()
-	springEnd := time.Date(int(year), time.May, 1, 0, 0, 0, 0, CentralTimeLocation).YearDay()
-	summerStart := time.Date(int(year), time.May, 25, 0, 0, 0, 0, CentralTimeLocation).YearDay()
-	summerEnd := time.Date(int(year), time.August, 15, 0, 0, 0, 0, CentralTimeLocation).YearDay()
-	fallStart := time.Date(int(year), time.August, 18, 0, 0, 0, 0, CentralTimeLocation).YearDay()
-	fallEnd := time.Date(int(year), time.December, 10, 0, 0, 0, 0, CentralTimeLocation).YearDay()
-
-	return YearDayRange{
-			Start: uint16(springStart),
-			End:   uint16(springEnd),
-		}, YearDayRange{
-			Start: uint16(summerStart),
-			End:   uint16(summerEnd),
-		}, YearDayRange{
-			Start: uint16(fallStart),
-			End:   uint16(fallEnd),
-		}
-}
-
-// GetCurrentTerm returns the current term, and the next term. Only the first term is nillable.
-// YearDay ranges are inclusive of the start, and exclusive of the end.
-func GetCurrentTerm(now time.Time) (*Term, *Term) {
-	year := uint16(now.Year())
-	dayOfYear := uint16(now.YearDay())
-
-	// Fall of 2024 => 202410
-	// Spring of 2024 => 202420
-	// Fall of 2025 => 202510
-	// Summer of 2025 => 202530
-
-	if (dayOfYear < SpringRange.Start) || (dayOfYear >= FallRange.End) {
-		// Fall over, Spring not yet begun
-		return nil, &Term{Year: year + 1, Season: Spring}
-	} else if (dayOfYear >= SpringRange.Start) && (dayOfYear < SpringRange.End) {
-		// Spring
-		return &Term{Year: year, Season: Spring}, &Term{Year: year, Season: Summer}
-	} else if dayOfYear < SummerRange.Start {
-		// Spring over, Summer not yet begun
-		return nil, &Term{Year: year, Season: Summer}
-	} else if (dayOfYear >= SummerRange.Start) && (dayOfYear < SummerRange.End) {
-		// Summer
-		return &Term{Year: year, Season: Summer}, &Term{Year: year, Season: Fall}
-	} else if dayOfYear < FallRange.Start {
-		// Summer over, Fall not yet begun
-		return nil, &Term{Year: year + 1, Season: Fall}
-	} else if (dayOfYear >= FallRange.Start) && (dayOfYear < FallRange.End) {
-		// Fall
-		return &Term{Year: year + 1, Season: Fall}, nil
-	}
-
-	panic(fmt.Sprintf("Impossible Code Reached (dayOfYear: %d)", dayOfYear))
-}
-
-// ParseTerm converts a Banner term code to a Term struct
-func ParseTerm(code string) Term {
-	year, _ := strconv.ParseUint(code[0:4], 10, 16)
-
-	var season uint8
-	termCode := code[4:6]
-	switch termCode {
-	case "10":
-		season = Fall
-	case "20":
-		season = Spring
-	case "30":
-		season = Summer
-	}
-
-	return Term{
-		Year:   uint16(year),
-		Season: season,
-	}
-}
-
-// TermToBannerTerm converts a Term struct to a Banner term code
-func (term Term) ToString() string {
-	var season string
-	switch term.Season {
-	case Fall:
-		season = "10"
-	case Spring:
-		season = "20"
-	case Summer:
-		season = "30"
-	}
-
-	return fmt.Sprintf("%d%s", term.Year, season)
-}
-
-// Default chooses the default term, which is the current term if it exists, otherwise the next term.
-func Default(t time.Time) Term {
-	currentTerm, nextTerm := GetCurrentTerm(t)
-	if currentTerm == nil {
-		return *nextTerm
-	}
-	return *currentTerm
-}

tests/basic_test.rs

@@ -0,0 +1,39 @@
+use banner::utils::shutdown::join_tasks;
+use tokio::task::JoinHandle;
+
+#[tokio::test]
+async fn test_join_tasks_success() {
+    // Create some tasks that complete successfully
+    let handles: Vec<JoinHandle<()>> = vec![
+        tokio::spawn(async { tokio::time::sleep(tokio::time::Duration::from_millis(10)).await }),
+        tokio::spawn(async { tokio::time::sleep(tokio::time::Duration::from_millis(20)).await }),
+        tokio::spawn(async { /* immediate completion */ }),
+    ];
+
+    // All tasks should complete successfully
+    let result = join_tasks(handles).await;
+    assert!(
+        result.is_ok(),
+        "Expected all tasks to complete successfully"
+    );
+}
+
+#[tokio::test]
+async fn test_join_tasks_with_panic() {
+    // Create some tasks, including one that panics
+    let handles: Vec<JoinHandle<()>> = vec![
+        tokio::spawn(async { tokio::time::sleep(tokio::time::Duration::from_millis(10)).await }),
+        tokio::spawn(async { panic!("intentional test panic") }),
+        tokio::spawn(async { /* immediate completion */ }),
+    ];
+
+    // Should return an error because one task panicked
+    let result = join_tasks(handles).await;
+    assert!(result.is_err(), "Expected an error when a task panics");
+
+    let error_msg = result.unwrap_err().to_string();
+    assert!(
+        error_msg.contains("1 task(s) panicked"),
+        "Error message should mention panicked tasks"
+    );
+}

types.go

@@ -1,320 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"strconv"
-	"strings"
-	"time"
-
-	log "github.com/rs/zerolog/log"
-)
-
-const JsonContentType = "application/json"
-
-type FacultyItem struct {
-	BannerId              string  `json:"bannerId"`
-	Category              *string `json:"category"`
-	Class                 string  `json:"class"`
-	CourseReferenceNumber string  `json:"courseReferenceNumber"`
-	DisplayName           string  `json:"displayName"`
-	Email                 string  `json:"emailAddress"`
-	Primary               bool    `json:"primaryIndicator"`
-	Term                  string  `json:"term"`
-}
-
-type MeetingTimeResponse struct {
-	Category              *string `json:"category"`
-	Class                 string  `json:"class"`
-	CourseReferenceNumber string  `json:"courseReferenceNumber"`
-	Faculty               []FacultyItem
-	MeetingTime           struct {
-		Category string `json:"category"`
-		// Some sort of metadata used internally by Banner (net.hedtech.banner.student.schedule.SectionSessionDecorator)
-		Class string `json:"class"`
-		// The start date of the meeting time in MM/DD/YYYY format (e.g. 01/16/2024)
-		StartDate string `json:"startDate"`
-		// The end date of the meeting time in MM/DD/YYYY format (e.g. 05/10/2024)
-		EndDate string `json:"endDate"`
-		// The start time of the meeting time in 24-hour format, hours & minutes, digits only (e.g. 1630)
-		BeginTime string `json:"beginTime"`
-		// The end time of the meeting time in 24-hour format, hours & minutes, digits only (e.g. 1745)
-		EndTime string `json:"endTime"`
-		// The room number within the building this course takes place at (e.g. 3.01.08, 200A)
-		Room string `json:"room"`
-		// The internal identifier for the term this course takes place in (e.g. 202420)
-		Term string `json:"term"`
-		// The internal identifier for the building this course takes place at (e.g. SP1)
-		Building string `json:"building"`
-		// The long name of the building this course takes place at (e.g. San Pedro I - Data Science)
-		BuildingDescription string `json:"buildingDescription"`
-		// The internal identifier for the campus this course takes place at (e.g. 1DT)
-		Campus string `json:"campus"`
-		// The long name of the campus this course takes place at (e.g. Main Campus, Downtown Campus)
-		CampusDescription     string `json:"campusDescription"`
-		CourseReferenceNumber string `json:"courseReferenceNumber"`
-		// The number of credit hours this class is worth (assumably)
-		CreditHourSession float64 `json:"creditHourSession"`
-		// The number of hours per week this class meets (e.g. 2.5)
-		HoursWeek float64 `json:"hoursWeek"`
-		// Unknown meaning - e.g. AFF, AIN, AHB, FFF, AFF, EFF, DFF, IFF, EHB, JFF, KFF, BFF, BIN
-		MeetingScheduleType string `json:"meetingScheduleType"`
-		// The short identifier for the meeting type (e.g. FF, HB, OS, OA)
-		MeetingType string `json:"meetingType"`
-		// The long name of the meeting type (e.g. Traditional in-person)
-		MeetingTypeDescription string `json:"meetingTypeDescription"`
-		// A boolean indicating if the class will meet on each Monday of the term
-		Monday bool `json:"monday"`
-		// A boolean indicating if the class will meet on each Tuesday of the term
-		Tuesday bool `json:"tuesday"`
-		// A boolean indicating if the class will meet on each Wednesday of the term
-		Wednesday bool `json:"wednesday"`
-		// A boolean indicating if the class will meet on each Thursday of the term
-		Thursday bool `json:"thursday"`
-		// A boolean indicating if the class will meet on each Friday of the term
-		Friday bool `json:"friday"`
-		// A boolean indicating if the class will meet on each Saturday of the term
-		Saturday bool `json:"saturday"`
-		// A boolean indicating if the class will meet on each Sunday of the term
-		Sunday bool `json:"sunday"`
-	} `json:"meetingTime"`
-	Term string `json:"term"`
-}
-
-func (m *MeetingTimeResponse) String() string {
-	switch m.MeetingTime.MeetingType {
-	case "HB":
-		return fmt.Sprintf("%s\nHybrid %s", m.TimeString(), m.PlaceString())
-	case "H2":
-		return fmt.Sprintf("%s\nHybrid %s", m.TimeString(), m.PlaceString())
-	case "H1":
-		return fmt.Sprintf("%s\nHybrid %s", m.TimeString(), m.PlaceString())
-	case "OS":
-		return fmt.Sprintf("%s\nOnline Only", m.TimeString())
-	case "OA":
-		return "No Time\nOnline Asynchronous"
-	case "OH":
-		return fmt.Sprintf("%s\nOnline Partial", m.TimeString())
-	case "ID":
-		return "To Be Arranged"
-	case "FF":
-		return fmt.Sprintf("%s\n%s", m.TimeString(), m.PlaceString())
-	}
-
-	// TODO: Add error log
-	return "Unknown"
-}
-
-func (m *MeetingTimeResponse) TimeString() string {
-	startTime := m.StartTime()
-	endTime := m.EndTime()
-
-	if startTime == nil || endTime == nil {
-		return "???"
-	}
-
-	return fmt.Sprintf("%s %s-%s", WeekdaysToString(m.Days()), m.StartTime().String(), m.EndTime().String())
-}
-
-// PlaceString returns a formatted string best representing the place of the meeting time
-func (m *MeetingTimeResponse) PlaceString() string {
-	mt := m.MeetingTime
-
-	// TODO: ADd format case for partial online classes
-	if mt.Room == "" {
-		return "Online"
-	}
-
-	return fmt.Sprintf("%s | %s | %s %s", mt.CampusDescription, mt.BuildingDescription, mt.Building, mt.Room)
-}
-
-func (m *MeetingTimeResponse) Days() map[time.Weekday]bool {
-	days := map[time.Weekday]bool{}
-
-	days[time.Monday] = m.MeetingTime.Monday
-	days[time.Tuesday] = m.MeetingTime.Tuesday
-	days[time.Wednesday] = m.MeetingTime.Wednesday
-	days[time.Thursday] = m.MeetingTime.Thursday
-	days[time.Friday] = m.MeetingTime.Friday
-	days[time.Saturday] = m.MeetingTime.Saturday
-
-	return days
-}
-
-// Returns the BYDAY value for the iCalendar RRule format
-func (m *MeetingTimeResponse) ByDay() string {
-	days := []string{}
-
-	if m.MeetingTime.Sunday {
-		days = append(days, "SU")
-	}
-	if m.MeetingTime.Monday {
-		days = append(days, "MO")
-	}
-	if m.MeetingTime.Tuesday {
-		days = append(days, "TU")
-	}
-	if m.MeetingTime.Wednesday {
-		days = append(days, "WE")
-	}
-	if m.MeetingTime.Thursday {
-		days = append(days, "TH")
-	}
-	if m.MeetingTime.Friday {
-		days = append(days, "FR")
-	}
-	if m.MeetingTime.Saturday {
-		days = append(days, "SA")
-	}
-
-	return strings.Join(days, ",")
-}
-
-const layout = "01/02/2006"
-
-// StartDay returns the start date of the meeting time as a time.Time object
-// This is not cached and is parsed on each invocation. It may also panic without handling.
-func (m *MeetingTimeResponse) StartDay() time.Time {
-	t, err := time.Parse(layout, m.MeetingTime.StartDate)
-	if err != nil {
-		log.Panic().Stack().Err(err).Str("raw", m.MeetingTime.StartDate).Msg("Cannot parse start date")
-	}
-	return t
-}
-
-// EndDay returns the end date of the meeting time as a time.Time object.
-// This is not cached and is parsed on each invocation. It may also panic without handling.
-func (m *MeetingTimeResponse) EndDay() time.Time {
-	t, err := time.Parse(layout, m.MeetingTime.EndDate)
-	if err != nil {
-		log.Panic().Stack().Err(err).Str("raw", m.MeetingTime.EndDate).Msg("Cannot parse end date")
-	}
-	return t
-}
-
-// StartTime returns the start time of the meeting time as a NaiveTime object
-// This is not cached and is parsed on each invocation. It may also panic without handling.
-func (m *MeetingTimeResponse) StartTime() *NaiveTime {
-	raw := m.MeetingTime.BeginTime
-	if raw == "" {
-		log.Panic().Stack().Msg("Start time is empty")
-	}
-
-	value, err := strconv.ParseUint(raw, 10, 32)
-	if err != nil {
-		log.Panic().Stack().Err(err).Str("raw", raw).Msg("Cannot parse start time integer")
-	}
-
-	return ParseNaiveTime(value)
-}
-
-// EndTime returns the end time of the meeting time as a NaiveTime object
-// This is not cached and is parsed on each invocation. It may also panic without handling.
-func (m *MeetingTimeResponse) EndTime() *NaiveTime {
-	raw := m.MeetingTime.EndTime
-	if raw == "" {
-		return nil
-	}
-
-	value, err := strconv.ParseUint(raw, 10, 32)
-	if err != nil {
-		log.Panic().Stack().Err(err).Str("raw", raw).Msg("Cannot parse end time integer")
-	}
-
-	return ParseNaiveTime(value)
-}
-
-// Converts the meeting time to a string that satisfies the iCalendar RRule format
-func (m *MeetingTimeResponse) RRule() string {
-	sb := strings.Builder{}
-
-	sb.WriteString("FREQ=WEEKLY;")
-	sb.WriteString(fmt.Sprintf("UNTIL=%s;", m.EndDay().UTC().Format(ICalTimestampFormatUtc)))
-	sb.WriteString(fmt.Sprintf("BYDAY=%s;", m.ByDay()))
-
-	return sb.String()
-}
-
-type SearchResult struct {
-	Success             bool   `json:"success"`
-	TotalCount          int    `json:"totalCount"`
-	PageOffset          int    `json:"pageOffset"`
-	PageMaxSize         int    `json:"pageMaxSize"`
-	PathMode            string `json:"pathMode"`
-	SearchResultsConfig []struct {
-		Config  string `json:"config"`
-		Display string `json:"display"`
-	} `json:"searchResultsConfig"`
-	Data []Course `json:"data"`
-}
-
-type Course struct {
-	// A internal identifier not used outside of the Banner system
-	Id int `json:"id"`
-	// The internal identifier for the term this class is in (e.g. 202420)
-	Term string `json:"term"`
-	// The human-readable name of the term this class is in (e.g. Fall 2021)
-	TermDesc string `json:"termDesc"`
-	// The specific identifier that describes this individual course. CRNs are unique to a term. (TODO: Verify this is true)
-	CourseReferenceNumber string `json:"courseReferenceNumber"`
-	// A rarely used identifier that species which part of the given term this course is in. By default, this is "1" to encompass the entire term. (e.g. B6, B5)
-	PartOfTerm string `json:"partOfTerm"`
-	// The 4-digit course code that defines this course (e.g. 3743, 0120, 4855, 7339), but not the specific instance (see CourseReferenceNumber)
-	CourseNumber string `json:"courseNumber"`
-	// The short acronym of the course subject (e.g. CS, AEPI)
-	Subject string `json:"subject"`
-	// The full name of the course subject (e.g. Computer Science, Academic English Program-Intl.)
-	SubjectDescription string `json:"subjectDescription"`
-	// The specific section of the course (e.g. 001, 002)
-	SequenceNumber string `json:"sequenceNumber"`
-	// The long name of the campus this course takes place at (e.g. Main Campus, Downtown Campus)
-	CampusDescription string `json:"campusDescription"`
-	// e.g. Lecture, Seminar, Dissertation, Internship, Independent Study, Thesis, Self-paced, Laboratory
-	ScheduleTypeDescription string `json:"scheduleTypeDescription"`
-	// The long name of the course (generally)
-	CourseTitle string `json:"courseTitle"`
-	CreditHours int    `json:"creditHours"`
-	// The maximum number of students that can enroll in this course
-	MaximumEnrollment int `json:"maximumEnrollment"`
-	// The number of students currently enrolled in this course
-	Enrollment int `json:"enrollment"`
-	// The number of seats available in this course (MaximumEnrollment - Enrollment)
-	SeatsAvailable int `json:"seatsAvailable"`
-	// The number of students that could waitlist for this course
-	WaitCapacity int `json:"waitCapacity"`
-	// The number of students currently on the waitlist for this course
-	WaitCount           int     `json:"waitCount"`
-	CrossList           *string `json:"crossList"`
-	CrossListCapacity   *int    `json:"crossListCapacity"`
-	CrossListCount      *int    `json:"crossListCount"`
-	CrossListAvailable  *int    `json:"crossListAvailable"`
-	CreditHourHigh      *int    `json:"creditHourHigh"`
-	CreditHourLow       *int    `json:"creditHourLow"`
-	CreditHourIndicator *string `json:"creditHourIndicator"`
-	OpenSection         bool    `json:"openSection"`
-	LinkIdentifier      *string `json:"linkIdentifier"`
-	IsSectionLinked     bool    `json:"isSectionLinked"`
-	// A combination of the subject and course number (e.g. subject=CS, courseNumber=3443 => "CS3443")
-	SubjectCourse                  string  `json:"subjectCourse"`
-	ReservedSeatSummary            *string `json:"reservedSeatSummary"`
-	InstructionalMethod            string  `json:"instructionalMethod"`
-	InstructionalMethodDescription string  `json:"instructionalMethodDescription"`
-	SectionAttributes              []struct {
-		// A internal API class identifier used by Banner
-		Class                 string `json:"class"`
-		CourseReferenceNumber string `json:"courseReferenceNumber"`
-		// UPPR, ZIEP, AIS, LEWR, ZZSL, 090, GRAD, ZZTL, 020, BU, CLEP
-		Code string `json:"code"`
-		// Seems to be the fully qualified meaning of the Code (Upper, Intensive English Program...)
-		Description string `json:"description"`
-		TermCode    string `json:"termCode"`
-		// Unknown; always false
-		IsZtcAttribute bool `json:"isZTCAttribute"`
-	} `json:"sectionAttributes"`
-	Faculty         []FacultyItem         `json:"faculty"`
-	MeetingsFaculty []MeetingTimeResponse `json:"meetingsFaculty"`
-}
-
-func (course Course) MarshalBinary() ([]byte, error) {
-	return json.Marshal(course)
-}

web/.gitignore

@@ -0,0 +1,9 @@
+node_modules
+.DS_Store
+dist
+dist-ssr
+*.local
+count.txt
+.env
+.nitro
+.tanstack

web/.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+  "files.watcherExclude": {
+    "**/routeTree.gen.ts": true
+  },
+  "search.exclude": {
+    "**/routeTree.gen.ts": true
+  },
+  "files.readonlyInclude": {
+    "**/routeTree.gen.ts": true
+  }
+}

web/biome.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  },
+  "files": {
+    "ignoreUnknown": false,
+    "ignore": ["dist/", "node_modules/", ".tanstack/"]
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 100,
+    "lineEnding": "lf"
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "double",
+      "trailingCommas": "es5",
+      "semicolons": "always",
+      "arrowParentheses": "always"
+    }
+  },
+  "linter": {
+    "enabled": false
+  }
+}

web/eslint.config.js

@@ -0,0 +1,60 @@
+import js from "@eslint/js";
+import tseslint from "typescript-eslint";
+import react from "eslint-plugin-react";
+import reactHooks from "eslint-plugin-react-hooks";
+import reactRefresh from "eslint-plugin-react-refresh";
+
+export default tseslint.config(
+  // Ignore generated files and build outputs
+  {
+    ignores: ["dist", "node_modules", "src/routeTree.gen.ts", "*.config.js"],
+  },
+  // Base configs
+  js.configs.recommended,
+  ...tseslint.configs.recommendedTypeChecked,
+  // React plugin configuration
+  {
+    files: ["**/*.{ts,tsx}"],
+    plugins: {
+      react,
+      "react-hooks": reactHooks,
+      "react-refresh": reactRefresh,
+    },
+    languageOptions: {
+      parserOptions: {
+        project: true,
+        tsconfigRootDir: import.meta.dirname,
+        ecmaFeatures: {
+          jsx: true,
+        },
+      },
+    },
+    settings: {
+      react: {
+        version: "19.0",
+      },
+    },
+    rules: {
+      // React rules
+      ...react.configs.recommended.rules,
+      ...react.configs["jsx-runtime"].rules,
+      ...reactHooks.configs.recommended.rules,
+
+      // React Refresh
+      "react-refresh/only-export-components": ["warn", { allowConstantExport: true }],
+
+      // TypeScript overrides
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        {
+          argsIgnorePattern: "^_",
+          varsIgnorePattern: "^_",
+        },
+      ],
+      "@typescript-eslint/no-explicit-any": "warn",
+
+      // Disable prop-types since we're using TypeScript
+      "react/prop-types": "off",
+    },
+  }
+);

web/index.html

@@ -0,0 +1,20 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="icon" href="/favicon.ico" />
+    <meta name="theme-color" content="#000000" />
+    <meta
+      name="description"
+      content="Banner, a Discord bot and web interface for UTSA Course Monitoring"
+    />
+    <link rel="apple-touch-icon" href="/logo192.png" />
+    <link rel="manifest" href="/manifest.json" />
+    <title>Banner</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

web/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "banner-web",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite --port 3000",
+    "start": "vite --port 3000",
+    "build": "vite build && tsc",
+    "serve": "vite preview",
+    "test": "vitest run",
+    "lint": "tsc && eslint . --ext .ts,.tsx",
+    "typecheck": "tsc --noEmit",
+    "format": "biome format --write .",
+    "format:check": "biome format ."
+  },
+  "dependencies": {
+    "@radix-ui/themes": "^3.2.1",
+    "@tanstack/react-devtools": "^0.2.2",
+    "@tanstack/react-router": "^1.130.2",
+    "@tanstack/react-router-devtools": "^1.131.5",
+    "@tanstack/router-plugin": "^1.121.2",
+    "lucide-react": "^0.544.0",
+    "next-themes": "^0.4.6",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-timeago": "^8.3.0",
+    "recharts": "^3.2.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@eslint/js": "^9.39.0",
+    "@testing-library/dom": "^10.4.0",
+    "@testing-library/react": "^16.2.0",
+    "@types/node": "^24.3.3",
+    "@types/react": "^19.0.8",
+    "@types/react-dom": "^19.0.3",
+    "@vitejs/plugin-react": "^4.3.4",
+    "eslint": "^9.39.0",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.4.24",
+    "jsdom": "^26.0.0",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.46.2",
+    "vite": "^6.3.5",
+    "vitest": "^3.0.5",
+    "web-vitals": "^4.2.4"
+  }
+}

web/public/manifest.json

@@ -0,0 +1,25 @@
+{
+  "short_name": "Banner",
+  "name": "Banner, a Discord bot and web interface for UTSA Course Monitoring",
+  "icons": [
+    {
+      "src": "favicon.ico",
+      "sizes": "64x64 32x32 24x24 16x16",
+      "type": "image/x-icon"
+    },
+    {
+      "src": "logo192.png",
+      "type": "image/png",
+      "sizes": "192x192"
+    },
+    {
+      "src": "logo512.png",
+      "type": "image/png",
+      "sizes": "512x512"
+    }
+  ],
+  "start_url": ".",
+  "display": "standalone",
+  "theme_color": "#ffffff",
+  "background_color": "#ffffff"
+}

web/public/robots.txt

@@ -0,0 +1,3 @@
+# https://www.robotstxt.org/robotstxt.html
+User-agent: *
+Disallow:

web/src/App.css

@@ -0,0 +1,34 @@
+.App {
+  min-height: 100vh;
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu",
+    "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue", sans-serif;
+  background-color: var(--color-background);
+  color: var(--color-text);
+}
+
+@keyframes pulse {
+  0%,
+  100% {
+    opacity: 0.2;
+  }
+  50% {
+    opacity: 0.4;
+  }
+}
+
+.animate-pulse {
+  animation: pulse 2s ease-in-out infinite;
+}
+
+/* Screen reader only text */
+.sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  border: 0;
+}

web/src/components/ThemeToggle.tsx

@@ -0,0 +1,60 @@
+import { useTheme } from "next-themes";
+import { Button } from "@radix-ui/themes";
+import { Sun, Moon, Monitor } from "lucide-react";
+import { useMemo } from "react";
+
+export function ThemeToggle() {
+  const { theme, setTheme } = useTheme();
+
+  const nextTheme = useMemo(() => {
+    switch (theme) {
+      case "light":
+        return "dark";
+      case "dark":
+        return "system";
+      case "system":
+        return "light";
+      default:
+        console.error(`Invalid theme: ${theme}`);
+        return "system";
+    }
+  }, [theme]);
+
+  const icon = useMemo(() => {
+    if (nextTheme === "system") {
+      return <Monitor size={18} />;
+    }
+    return nextTheme === "dark" ? <Moon size={18} /> : <Sun size={18} />;
+  }, [nextTheme]);
+
+  return (
+    <Button
+      variant="ghost"
+      size="3"
+      onClick={() => setTheme(nextTheme)}
+      style={{
+        cursor: "pointer",
+        backgroundColor: "transparent",
+        border: "none",
+        margin: "4px",
+        padding: "7px",
+        borderRadius: "6px",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        color: "var(--gray-11)",
+        transition: "background-color 0.2s, color 0.2s",
+        transform: "scale(1.25)",
+      }}
+      onMouseEnter={(e) => {
+        e.currentTarget.style.backgroundColor = "var(--gray-4)";
+      }}
+      onMouseLeave={(e) => {
+        e.currentTarget.style.backgroundColor = "transparent";
+      }}
+    >
+      {icon}
+      <span className="sr-only">Toggle theme</span>
+    </Button>
+  );
+}