Create first handlers for political groups

Author: pohlm01

src/candidate_lists/pages/update.rs

@@ -129,7 +129,8 @@ mod tests {
             created_at: creation_date,
             updated_at: creation_date,
         };
-        candidate_lists::create_candidate_list(&mut conn, &candidate_list).await?;
+        let candidate_list =
+            candidate_lists::create_candidate_list(&mut conn, &candidate_list).await?;
 
         let form = CandidateListForm {
             electoral_districts: vec![ElectoralDistrict::DR],
@@ -170,10 +171,10 @@ mod tests {
             vec![ElectoralDistrict::DR],
             updated_list.electoral_districts
         );
-        assert!(creation_date - Utc::now() < Duration::seconds(10));
+        assert!((candidate_list.created_at - Utc::now()).abs() < Duration::seconds(10));
         // we don't know the exact update date
         // best we can do is to check it at least got updated (i.e. not equal to creation_date)
-        assert_ne!(creation_date, updated_list.updated_at);
+        assert_ne!(candidate_list.created_at, updated_list.updated_at);
 
         Ok(())
     }

src/candidate_lists/structs/candidate_position.rs

@@ -1,5 +1,4 @@
 use serde::{Deserialize, Serialize};
-use std::str::FromStr;
 use strum::{Display, EnumString};
 
 use crate::form::{TokenValue, WithCsrfToken};

src/common/new_type.rs

@@ -19,6 +19,13 @@ macro_rules! id_newtype {
             fn from(v: uuid::Uuid) -> Self { Self(v) }
         }
 
+        impl std::str::FromStr for $name {
+            type Err = uuid::Error;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                Ok(Self(uuid::Uuid::parse_str(s)?))
+            }
+        }
+
         impl From<$name> for uuid::Uuid {
             fn from(v: $name) -> Self { v.0 }
         }

src/persons/pages/create.rs

@@ -27,8 +27,7 @@ pub async fn new_person_form(
             person_pagination,
         },
         context,
-    )
-    .into_response())
+    ))
 }
 
 pub async fn create_person(

src/political_group/mod.rs

@@ -1,2 +1,5 @@
+mod pages;
 mod repository;
 mod structs;
+
+pub use repository::*;

src/political_group/pages/create.rs

@@ -0,0 +1,47 @@
+use crate::{
+    AppError, Context, DbConnection, HtmlTemplate,
+    form::{FormData, Validate},
+    political_group,
+    political_group::{pages::PoliticalGroupNewPath, structs::PoliticalGroupForm},
+};
+use askama::Template;
+use axum::{
+    Form,
+    response::{IntoResponse, Redirect, Response},
+};
+
+#[derive(Template)]
+#[template(path = "political_group/create.html")]
+struct PoliticalGroupCreateTemplate {
+    form: FormData<PoliticalGroupForm>,
+}
+
+pub async fn new_political_group_form(
+    _: PoliticalGroupNewPath,
+    context: Context,
+) -> Result<impl IntoResponse, AppError> {
+    Ok(HtmlTemplate(
+        PoliticalGroupCreateTemplate {
+            form: FormData::new(&context.csrf_tokens),
+        },
+        context,
+    ))
+}
+
+pub async fn create_political_group(
+    _: PoliticalGroupNewPath,
+    context: Context,
+    DbConnection(mut conn): DbConnection,
+    Form(form): Form<PoliticalGroupForm>,
+) -> Result<Response, AppError> {
+    match form.validate_create(&context.csrf_tokens) {
+        Err(form) => {
+            Ok(HtmlTemplate(PoliticalGroupCreateTemplate { form }, context).into_response())
+        }
+        Ok(political_group) => {
+            political_group::create_political_group(&mut conn, &political_group).await?;
+
+            Ok(Redirect::to("/").into_response())
+        }
+    }
+}

src/political_group/pages/mod.rs

@@ -0,0 +1,7 @@
+use axum_extra::routing::TypedPath;
+
+mod create;
+
+#[derive(TypedPath)]
+#[typed_path("/political_group/new", rejection(crate::AppError))]
+pub struct PoliticalGroupNewPath;

src/political_group/structs/mod.rs

@@ -3,7 +3,11 @@ mod authorized_agent_form;
 mod list_submitter;
 mod list_submitter_form;
 mod political_group;
+mod political_group_form;
 
 pub use authorized_agent::{AuthorisedAgent, AuthorisedAgentId};
+pub use authorized_agent_form::AuthorisedAgentForm;
 pub use list_submitter::{ListSubmitter, ListSubmitterId};
+pub use list_submitter_form::ListSubmitterForm;
 pub use political_group::{PoliticalGroup, PoliticalGroupId};
+pub use political_group_form::PoliticalGroupForm;

src/political_group/structs/political_group_form.rs

@@ -0,0 +1,59 @@
+use crate::{
+    TokenValue,
+    form::*,
+    political_group::structs::{
+        AuthorisedAgentId, ListSubmitterId, PoliticalGroup, PoliticalGroupId,
+    },
+};
+use chrono::Utc;
+use serde::Deserialize;
+use validate::Validate;
+
+#[derive(Default, Deserialize, Debug, Validate)]
+#[validate(
+    target = "PoliticalGroup",
+    build = "PoliticalGroupForm::build_political_group"
+)]
+pub struct PoliticalGroupForm {
+    #[validate(with = "validate_length(2, 255)")]
+    legal_name: String,
+    #[validate(with = "validate_length(2, 255)")]
+    display_name: String,
+    #[validate(parse = "AuthorisedAgentId", optional)]
+    authorised_agent_id: String,
+    #[validate(parse = "ListSubmitterId", optional)]
+    list_submitter_id: String,
+    #[validate(csrf)]
+    pub csrf_token: TokenValue,
+}
+
+impl WithCsrfToken for PoliticalGroupForm {
+    fn with_csrf_token(self, csrf_token: CsrfToken) -> Self {
+        PoliticalGroupForm {
+            csrf_token: csrf_token.value,
+            ..self
+        }
+    }
+}
+
+impl PoliticalGroupForm {
+    fn build_political_group(
+        validated: PoliticalGroupFormValidated,
+        current: Option<PoliticalGroup>,
+    ) -> PoliticalGroup {
+        if let Some(current) = current {
+            current
+        } else {
+            PoliticalGroup {
+                id: PoliticalGroupId::new(),
+
+                legal_name: validated.legal_name,
+                display_name: validated.display_name,
+                authorised_agent_id: validated.authorised_agent_id,
+                list_submitter_id: validated.list_submitter_id,
+                created_at: Utc::now(),
+                updated_at: Utc::now(),
+            }
+        }
+    }
+}