src/main.rs

@@ -1,7 +1,6 @@
 // Webserver
 #[macro_use] extern crate rocket;
 
-use entities::members::ActiveModel;
 use rocket::{State, Error};
 use rocket::response::status;
 use rocket::serde::{Serialize, Deserialize, json::Json};
@@ -21,16 +20,6 @@ struct RfidCard {
     cardComment: String
 }
 
-// Implement `.into()` to auto map values from the database model to the local struct
-impl From<<entities::rfid_cards::Entity as sea_orm::EntityTrait>::Model> for RfidCard {
-    fn from(rfid_card: <entities::rfid_cards::Entity as sea_orm::EntityTrait>::Model) -> RfidCard {
-        RfidCard {
-            cardId: rfid_card.card_id,
-            cardComment: rfid_card.card_comment,
-        }
-    }
-}
-
 #[derive(Serialize, Deserialize)]
 struct Member {
     id: i32,
@@ -43,51 +32,6 @@ struct Member {
     rfidCards: Vec<RfidCard>
 }
 
-// Create the `.into()` functionality to auto map values from the database model to the local struct
-// Don't be scared by the long model name, I typed `Members::Model` and applied the auto fix vscode suggested
-impl From<entities::members::Model> for Member {
-    fn from(member: entities::members::Model) -> Member {
-        Member {
-            id: member.id,
-            ntnuUsername: member.ntnu_username,
-            firstName: member.first_name,
-            lastName: member.last_name,
-            email: member.email,
-            balance: member.balance,
-            imagePreference: member.image_preference,
-            rfidCards: Vec::new(),
-        }
-    }
-}
-
-// Implement DB Member Model -> MinimalMember 
-impl From<entities::members::Model> for MinimalMember {
-    fn from(member: entities::members::Model) -> MinimalMember {
-        MinimalMember {
-            id: member.id,
-            ntnuUsername: member.ntnu_username,
-            firstName: member.first_name,
-            lastName: member.last_name,
-            email: member.email,
-        }
-    }
-}
-
-// Create the functionality to create a database model member from the local struct model member
-impl Into<entities::members::ActiveModel> for rocket::serde::json::Json<MinimalMemberWithoutId> {
-    fn into(self) -> entities::members::ActiveModel {
-        entities::members::ActiveModel {
-            ntnu_username: ActiveValue::Set(self.ntnuUsername.to_owned()),
-            first_name: ActiveValue::Set(self.firstName.to_owned()),
-            last_name: ActiveValue::Set(self.lastName.to_owned()),
-            email: ActiveValue::Set(self.email.to_owned()),
-            balance: ActiveValue::Set(0),
-            image_preference: ActiveValue::Set("".to_string()),
-            ..Default::default()
-        }
-    }
-}
-
 #[derive(Serialize, Deserialize)]
 struct MinimalMember {
     id: i32,
@@ -105,11 +49,6 @@ struct MinimalMemberWithoutId {
     email: String,
 }
 
-#[derive(Serialize)]
-struct MultipleMembersStruct {
-    members: Vec<Member>,
-}
-
 #[derive(Responder)]
 #[response(status = 500, content_type = "text/plain")]
 struct ErrorResponder {
@@ -137,47 +76,14 @@ fn index() -> &'static str {
     "Hello, world!\nNothing useful is served here."
 }
 
-#[get("/members")]
+#[post("/member", data = "<minimalMemberWithoutId>")]
-async fn get_members(db: &State<DatabaseConnection>) -> Result<Json<MultipleMembersStruct>, ErrorResponder> {
+async fn add_member(db: &State<DatabaseConnection>, minimalMemberWithoutId: Json<MinimalMemberWithoutId>) -> Result<Json<MinimalMember>, ErrorResponder> {
-    let db = db as &DatabaseConnection;
-
-    // Get a list of all members from the database
-    let members = Members::find().all(db).await?;
-
-    // Convert this vector from the database model to the local struct model
-    let mut members: Vec<Member> = members.into_iter().map(Member::from).collect();
-
-    // Fetch the member's RFID card
-    for member in &mut members {
-        // Look up all RFID cards associated with this member
-        let rfid_cards = RfidCards::find()
-            .filter(rfid_cards::Column::MemberId.eq(member.id))
-            .all(db)
-            .await?;
-
-        // Convert the RFID cards vector from the database model to the local struct model
-        let rfid_cards: Vec<RfidCard> = rfid_cards.into_iter().map(RfidCard::from).collect();
-
-        // Add these cards to the member's rfidCards field
-        member.rfidCards = rfid_cards;
-    }
-
-
-    // Put this into the `MultipleMembersStruct` so that the aquired JSON will look as the API demands
-    let output = MultipleMembersStruct { members };
-
-    // Return the output
-    Ok(Json(output))
-}
-
-#[post("/member", data = "<minimal_member_without_id>")]
-async fn add_member(db: &State<DatabaseConnection>, minimal_member_without_id: 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(minimal_member_without_id.ntnuUsername.to_owned())) // Filter by the provided username in the NtnuUsername column
+        .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
 
@@ -191,7 +97,15 @@ async fn add_member(db: &State<DatabaseConnection>, minimal_member_without_id: J
     }
 
     // Create the new member info from the provided JSON
-    let new_member: members::ActiveModel = minimal_member_without_id.into();
+    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?;
@@ -210,7 +124,13 @@ async fn add_member(db: &State<DatabaseConnection>, minimal_member_without_id: J
     }
 
     // Put the fetched info into a minimal member for returning
-    let member: MinimalMember = new_member.into();
+    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))
 }
@@ -219,27 +139,34 @@ async fn add_member(db: &State<DatabaseConnection>, minimal_member_without_id: J
 async fn get_member_by_id(db: &State<DatabaseConnection>, memberId: i32) -> Result<Json<Member>, ErrorResponder> {
     let db = db as &DatabaseConnection;
 
-    // Create an empty variable to store the resulting member info
     let database_member;
-    // Search the database for the member based on the ID
     match Members::find_by_id(memberId).one(db).await? {
-        Some(model) => database_member = model, // If the member is found, add the info to the previously created variable
+        Some(model) => database_member = model,
         None => {
             return Err(
                 ErrorResponder {
-                    message: format!("Failed to fetch member by ID. memberId: {}", memberId) // If it is not found return with this error
+                    message: format!("Failed to fetch member by ID. memberId: {}", memberId)
                 }
             );
         },
     };
 
-    // Get the member's RFID cards
     let member_rfid_cards: Vec<rfid_cards::Model> = database_member.find_related(RfidCards).all(db).await?;
-    let rfids: Vec<RfidCard> = member_rfid_cards.into_iter().map(RfidCard::from).collect();
+    let rfids: Vec<RfidCard> = member_rfid_cards.iter().map(|model| RfidCard {
+        cardId: model.card_id.clone(),
+        cardComment: model.card_comment.clone()
+    }).collect();
 
-    // Create a member from the database model and append the RFID cards
+    let member = Member {
-    let mut member: Member = database_member.into();
+        id: database_member.id,
-    member.rfidCards = rfids;
+        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))
 }
@@ -256,7 +183,6 @@ async fn rocket() -> _ {
         .mount("/", routes![
             index,
             get_member_by_id,
-            add_member,
+            add_member
-            get_members
         ])
 }