フォームドメインのリファクタリング

server/Makefile.toml

@@ -14,11 +14,18 @@ args = ["migrate", "generate", "${@}"]
 command = "cargo"
 args = ["clippy", "--fix", "--allow-dirty", "--allow-staged"]
 
-[tasks.test]
+[tasks.doctest]
+command = "cargo"
+args = ["test", "--doc"]
+
+[tasks.nextest]
 install_crate = { crate_name = "cargo-nextst" }
 command = "cargo"
 args = ["nextest", "run"]
 
+[tasks.test]
+dependencies = ["nextest", "doctest"]
+
 [tasks.lint]
 command = "cargo"
 args = ["clippy", "--", "-D", "warnings"]

server/domain/Cargo.toml

@@ -18,6 +18,7 @@ typed-builder = "0.20.0"
 types = { path = "../types" }
 uuid = { workspace = true }
 tokio = { workspace = true }
+regex = { workspace = true }
 
 [dev-dependencies]
 chrono = { workspace = true, features = ["arbitrary"] }

server/domain/src/form.rs

@@ -1 +1,6 @@
+pub mod answer;
+pub mod comment;
+pub mod message;
 pub mod models;
+pub mod question;
+pub mod service;

server/domain/src/form/answer.rs

@@ -0,0 +1,3 @@
+pub mod models;
+pub mod service;
+pub mod settings;

server/domain/src/form/answer/models.rs

