Server/src/main.rs

// Webserver
#[macro_use] extern crate rocket;

use rocket::{State, Error};
use rocket::response::status;
use rocket::serde::{Serialize, Deserialize, json::Json};

// Database
use sea_orm::*;

mod setup;
use setup::set_up_db;

mod entities;
use entities::{prelude::*, *};

#[derive(Serialize, Deserialize)]
struct RfidCard {
    cardId: String,
    cardComment: String
}

#[derive(Serialize, Deserialize)]
struct Member {
    id: i32,
    ntnuUsername: String,
    firstName: String,
    lastName: String,
    email: String,
    balance: i32,
    imagePreference: String,
    rfidCards: Vec<RfidCard>
}

#[derive(Serialize, Deserialize)]
struct MinimalMember {
    id: i32,
    ntnuUsername: String,
    firstName: String,
    lastName: String,
    email: String,
}

#[derive(Serialize, Deserialize)]
struct MinimalMemberWithoutId {
    ntnuUsername: String,
    firstName: String,
    lastName: String,
    email: String,
}

#[derive(Responder)]
#[response(status = 500, content_type = "text/plain")]
struct ErrorResponder {
    message: String
}

impl From<DbErr> for ErrorResponder {
    fn from(err: DbErr) -> ErrorResponder {
        ErrorResponder { message: err.to_string() }
    }
}
impl From<String> for ErrorResponder {
    fn from(string: String) -> ErrorResponder {
        ErrorResponder { message: string }
    }
}
impl From<&str> for ErrorResponder {
    fn from(str: &str) -> ErrorResponder {
        ErrorResponder { message: str.to_owned().into() }
    }
}

#[get("/")]
fn index() -> &'static str {
    "Hello, world!\nNothing useful is served here."
}

#[post("/member", data = "<minimalMemberWithoutId>")]
async fn add_member(db: &State<DatabaseConnection>, minimalMemberWithoutId: Json<MinimalMemberWithoutId>) -> Result<Json<MinimalMember>, ErrorResponder> {
    // Grab the database connection
    let db = db as &DatabaseConnection;

    // Check if a member with the same NTNU username already exists
    let matching_member: Option<members::Model> = Members::find() // Find a member in the "Members" table
        .filter(members::Column::NtnuUsername.eq(minimalMemberWithoutId.ntnuUsername.to_owned())) // Filter by the provided username in the NtnuUsername column
        .one(db) // We only care about one result
        .await?; // Wait for the result

    // If a member exists return an error
    if matching_member.is_some() {
        return Err(
            ErrorResponder {
                message: "A member with this NTNU username already exists".to_string(),
            }
        )
    }

    // Create the new member info from the provided JSON
    let new_member = members::ActiveModel {
        ntnu_username: ActiveValue::Set(minimalMemberWithoutId.ntnuUsername.to_owned()),
        first_name: ActiveValue::Set(minimalMemberWithoutId.firstName.to_owned()),
        last_name: ActiveValue::Set(minimalMemberWithoutId.lastName.to_owned()),
        email: ActiveValue::Set(minimalMemberWithoutId.email.to_owned()),
        balance: ActiveValue::Set(0),
        image_preference: ActiveValue::Set("Money".to_string()),
        ..Default::default()
    };

    // Add the new member to the database
    let res = Members::insert(new_member).exec(db).await?;

    // Fetch the member's info back from the DB to verify
    let new_member;
    match Members::find_by_id(res.last_insert_id).one(db).await? {
        Some(model) => new_member = model,
        None => {
            return Err(
                ErrorResponder {
                    message: format!("Failed to fetch member for verification of creating new member with ID. memberId: {}", res.last_insert_id)
                }
            );
        },
    }

    // Put the fetched info into a minimal member for returning
    let member = MinimalMember {
        id: new_member.id,
        ntnuUsername: new_member.ntnu_username,
        firstName: new_member.first_name,
        lastName: new_member.last_name,
        email: new_member.email,
    };

    Ok(Json(member))
}

#[get("/member/<memberId>")]
async fn get_member_by_id(db: &State<DatabaseConnection>, memberId: i32) -> Result<Json<Member>, ErrorResponder> {
    let db = db as &DatabaseConnection;

    let database_member;
    match Members::find_by_id(memberId).one(db).await? {
        Some(model) => database_member = model,
        None => {
            return Err(
                ErrorResponder {
                    message: format!("Failed to fetch member by ID. memberId: {}", memberId)
                }
            );
        },
    };

    let member_rfid_cards: Vec<rfid_cards::Model> = database_member.find_related(RfidCards).all(db).await?;
    let rfids: Vec<RfidCard> = member_rfid_cards.iter().map(|model| RfidCard {
        cardId: model.card_id.clone(),
        cardComment: model.card_comment.clone()
    }).collect();

    let member = Member {
        id: database_member.id,
        ntnuUsername: database_member.ntnu_username,
        firstName: database_member.first_name,
        lastName: database_member.last_name,
        email: database_member.email,
        balance: database_member.balance,
        imagePreference: database_member.image_preference,
        rfidCards: rfids
    };

    Ok(Json(member))
}

#[launch]
async fn rocket() -> _ {
    let db = match set_up_db().await {
        Ok(db) => db,
        Err(err) => panic!("{}", err)
    };

    rocket::build()
        .manage(db)
        .mount("/", routes![
            index,
            get_member_by_id,
            add_member
        ])
}