Add "ReadNewsCase".

Author: metalwhale

chloria-backend/Cargo.lock

@@ -9,12 +9,16 @@ argon2 = { version = "0.5.3", features = ["std"] }
 async-trait = "0.1.86"
 axum = "0.8.1"
 axum-extra = { version = "0.10.0", features = ["typed-header"] }
-diesel = { version = "2.2.7", features = ["postgres", "r2d2"] }
+chrono = "0.4.40"
+csv = "1.3.1"
+diesel = { version = "2.2.7", features = ["chrono", "postgres", "r2d2"] }
 jsonwebtoken = "9.3.1"
+log = "0.4.26"
 mockall = "0.13.1"
 serde = "1.0.218"
 serde_json = "1.0.140"
 serde_with = "3.12.0"
 strum = { version = "0.27.1", features = ["derive"] }
 tokio = { version = "1.43.0", features = ["rt-multi-thread"] }
+tokio-util = { version = "0.7.13", features = ["io"] }
 tower = "0.5.2"

chloria-backend/chloria-api/Cargo.toml

@@ -1,4 +1,5 @@
 pub(crate) mod authenticate;
+pub(crate) mod read_news;
 
 use anyhow::Result;
 use async_trait::async_trait;

chloria-backend/chloria-api/src/execution/cases/mod.rs

@@ -0,0 +1,61 @@
+use std::{io::Cursor, sync::Arc};
+
+use anyhow::Result;
+use async_trait::async_trait;
+use chrono::NaiveDate;
+use csv::Writer;
+use log::error;
+use tokio_util::io::ReaderStream;
+
+use super::{
+    super::{
+        ports::repository::{Repository, SelectNewsInput},
+        workshop::Workshop,
+    },
+    Case,
+};
+
+pub(crate) struct ReadNewsCaseInput {
+    pub(crate) date: NaiveDate,
+}
+
+pub(crate) struct ReadNewsCaseOutput {
+    pub(crate) articles_stream: ReaderStream<Cursor<Vec<u8>>>,
+}
+
+struct ReadNewsCase {
+    repository: Arc<dyn Repository>,
+    input: ReadNewsCaseInput,
+}
+
+impl Workshop {
+    pub(crate) async fn execute_read_news_case(&self, input: ReadNewsCaseInput) -> Result<ReadNewsCaseOutput> {
+        let case = ReadNewsCase {
+            repository: Arc::clone(&self.repository),
+            input,
+        };
+        self.run_case(case).await
+    }
+}
+
+#[async_trait]
+impl Case for ReadNewsCase {
+    type Output = ReadNewsCaseOutput;
+
+    async fn execute(self) -> Result<Self::Output> {
+        let mut writer = Writer::from_writer(vec![]);
+        for select_news_output in self
+            .repository
+            .select_news(SelectNewsInput { date: self.input.date })
+            .await?
+        {
+            if let Err(error) = writer.serialize(select_news_output) {
+                error!("error={}", error);
+            }
+        }
+        let output = ReadNewsCaseOutput {
+            articles_stream: ReaderStream::new(Cursor::new(writer.into_inner()?)),
+        };
+        Ok(output)
+    }
+}

chloria-backend/chloria-api/src/execution/cases/read_news.rs

@@ -1,9 +1,25 @@
 use anyhow::Result;
 use async_trait::async_trait;
+use chrono::NaiveDate;
 use mockall::automock;
+use serde::Serialize;
+
+pub(crate) struct SelectNewsInput {
+    pub(crate) date: NaiveDate,
+}
+
+#[derive(Serialize)]
+pub(crate) struct SelectNewsOutput {
+    pub(crate) source_name: String,
+    pub(crate) article_id: String,
+    pub(crate) title: Option<String>,
+    pub(crate) text: Option<String>,
+    pub(crate) image_path: Option<String>,
+}
 
 #[async_trait]
 #[automock] // See: https://github.com/asomers/mockall/issues/189#issuecomment-689145249
 pub(crate) trait Repository: Send + Sync {
     async fn select_client_api_secret(&self, api_key_input: &str) -> Result<Option<String>>;
+    async fn select_news(&self, input: SelectNewsInput) -> Result<Vec<SelectNewsOutput>>;
 }

chloria-backend/chloria-api/src/execution/ports/repository.rs

@@ -1,12 +1,19 @@
 use anyhow::Result;
 use async_trait::async_trait;