@@ -0,0 +1,94 @@
+use chrono::{DateTime, Utc};
+use derive_getters::Getters;
+use deriving_via::DerivingVia;
+#[cfg(test)]
+use proptest_derive::Arbitrary;
+use serde::{Deserialize, Serialize};
+use types::non_empty_string::NonEmptyString;
+
+use crate::{
+    form::{models::FormId, question::models::QuestionId},
+    user::models::User,
+};
+
+pub type AnswerId = types::Id<AnswerEntry>;
+
+#[derive(Clone, DerivingVia, Default, Debug, PartialEq)]
+#[deriving(From, Into, IntoInner, Serialize(via: Option::<NonEmptyString>), Deserialize(via: Option::<NonEmptyString>
+))]
+pub struct AnswerTitle(Option<NonEmptyString>);
+
+impl AnswerTitle {
+    pub fn new(title: Option<NonEmptyString>) -> Self {
+        Self(title)
+    }
+}
+
+#[derive(Serialize, Deserialize, Getters, PartialEq, Debug)]
+pub struct AnswerEntry {
+    id: AnswerId,
+    user: User,
+    timestamp: DateTime<Utc>,
+    form_id: FormId,
+    title: AnswerTitle,
+}
+
+impl AnswerEntry {
+    /// [`AnswerEntry`] を新しく作成します。
+    pub fn new(user: User, form_id: FormId, title: AnswerTitle) -> Self {
+        Self {
+            id: AnswerId::new(),
+            user,
+            timestamp: Utc::now(),
+            form_id,
+            title,
+        }
+    }
+
+    /// [`AnswerEntry`] の各フィールドを指定して新しく作成します。
+    ///
+    /// # Safety
+    /// この関数はオブジェクトを新しく作成しない場合
+    /// (例えば、データベースから取得した場合)にのみ使用してください。
+    pub unsafe fn from_raw_parts(
+        id: AnswerId,
+        user: User,
+        timestamp: DateTime<Utc>,
+        form_id: FormId,
+        title: AnswerTitle,
+    ) -> Self {
+        Self {
+            id,
+            user,
+            timestamp,
+            form_id,
+            title,
+        }
+    }
+
+    pub fn with_title(&self, title: AnswerTitle) -> Self {
+        Self {
+            id: self.id,
+            user: self.user.to_owned(),
+            form_id: self.form_id,
+            timestamp: self.timestamp,
+            title,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, PartialEq, Debug)]
+pub struct FormAnswerContent {
+    pub answer_id: AnswerId,
+    pub question_id: QuestionId,
+    pub answer: String,
+}
+
+pub type AnswerLabelId = types::IntegerId<AnswerLabel>;
+
+#[cfg_attr(test, derive(Arbitrary))]
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+pub struct AnswerLabel {
+    pub id: AnswerLabelId,
+    pub name: String,
+}

server/domain/src/form/answer/service.rs

@@ -0,0 +1,102 @@
+use chrono::Utc;
+
+use crate::{
+    form::{
+        answer::{
+            models::{AnswerEntry, FormAnswerContent},
+            settings::models::{AnswerVisibility, ResponsePeriod},
+        },
+        models::Visibility,
+    },
+    types::authorization_guard_with_context::{
+        Actions, AuthorizationGuardWithContext, AuthorizationGuardWithContextDefinitions,
+    },
+    user::models::{Role, User},
+};
+
+#[derive(Debug)]
+pub struct AnswerEntryAuthorizationContext {
+    pub form_visibility: Visibility,
+    pub response_period: ResponsePeriod,
+    pub answer_visibility: AnswerVisibility,
+}
+
+// NOTE: FormAnswerEntry は FormAnswerContent と同じ条件でアクセス制御を行う
+impl AuthorizationGuardWithContextDefinitions<AnswerEntry, AnswerEntryAuthorizationContext>
+    for AnswerEntry
+{
+    fn can_create(&self, actor: &User, context: &AnswerEntryAuthorizationContext) -> bool {
+        let is_public_form = context.form_visibility == Visibility::PUBLIC;
+        let is_within_period = context.response_period.is_within_period(Utc::now());
+
+        (is_public_form && is_within_period) || actor.role == Role::Administrator
+    }
+
+    fn can_read(&self, actor: &User, context: &AnswerEntryAuthorizationContext) -> bool {
+        self.user().id == actor.id
+            || context.answer_visibility == AnswerVisibility::PUBLIC
+            || actor.role == Role::Administrator
+    }
+
+    fn can_update(&self, _actor: &User, _context: &AnswerEntryAuthorizationContext) -> bool {
+        false
+    }
+
+    fn can_delete(&self, actor: &User, _context: &AnswerEntryAuthorizationContext) -> bool {
+        actor.role == Role::Administrator
+    }
+}
+
+pub struct FormAnswerContentAuthorizationContext<'a, Action: Actions> {
+    pub answer_entry_authorization_context: &'a AnswerEntryAuthorizationContext,
+    pub answer_entry:
+        &'a AuthorizationGuardWithContext<AnswerEntry, Action, AnswerEntryAuthorizationContext>,
+}
+
+// NOTE: FormAnswerContent は FormAnswerEntry と同じ条件でアクセス制御を行う
+impl<Action: Actions>
+    AuthorizationGuardWithContextDefinitions<
+        FormAnswerContent,
+        FormAnswerContentAuthorizationContext<'_, Action>,
+    > for FormAnswerContent
+{
+    fn can_create(
+        &self,
+        actor: &User,
+        context: &FormAnswerContentAuthorizationContext<'_, Action>,
+    ) -> bool {
+        context
+            .answer_entry
+            .can_create(actor, context.answer_entry_authorization_context)
+    }
+
+    fn can_read(
+        &self,
+        actor: &User,
+        context: &FormAnswerContentAuthorizationContext<'_, Action>,
+    ) -> bool {
+        context
+            .answer_entry
+            .can_read(actor, context.answer_entry_authorization_context)
+    }
+
+    fn can_update(
+        &self,
+        actor: &User,
+        context: &FormAnswerContentAuthorizationContext<'_, Action>,
+    ) -> bool {
+        context
+            .answer_entry
+            .can_update(actor, context.answer_entry_authorization_context)
+    }
+
+    fn can_delete(
+        &self,
+        actor: &User,
+        context: &FormAnswerContentAuthorizationContext<'_, Action>,
+    ) -> bool {
+        context
+            .answer_entry
+            .can_delete(actor, context.answer_entry_authorization_context)
+    }
+}

