chore: rustfmt

.gitignore

@@ -1,3 +1,4 @@
 .env
 /target
-/go/
+/go/
+.cargo/config.toml

Cargo.toml

@@ -2,31 +2,46 @@
 name = "banner"
 version = "0.1.0"
 edition = "2024"
+default-run = "banner"
 
 [dependencies]
-tokio = { version = "1.47.1", features = ["full"] }
-axum = "0.8.4"
-serenity = { version = "0.12.4", features = ["rustls_backend"] }
-reqwest = { version = "0.12.23", features = ["json", "cookies"] }
-diesel = { version = "2.2.12", features = ["chrono", "postgres", "uuid"] }
-redis = { version = "0.32.5", features = ["tokio-comp"] }
-figment = { version = "0.10.19", features = ["toml", "env"] }
-serde_json = "1.0.143"
-serde = { version = "1.0.219", features = ["derive"] }
-governor = "0.10.1"
-tracing = "0.1.41"
-tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
-dotenvy = "0.15.7"
-poise = "0.6.1"
-async-trait = "0.1"
-fundu = "2.0.1"
 anyhow = "1.0.99"
-thiserror = "2.0.16"
-chrono = { version = "0.4", features = ["serde"] }
-chrono-tz = "0.8"
-rand = "0.8"
-regex = "1.10"
-url = "2.5"
+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"
+redis = { version = "0.32.5", features = ["tokio-comp", "r2d2"] }
+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.41"
-bitflags = { version = "2.9.3", features = ["serde"] }
+tokio = { version = "1.47.1", features = ["full"] }
+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"
+
+[dev-dependencies]

Dockerfile