+use chrono::{DateTime, Duration, Local, NaiveTime};
 use diesel::{
     prelude::*,
     r2d2::{ConnectionManager, Pool},
     PgConnection,
 };
 
-use crate::{execution::ports::repository::Repository, schema::client_credentials::dsl::*};
+use crate::{
+    execution::ports::repository::{Repository, SelectNewsInput, SelectNewsOutput},
+    schema::{
+        client_credentials::dsl::*,
+        news::{self, dsl::*},
+    },
+};
 
 pub(crate) struct PostgresqlClient {
     pool: Pool<ConnectionManager<PgConnection>>,
@@ -31,4 +38,24 @@ impl Repository for PostgresqlClient {
             .optional()?;
         Ok(api_secret_value)
     }
+
+    async fn select_news(&self, input: SelectNewsInput) -> Result<Vec<SelectNewsOutput>> {
+        let date: DateTime<Local> = DateTime::from(input.date.and_time(NaiveTime::default()).and_utc());
+        let next_date = date + Duration::days(1);
+        let mut outputs = vec![];
+        for (source_name_value, article_id_value, title_value, long_text_value, image_path_value) in news
+            .filter(news::created_at.ge(date).and(news::created_at.lt(next_date)))
+            .select((source_name, article_id, title, long_text, image_path))
+            .get_results(&mut self.pool.get()?)?
+        {
+            outputs.push(SelectNewsOutput {
+                source_name: source_name_value,
+                article_id: article_id_value,
+                title: title_value,
+                text: long_text_value,
+                image_path: image_path_value,
+            });
+        }
+        Ok(outputs)
+    }
 }

chloria-backend/chloria-api/src/infrastructure/repository/postgresql.rs

@@ -1,4 +1,5 @@
 pub(super) mod auth;
+pub(super) mod read_news;
 
 use serde::Serialize;
 use serde_json::Value;

chloria-backend/chloria-api/src/interface/adapters/mod.rs

@@ -0,0 +1,36 @@
+use anyhow::Result;
+use axum::{
+    body::Body,
+    extract::{Query, State},
+    http::{header, HeaderName, StatusCode},
+    Json,
+};
+use chrono::NaiveDate;
+use serde::Deserialize;
+
+use super::{super::state::RouterState, ErrorResponse};
+use crate::execution::cases::read_news::ReadNewsCaseInput;
+
+#[derive(Deserialize)]
+pub(in super::super) struct ReadNewsRequest {
+    date: String,
+}
+
+pub(in super::super) async fn read_news(
+    State(state): State<RouterState>,
+    Query(request): Query<ReadNewsRequest>,
+) -> Result<([(HeaderName, &'static str); 2], Body), (StatusCode, Json<ErrorResponse>)> {
+    let date = NaiveDate::parse_from_str(&request.date, "%Y-%m-%d")
+        .map_err(|e| (StatusCode::BAD_REQUEST, Json(e.to_string().into())))?;
+    let output = state
+        .workshop
+        .execute_read_news_case(ReadNewsCaseInput { date })
+        .await
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, Json(e.to_string().into())))?;
+    let body = Body::from_stream(output.articles_stream);
+    let headers = [
+        (header::CONTENT_TYPE, "text/csv; charset=utf-8"),
+        (header::CONTENT_DISPOSITION, "attachment; filename=\"articles.csv\""),
+    ];
+    Ok((headers, body))
+}

chloria-backend/chloria-api/src/interface/adapters/read_news.rs

@@ -7,7 +7,10 @@ use jsonwebtoken::{DecodingKey, EncodingKey};
 use tower::ServiceBuilder;
 
 use super::{
-    adapters::auth::{authenticate, authorize},
+    adapters::{
+        auth::{authenticate, authorize},
+        read_news::read_news,
+    },
     state::{RouterState, RouterStateJwt},
 };
 use crate::execution::workshop::Workshop;
@@ -31,9 +34,8 @@ pub(crate) fn new(config: RouterConfig, workshop: Workshop) -> Router {
         .with_state(state.clone());
     let authorized_router = Router::new()
         .route("/news", get(read_news))
-        .route_layer(ServiceBuilder::new().layer(middleware::from_fn_with_state(state, authorize)));
+        .route_layer(ServiceBuilder::new().layer(middleware::from_fn_with_state(state.clone(), authorize)))
+        .with_state(state.clone());
     let router = Router::new().merge(public_router).merge(authorized_router);
     router
 }
-
-async fn read_news() {}