server/domain/src/form/answer/settings.rs

@@ -0,0 +1 @@
+pub mod models;

server/domain/src/form/answer/settings/models.rs

@@ -0,0 +1,103 @@
+use chrono::{DateTime, Utc};
+#[cfg(test)]
+use common::test_utils::arbitrary_opt_date_time;
+use derive_getters::Getters;
+use deriving_via::DerivingVia;
+use errors::domain::DomainError;
+#[cfg(test)]
+use proptest_derive::Arbitrary;
+use serde::{Deserialize, Serialize};
+use strum_macros::{Display, EnumString};
+use types::non_empty_string::NonEmptyString;
+
+#[cfg_attr(test, derive(Arbitrary))]
+#[derive(Clone, DerivingVia, Default, Debug, PartialEq)]
+#[deriving(From, Into, IntoInner, Serialize(via: Option::<NonEmptyString>), Deserialize(via: Option::<NonEmptyString>
+))]
+pub struct DefaultAnswerTitle(Option<NonEmptyString>);
+
+impl DefaultAnswerTitle {
+    pub fn new(title: Option<NonEmptyString>) -> Self {
+        Self(title)
+    }
+}
+
+#[cfg_attr(test, derive(Arbitrary))]
+#[derive(
+    Serialize, Deserialize, Debug, EnumString, Display, Copy, Clone, Default, PartialOrd, PartialEq,
+)]
+pub enum AnswerVisibility {
+    PUBLIC,
+    #[default]
+    PRIVATE,
+}
+
+impl TryFrom<String> for AnswerVisibility {
+    type Error = DomainError;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        use std::str::FromStr;
+        Self::from_str(&value).map_err(Into::into)
+    }
+}
+
+#[cfg_attr(test, derive(Arbitrary))]
+#[derive(Serialize, Deserialize, Getters, Clone, Default, Debug, PartialEq)]
+pub struct ResponsePeriod {
+    #[cfg_attr(test, proptest(strategy = "arbitrary_opt_date_time()"))]
+    #[serde(default)]
+    start_at: Option<DateTime<Utc>>,
+    #[cfg_attr(test, proptest(strategy = "arbitrary_opt_date_time()"))]
+    #[serde(default)]
+    end_at: Option<DateTime<Utc>>,
+}
+
+impl ResponsePeriod {
+    pub fn try_new(
+        start_at: Option<DateTime<Utc>>,
+        end_at: Option<DateTime<Utc>>,
+    ) -> Result<Self, DomainError> {
+        match (start_at, end_at) {
+            (Some(start_at), Some(end_at)) if start_at > end_at => {
+                Err(DomainError::InvalidResponsePeriod)
+            }
+            _ => Ok(Self { start_at, end_at }),
+        }
+    }
+
+    pub fn is_within_period(&self, now: DateTime<Utc>) -> bool {
+        if let Some(start_at) = self.start_at {
+            if start_at > now {
+                return false;
+            }
+        }
+        if let Some(end_at) = self.end_at {
+            if end_at < now {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+#[cfg_attr(test, derive(Arbitrary))]
+#[derive(Serialize, Deserialize, Getters, Default, Debug, PartialEq)]
+pub struct AnswerSettings {
+    default_answer_title: DefaultAnswerTitle,
+    visibility: AnswerVisibility,
+    response_period: ResponsePeriod,
+}
+
+impl AnswerSettings {
+    pub fn new(
+        default_answer_title: DefaultAnswerTitle,
+        visibility: AnswerVisibility,
+        response_period: ResponsePeriod,
+    ) -> Self {
+        Self {
+            default_answer_title,
+            visibility,
+            response_period,
+        }
+    }
+}

server/domain/src/form/comment.rs

@@ -0,0 +1,2 @@
+pub mod models;
+pub mod service;