General Update

Adds functional parsing tool, updates project libraries, general
optimizations and fixes to match database schema and constraints

Author: Sam-Cordry

backend/Cargo.lock

@@ -10,7 +10,12 @@ edition = "2021"
 serde = { version = "1.0.99", features = ["derive"] }
 csv = "1.1.1"
 clap = { version = "4.3.10", features = ["cargo", "derive"] }
-sqlx = { version = "0.7.0", features = ["runtime-tokio-native-tls", "postgres", "chrono", "macros"] }
+sqlx = { version = "0.7.0", features = [
+  "runtime-tokio-native-tls",
+  "postgres",
+  "chrono",
+  "macros",
+] }
 actix-cors = "0.6.4"
 actix-multipart = "0.6.0"
 actix-test = "0.1.1"
@@ -20,7 +25,11 @@ serde_json = { version = "1.0.102", features = ["preserve_order"] }
 dotenvy = "0.15.7"
 typenum = { version = "1.16.0", features = ["force_unix_path_separator"] }
 lazy_static = "1.4.0"
-utoipa = { version = "4.2.0", features = ["actix_extras", "openapi_extensions", "chrono"] }
+utoipa = { version = "4.2.0", features = [
+  "actix_extras",
+  "openapi_extensions",
+  "chrono",
+] }
 utoipa-swagger-ui = { version = "6.0.0", features = ["actix-web"] }
 itertools = "0.12.0"
 chrono = { version = "0.4.33", features = ["serde"] }

backend/Cargo.toml

@@ -1,10 +1,9 @@
-use actix_web::{HttpResponse, Responder, get, web::Data};
-use sqlx::query_as;
-use std::format;
-use log::{log, Level};
 use crate::api::AppState;
 use crate::model::Department;
-use crate::db::log_query_as;
+use actix_web::{get, web::Data, HttpResponse, Responder};
+use log::{log, Level};
+use sqlx::query_as;
+use std::format;
 
 #[utoipa::path(
     context_path = "/api",
@@ -17,18 +16,13 @@ use crate::db::log_query_as;
 pub async fn get_departments(state: Data<AppState>) -> impl Responder {
     log!(Level::Info, "GET /departments");
 
-    match log_query_as(
-        query_as!(
+    match query_as!(
             Department,
             "SELECT DISTINCT d.code AS dept_code, d.title AS dept_title, s.code AS school_code, s.title AS school_title FROM departments d, schools s WHERE d.school = s.id",
         )
         .fetch_all(&state.db)
-        .await,
-        None,
-    )
     .await {
-        Ok((_, depts)) => HttpResponse::Ok().json(depts),
-        Err(e) => return e,
+        Ok(depts) => HttpResponse::Ok().json(depts),
+        Err(e) => HttpResponse::InternalServerError().json(e.to_string()),
     }
 }
-

backend/src/api/departments.rs

@@ -1,9 +1,14 @@
-use actix_web::{post, web::{Json, Data}, HttpResponse, Responder};
-use sqlx::{QueryBuilder, Postgres};
+use crate::{
+    api::AppState,
+    model::{Building, CourseOption, Search, SectionInfo, SectionTimeInfo, Time, WeekDay},
+};
+use actix_web::{
+    post,
+    web::{Data, Json},
+    HttpResponse, Responder,
+};
 use log::{log, Level};
-use crate::api::AppState;
-use crate::model::{Search, SectionInfo, CourseOption, SectionTimeInfo, Time, Building, WeekDay};
-use crate::db::log_query_as;
+use sqlx::{Postgres, QueryBuilder};
 
 #[utoipa::path(
     context_path = "/api",
@@ -14,14 +19,12 @@ use crate::db::log_query_as;
     )
 )]
 #[post("/generate/getCourseOpts")]