@@ -0,0 +1,77 @@
+# Build Stage
+ARG RUST_VERSION=1.86.0
+FROM rust:${RUST_VERSION}-bookworm AS builder
+
+# Install build dependencies
+RUN apt-get update && apt-get install -y \
+    pkg-config \
+    libssl-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /usr/src
+RUN USER=root cargo new --bin banner
+WORKDIR /usr/src/banner
+
+# Copy dependency files for better layer caching
+COPY ./Cargo.toml ./Cargo.lock* ./
+
+# Build empty app with downloaded dependencies to produce a stable image layer for next build
+RUN cargo build --release
+
+# Build web app with own code
+RUN rm src/*.rs
+COPY ./src ./src
+RUN rm ./target/release/deps/banner*
+RUN cargo build --release
+
+# Strip the binary to reduce size
+RUN strip target/release/banner
+
+# Runtime Stage - Debian slim for glibc compatibility
+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 files
+COPY --from=builder --chown=$APP_USER:$APP_USER /usr/src/banner/target/release/banner ${APP}/banner
+COPY --from=builder --chown=$APP_USER:$APP_USER /usr/src/banner/src/fonts ${APP}/fonts
+
+# 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
+CMD ["sh", "-c", "exec ./banner --server ${HOSTS}"]

bacon.toml

@@ -0,0 +1,92 @@
+# 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"]
+need_stdout = false
+
+[jobs.check-all]
+command = ["cargo", "check", "--all-targets"]
+need_stdout = false
+
+# Run clippy on the default target
+[jobs.clippy]
+command = ["cargo", "clippy"]
+need_stdout = false
+
+# Run clippy on all targets
+# To disable some lints, you may change the job this way:
+#    [jobs.clippy-all]
+#    command = [
+#        "cargo", "clippy",
+#        "--all-targets",
+#    	 "--",
+#    	 "-A", "clippy::bool_to_int_with_if",
+#    	 "-A", "clippy::collapsible_if",
+#    	 "-A", "clippy::derive_partial_eq_without_eq",
+#    ]
+# need_stdout = false
+[jobs.clippy-all]
+command = ["cargo", "clippy", "--all-targets"]
+need_stdout = false
+
+# This job lets you run
+# - all tests: bacon test
+# - a specific test: bacon test -- config::test_default_files
+# - the tests of a package: bacon test -- -- -p config
+[jobs.test]
+command = ["cargo", "test"]
+need_stdout = true
+
+[jobs.nextest]
+command = [
+    "cargo", "nextest", "run",
+    "--hide-progress-bar", "--failure-output", "final"
+]
+need_stdout = true
+analyzer = "nextest"
+
+[jobs.doc]
+command = ["cargo", "doc", "--no-deps"]
+need_stdout = false
+
+# If the doc compiles, then it opens in your browser and bacon switches
+# to the previous job
+[jobs.doc-open]
+command = ["cargo", "doc", "--no-deps", "--open"]
+need_stdout = false
+on_success = "back" # so that we don't open the browser at each change
+
+[jobs.run]
+command = [
+    "cargo", "run",
+]
+need_stdout = true
+allow_warnings = true
+background = false
+on_change_strategy = "kill_then_restart"
+# kill = ["pkill", "-TERM", "-P"]'
+
+# This parameterized job runs the example of your choice, as soon
+# as the code compiles.
+# Call it as
+#    bacon ex -- my-example
+[jobs.ex]
+command = ["cargo", "run", "--example"]
+need_stdout = true
+allow_warnings = true
+
+# 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]
+# alt-m = "job:my-job"
+c = "job:clippy-all" # comment this to have 'c' run clippy on only the default target

diesel.toml

@@ -0,0 +1,9 @@
+# For documentation on how to configure this file,
+# see https://diesel.rs/guides/configuring-diesel-cli
+
+[print_schema]
+file = "src/data/schema.rs"
+custom_type_derives = ["diesel::query_builder::QueryId", "Clone"]
+
+[migrations_directory]
+dir = "migrations"

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
+);

src/banner/api.rs

@@ -1,81 +1,211 @@
 //! Main Banner API client implementation.
 
-use crate::banner::{SessionManager, models::*, query::SearchQuery};
-use anyhow::{Context, Result};
-use axum::http::HeaderValue;
-use reqwest::Client;
-use serde_json;
+use std::{
+    collections::{HashMap, VecDeque},
+    sync::{Arc, Mutex},
+    time::Instant,
+};
 
-// use tracing::debug;
+use crate::banner::{
+    BannerSession, SessionPool, errors::BannerApiError, json::parse_json_with_context,
+    middleware::TransparentMiddleware, models::*, nonce, query::SearchQuery, 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.
-#[derive(Debug)]
 pub struct BannerApi {
-    session_manager: SessionManager,
-    client: Client,
+    pub sessions: SessionPool,
+    http: ClientWithMiddleware,
     base_url: String,
 }
 
 impl BannerApi {
     /// Creates a new Banner API client.
     pub fn new(base_url: String) -> Result<Self> {
-        let client = Client::builder()
-            .cookie_store(true)
-            .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")?;
-
-        let session_manager = SessionManager::new(base_url.clone(), client.clone());
+        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)
+        .build();
 
         Ok(Self {
-            session_manager,
-            client,
+            sessions: SessionPool::new(http.clone(), base_url.clone()),
+            http,
             base_url,
         })
     }
 
-    /// Sets up the API client by initializing session cookies.
-    pub async fn setup(&self) -> Result<()> {
-        self.session_manager.setup().await
+    /// 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(())
+        }
     }
 
-    /// Retrieves a list of terms from the Banner API.
-    pub async fn get_terms(
+    /// Builds common search parameters for list endpoints.
+    fn build_list_params(
         &self,
         search: &str,
-        page: i32,
+        term: &str,
+        offset: i32,
         max_results: i32,
-    ) -> Result<Vec<BannerTerm>> {
-        if page <= 0 {
-            return Err(anyhow::anyhow!("Page must be greater than 0"));
-        }
+        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()),
+        ]
+    }
 
-        let url = format!("{}/classSearch/getTerms", self.base_url);
-        let params = [
-            ("searchTerm", search),
-            ("offset", &page.to_string()),
-            ("max", &max_results.to_string()),
-            ("_", &timestamp_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
-            .client
+            .http
             .get(&url)
             .query(&params)
             .send()
             .await
-            .context("Failed to get terms")?;
+            .with_context(|| format!("Failed to get {}", endpoint))?;
 
-        let terms: Vec<BannerTerm> = response
+        let data: Vec<T> = response
             .json()
             .await
-            .context("Failed to parse terms response")?;
+            .with_context(|| format!("Failed to parse {} response", endpoint))?;
 
-        Ok(terms)
+        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.
+    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,
+            query = ?query,
+            sort = sort,
+            sort_descending = sort_descending,
+            "Searching for courses with params: {:?}", params
+        );
+
+        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}\nBody: {body}"
+            ))
+        })?;
+
+        // 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.
@@ -86,35 +216,8 @@ impl BannerApi {
         offset: i32,
         max_results: i32,
     ) -> Result<Vec<Pair>> {
-        if offset <= 0 {
-            return Err(anyhow::anyhow!("Offset must be greater than 0"));
-        }
-
-        let session_id = self.session_manager.ensure_session()?;
-        let url = format!("{}/classSearch/get_subject", self.base_url);
-        let params = [
-            ("searchTerm", search),
-            ("term", term),
-            ("offset", &offset.to_string()),
-            ("max", &max_results.to_string()),
-            ("uniqueSessionId", &session_id),
-            ("_", &timestamp_nonce()),
-        ];
-
-        let response = self
-            .client
-            .get(&url)
-            .query(&params)
-            .send()
+        self.get_list_endpoint("get_subject", search, term, offset, max_results)
             .await
-            .context("Failed to get subjects")?;
-
-        let subjects: Vec<Pair> = response
-            .json()
-            .await
-            .context("Failed to parse subjects response")?;
-
-        Ok(subjects)
     }
 
     /// Retrieves a list of instructors from the Banner API.
@@ -125,87 +228,33 @@ impl BannerApi {
         offset: i32,
         max_results: i32,
     ) -> Result<Vec<Instructor>> {
-        if offset <= 0 {
-            return Err(anyhow::anyhow!("Offset must be greater than 0"));
-        }
-
-        let session_id = self.session_manager.ensure_session()?;
-        let url = format!("{}/classSearch/get_instructor", self.base_url);
-        let params = [
-            ("searchTerm", search),
-            ("term", term),
-            ("offset", &offset.to_string()),
-            ("max", &max_results.to_string()),
-            ("uniqueSessionId", &session_id),
-            ("_", &timestamp_nonce()),
-        ];
-
-        let response = self
-            .client
-            .get(&url)
-            .query(&params)
-            .send()
+        self.get_list_endpoint("get_instructor", search, term, offset, max_results)
             .await
-            .context("Failed to get instructors")?;
-
-        let instructors: Vec<Instructor> = response
-            .json()
-            .await
-            .context("Failed to parse instructors response")?;
-
-        Ok(instructors)
     }
 
     /// Retrieves a list of campuses from the Banner API.
     pub async fn get_campuses(
         &self,
         search: &str,
-        term: i32,
+        term: &str,
         offset: i32,
         max_results: i32,
     ) -> Result<Vec<Pair>> {
-        if offset <= 0 {
-            return Err(anyhow::anyhow!("Offset must be greater than 0"));
-        }
-
-        let session_id = self.session_manager.ensure_session()?;
-        let url = format!("{}/classSearch/get_campus", self.base_url);
-        let params = [
-            ("searchTerm", search),
-            ("term", &term.to_string()),
-            ("offset", &offset.to_string()),
-            ("max", &max_results.to_string()),
-            ("uniqueSessionId", &session_id),
-            ("_", &timestamp_nonce()),
-        ];
-
-        let response = self
-            .client
-            .get(&url)
-            .query(&params)
-            .send()
+        self.get_list_endpoint("get_campus", search, term, offset, max_results)
             .await
-            .context("Failed to get campuses")?;
-
-        let campuses: Vec<Pair> = response
-            .json()
-            .await
-            .context("Failed to parse campuses response")?;
-
-        Ok(campuses)
     }
 
     /// Retrieves meeting time information for a course.
     pub async fn get_course_meeting_time(
         &self,
         term: &str,
-        crn: i32,
+        crn: &str,
     ) -> Result<Vec<MeetingScheduleInfo>> {
         let url = format!("{}/searchResults/getFacultyMeetingTimes", self.base_url);
-        let params = [("term", term), ("courseReferenceNumber", &crn.to_string())];
+        let params = [("term", term), ("courseReferenceNumber", crn)];
 
         let response = self
-            .client
+            .http
             .get(&url)
             .query(&params)
             .send()
@@ -236,14 +285,14 @@ impl BannerApi {
             ));
         }
 
-        #[derive(serde::Deserialize)]
-        struct ResponseWrapper {
-            fmt: Vec<MeetingTimeResponse>,
-        }
+        let response: MeetingTimesApiResponse =
+            response.json().await.context("Failed to parse response")?;
 
-        let wrapper: ResponseWrapper = response.json().await.context("Failed to parse response")?;
-
-        Ok(wrapper.fmt.into_iter().map(|m| m.schedule_info()).collect())
+        Ok(response
+            .fmt
+            .into_iter()
+            .map(|m| m.schedule_info())
+            .collect())
     }
 
     /// Performs a search for courses.
@@ -253,95 +302,31 @@ impl BannerApi {
         query: &SearchQuery,
         sort: &str,
         sort_descending: bool,
-    ) -> Result<SearchResult> {
-        self.session_manager.reset_data_form().await?;
-
-        let session_id = self.session_manager.ensure_session()?;
-        let mut params = query.to_params();
-
-        // Add additional parameters
-        params.insert("txt_term".to_string(), term.to_string());
-        params.insert("uniqueSessionId".to_string(), session_id);
-        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());
-
-        let url = format!("{}/searchResults/searchResults", self.base_url);
-        let response = self
-            .client
-            .get(&url)
-            .query(&params)
-            .send()
+    ) -> Result<SearchResult, BannerApiError> {
+        self.perform_search(term, query, sort, sort_descending)
             .await
-            .context("Failed to search courses")?;
-
-        let search_result: SearchResult = response
-            .json()
-            .await
-            .context("Failed to parse search response")?;
-
-        if !search_result.success {
-            return Err(anyhow::anyhow!(
-                "Search marked as unsuccessful by Banner API"
-            ));
-        }
-
-        Ok(search_result)
-    }
-
-    /// Selects a term for the current session.
-    pub async fn select_term(&self, term: &str) -> Result<()> {
-        self.session_manager.select_term(term).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>> {
-        self.session_manager.reset_data_form().await?;
-        // Ensure session is configured for this term
-        self.select_term(term).await?;
-
-        let session_id = self.session_manager.ensure_session()?;
-
+    pub async fn get_course_by_crn(
+        &self,
+        term: &str,
+        crn: &str,
+    ) -> Result<Option<Course>, BannerApiError> {
         let query = SearchQuery::new()
             .course_reference_number(crn)
             .max_results(1);
 
-        let mut params = query.to_params();
-        params.insert("txt_term".to_string(), term.to_string());
-        params.insert("uniqueSessionId".to_string(), session_id);
-        params.insert("sortColumn".to_string(), "subjectDescription".to_string());
-        params.insert("sortDirection".to_string(), "asc".to_string());
-        params.insert("startDatepicker".to_string(), String::new());
-        params.insert("endDatepicker".to_string(), String::new());
+        let search_result = self
+            .perform_search(term, &query, "subjectDescription", false)
+            .await?;
 
-        let url = format!("{}/searchResults/searchResults", self.base_url);
-        let response = self
-            .client
-            .get(&url)
-            .query(&params)
-            .send()
-            .await
-            .context("Failed to search course by CRN")?;
-
-        let status = response.status();
-        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| {
-            anyhow::anyhow!(
-                "Failed to parse search response for CRN (status={status}, url={url}): {e}",
-            )
-        })?;
-
-        if !search_result.success {
-            return Err(anyhow::anyhow!(
-                "Search marked as unsuccessful by Banner API"
+        // 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(),
             ));
         }
 
@@ -351,16 +336,16 @@ impl BannerApi {
     }
 
     /// Gets course details (placeholder - needs implementation).
-    pub async fn get_course_details(&self, term: i32, crn: i32) -> Result<ClassDetails> {
+    pub async fn get_course_details(&self, term: &str, crn: &str) -> Result<ClassDetails> {
         let body = serde_json::json!({
-            "term": term.to_string(),
-            "courseReferenceNumber": crn.to_string(),
+            "term": term,
+            "courseReferenceNumber": crn,
             "first": "first"
         });
 
         let url = format!("{}/searchResults/getClassDetails", self.base_url);
         let response = self
-            .client
+            .http
             .post(&url)
             .json(&body)
             .send()
@@ -375,54 +360,3 @@ impl BannerApi {
         Ok(details)
     }
 }
-
-/// Generates a timestamp-based nonce.
-fn timestamp_nonce() -> String {
-    std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .unwrap()
-        .as_millis()
-        .to_string()
-}
-
-/// Returns a browser-like user agent string.
-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"
-}
-
-/// Attempt to parse JSON and, on failure, include a contextual snippet around the error location
-fn parse_json_with_context<T: serde::de::DeserializeOwned>(body: &str) -> Result<T> {
-    match serde_json::from_str::<T>(body) {
-        Ok(value) => Ok(value),
-        Err(err) => {
-            let (line, column) = (err.line(), err.column());
-            let snippet = build_error_snippet(body, line as usize, column as usize, 120);
-            Err(anyhow::anyhow!(
-                "{} at line {}, column {}\nSnippet:\n{}",
-                err,
-                line,
-                column,
-                snippet
-            ))
-        }
-    }
-}
-
-fn build_error_snippet(body: &str, line: usize, column: usize, max_len: usize) -> String {
-    let target_line = body.lines().nth(line.saturating_sub(1)).unwrap_or("");
-    if target_line.is_empty() {
-        return String::new();
-    }
-
-    let start = column.saturating_sub(max_len.min(column));
-    let end = (column + max_len).min(target_line.len());
-    let slice = &target_line[start..end];
-
-    let mut indicator = String::new();
-    if column > start {
-        indicator.push_str(&" ".repeat(column - start - 1));
-        indicator.push('^');
-    }
-
-    format!("{}\n{}", slice, indicator)
-}

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,39 @@
+//! JSON parsing utilities for the Banner API client.
+
+use anyhow::Result;
+
+/// Attempt to parse JSON and, on failure, include a contextual snippet of the
+/// line where the error occurred. This prevents dumping huge JSON bodies to logs.
+pub fn parse_json_with_context<T: serde::de::DeserializeOwned>(body: &str) -> Result<T> {
+    match serde_json::from_str::<T>(body) {
+        Ok(value) => Ok(value),
+        Err(err) => {
+            let (line, column) = (err.line(), err.column());
+            let snippet = build_error_snippet(body, line, column, 80);
+            Err(anyhow::anyhow!(
+                "{err} at line {line}, column {column}\nSnippet:\n{snippet}",
+            ))
+        }
+    }
+}
+
+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}")
+}

src/banner/middleware.rs

@@ -0,0 +1,49 @@
+//! HTTP middleware for the Banner API client.
+
+use http::Extensions;
+use reqwest::{Request, Response};
+use reqwest_middleware::{Middleware, Next};
+use tracing::{trace, warn};
+
+pub struct TransparentMiddleware;
+
+#[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> {
+        trace!(
+            domain = req.url().domain(),
+            headers = ?req.headers(),
+            "{method} {path}",
+            method = req.method().to_string(),
+            path = req.url().path(),
+        );
+        let response_result = next.run(req, extensions).await;
+
+        match response_result {
+            Ok(response) => {
+                if response.status().is_success() {
+                    trace!(
+                        "{code} {reason} {path}",
+                        code = response.status().as_u16(),
+                        reason = response.status().canonical_reason().unwrap_or("??"),
+                        path = response.url().path(),
+                    );
+                    Ok(response)
+                } else {
+                    let e = response.error_for_status_ref().unwrap_err();
+                    warn!(error = ?e, "Request failed (server)");
+                    Ok(response)
+                }
+            }
+            Err(error) => {
+                warn!(?error, "Request failed (middleware)");
+                Err(error)
+            }
+        }
+    }
+}

src/banner/mod.rs

@@ -1,3 +1,5 @@
+#![allow(unused_imports)]
+
 //! Banner API module for interacting with Ellucian Banner systems.
 //!
 //! This module provides functionality to:
@@ -7,12 +9,16 @@
 //! - 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 scraper;
 pub mod session;
+pub mod util;
 
 pub use api::*;
+pub use errors::*;
 pub use models::*;
 pub use query::*;
 pub use session::*;

src/banner/models/courses.rs

@@ -59,6 +59,24 @@ pub struct Course {
     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 {

src/banner/models/meetings.rs

@@ -1,7 +1,7 @@
 use bitflags::{Flags, bitflags};
 use chrono::{DateTime, NaiveDate, NaiveTime, Timelike, Utc};
 use serde::{Deserialize, Deserializer, Serialize};
-use std::{cmp::Ordering, str::FromStr};
+use std::{cmp::Ordering, collections::HashSet, fmt::Display, str::FromStr};
 
 use super::terms::Term;
 
@@ -42,11 +42,11 @@ pub struct FacultyItem {
 #[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: String, // HHMM, e.g 1000
-    pub end_time: String,   // HHMM, e.g 1100
-    pub category: String,   // unknown meaning, e.g. 01, 02, etc
+    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
@@ -55,13 +55,13 @@ pub struct MeetingTime {
     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: String,  // e.g. 1238
+    pub room: Option<String>, // e.g. 1.238
     #[serde(deserialize_with = "deserialize_string_to_term")]
     pub term: Term, // e.g 202510
-    pub building: String, // e.g NPB
-    pub building_description: String, // e.g North Paseo Building
-    pub campus: String, // campus code, e.g 11
-    pub campus_description: String, // name of campus, e.g Main Campus
+    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: f64, // e.g. 30
     pub hours_week: f64, // e.g. 30
@@ -148,20 +148,20 @@ pub enum DayOfWeek {
 
 impl DayOfWeek {
     /// Convert to short string representation
-    pub fn to_short_string(&self) -> &'static str {
+    pub fn to_short_string(self) -> &'static str {
         match self {
-            DayOfWeek::Monday => "M",
+            DayOfWeek::Monday => "Mo",
             DayOfWeek::Tuesday => "Tu",
-            DayOfWeek::Wednesday => "W",
+            DayOfWeek::Wednesday => "We",
             DayOfWeek::Thursday => "Th",
-            DayOfWeek::Friday => "F",
+            DayOfWeek::Friday => "Fr",
             DayOfWeek::Saturday => "Sa",
             DayOfWeek::Sunday => "Su",
         }
     }
 
     /// Convert to full string representation
-    pub fn to_string(&self) -> &'static str {
+    pub fn to_full_string(self) -> &'static str {
         match self {
             DayOfWeek::Monday => "Monday",
             DayOfWeek::Tuesday => "Tuesday",
@@ -196,10 +196,9 @@ impl TryFrom<MeetingDays> for DayOfWeek {
             });
         }
 
-        return Err(anyhow::anyhow!(
-            "Cannot convert multiple days to a single day: {:?}",
-            days
-        ));
+        Err(anyhow::anyhow!(
+            "Cannot convert multiple days to a single day: {days:?}"
+        ))
     }
 }
 
@@ -252,15 +251,8 @@ impl TimeRange {
         let hour = time.hour();
         let minute = time.minute();
 
-        if hour == 0 {
-            format!("12:{:02}AM", minute)
-        } else if hour < 12 {
-            format!("{}:{:02}AM", hour, minute)
-        } else if hour == 12 {
-            format!("12:{:02}PM", minute)
-        } else {
-            format!("{}:{:02}PM", hour - 12, minute)
-        }
+        let meridiem = if hour < 12 { "AM" } else { "PM" };
+        format!("{hour}:{minute:02}{meridiem}")
     }
 
     /// Get duration in minutes
@@ -355,37 +347,58 @@ impl MeetingType {
 
 /// Meeting location information
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct MeetingLocation {
-    pub campus: String,
-    pub building: String,
-    pub building_description: String,
-    pub room: String,
-    pub is_online: bool,
+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 {
-        let is_online = meeting_time.room.is_empty();
+        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 {
-            campus: meeting_time.campus_description.clone(),
-            building: meeting_time.building.clone(),
-            building_description: meeting_time.building_description.clone(),
-            room: meeting_time.room.clone(),
-            is_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(),
         }
     }
+}
 
-    /// Convert to formatted string
-    pub fn to_string(&self) -> String {
-        if self.is_online {
-            "Online".to_string()
-        } else {
-            format!(
-                "{} | {} | {} {}",
-                self.campus, self.building_description, self.building, self.room
-            )
+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,
+            ),
         }
     }
 }
@@ -405,7 +418,11 @@ 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 = TimeRange::from_hhmm(&meeting_time.begin_time, &meeting_time.end_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(|| {
@@ -439,32 +456,52 @@ impl MeetingScheduleInfo {
     }
 
     /// Get formatted days string
-    pub fn days_string(&self) -> String {
+    pub fn days_string(&self) -> Option<String> {
         if self.days.is_empty() {
-            "None".to_string()
-        } else if self.days.is_all() {
-            "Everyday".to_string()
-        } else {
-            self.days_of_week()
-                .iter()
-                .map(|day| day.to_short_string())
-                .collect::<Vec<_>>()
-                .join("")
+            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 {
-        if self.location.room.is_empty() {
-            "Online".to_string()
-        } else {
-            format!(
+        match &self.location {
+            MeetingLocation::Online => "Online".to_string(),
+            MeetingLocation::InPerson {
+                campus,
+                building,
+                building_description,
+                room,
+                ..
+            } => format!(
                 "{} | {} | {} {}",
-                self.location.campus,
-                self.location.building_description,
-                self.location.building,
-                self.location.room
-            )
+                campus, building_description, building, room
+            ),
         }
     }
 

src/banner/models/search.rs

@@ -10,8 +10,8 @@ pub struct SearchResult {
     pub total_count: i32,
     pub page_offset: i32,
     pub page_max_size: i32,
-    pub path_mode: String,
-    pub search_results_config: Vec<SearchResultConfig>,
+    pub path_mode: Option<String>,
+    pub search_results_config: Option<Vec<SearchResultConfig>>,
     pub data: Option<Vec<Course>>,
 }
 

src/banner/models/terms.rs

@@ -13,7 +13,7 @@ const CURRENT_YEAR: u32 = compile_time::date!().year() as u32;
 const VALID_YEARS: RangeInclusive<u32> = 2007..=(CURRENT_YEAR + 10);
 
 /// Represents a term in the Banner system
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
 pub struct Term {
     pub year: u32, // 2024, 2025, etc
     pub season: Season,
@@ -29,7 +29,7 @@ pub enum TermPoint {
 }
 
 /// Represents a season within a term
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
 pub enum Season {
     Fall,
     Spring,
@@ -46,7 +46,7 @@ impl Term {
     /// 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() 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.
@@ -115,22 +115,22 @@ impl Term {
     fn get_season_ranges(year: u32) -> SeasonRanges {
         let spring_start = NaiveDate::from_ymd_opt(year as i32, 1, 14)
             .unwrap()
-            .ordinal() as u32;
+            .ordinal();
         let spring_end = NaiveDate::from_ymd_opt(year as i32, 5, 1)
             .unwrap()
-            .ordinal() as u32;
+            .ordinal();
         let summer_start = NaiveDate::from_ymd_opt(year as i32, 5, 25)
             .unwrap()
-            .ordinal() as u32;
+            .ordinal();
         let summer_end = NaiveDate::from_ymd_opt(year as i32, 8, 15)
             .unwrap()
-            .ordinal() as u32;
+            .ordinal();
         let fall_start = NaiveDate::from_ymd_opt(year as i32, 8, 18)
             .unwrap()
-            .ordinal() as u32;
+            .ordinal();
         let fall_end = NaiveDate::from_ymd_opt(year as i32, 12, 10)
             .unwrap()
-            .ordinal() as u32;
+            .ordinal();
 
         SeasonRanges {
             spring: YearDayRange {
@@ -179,16 +179,21 @@ struct YearDayRange {
     end: u32,
 }
 
-impl ToString for Term {
+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 to_string(&self) -> String {
-        format!("{}{}", self.year, self.season.to_str())
+    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 {
+    fn to_str(self) -> &'static str {
         match self {
             Season::Fall => "10",
             Season::Spring => "20",
@@ -215,7 +220,7 @@ impl FromStr for Season {
             "10" => Season::Fall,
             "20" => Season::Spring,
             "30" => Season::Summer,
-            _ => return Err(anyhow::anyhow!("Invalid season: {}", s)),
+            _ => return Err(anyhow::anyhow!("Invalid season: {s}")),
         };
         Ok(season)
     }

src/banner/query.rs

@@ -270,7 +270,7 @@ impl std::fmt::Display for SearchQuery {
         let mut parts = Vec::new();
 
         if let Some(ref subject) = self.subject {
-            parts.push(format!("subject={}", subject));
+            parts.push(format!("subject={subject}"));
         }
         if let Some(ref title) = self.title {
             parts.push(format!("title={}", title.trim()));
@@ -296,21 +296,21 @@ impl std::fmt::Display for SearchQuery {
                 .map(|i| i.to_string())
                 .collect::<Vec<_>>()
                 .join(",");
-            parts.push(format!("instructor={}", instructor_str));
+            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));
+            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));
+            parts.push(format!("endTime={hour}:{minute}:{meridiem}"));
         }
         if let Some(min_credits) = self.min_credits {
-            parts.push(format!("minCredits={}", min_credits));
+            parts.push(format!("minCredits={min_credits}"));
         }
         if let Some(max_credits) = self.max_credits {
-            parts.push(format!("maxCredits={}", 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));

src/banner/scraper.rs

@@ -1,293 +0,0 @@
-//! Course scraping functionality for the Banner API.
-
-use crate::banner::{api::BannerApi, models::*, query::SearchQuery};
-use anyhow::{Context, Result};
-use redis::AsyncCommands;
-use std::time::Duration;
-use tokio::time;
-use tracing::{debug, error, info, warn};
-
-/// Priority majors that should be scraped more frequently
-const PRIORITY_MAJORS: &[&str] = &["CS", "CPE", "MAT", "EE", "IS"];
-
-/// Maximum number of courses to fetch per page
-const MAX_PAGE_SIZE: i32 = 500;
-
-/// Course scraper for Banner API
-pub struct CourseScraper {
-    api: BannerApi,
-    redis_client: redis::Client,
-}
-
-impl CourseScraper {
-    /// Creates a new course scraper
-    pub fn new(api: BannerApi, redis_url: &str) -> Result<Self> {
-        let redis_client =
-            redis::Client::open(redis_url).context("Failed to create Redis client")?;
-
-        Ok(Self { api, redis_client })
-    }
-
-    /// Scrapes all courses and stores them in Redis
-    pub async fn scrape_all(&self, term: &str) -> Result<()> {
-        // Get all subjects
-        let subjects = self
-            .api
-            .get_subjects("", term, 1, 100)
-            .await
-            .context("Failed to get subjects for scraping")?;
-
-        if subjects.is_empty() {
-            return Err(anyhow::anyhow!("No subjects found for term {}", term));
-        }
-
-        // Categorize subjects
-        let (priority_subjects, other_subjects): (Vec<_>, Vec<_>) = subjects
-            .into_iter()
-            .partition(|subject| PRIORITY_MAJORS.contains(&subject.code.as_str()));
-
-        // Get expired subjects that need scraping
-        let mut expired_subjects = Vec::new();
-        expired_subjects.extend(self.get_expired_subjects(&priority_subjects, term).await?);
-        expired_subjects.extend(self.get_expired_subjects(&other_subjects, term).await?);
-
-        if expired_subjects.is_empty() {
-            info!("No expired subjects found, skipping scrape");
-            return Ok(());
-        }
-
-        info!(
-            "Scraping {} subjects for term {}",
-            expired_subjects.len(),
-            term
-        );
-
-        // Scrape each expired subject
-        for subject in expired_subjects {
-            if let Err(e) = self.scrape_subject(&subject.code, term).await {
-                error!("Failed to scrape subject {}: {}", subject.code, e);
-            }
-
-            // Rate limiting between subjects
-            time::sleep(Duration::from_secs(2)).await;
-        }
-
-        Ok(())
-    }
-
-    /// Gets subjects that have expired and need to be scraped
-    async fn get_expired_subjects(&self, subjects: &[Pair], term: &str) -> Result<Vec<Pair>> {
-        let mut conn = self
-            .redis_client
-            .get_multiplexed_async_connection()
-            .await
-            .context("Failed to get Redis connection")?;
-
-        let mut expired = Vec::new();
-
-        for subject in subjects {
-            let key = format!("scraped:{}:{}", subject.code, term);
-            let scraped: Option<String> = conn
-                .get(&key)
-                .await
-                .context("Failed to check scrape status in Redis")?;
-
-            // If not scraped or marked as expired (empty/0), add to list
-            if scraped.is_none() || scraped.as_deref() == Some("0") {
-                expired.push(subject.clone());
-            }
-        }
-
-        Ok(expired)
-    }
-
-    /// Scrapes all courses for a specific subject
-    pub async fn scrape_subject(&self, subject: &str, term: &str) -> Result<()> {
-        let mut offset = 0;
-        let mut total_courses = 0;
-
-        loop {
-            let query = SearchQuery::new()
-                .subject(subject)
-                .offset(offset)
-                .max_results(MAX_PAGE_SIZE * 2);
-
-            // Ensure session term is selected before searching
-            self.api.select_term(term).await?;
-
-            let result = self
-                .api
-                .search(term, &query, "subjectDescription", false)
-                .await
-                .with_context(|| {
-                    format!(
-                        "Failed to search for subject {} at offset {}",
-                        subject, offset
-                    )
-                })?;
-
-            if !result.success {
-                return Err(anyhow::anyhow!(
-                    "Search marked unsuccessful for subject {}",
-                    subject
-                ));
-            }
-
-            let course_count = result.data.as_ref().map(|v| v.len() as i32).unwrap_or(0);
-            total_courses += course_count;
-
-            debug!(
-                "Retrieved {} courses for subject {} at offset {}",
-                course_count, subject, offset
-            );
-
-            // Store each course in Redis
-            for course in result.data.unwrap_or_default() {
-                if let Err(e) = self.store_course(&course).await {
-                    error!(
-                        "Failed to store course {}: {}",
-                        course.course_reference_number, e
-                    );
-                }
-            }
-
-            // Check if we got a full page and should continue
-            if course_count >= MAX_PAGE_SIZE {
-                if course_count > MAX_PAGE_SIZE {
-                    warn!(
-                        "Course count {} exceeds max page size {}",
-                        course_count, MAX_PAGE_SIZE
-                    );
-                }
-
-                offset += MAX_PAGE_SIZE;
-                debug!(
-                    "Continuing to next page for subject {} at offset {}",
-                    subject, offset
-                );
-
-                // Rate limiting between pages
-                time::sleep(Duration::from_secs(3)).await;
-                continue;
-            }
-
-            break;
-        }
-
-        info!(
-            "Scraped {} total courses for subject {}",
-            total_courses, subject
-        );
-
-        // Mark subject as scraped with expiry
-        self.mark_subject_scraped(subject, term, total_courses)
-            .await?;
-
-        Ok(())
-    }
-
-    /// Stores a course in Redis
-    async fn store_course(&self, course: &Course) -> Result<()> {
-        let mut conn = self
-            .redis_client
-            .get_multiplexed_async_connection()
-            .await
-            .context("Failed to get Redis connection")?;
-
-        let key = format!("class:{}", course.course_reference_number);
-        let serialized = serde_json::to_string(course).context("Failed to serialize course")?;
-
-        let _: () = conn
-            .set(&key, serialized)
-            .await
-            .context("Failed to store course in Redis")?;
-
-        Ok(())
-    }
-
-    /// Marks a subject as scraped with appropriate expiry time
-    async fn mark_subject_scraped(
-        &self,
-        subject: &str,
-        term: &str,
-        course_count: i32,
-    ) -> Result<()> {
-        let mut conn = self
-            .redis_client
-            .get_multiplexed_async_connection()
-            .await
-            .context("Failed to get Redis connection")?;
-
-        let key = format!("scraped:{}:{}", subject, term);
-        let expiry = self.calculate_expiry(subject, course_count);
-
-        let value = if course_count == 0 { -1 } else { course_count };
-
-        let _: () = conn
-            .set_ex(&key, value, expiry.as_secs() as u64)
-            .await
-            .context("Failed to mark subject as scraped")?;
-
-        debug!(
-            "Marked subject {} as scraped with {} courses, expiry: {:?}",
-            subject, course_count, expiry
-        );
-
-        Ok(())
-    }
-
-    /// Calculates expiry time for a scraped subject based on various factors
-    fn calculate_expiry(&self, subject: &str, course_count: i32) -> Duration {
-        // Base calculation: 1 hour per 100 courses
-        let mut base_expiry = Duration::from_secs(3600 * (course_count as u64 / 100).max(1));
-
-        // Special handling for subjects with few courses
-        if course_count < 50 {
-            // Linear interpolation: 1 course = 12 hours, 49 courses = 1 hour
-            let hours = 12.0 - ((course_count as f64 - 1.0) / 48.0) * 11.0;
-            base_expiry = Duration::from_secs((hours * 3600.0) as u64);
-        }
-
-        // Priority subjects get shorter expiry (more frequent updates)
-        if PRIORITY_MAJORS.contains(&subject) {
-            base_expiry = base_expiry / 3;
-        }
-
-        // Add random variance (±15%)
-        let variance = (base_expiry.as_secs() as f64 * 0.15) as u64;
-        let random_offset = (rand::random::<f64>() - 0.5) * 2.0 * variance as f64;
-
-        let final_expiry = if random_offset > 0.0 {
-            base_expiry + Duration::from_secs(random_offset as u64)
-        } else {
-            base_expiry.saturating_sub(Duration::from_secs((-random_offset) as u64))
-        };
-
-        // Ensure minimum of 1 hour
-        final_expiry.max(Duration::from_secs(3600))
-    }
-
-    /// Gets a course from Redis cache
-    pub async fn get_course(&self, crn: &str) -> Result<Option<Course>> {
-        let mut conn = self
-            .redis_client
-            .get_multiplexed_async_connection()
-            .await
-            .context("Failed to get Redis connection")?;
-
-        let key = format!("class:{}", crn);
-        let serialized: Option<String> = conn
-            .get(&key)
-            .await
-            .context("Failed to get course from Redis")?;
-
-        match serialized {
-            Some(data) => {
-                let course: Course = serde_json::from_str(&data)
-                    .context("Failed to deserialize course from Redis")?;
-                Ok(Some(course))
-            }
-            None => Ok(None),
-        }
-    }
-}

src/banner/session.rs

@@ -1,120 +1,424 @@
 //! Session management for Banner API.
 
-use anyhow::Result;
-use rand::distributions::{Alphanumeric, DistString};
-use reqwest::Client;
-use std::sync::Mutex;
+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};
+use url::Url;
 
-/// Session manager for Banner API interactions
-#[derive(Debug)]
-pub struct SessionManager {
-    current_session: Mutex<Option<SessionData>>,
-    base_url: String,
-    client: Client,
-}
+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)]
-struct SessionData {
-    session_id: String,
+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,
 }
 
-impl SessionManager {
-    const SESSION_EXPIRY: Duration = Duration::from_secs(25 * 60); // 25 minutes
+/// 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)
+}
 
-    /// Creates a new session manager
-    pub fn new(base_url: String, client: Client) -> Self {
+/// 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) {
+        debug!(id = self.unique_session_id, "Session was used");
+        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 {
-            current_session: Mutex::new(None),
-            base_url,
-            client,
+            sessions: Mutex::new(VecDeque::new()),
+            notifier: Notify::new(),
+            is_creating: Mutex::new(false),
         }
     }
 
-    /// Ensures a valid session is available, creating one if necessary
-    pub fn ensure_session(&self) -> Result<String> {
-        let mut session_guard = self.current_session.lock().unwrap();
+    async fn release(&self, session: BannerSession) {
+        let id = session.unique_session_id.clone();
+        if session.is_expired() {
+            debug!(id = id, "Session is now 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;
+        }
 
-        if let Some(ref session) = *session_guard {
-            if session.created_at.elapsed() < Self::SESSION_EXPIRY {
-                return Ok(session.session_id.clone());
+        let mut queue = self.sessions.lock().await;
+        queue.push_back(session);
+        let queue_size = queue.len();
+        drop(queue); // Release lock before notifying
+
+        debug!(
+            id = id,
+            "Session returned to pool. Queue size is now {queue_size}."
+        );
+        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();
+
+        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() {
+                        debug!(id = session.unique_session_id, "Reusing session from pool");
+                        return Ok(PooledSession {
+                            session: Some(session),
+                            pool: Arc::clone(&term_pool),
+                        });
+                    } else {
+                        debug!(
+                            id = session.unique_session_id,
+                            "Popped an expired session, discarding."
+                        );
+                    }
+                }
+            } // 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);
+                debug!("Another task is creating a session, waiting for notification...");
+                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.
+            debug!("Pool empty, racing notifier vs rate limiter...");
+            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.
+                    debug!("Notified that a session was returned. Looping to retry.");
+                    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.
+                    debug!("Rate limiter ready. Proceeding to create a new 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) => {
+                            debug!(id = new_session.unique_session_id, "Successfully 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"));
+                        }
+                    }
+                }
             }
         }
-
-        // Generate new session
-        let session_id = self.generate_session_id();
-        *session_guard = Some(SessionData {
-            session_id: session_id.clone(),
-            created_at: Instant::now(),
-        });
-
-        debug!("Generated new Banner session: {}", session_id);
-        Ok(session_id)
-    }
-
-    /// Generates a new session ID mimicking Banner's format
-    fn generate_session_id(&self) -> String {
-        let random_part = Alphanumeric.sample_string(&mut rand::thread_rng(), 5);
-        let timestamp = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_millis();
-        format!("{}{}", random_part, timestamp)
     }
 
     /// Sets up initial session cookies by making required Banner API requests
-    pub async fn setup(&self) -> Result<()> {
-        info!("Setting up Banner session...");
+    pub async fn create_session(&self, term: &Term) -> Result<BannerSession> {
+        info!("setting up banner session for term {term}");
 
-        let request_paths = ["/registration/registration", "/selfServiceMenu/data"];
+        // The 'register' or 'search' registration page
+        let initial_registration = self
+            .http
+            .get(format!("{}/registration", self.base_url))
+            .send()
+            .await?;
+        // TODO: Validate success
 
-        for path in &request_paths {
-            let url = format!("{}{}", self.base_url, path);
-            let response = self
-                .client
-                .get(&url)
-                .query(&[("_", timestamp_nonce())])
-                .header("User-Agent", user_agent())
-                .send()
-                .await?;
+        let cookies = initial_registration
+            .headers()
+            .get_all("Set-Cookie")
+            .iter()
+            .filter_map(|header_value| {
+                if let Ok(cookie) = Cookie::parse(header_value.to_str().unwrap()) {
+                    Some((cookie.name().to_string(), cookie.value().to_string()))
+                } else {
+                    None
+                }
+            })
+            .collect::<HashMap<String, String>>();
 
-            if !response.status().is_success() {
-                return Err(anyhow::anyhow!(
-                    "Failed to setup session, request to {} returned {}",
-                    path,
-                    response.status()
-                ));
-            }
+        if !cookies.contains_key("JSESSIONID") || !cookies.contains_key("SSB_COOKIE") {
+            return Err(anyhow::anyhow!("Failed to get cookies"));
         }
 
-        // Note: Cookie validation would require additional setup in a real implementation
-        debug!("Session setup complete");
-        Ok(())
+        let jsessionid = cookies.get("JSESSIONID").unwrap();
+        let ssb_cookie = cookies.get("SSB_COOKIE").unwrap();
+        let cookie_header = format!("JSESSIONID={}; SSB_COOKIE={}", jsessionid, ssb_cookie);
+
+        debug!(
+            jsessionid = jsessionid,
+            ssb_cookie = ssb_cookie,
+            "New session cookies acquired"
+        );
+
+        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) -> Result<()> {
-        let session_id = self.ensure_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", &session_id),
+            ("uniqueSessionId", unique_session_id),
         ];
 
         let url = format!("{}/term/search", self.base_url);
         let response = self
-            .client
+            .http
             .post(&url)
+            .header("Cookie", cookie_header)
             .query(&[("mode", "search")])
             .form(&form_data)
-            .header("User-Agent", user_agent())
-            .header("Content-Type", "application/x-www-form-urlencoded")
             .send()
             .await?;
 
@@ -128,18 +432,21 @@ impl SessionManager {
 
         #[derive(serde::Deserialize)]
         struct RedirectResponse {
-            #[serde(rename = "fwdUrl")]
+            #[serde(rename = "fwdURL")]
             fwd_url: String,
         }
 
         let redirect: RedirectResponse = response.json().await?;
 
+        let base_url_path = self.base_url.parse::<Url>().unwrap().path().to_string();
+        let non_overlap_redirect = redirect.fwd_url.strip_prefix(&base_url_path).unwrap();
+
         // Follow the redirect
-        let redirect_url = format!("{}{}", self.base_url, redirect.fwd_url);
+        let redirect_url = format!("{}{}", self.base_url, non_overlap_redirect);
         let redirect_response = self
-            .client
+            .http
             .get(&redirect_url)
-            .header("User-Agent", user_agent())
+            .header("Cookie", cookie_header)
             .send()
             .await?;
 
@@ -150,41 +457,7 @@ impl SessionManager {
             ));
         }
 
-        debug!("Successfully selected term: {}", term);
-        Ok(())
-    }
-
-    /// Resets the data form (required before new searches)
-    pub async fn reset_data_form(&self) -> Result<()> {
-        let url = format!("{}/classSearch/resetDataForm", self.base_url);
-        let response = self
-            .client
-            .post(&url)
-            .header("User-Agent", user_agent())
-            .send()
-            .await?;
-
-        if !response.status().is_success() {
-            return Err(anyhow::anyhow!(
-                "Failed to reset data form: {}",
-                response.status()
-            ));
-        }
-
+        debug!(term = term, "successfully selected term");
         Ok(())
     }
 }
-
-/// Generates a timestamp-based nonce
-fn timestamp_nonce() -> String {
-    std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .unwrap()
-        .as_millis()
-        .to_string()
-}
-
-/// Returns a browser-like user agent string
-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/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,131 @@
+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().only(&["DATABASE_URL"]))
+        .merge(Env::prefixed("APP_"))
+        .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(config.banner_base_url).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!("Executing {} concurrent searches", queries.len());
+
+    // Execute all searches concurrently
+    let search_futures = queries.into_iter().map(|(label, query)| {
+        info!("Starting search: {}", label);
+        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

@@ -1,10 +1,10 @@
 //! Google Calendar command implementation.
 
-use crate::banner::{Course, DayOfWeek, MeetingScheduleInfo, Term};
-use crate::bot::{Context, Error};
+use crate::banner::{Course, DayOfWeek, MeetingScheduleInfo};
+use crate::bot::{Context, Error, utils};
 use chrono::NaiveDate;
 use std::collections::HashMap;
-use tracing::{error, info};
+use tracing::info;
 use url::Url;
 
 /// Generate a link to create a Google Calendar event for a course
@@ -18,36 +18,16 @@ pub async fn gcal(
 
     ctx.defer().await?;
 
-    let app_state = &ctx.data().app_state;
-    let banner_api = &app_state.banner_api;
-
-    // Get current term dynamically
-    let current_term_status = Term::get_current();
-    let term = current_term_status.inner();
-
-    // Fetch live course data from Redis cache via AppState
-    let course = match app_state
-        .get_course_or_fetch(&term.to_string(), &crn.to_string())
-        .await
-    {
-        Ok(course) => course,
-        Err(e) => {
-            error!(%e, crn, "Failed to fetch course data");
-            return Err(Error::from(e));
-        }
-    };
+    let course = utils::get_course_by_crn(&ctx, crn).await?;
+    let term = course.term.clone();
 
     // Get meeting times
-    let meeting_times = match banner_api
-        .get_course_meeting_time(&term.to_string(), crn)
-        .await
-    {
-        Ok(meeting_time) => meeting_time,
-        Err(e) => {
-            error!("Failed to get meeting times: {}", e);
-            return Err(Error::from(e));
-        }
-    };
+    let meeting_times = ctx
+        .data()
+        .app_state
+        .banner_api
+        .get_course_meeting_time(&term, &crn.to_string())
+        .await?;
 
     struct LinkDetail {
         link: String,
@@ -74,8 +54,10 @@ pub async fn gcal(
                 .map(|m| {
                     let link = generate_gcal_url(&course, m)?;
                     let detail = match &m.time_range {
-                        Some(range) => format!("{} {}", m.days_string(), range.format_12hr()),
-                        None => m.days_string(),
+                        Some(range) => {
+                            format!("{} {}", m.days_string().unwrap(), range.format_12hr())
+                        }
+                        None => m.days_string().unwrap(),
                     };
                     Ok(LinkDetail { link, detail })
                 })
@@ -104,10 +86,7 @@ fn generate_gcal_url(
     course: &Course,
     meeting_time: &MeetingScheduleInfo,
 ) -> Result<String, anyhow::Error> {
-    let course_text = format!(
-        "{} {} - {}",
-        course.subject, course.course_number, course.course_title
-    );
+    let course_text = course.display_title();
 
     let dates_text = {
         let (start, end) = meeting_time.datetime_range();
@@ -119,18 +98,14 @@ fn generate_gcal_url(
     };
 
     // Get instructor name
-    let instructor_name = if !course.faculty.is_empty() {
-        &course.faculty[0].display_name
-    } else {
-        "Unknown"
-    };
+    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()
+        meeting_time.days_string().unwrap()
     );
 
     // The event location

src/bot/commands/ics.rs

@@ -1,6 +1,7 @@
 //! ICS command implementation for generating calendar files.
 
-use crate::bot::{Context, Error};
+use crate::bot::{Context, Error, utils};
+use tracing::info;
 
 /// Generate an ICS file for a course
 #[poise::command(slash_command, prefix_command)]
@@ -10,16 +11,15 @@ pub async fn ics(
 ) -> Result<(), Error> {
     ctx.defer().await?;
 
-    // TODO: Get BannerApi from context or global state
-    // TODO: Get current term dynamically
-    let term = 202510; // Hardcoded for now
+    let course = utils::get_course_by_crn(&ctx, crn).await?;
 
     // TODO: Implement actual ICS file generation
     ctx.say(format!(
-        "ICS command not yet implemented - BannerApi integration needed\nCRN: {}, Term: {}",
-        crn, term
+        "ICS generation for '{}' is not yet implemented.",
+        course.display_title()
     ))
     .await?;
 
+    info!("ics command completed for CRN: {}", crn);
     Ok(())
 }

src/bot/commands/mod.rs

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

src/bot/commands/search.rs

@@ -1,8 +1,10 @@
 //! Course search command implementation.
 
-use crate::banner::SearchQuery;
+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)]
@@ -40,12 +42,37 @@ pub async fn search(
         query = query.max_results(max_results.min(25)); // Cap at 25
     }
 
-    // TODO: Get current term dynamically
-    // TODO: Get BannerApi from context or global state
-    // For now, we'll return an error
-    ctx.say("Search functionality not yet implemented - BannerApi integration needed")
+    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(())
 }
 
@@ -65,22 +92,22 @@ fn parse_course_code(input: &str) -> Result<(i32, i32), Error> {
             };
 
             if low > high {
-                return Err("Invalid range: low value greater than high value".into());
+                return Err(anyhow!("Invalid range: low value greater than high value"));
             }
 
             if low < 1000 || high > 9999 {
-                return Err("Course codes must be between 1000 and 9999".into());
+                return Err(anyhow!("Course codes must be between 1000 and 9999"));
             }
 
             return Ok((low, high));
         }
-        return Err("Invalid range format".into());
+        return Err(anyhow!("Invalid range format"));
     }
 
     // Handle wildcard format (e.g, "34xx")
     if input.contains('x') {
         if input.len() != 4 {
-            return Err("Wildcard format must be exactly 4 characters".into());
+            return Err(anyhow!("Wildcard format must be exactly 4 characters"));
         }
 
         let re = Regex::new(r"(\d+)(x+)").unwrap();
@@ -92,22 +119,22 @@ fn parse_course_code(input: &str) -> Result<(i32, i32), Error> {
             let high = low + 10_i32.pow(x_count as u32) - 1;
 
             if low < 1000 || high > 9999 {
-                return Err("Course codes must be between 1000 and 9999".into());
+                return Err(anyhow!("Course codes must be between 1000 and 9999"));
             }
 
             return Ok((low, high));
         }
-        return Err("Invalid wildcard format".into());
+        return Err(anyhow!("Invalid wildcard format"));
     }
 
     // Handle single course code
     if input.len() == 4 {
         let code: i32 = input.parse()?;
-        if code < 1000 || code > 9999 {
-            return Err("Course codes must be between 1000 and 9999".into());
+        if !(1000..=9999).contains(&code) {
+            return Err(anyhow!("Course codes must be between 1000 and 9999"));
         }
         return Ok((code, code));
     }
 
-    Err("Invalid course code format".into())
+    Err(anyhow!("Invalid course code format"))
 }

src/bot/commands/terms.rs

@@ -1,6 +1,8 @@
 //! 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)]
@@ -13,14 +15,45 @@ pub async fn terms(
 
     let search_term = search.unwrap_or_default();
     let page_number = page.unwrap_or(1).max(1);
+    let max_results = 10;
 
-    // TODO: Get BannerApi from context or global state
-    // For now, we'll return a placeholder response
-    ctx.say(format!(
-        "Terms command not yet implemented - BannerApi integration needed\nSearch: '{}', Page: {}",
-        search_term, page_number
-    ))
-    .await?;
+    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

@@ -1,6 +1,7 @@
 //! Time command implementation for course meeting times.
 
-use crate::bot::{Context, Error};
+use crate::bot::{Context, Error, utils};
+use tracing::info;
 
 /// Get meeting times for a specific course
 #[poise::command(slash_command, prefix_command)]
@@ -10,16 +11,15 @@ pub async fn time(
 ) -> Result<(), Error> {
     ctx.defer().await?;
 
-    // TODO: Get BannerApi from context or global state
-    // TODO: Get current term dynamically
-    let term = 202510; // Hardcoded for now
+    let course = utils::get_course_by_crn(&ctx, crn).await?;
 
-    // TODO: Implement actual meeting time retrieval
+    // TODO: Implement actual meeting time retrieval and display
     ctx.say(format!(
-        "Time command not yet implemented - BannerApi integration needed\nCRN: {}, Term: {}",
-        crn, term
+        "Meeting time display for '{}' is not yet implemented.",
+        course.display_title()
     ))
     .await?;
 
+    info!("time command completed for CRN: {}", crn);
     Ok(())
 }

src/bot/mod.rs

@@ -1,12 +1,12 @@
-use crate::app_state::AppState;
+use crate::error::Error;
+use crate::state::AppState;
 
 pub mod commands;
+pub mod utils;
 
-#[derive(Debug)]
 pub struct Data {
     pub app_state: AppState,
 } // User data, which is stored and accessible in all command invocations
-pub type Error = Box<dyn std::error::Error + Send + Sync>;
 pub type Context<'a> = poise::Context<'a, Data, Error>;
 
 /// Get all available commands

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 Redis cache via AppState
+    app_state
+        .get_course_or_fetch(&term.to_string(), &crn.to_string())
+        .await
+        .map_err(|e| {
+            error!(%e, crn, "failed to fetch course data");
+            e
+        })
+}

src/config/mod.rs

@@ -3,8 +3,6 @@
 //! 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.
-//!
-//! All configuration is loaded from environment variables with the `APP_` prefix:
 
 use fundu::{DurationParser, TimeUnit};
 use serde::{Deserialize, Deserializer};
@@ -13,8 +11,20 @@ use std::time::Duration;
 /// Application configuration loaded from environment variables
 #[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,
     /// Discord bot token for authentication
     pub bot_token: String,
+    /// Port for the web server
+    #[serde(default = "default_port")]
+    pub port: u16,
     /// Database connection URL
     pub database_url: String,
     /// Redis connection URL
@@ -23,8 +33,6 @@ pub struct Config {
     pub banner_base_url: String,
     /// Target Discord guild ID where the bot operates
     pub bot_target_guild: u64,
-    /// Discord application ID
-    pub bot_app_id: u64,
     /// Graceful shutdown timeout duration
     ///
     /// Accepts both numeric values (seconds) and duration strings
@@ -36,6 +44,16 @@ pub struct Config {
     pub shutdown_timeout: Duration,
 }
 
+/// Default log level of "info"
+fn default_log_level() -> String {
+    "info".to_string()
+}
+
+/// Default port of 3000
+fn default_port() -> u16 {
+    3000
+}
+
 /// Default shutdown timeout of 8 seconds
 fn default_shutdown_timeout() -> Duration {
     Duration::from_secs(8)

src/data/mod.rs

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

src/data/models.rs

@@ -0,0 +1,71 @@
+//! `sqlx` models for the database schema.
+
+use chrono::{DateTime, Utc};
+use serde_json::Value;
+
+#[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>,
+}
+
+#[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,
+}
+
+#[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.
+#[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>>,
+}

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/lib.rs

@@ -1,5 +1,9 @@
-pub mod app_state;
 pub mod banner;
 pub mod bot;
+pub mod config;
+pub mod data;
+pub mod error;
+pub mod scraper;
 pub mod services;
+pub mod state;
 pub mod web;

src/main.rs

@@ -1,21 +1,29 @@
 use serenity::all::{ClientBuilder, GatewayIntents};
 use tokio::signal;
-use tracing::{debug, error, info, warn};
+use tracing::{error, info, warn};
 use tracing_subscriber::{EnvFilter, FmtSubscriber};
 
-use crate::app_state::AppState;
 use crate::banner::BannerApi;
 use crate::bot::{Data, get_commands};
 use crate::config::Config;
+use crate::scraper::ScraperService;
 use crate::services::manager::ServiceManager;
-use crate::services::{ServiceResult, bot::BotService, run_service};
+use crate::services::{ServiceResult, bot::BotService, web::WebService};
+use crate::state::AppState;
+use crate::web::routes::BannerState;
 use figment::{Figment, providers::Env};
+use sqlx::postgres::PgPoolOptions;
+use std::sync::Arc;
 
-mod app_state;
 mod banner;
 mod bot;
 mod config;
+mod data;
+mod error;
+mod scraper;
 mod services;
+mod state;
+mod web;
 
 #[tokio::main]
 async fn main() {
@@ -35,24 +43,53 @@ async fn main() {
         }
     }
     .with_env_filter(filter)
+    .with_target(true)
     .finish();
     tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
 
+    // Log application startup context
+    info!(
+        version = env!("CARGO_PKG_VERSION"),
+        environment = if cfg!(debug_assertions) {
+            "development"
+        } else {
+            "production"
+        },
+        "starting banner"
+    );
+
     let config: Config = Figment::new()
+        .merge(Env::raw().only(&["DATABASE_URL"]))
         .merge(Env::prefixed("APP_"))
         .extract()
         .expect("Failed to load config");
 
+    // Create database connection pool
+    let db_pool = PgPoolOptions::new()
+        .max_connections(10)
+        .connect(&config.database_url)
+        .await
+        .expect("Failed to create database pool");
+
+    info!(
+        port = config.port,
+        shutdown_timeout = format!("{:.2?}", config.shutdown_timeout),
+        banner_base_url = config.banner_base_url,
+        "configuration loaded"
+    );
+
     // Create BannerApi and AppState
     let banner_api =
         BannerApi::new(config.banner_base_url.clone()).expect("Failed to create BannerApi");
-    banner_api
-        .setup()
-        .await
-        .expect("Failed to set up BannerApi session");
 
-    let app_state =
-        AppState::new(banner_api, &config.redis_url).expect("Failed to create AppState");
+    let banner_api_arc = Arc::new(banner_api);
+    let app_state = AppState::new(banner_api_arc.clone(), &config.redis_url)
+        .expect("Failed to create AppState");
+
+    // Create BannerState for web service
+    let banner_state = BannerState {
+        api: banner_api_arc.clone(),
+    };
 
     // Configure the client with your Discord bot token in the environment
     let intents = GatewayIntents::non_privileged();
@@ -62,6 +99,50 @@ async fn main() {
     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!("Fatal error while sending error message: {}", e);
+                    }
+                    // error!(error = ?error, "command error");
+                })
+            },
             ..Default::default()
         })
         .setup(move |ctx, _ready, framework| {
@@ -86,77 +167,89 @@ async fn main() {
 
     // Extract shutdown timeout before moving config
     let shutdown_timeout = config.shutdown_timeout;
+    let port = config.port;
 
     // Create service manager
     let mut service_manager = ServiceManager::new();
 
-    // Create and add services
+    // Register services with the manager
     let bot_service = Box::new(BotService::new(client));
+    let web_service = Box::new(WebService::new(port, banner_state));
+    let scraper_service = Box::new(ScraperService::new(db_pool.clone(), banner_api_arc.clone()));
 
-    let bot_handle = tokio::spawn(run_service(bot_service, service_manager.subscribe()));
+    service_manager.register_service("bot", bot_service);
+    service_manager.register_service("web", web_service);
+    service_manager.register_service("scraper", scraper_service);
 
-    service_manager.add_service("bot".to_string(), bot_handle);
+    // Spawn all registered services
+    service_manager.spawn_all();
 
     // Set up CTRL+C signal handling
     let ctrl_c = async {
         signal::ctrl_c()
             .await
             .expect("Failed to install CTRL+C signal handler");
-        info!("Received CTRL+C, gracefully shutting down...");
+        info!("received ctrl+c, gracefully shutting down...");
     };
 
     // Main application loop - wait for services or CTRL+C
     let mut exit_code = 0;
 
-    let join = |strings: Vec<String>| {
-        strings
-            .iter()
-            .map(|s| format!("\"{}\"", s))
-            .collect::<Vec<_>>()
-            .join(", ")
-    };
-
     tokio::select! {
         (service_name, result) = service_manager.run() => {
             // A service completed unexpectedly
             match result {
                 ServiceResult::GracefulShutdown => {
-                    info!(service = service_name, "Service completed gracefully");
+                    info!(service = service_name, "service completed gracefully");
                 }
                 ServiceResult::NormalCompletion => {
-                    warn!(service = service_name, "Service completed unexpectedly");
+                    warn!(service = service_name, "service completed unexpectedly");
                     exit_code = 1;
                 }
                 ServiceResult::Error(e) => {
-                    error!(service = service_name, "Service failed: {e}");
+                    error!(service = service_name, error = ?e, "service failed");
                     exit_code = 1;
                 }
             }
 
             // Shutdown remaining services
             match service_manager.shutdown(shutdown_timeout).await {
-                Ok(()) => {
-                    debug!("Graceful shutdown complete");
+                Ok(elapsed) => {
+                    info!(
+                        remaining = format!("{:.2?}", shutdown_timeout - elapsed),
+                        "graceful shutdown complete"
+                    );
                 }
                 Err(pending_services) => {
                     warn!(
-                        "Graceful shutdown elapsed - the following service(s) did not complete: {}",
-                        join(pending_services)
+                        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 2 if not set
                     exit_code = if exit_code == 0 { 2 } else { exit_code };
                 }
             }
         }
         _ = ctrl_c => {
             // User requested shutdown
+            info!("user requested shutdown via ctrl+c");
             match service_manager.shutdown(shutdown_timeout).await {
-                Ok(()) => {
-                    debug!("Graceful shutdown complete");
+                Ok(elapsed) => {
+                    info!(
+                        remaining = format!("{:.2?}", shutdown_timeout - elapsed),
+                        "graceful shutdown complete"
+                    );
+                    info!("graceful shutdown complete");
                 }
                 Err(pending_services) => {
                     warn!(
-                        "Graceful shutdown elapsed - the following service(s) did not complete: {}",
-                        join(pending_services)
+                        pending_count = pending_services.len(),
+                        pending_services = ?pending_services,
+                        "graceful shutdown elapsed - {} service(s) did not complete",
+                        pending_services.len()
                     );
                     exit_code = 2;
                 }
@@ -164,6 +257,6 @@ async fn main() {
         }
     }
 
-    info!(exit_code = exit_code, "Shutdown complete");
+    info!(exit_code, "application shutdown complete");
     std::process::exit(exit_code);
 }

src/scraper/mod.rs

@@ -0,0 +1,87 @@
+pub mod scheduler;
+pub mod worker;
+
+use crate::banner::BannerApi;
+use sqlx::PgPool;
+use std::sync::Arc;
+use tokio::task::JoinHandle;
+use tracing::info;
+
+use self::scheduler::Scheduler;
+use self::worker::Worker;
+use crate::services::Service;
+
+/// 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<()>>,
+}
+
+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(),
+        }
+    }
+
+    /// Starts the scheduler and a pool of workers.
+    pub fn start(&mut self) {
+        info!("ScraperService starting...");
+
+        let scheduler = Scheduler::new(self.db_pool.clone(), self.banner_api.clone());
+        let scheduler_handle = tokio::spawn(async move {
+            scheduler.run().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 worker_handle = tokio::spawn(async move {
+                worker.run().await;
+            });
+            self.worker_handles.push(worker_handle);
+        }
+        info!("Spawned {} worker tasks.", self.worker_handles.len());
+    }
+
+    /// Signals all child tasks to gracefully shut down.
+    pub async fn shutdown(&mut self) {
+        info!("Shutting down scraper service...");
+        if let Some(handle) = self.scheduler_handle.take() {
+            handle.abort();
+        }
+        for handle in self.worker_handles.drain(..) {
+            handle.abort();
+        }
+        info!("Scraper service shutdown.");
+    }
+}
+
+#[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> {
+        self.shutdown().await;
+        Ok(())
+    }
+}

src/scraper/scheduler.rs

@@ -0,0 +1,85 @@
+use crate::banner::{BannerApi, Term};
+use crate::data::models::{ScrapePriority, TargetType};
+use crate::error::Result;
+use serde_json::json;
+use sqlx::PgPool;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::time;
+use tracing::{error, info};
+
+/// 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.
+    pub async fn run(&self) {
+        info!("Scheduler service started.");
+        let mut interval = time::interval(Duration::from_secs(60)); // Runs every minute
+
+        loop {
+            interval.tick().await;
+            info!("Scheduler waking up to analyze and schedule jobs...");
+            if let Err(e) = self.schedule_jobs().await {
+                error!(error = ?e, "Failed to schedule jobs");
+            }
+        }
+    }
+
+    /// The core logic for deciding what jobs to create.
+    async fn schedule_jobs(&self) -> Result<()> {
+        // For now, we will implement a simple baseline scheduling strategy:
+        // 1. Get a list of all subjects from the Banner API.
+        // 2. For each subject, check if an active (not locked, not completed) job already exists.
+        // 3. If no job exists, create a new, low-priority job to be executed in the near future.
+        let term = Term::get_current().inner().to_string();
+
+        info!(
+            term = term,
+            "[Scheduler] Enqueuing baseline subject scrape jobs..."
+        );
+
+        let subjects = self.banner_api.get_subjects("", &term, 1, 500).await?;
+
+        for subject in subjects {
+            let payload = json!({ "subject": subject.code });
+
+            let existing_job: Option<(i32,)> = sqlx::query_as(
+                "SELECT id FROM scrape_jobs WHERE target_type = $1 AND target_payload = $2 AND locked_at IS NULL"
+            )
+            .bind(TargetType::Subject)
+            .bind(&payload)
+            .fetch_optional(&self.db_pool)
+            .await?;
+
+            if existing_job.is_some() {
+                continue;
+            }
+
+            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(chrono::Utc::now())
+            .execute(&self.db_pool)
+            .await?;
+
+            info!(subject = subject.code, "[Scheduler] Enqueued new job");
+        }
+
+        info!("[Scheduler] Job scheduling complete.");
+        Ok(())
+    }
+}

src/scraper/worker.rs

@@ -0,0 +1,205 @@
+use crate::banner::{BannerApi, BannerApiError, Course, SearchQuery, Term};
+use crate::data::models::ScrapeJob;
+use crate::error::Result;
+use serde_json::Value;
+use sqlx::PgPool;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::time;
+use tracing::{error, info, 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) {
+        info!(worker_id = self.id, "Worker started.");
+        loop {
+            match self.fetch_and_lock_job().await {
+                Ok(Some(job)) => {
+                    let job_id = job.id;
+                    info!(worker_id = self.id, job_id = job.id, "Processing job");
+                    if let Err(e) = self.process_job(job).await {
+                        // Check if the error is due to an invalid session
+                        if let Some(BannerApiError::InvalidSession(_)) =
+                            e.downcast_ref::<BannerApiError>()
+                        {
+                            warn!(
+                                worker_id = self.id,
+                                job_id, "Invalid session detected. Forcing session refresh."
+                            );
+                        } else {
+                            error!(worker_id = self.id, job_id, error = ?e, "Failed to process job");
+                        }
+
+                        // Unlock the job so it can be retried
+                        if let Err(unlock_err) = self.unlock_job(job_id).await {
+                            error!(
+                                worker_id = self.id,
+                                job_id,
+                                ?unlock_err,
+                                "Failed to unlock job"
+                            );
+                        }
+                    } else {
+                        info!(worker_id = self.id, job_id, "Job processed successfully");
+                        // If successful, delete the job.
+                        if let Err(delete_err) = self.delete_job(job_id).await {
+                            error!(
+                                worker_id = self.id,
+                                job_id,
+                                ?delete_err,
+                                "Failed to delete job"
+                            );
+                        }
+                    }
+                }
+                Ok(None) => {
+                    // No job found, wait for a bit before polling again.
+                    time::sleep(Duration::from_secs(5)).await;
+                }
+                Err(e) => {
+                    warn!(worker_id = self.id, error = ?e, "Failed to fetch job");
+                    // Wait before retrying to avoid spamming errors.
+                    time::sleep(Duration::from_secs(10)).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<()> {
+        match job.target_type {
+            crate::data::models::TargetType::Subject => {
+                self.process_subject_job(&job.target_payload).await
+            }
+            _ => {
+                warn!(worker_id = self.id, job_id = job.id, "unhandled job type");
+                Ok(())
+            }
+        }
+    }
+
+    async fn process_subject_job(&self, payload: &Value) -> Result<()> {
+        let subject_code = payload["subject"]
+            .as_str()
+            .ok_or_else(|| anyhow::anyhow!("Invalid subject payload"))?;
+        info!(
+            worker_id = self.id,
+            subject = subject_code,
+            "Processing subject job"
+        );
+
+        let term = Term::get_current().inner().to_string();
+        let query = SearchQuery::new().subject(subject_code).max_results(500);
+
+        let search_result = self
+            .banner_api
+            .search(&term, &query, "subjectDescription", false)
+            .await?;
+
+        if let Some(courses_from_api) = search_result.data {
+            info!(
+                worker_id = self.id,
+                subject = subject_code,
+                count = courses_from_api.len(),
+                "Found courses to upsert"
+            );
+            for course in courses_from_api {
+                self.upsert_course(&course).await?;
+            }
+        }
+
+        Ok(())
+    }
+
+    async fn upsert_course(&self, course: &Course) -> Result<()> {
+        sqlx::query(
+            r#"
+            INSERT INTO courses (crn, subject, course_number, title, term_code, enrollment, max_enrollment, wait_count, wait_capacity, last_scraped_at)
+            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+            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(&course.course_reference_number)
+        .bind(&course.subject)
+        .bind(&course.course_number)
+        .bind(&course.course_title)
+        .bind(&course.term)
+        .bind(course.enrollment)
+        .bind(course.maximum_enrollment)
+        .bind(course.wait_count)
+        .bind(course.wait_capacity)
+        .bind(chrono::Utc::now())
+        .execute(&self.db_pool)
+        .await?;
+
+        Ok(())
+    }
+
+    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?;
+        info!(worker_id = self.id, job_id, "Job deleted");
+        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?;
+        info!(worker_id = self.id, job_id, "Job unlocked after failure");
+        Ok(())
+    }
+}

src/services/bot.rs

@@ -1,7 +1,7 @@
 use super::Service;
 use serenity::Client;
 use std::sync::Arc;
-use tracing::{error, warn};
+use tracing::{debug, error};
 
 /// Discord bot service implementation
 pub struct BotService {
@@ -28,11 +28,11 @@ impl Service for BotService {
     async fn run(&mut self) -> Result<(), anyhow::Error> {
         match self.client.start().await {
             Ok(()) => {
-                warn!(service = "bot", "Stopped early.");
+                debug!(service = "bot", "stopped early.");
                 Err(anyhow::anyhow!("bot stopped early"))
             }
             Err(e) => {
-                error!(service = "bot", "Error: {e:?}");
+                error!(service = "bot", "error: {e:?}");
                 Err(e.into())
             }
         }

src/services/manager.rs

@@ -2,65 +2,91 @@ use std::collections::HashMap;
 use std::time::Duration;
 use tokio::sync::broadcast;
 use tokio::task::JoinHandle;
-use tracing::{error, info, warn};
+use tracing::{debug, error, info, trace, warn};
 
-use crate::services::ServiceResult;
+use crate::services::{Service, ServiceResult, run_service};
 
 /// Manages multiple services and their lifecycle
 pub struct ServiceManager {
-    services: HashMap<String, JoinHandle<ServiceResult>>,
+    registered_services: HashMap<String, Box<dyn Service>>,
+    running_services: HashMap<String, JoinHandle<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);
         Self {
-            services: HashMap::new(),
+            registered_services: HashMap::new(),
+            running_services: HashMap::new(),
             shutdown_tx,
         }
     }
 
-    /// Add a service to be managed
-    pub fn add_service(&mut self, name: String, handle: JoinHandle<ServiceResult>) {
-        self.services.insert(name, handle);
+    /// 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);
     }
 
-    /// Get a shutdown receiver for services to subscribe to
-    pub fn subscribe(&self) -> broadcast::Receiver<()> {
-        self.shutdown_tx.subscribe()
+    /// 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 handle = tokio::spawn(run_service(service, shutdown_rx));
+            trace!(service = name, id = ?handle.id(), "service spawned",);
+            self.running_services.insert(name, handle);
+        }
+
+        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.services.is_empty() {
+        if self.running_services.is_empty() {
             return (
                 "none".to_string(),
                 ServiceResult::Error(anyhow::anyhow!("No services to run")),
             );
         }
 
-        info!("ServiceManager running {} services", self.services.len());
+        info!(
+            "servicemanager running {} services",
+            self.running_services.len()
+        );
 
         // Wait for any service to complete
         loop {
             let mut completed_services = Vec::new();
 
-            for (name, handle) in &mut self.services {
+            for (name, handle) in &mut self.running_services {
                 if handle.is_finished() {
                     completed_services.push(name.clone());
                 }
             }
 
             if let Some(completed_name) = completed_services.first() {
-                let handle = self.services.remove(completed_name).unwrap();
+                let handle = self.running_services.remove(completed_name).unwrap();
                 match handle.await {
                     Ok(result) => {
                         return (completed_name.clone(), result);
                     }
                     Err(e) => {
-                        error!(service = completed_name, "Service task panicked: {e}");
+                        error!(service = completed_name, "service task panicked: {e}");
                         return (
                             completed_name.clone(),
                             ServiceResult::Error(anyhow::anyhow!("Task panic: {e}")),
@@ -74,82 +100,65 @@ impl ServiceManager {
         }
     }
 
-    /// Shutdown all services gracefully with a timeout
-    /// Returns Ok(()) if all services shut down, or Err(Vec<String>) with names of services that timed out
-    pub async fn shutdown(mut self, timeout: Duration) -> Result<(), Vec<String>> {
-        if self.services.is_empty() {
-            info!("No services to shutdown");
-            return Ok(());
-        }
+    /// Shutdown all services gracefully with a timeout.
+    ///
+    /// If any service fails to shutdown, it will return an error containing the names of the services that failed to shutdown.
+    /// If all services shutdown successfully, the function will return the duration elapsed.
+    pub async fn shutdown(&mut self, timeout: Duration) -> Result<Duration, Vec<String>> {
+        let service_count = self.running_services.len();
+        let service_names: Vec<_> = self.running_services.keys().cloned().collect();
 
         info!(
-            "Shutting down {} services with {}s timeout",
-            self.services.len(),
-            timeout.as_secs()
+            service_count,
+            services = ?service_names,
+            timeout = format!("{:.2?}", timeout),
+            "shutting down {} services with {:?} timeout",
+            service_count,
+            timeout
         );
 
-        // Signal all services to shutdown
+        // Send shutdown signal to all services
         let _ = self.shutdown_tx.send(());
 
-        // Wait for all services to complete with timeout
-        let shutdown_result = tokio::time::timeout(timeout, async {
-            let mut completed = Vec::new();
-            let mut failed = Vec::new();
+        // Wait for all services to complete
+        let start_time = std::time::Instant::now();
+        let mut pending_services = Vec::new();
 
-            while !self.services.is_empty() {
-                let mut to_remove = Vec::new();
-
-                for (name, handle) in &mut self.services {
-                    if handle.is_finished() {
-                        to_remove.push(name.clone());
-                    }
+        for (name, handle) in self.running_services.drain() {
+            match tokio::time::timeout(timeout, handle).await {
+                Ok(Ok(_)) => {
+                    debug!(service = name, "service shutdown completed");
                 }
-
-                for name in to_remove {
-                    let handle = self.services.remove(&name).unwrap();
-                    match handle.await {
-                        Ok(ServiceResult::GracefulShutdown) => {
-                            completed.push(name);
-                        }
-                        Ok(ServiceResult::NormalCompletion) => {
-                            warn!(service = name, "Service completed normally during shutdown");
-                            completed.push(name);
-                        }
-                        Ok(ServiceResult::Error(e)) => {
-                            error!(service = name, "Service error during shutdown: {e}");
-                            failed.push(name);
-                        }
-                        Err(e) => {
-                            error!(service = name, "Service panic during shutdown: {e}");
-                            failed.push(name);
-                        }
-                    }
+                Ok(Err(e)) => {
+                    warn!(service = name, error = ?e, "service shutdown failed");
+                    pending_services.push(name);
                 }
-
-                if !self.services.is_empty() {
-                    tokio::time::sleep(Duration::from_millis(10)).await;
+                Err(_) => {
+                    warn!(service = name, "service shutdown timed out");
+                    pending_services.push(name);
                 }
             }
+        }
 
-            (completed, failed)
-        })
-        .await;
-
-        match shutdown_result {
-            Ok((completed, failed)) => {
-                if !completed.is_empty() {
-                    info!("Services shutdown completed: {}", completed.join(", "));
-                }
-                if !failed.is_empty() {
-                    warn!("Services had errors during shutdown: {}", failed.join(", "));
-                }
-                Ok(())
-            }
-            Err(_) => {
-                // Timeout occurred - return names of services that didn't complete
-                let pending_services: Vec<String> = self.services.keys().cloned().collect();
-                Err(pending_services)
-            }
+        let elapsed = start_time.elapsed();
+        if pending_services.is_empty() {
+            info!(
+                service_count,
+                elapsed = format!("{:.2?}", elapsed),
+                "services shutdown completed: {}",
+                service_names.join(", ")
+            );
+            Ok(elapsed)
+        } else {
+            warn!(
+                pending_count = pending_services.len(),
+                pending_services = ?pending_services,
+                elapsed = format!("{:.2?}", elapsed),
+                "services shutdown completed with {} pending: {}",
+                pending_services.len(),
+                pending_services.join(", ")
+            );
+            Err(pending_services)
         }
     }
 }

src/services/mod.rs

@@ -3,6 +3,7 @@ use tracing::{error, info, warn};
 
 pub mod bot;
 pub mod manager;
+pub mod web;
 
 #[derive(Debug)]
 pub enum ServiceResult {
@@ -21,6 +22,8 @@ pub trait Service: Send + Sync {
     async fn run(&mut self) -> Result<(), anyhow::Error>;
 
     /// Gracefully shutdown the service
+    ///
+    /// An 'Ok' result does not mean the service has completed shutdown, it merely means that the service shutdown was initiated.
     async fn shutdown(&mut self) -> Result<(), anyhow::Error>;
 }
 
@@ -30,16 +33,16 @@ pub async fn run_service(
     mut shutdown_rx: broadcast::Receiver<()>,
 ) -> ServiceResult {
     let name = service.name();
-    info!(service = name, "Service started");
+    info!(service = name, "service started");
 
     let work = async {
         match service.run().await {
             Ok(()) => {
-                warn!(service = name, "Service completed unexpectedly");
+                warn!(service = name, "service completed unexpectedly");
                 ServiceResult::NormalCompletion
             }
             Err(e) => {
-                error!(service = name, "Service failed: {e}");
+                error!(service = name, "service failed: {e}");
                 ServiceResult::Error(e)
             }
         }
@@ -48,18 +51,18 @@ pub async fn run_service(
     tokio::select! {
         result = work => result,
         _ = shutdown_rx.recv() => {
-            info!(service = name, "Shutting down...");
+            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?}");
+                    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}");
+                    error!(service = name, "shutdown failed after {elapsed:.2?}: {e}");
                     ServiceResult::Error(e)
                 }
             }

src/services/web.rs

@@ -0,0 +1,79 @@
+use super::Service;
+use crate::web::{BannerState, create_router};
+use std::net::SocketAddr;
+use tokio::net::TcpListener;
+use tokio::sync::broadcast;
+use tracing::{debug, info, 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));
+        info!(
+            service = "web",
+            link = format!("http://localhost:{}", addr.port()),
+            "starting web server",
+        );
+
+        let listener = TcpListener::bind(addr).await?;
+        debug!(
+            service = "web",
+            "web server listening on {}",
+            format!("http://{}", addr)
+        );
+
+        // 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;
+                debug!(
+                    service = "web",
+                    "received shutdown signal, starting graceful shutdown"
+                );
+            })
+            .await?;
+
+        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(());
+        } else {
+            warn!(
+                service = "web",
+                "no shutdown channel found, cannot trigger graceful shutdown"
+            );
+        }
+        Ok(())
+    }
+}

src/state.rs

@@ -5,24 +5,24 @@ use crate::banner::Course;
 use anyhow::Result;
 use redis::AsyncCommands;
 use redis::Client;
-use serde_json;
+use std::sync::Arc;
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct AppState {
-    pub banner_api: std::sync::Arc<BannerApi>,
-    pub redis: std::sync::Arc<Client>,
+    pub banner_api: Arc<BannerApi>,
+    pub redis: Arc<Client>,
 }
 
 impl AppState {
     pub fn new(
-        banner_api: BannerApi,
+        banner_api: Arc<BannerApi>,
         redis_url: &str,
     ) -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
         let redis_client = Client::open(redis_url)?;
 
         Ok(Self {
-            banner_api: std::sync::Arc::new(banner_api),
-            redis: std::sync::Arc::new(redis_client),
+            banner_api,
+            redis: Arc::new(redis_client),
         })
     }
 
@@ -30,7 +30,7 @@ impl AppState {
     pub async fn get_course_or_fetch(&self, term: &str, crn: &str) -> Result<Course> {
         let mut conn = self.redis.get_multiplexed_async_connection().await?;
 
-        let key = format!("class:{}", crn);
+        let key = format!("class:{crn}");
         if let Some(serialized) = conn.get::<_, Option<String>>(&key).await? {
             let course: Course = serde_json::from_str(&serialized)?;
             return Ok(course);
@@ -43,6 +43,6 @@ impl AppState {
             return Ok(course);
         }
 
-        Err(anyhow::anyhow!("Course not found for CRN {}", crn))
+        Err(anyhow::anyhow!("Course not found for CRN {crn}"))
     }
 }

src/web/mod.rs

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

src/web/routes.rs

@@ -0,0 +1,87 @@
+//! Web API endpoints for Banner bot monitoring and metrics.
+
+use axum::{Router, extract::State, response::Json, routing::get};
+use serde_json::{Value, json};
+use std::sync::Arc;
+use tracing::info;
+
+use crate::banner::BannerApi;
+
+/// Shared application state for web server
+#[derive(Clone)]
+pub struct BannerState {
+    pub api: Arc<BannerApi>,
+}
+
+/// Creates the web server router
+pub fn create_router(state: BannerState) -> Router {
+    Router::new()
+        .route("/", get(root))
+        .route("/health", get(health))
+        .route("/status", get(status))
+        .route("/metrics", get(metrics))
+        .with_state(state)
+}
+
+async fn root() -> Json<Value> {
+    Json(json!({
+        "message": "Banner Discord Bot API",
+        "version": "0.1.0",
+        "endpoints": {
+            "health": "/health",
+            "status": "/status",
+            "metrics": "/metrics"
+        }
+    }))
+}
+
+/// Health check endpoint
+async fn health() -> Json<Value> {
+    info!("health check requested");
+    Json(json!({
+        "status": "healthy",
+        "timestamp": chrono::Utc::now().to_rfc3339()
+    }))
+}
+
+/// Status endpoint showing bot and system status
+async fn status(State(_state): State<BannerState>) -> Json<Value> {
+    // For now, return basic status without accessing private fields
+    Json(json!({
+        "status": "operational",
+        "bot": {
+            "status": "running",
+            "uptime": "TODO: implement uptime tracking"
+        },
+        "cache": {
+            "status": "connected",
+            "courses": "TODO: implement course counting",
+            "subjects": "TODO: implement subject counting"
+        },
+        "banner_api": {
+            "status": "connected"
+        },
+        "timestamp": chrono::Utc::now().to_rfc3339()
+    }))
+}
+
+/// Metrics endpoint for monitoring
+async fn metrics(State(_state): State<BannerState>) -> Json<Value> {
+    // For now, return basic metrics structure
+    Json(json!({
+        "redis": {
+            "status": "connected",
+            "connected_clients": "TODO: implement client counting",
+            "used_memory": "TODO: implement memory tracking"
+        },
+        "cache": {
+            "courses": {
+                "count": "TODO: implement course counting"
+            },
+            "subjects": {
+                "count": "TODO: implement subject counting"
+            }
+        },
+        "timestamp": chrono::Utc::now().to_rfc3339()
+    }))
+}