Started on member migration

server/src/routes/member/migrate.rs

@@ -0,0 +1,260 @@
+use std::collections::HashMap;
+
+use axum::{extract::State, Json};
+use itertools::Itertools;
+use sqlx::PgPool;
+
+use crate::{
+    auth::{AuthError, Permissions},
+    database::model::Member as DbMember,
+    model::{member::Name, Member},
+    util::convert_vec,
+    AppState,
+};
+
+pub async fn migrate_request<'a>(
+    State(state): State<AppState>,
+    permissions: Permissions<'a>,
+    body: String,
+) -> Result<Json<MigrationResponse>, crate::Error> {
+    if !permissions.0.contains("root") {
+        return Err(AuthError::NoPermssions.into());
+    }
+
+    // Convert the input CSV to a vector of members
+    let members_new: Vec<Member> = Row::from_csv_multiple(&body)?
+        .into_iter()
+        .map(|m| m.into())
+        .collect();
+
+    // TODO: Write function to get members from database
+    let members_old: Vec<Member> = Vec::new();
+
+    let members_diff = generate_diff(members_new, members_old);
+
+    let count = state
+        .migration_store
+        .lock()
+        .await
+        .insert(members_diff.clone());
+
+    Ok(Json(MigrationResponse::from((count, members_diff))))
+}
+
+pub async fn migrate_confirm<'a>(
+    State(state): State<AppState>,
+    permissions: Permissions<'a>,
+    body: String,
+) -> Result<(), crate::Error> {
+    if !permissions.0.contains("root") {
+        return Err(AuthError::NoPermssions.into());
+    }
+
+    // TODO: Implement better error naming
+    let count = match body.trim().parse::<u32>() {
+        Ok(c) => c,
+        Err(_) => return Err(crate::Error::NotFound),
+    };
+
+    let mut store = state.migration_store.lock().await;
+
+    let members_diff = match store.remove(&count) {
+        Some(m) => m,
+        None => return Err(crate::Error::NotFound),
+    };
+
+    migrate_transaction(&state.pool, members_diff).await?;
+
+    Ok(())
+}
+
+async fn migrate_transaction(pool: &PgPool, members_diff: MembersDiff) -> Result<(), sqlx::Error> {
+    let mut transaction = pool.begin().await?;
+
+    // DbMember::insert_multiple(&mut transaction, convert_vec(members_diff.insert)).await?;
+    DbMember::update_multiple(&mut transaction, convert_vec(members_diff.update)).await?;
+
+    transaction.commit().await?;
+
+    Ok(())
+}
+
+// Create a row for the csv file
+#[derive(Debug, serde::Deserialize, Clone)]
+struct Row {
+    #[serde(rename = "Relatiecode")]
+    id: String,
+    #[serde(rename = "Roepnaam")]
+    first_name: String,
+    // #[serde(rename = "Tussenvoegsel(s)")]
+    // middle_name: String,
+    // #[serde(rename = "Achternaam")]
+    // last_name: String,
+    #[serde(rename = "E-mail")]
+    email: String,
+    #[serde(rename = "Verenigingssporten")]
+    hours: String,
+    #[serde(rename = "Diploma dropdown 1")]
+    diploma: Option<String>,
+}
+
+#[derive(Clone)]
+pub struct MembersDiff {
+    insert: Vec<Member>,
+    update: Vec<Member>,
+    remove: Vec<Member>,
+}
+
+#[derive(serde::Serialize)]
+pub struct MigrationResponse {
+    count: u32,
+    insert: Vec<(String, Name)>,
+    update: Vec<(String, Name)>,
+    remove: Vec<(String, Name)>,
+}
+
+pub struct MigrationStore {
+    pub store: HashMap<u32, MembersDiff>,
+    pub count: u32,
+}
+
+impl Default for MigrationStore {
+    fn default() -> Self {
+        Self {
+            count: 0,
+            store: HashMap::new(),
+        }
+    }
+}
+
+impl Row {
+    fn from_csv_multiple(input: &str) -> Result<Vec<Self>, csv::Error> {
+        let mut rdr = csv::ReaderBuilder::new()
+            .delimiter(b';')
+            .from_reader(input.as_bytes());
+
+        let members: Result<Vec<Row>, csv::Error> = rdr.deserialize().collect();
+
+        members
+    }
+
+    fn hours_parsed(&self) -> Vec<String> {
+        let mut hours: Vec<String> = Vec::new();
+
+        let group_parts: Vec<&str> = self.hours.split(", ").collect();
+
+        for group in group_parts {
+            let hour_parts: Vec<&str> = group.split(" - ").collect();
+
+            for part in hour_parts {
+                if &*part != "Groep" {
+                    hours.push(part.to_string());
+                }
+            }
+        }
+
+        hours.into_iter().unique().collect()
+    }
+}
+
+impl Into<Name> for Row {
+    fn into(self) -> Name {
+        Name {
+            first: self.first_name,
+            full: "Temporarely full name".to_string(),
+        }
+    }
+}
+
+impl Into<Member> for Row {
+    fn into(self) -> Member {
+        let name: Name = self.clone().into();
+
+        Member {
+            id: self.id.clone(),
+            name,
+            registration_token: None,
+            diploma: self.diploma.clone(),
+            hours: self.hours_parsed(),
+            groups: Vec::new(),
+        }
+    }
+}
+
+impl From<(u32, MembersDiff)> for MigrationResponse {
+    fn from(value: (u32, MembersDiff)) -> Self {
+        let members_insert: Vec<(String, Name)> =
+            value.1.insert.into_iter().map(|m| (m.id, m.name)).collect();
+        let members_update: Vec<(String, Name)> =
+            value.1.update.into_iter().map(|m| (m.id, m.name)).collect();
+        let members_remove: Vec<(String, Name)> =
+            value.1.remove.into_iter().map(|m| (m.id, m.name)).collect();
+
+        Self {
+            count: value.0,
+            insert: members_insert,
+            update: members_update,
+            remove: members_remove,
+        }
+    }
+}
+
+impl MigrationStore {
+    fn insert(&mut self, members_diff: MembersDiff) -> u32 {
+        let count = self.count + 1;
+        self.store.insert(count, members_diff);
+        self.count = count;
+        count
+    }
+
+    fn get(&self, id: &u32) -> Option<&MembersDiff> {
+        self.store.get(id)
+    }
+
+    fn remove(&mut self, id: &u32) -> Option<MembersDiff> {
+        self.store.remove(id)
+    }
+}
+
+fn generate_diff(members_new: Vec<Member>, members_old: Vec<Member>) -> MembersDiff {
+    let members_old_map: HashMap<String, Member> = members_old
+        .iter()
+        .map(|m| (m.id.clone(), m.clone()))
+        .collect();
+
+    let members_new_map: HashMap<String, Member> = members_new
+        .iter()
+        .map(|m| (m.id.clone(), m.clone()))
+        .collect();
+
+    let mut members_insert: Vec<Member> = Vec::new();
+    let mut members_update: Vec<Member> = Vec::new();
+    let mut members_remove: Vec<Member> = Vec::new();
+
+    for old_member in members_old {
+        if let Some(new_member) = members_new_map.get(&old_member.id) {
+            members_update.push(Member {
+                id: old_member.id,
+                name: new_member.name.clone(),
+                registration_token: old_member.registration_token,
+                diploma: new_member.diploma.clone(),
+                hours: new_member.hours.clone(),
+                groups: old_member.groups,
+            })
+        } else {
+            members_remove.push(old_member);
+        }
+    }
+
+    for new_member in members_new {
+        if !members_old_map.contains_key(&new_member.id) {
+            members_insert.push(new_member);
+        }
+    }
+
+    MembersDiff {
+        insert: members_insert,
+        update: members_update,
+        remove: members_remove,
+    }
+}