-pub async fn get_course_options(
-    state: Data<AppState>,
-    options: Json<Search>,
-) -> impl Responder {
+pub async fn get_course_options(state: Data<AppState>, options: Json<Search>) -> impl Responder {
     log!(Level::Info, "GET /generate/getCourseOpts");
     let course_number = format!("{}%", options.course).to_uppercase();
 
-    let mut query_builder: QueryBuilder<Postgres> = QueryBuilder::new("
+    let mut query_builder: QueryBuilder<Postgres> = QueryBuilder::new(
+        "
             SELECT c.id AS course_id,
                 c.course,
                 c.title,
@@ -38,20 +41,19 @@ pub async fn get_course_options(
                 c.department = d.id AND
                 s.status != 'X' AND
                 c.term = $1 AND
-                (d.code || '-' || c.course || '-' || s.section) LIKE '$2'");
+                (d.code || '-' || c.course || '-' || s.section) LIKE '$2'",
+    );
 
     query_builder.push_bind(options.term);
     query_builder.push_bind(course_number);
 
-    let sections: Vec<SectionInfo>;
-    match log_query_as(
-        query_builder.build_query_as::<SectionInfo>()
-            .fetch_all(&state.db)
-            .await,
-        None,
-    ).await {
-        Ok((_, secs)) => { sections = secs; },
-        Err(e) => return e,
+    let sections: Vec<SectionInfo> = match query_builder
+        .build_query_as::<SectionInfo>()
+        .fetch_all(&state.db)
+        .await
+    {
+        Ok(sections) => sections,
+        Err(e) => return HttpResponse::InternalServerError().json(e.to_string()),
     };
 
     let stem = "
@@ -75,7 +77,7 @@ pub async fn get_course_options(
     }
 
     if let Some(credit_hours) = options.credit_hours {
-        if credit_hours >= 0 && credit_hours <= 12 {
+        if (0..=12).contains(&credit_hours) {
             qb.push(" AND c.credits = $1");
             qb.push_bind(credit_hours);
         }
@@ -111,10 +113,10 @@ pub async fn get_course_options(
             qb.push_bind(section.section_id);
 
             if let Some(days) = &options.days {
-                for idx in 0..7 {
-                    if days[idx] {
+                for (i, day) in days.iter().enumerate() {
+                    if *day {
                         qb.push(" AND t.day = $1");
-                        qb.push_bind(idx as i32);
+                        qb.push_bind(i as i32);
                     }
                 }
             }
@@ -127,16 +129,11 @@ pub async fn get_course_options(
                 qb.push(" AND NOT b.code = 'OFFC'");
             }
 
-            let section_times: Vec<SectionTimeInfo>;
-            match futures::executor::block_on(log_query_as(
-                futures::executor::block_on(
-                    qb.build_query_as::<SectionTimeInfo>()
-                        .fetch_all(&state.db)
-                ),
-                None,
-            )) {
-                Ok((_, t)) => { section_times = t; },
-                Err(_) => { section_times = vec![] },
+            let section_times: Vec<SectionTimeInfo> = match futures::executor::block_on(
+                qb.build_query_as::<SectionTimeInfo>().fetch_all(&state.db),
+            ) {
+                Ok(times) => times,
+                Err(_) => vec![],
             };
 
             let times: Vec<Time> = section_times
@@ -159,7 +156,7 @@ pub async fn get_course_options(
                     };
 
                     Time {
-                        building: building,
+                        building,
                         day: weekday,
                         start: sec_time.start_time as u32,
                         end: sec_time.end_time as u32,
@@ -180,11 +177,10 @@ pub async fn get_course_options(
                 enrollment_capacity: section.max_enroll,
                 instructor_name: section.instructor,
                 online: times[0].building.code == "ON",
-                times: times,
+                times,
             }
         })
         .collect::<Vec<CourseOption>>();
 
     HttpResponse::Ok().json(courses)
 }
-

backend/src/api/get_course_options.rs

@@ -3,14 +3,14 @@ use actix_web::{
     web::{self, scope, Data},
     App, HttpResponse, HttpServer,
 };
+mod departments;
 mod get_course_options;
 mod terms;
-mod departments;
 use actix_cors::Cors;
+use sqlx::{postgres::PgPoolOptions, Pool, Postgres};
+use std::env;
 use utoipa::OpenApi;
 use utoipa_swagger_ui::SwaggerUi;
-use sqlx::{Pool, Postgres, postgres::PgPoolOptions};
-use std::env;
 
 use crate::model;
 
@@ -83,9 +83,5 @@ pub async fn get_app_data() -> Data<AppState> {
         .connect(&env::var("DATABASE_URL").expect("DATABASE_URL not set"))
         .await
         .expect("Could not connect to database");
-    println!("Successfully opened db connection");
-    Data::new(AppState {
-        db: db_pool,
-    })
+    Data::new(AppState { db: db_pool })
 }
-

backend/src/api/mod.rs

@@ -1,9 +1,7 @@
-use actix_web::{HttpResponse, Responder, get, web::Data};
-use sqlx::query_as;
+use crate::{api::AppState, model::Term};
+use actix_web::{get, web::Data, HttpResponse, Responder};
 use log::{log, Level};
-use crate::api::AppState;
-use crate::model::Term;
-use crate::db::log_query_as;
+use sqlx::query_as;
 
 #[utoipa::path(
     context_path = "/api",
@@ -16,18 +14,14 @@ use crate::db::log_query_as;
 pub async fn get_terms(state: Data<AppState>) -> impl Responder {
     log!(Level::Info, "GET /terms");
 
-    match log_query_as(
-        query_as!(
-            Term,
-            "SELECT DISTINCT term FROM academicterms ORDER BY term DESC",
-        )
-        .fetch_all(&state.db)
-        .await,
-        None,
+    match query_as!(
+        Term,
+        "SELECT DISTINCT term FROM academicterms ORDER BY term DESC",
     )
-    .await {
-        Ok((_, terms)) => HttpResponse::Ok().json(terms),
-        Err(e) => return e,
+    .fetch_all(&state.db)
+    .await
+    {
+        Ok(terms) => HttpResponse::Ok().json(terms),
+        Err(e) => HttpResponse::InternalServerError().json(e.to_string()),
     }
 }
-

backend/src/api/terms.rs

@@ -1,7 +1,7 @@
-use sqlx::{Pool, Postgres, Transaction, Error};
-use tokio::sync::OnceCell;
+use actix_web::HttpResponse;
 use log::{log, Level};
-use actix_web::{HttpResponse};
+use sqlx::{Error, Pool, Postgres, Transaction};
+use tokio::sync::OnceCell;
 
 static POOL: OnceCell<Pool<Postgres>> = OnceCell::const_new();
 
@@ -23,48 +23,3 @@ pub async fn open_transaction(db: &Pool<Postgres>) -> Result<Transaction<Postgre
         }
     }
 }
-
-pub async fn log_query_as<T>(
-    query: Result<Vec<T>, Error>,
-    tx: Option<Transaction<'_, Postgres>>,
-) -> Result<(Option<Transaction<'_, Postgres>>, Vec<T>), HttpResponse> {
-    match query {
-        Ok(v) => Ok((tx, v)),
-        Err(e) => {
-            log!(Level::Warn, "DB Query failed: {}", e);
-            if let Some(tx) = tx {
-                match tx.rollback().await {
-                    Ok(_) => {}
-                    Err(tx_e) => {
-                        log!(Level::Error, "Transaction failed to rollback: {}", tx_e);
-                        return Err(HttpResponse::InternalServerError().body("Internal DB Error"));
-                    }
-                }
-            }
-            return Err(HttpResponse::InternalServerError().body("Internal DB Error"));
-        }
-    }
-}
-
-pub async fn log_query(
-    query: Result<(), Error>,
-    tx: Option<Transaction<'_, Postgres>>,
-) -> Result<Option<Transaction<'_, Postgres>>, HttpResponse> {
-    match query {
-        Ok(_) => Ok(tx),
-        Err(e) => {
-            log!(Level::Warn, "DB Query failed: {}", e);
-            if let Some(tx) = tx {
-                match tx.rollback().await {
-                    Ok(_) => {}
-                    Err(tx_e) => {
-                        log!(Level::Error, "Transaction failed to rollback: {}", tx_e);
-                        return Err(HttpResponse::InternalServerError().body("Internal DB Error"));
-                    }
-                }
-            }
-            return Err(HttpResponse::InternalServerError().body("Internal DB Error"));
-        }
-    }
-}
-

backend/src/db.rs

@@ -5,6 +5,7 @@ mod dat;
 mod db;
 mod import;
 mod model;
+mod parse;
 use crate::api::serve;
 
 #[derive(Parser)]
@@ -34,7 +35,10 @@ async fn main() {
 
     let cli = Cli::parse();
     match cli.command {
-        Subcommands::Import => import::import(pool).await.expect("Couldn't import :("),
+        Subcommands::Import => {
+            import::import(pool).await.expect("Couldn't import :(");
+            parse::parse(pool).await.expect("Couldn't parse :(");
+        }
         Subcommands::Serve => serve().await,
     }
 }