feat: v0.3.0 — standardize codebase, centralize infra, merge QR into CMS

- Enforce axum best practices across all 13 workspace crates
  (max 200 LOC/file, no comments, no unwrap, clean architecture)
- Fix domain→infrastructure dependency inversions in imphnen-iam and imphnen-dimentorin
- Extract imphnen-storage (MinIO) and imphnen-email (Lettre) as standalone crates
- Centralize all config in ENV struct: CDN_URL, CORS_ALLOWED_ORIGINS
- Centralize SMTP through imphnen-email; remove dead HackathonConfig
- Centralize database: QR crate now shares main DB pool (single DATABASE_URL)
- Rename QR users table to qr_users to avoid collision with main users table
- Merge imphnen-qr into imphnen-cms/src/qr (13 crates, down from 14)
- Restructure imphnen-hackathon flat modules into clean architecture
- Remove all stale env vars from .env.example (SurrealDB, QR_JWT, Hackathon infra)
- Fix Dockerfile to include all current workspace crates
- Bump all crate versions 0.2.0 → 0.3.0

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

imphnen-cms/src/events/application/event_service.rs

@@ -1,40 +1,43 @@
-use std::sync::Arc;
+use crate::events::domain::{EventEntity, EventRepository, EventService};
 use async_trait::async_trait;
+use imphnen_utils::AppError;
 use paginator_rs::PaginationParams;
 use paginator_utils::PaginatorResponse;
+use std::sync::Arc;
 use uuid::Uuid;
-use imphnen_utils::AppError;
-use crate::events::domain::{EventEntity, EventRepository, EventService};
 
 pub struct EventServiceImpl {
-    repo: Arc<dyn EventRepository>,
+	repo: Arc<dyn EventRepository>,
 }
 
 impl EventServiceImpl {
-    pub fn new(repo: Arc<dyn EventRepository>) -> Self {
-        Self { repo }
-    }
+	pub fn new(repo: Arc<dyn EventRepository>) -> Self {
+		Self { repo }
+	}
 }
 
 #[async_trait]
 impl EventService for EventServiceImpl {
-    async fn list(&self, params: PaginationParams) -> Result<PaginatorResponse<EventEntity>, AppError> {
-        self.repo.find_all(params).await
-    }
+	async fn list(
+		&self,
+		params: PaginationParams,
+	) -> Result<PaginatorResponse<EventEntity>, AppError> {
+		self.repo.find_all(params).await
+	}
 
-    async fn get(&self, id: Uuid) -> Result<EventEntity, AppError> {
-        self.repo.find_by_id(id).await
-    }
+	async fn get(&self, id: Uuid) -> Result<EventEntity, AppError> {
+		self.repo.find_by_id(id).await
+	}
 
-    async fn create(&self, entity: EventEntity) -> Result<(), AppError> {
-        self.repo.create(entity).await
-    }
+	async fn create(&self, entity: EventEntity) -> Result<(), AppError> {
+		self.repo.create(entity).await
+	}
 
-    async fn update(&self, entity: EventEntity) -> Result<(), AppError> {
-        self.repo.update(entity).await
-    }
+	async fn update(&self, entity: EventEntity) -> Result<(), AppError> {
+		self.repo.update(entity).await
+	}
 
-    async fn delete(&self, id: Uuid) -> Result<(), AppError> {
-        self.repo.delete(id).await
-    }
+	async fn delete(&self, id: Uuid) -> Result<(), AppError> {
+		self.repo.delete(id).await
+	}
 }

imphnen-cms/src/events/domain/event.rs

@@ -3,16 +3,16 @@ use uuid::Uuid;
 
 #[derive(Clone, Debug)]
 pub struct EventEntity {
-    pub id: Uuid,
-    pub name: String,
-    pub description: String,
-    pub detail_link: String,
-    pub price: f64,
-    pub is_online: bool,
-    pub is_deleted: bool,
-    pub location: Option<String>,
-    pub start_date: DateTime<Utc>,
-    pub end_date: DateTime<Utc>,
-    pub created_at: DateTime<Utc>,
-    pub updated_at: DateTime<Utc>,
+	pub id: Uuid,
+	pub name: String,
+	pub description: String,
+	pub detail_link: String,
+	pub price: f64,
+	pub is_online: bool,
+	pub is_deleted: bool,
+	pub location: Option<String>,
+	pub start_date: DateTime<Utc>,
+	pub end_date: DateTime<Utc>,
+	pub created_at: DateTime<Utc>,
+	pub updated_at: DateTime<Utc>,
 }

imphnen-cms/src/events/domain/repository.rs

@@ -1,15 +1,18 @@
+use super::event::EventEntity;
 use async_trait::async_trait;
+use imphnen_utils::AppError;
 use paginator_rs::PaginationParams;
 use paginator_utils::PaginatorResponse;
 use uuid::Uuid;
-use imphnen_utils::AppError;
-use super::event::EventEntity;
 
 #[async_trait]
 pub trait EventRepository: Send + Sync {
-    async fn find_all(&self, params: PaginationParams) -> Result<PaginatorResponse<EventEntity>, AppError>;
-    async fn find_by_id(&self, id: Uuid) -> Result<EventEntity, AppError>;
-    async fn create(&self, entity: EventEntity) -> Result<(), AppError>;
-    async fn update(&self, entity: EventEntity) -> Result<(), AppError>;
-    async fn delete(&self, id: Uuid) -> Result<(), AppError>;
+	async fn find_all(
+		&self,
+		params: PaginationParams,
+	) -> Result<PaginatorResponse<EventEntity>, AppError>;
+	async fn find_by_id(&self, id: Uuid) -> Result<EventEntity, AppError>;
+	async fn create(&self, entity: EventEntity) -> Result<(), AppError>;
+	async fn update(&self, entity: EventEntity) -> Result<(), AppError>;
+	async fn delete(&self, id: Uuid) -> Result<(), AppError>;
 }

imphnen-cms/src/events/domain/service.rs

@@ -1,15 +1,18 @@
+use super::event::EventEntity;
 use async_trait::async_trait;
+use imphnen_utils::AppError;
 use paginator_rs::PaginationParams;
 use paginator_utils::PaginatorResponse;
 use uuid::Uuid;
-use imphnen_utils::AppError;
-use super::event::EventEntity;
 
 #[async_trait]
 pub trait EventService: Send + Sync {
-    async fn list(&self, params: PaginationParams) -> Result<PaginatorResponse<EventEntity>, AppError>;
-    async fn get(&self, id: Uuid) -> Result<EventEntity, AppError>;
-    async fn create(&self, entity: EventEntity) -> Result<(), AppError>;
-    async fn update(&self, entity: EventEntity) -> Result<(), AppError>;
-    async fn delete(&self, id: Uuid) -> Result<(), AppError>;
+	async fn list(
+		&self,
+		params: PaginationParams,
+	) -> Result<PaginatorResponse<EventEntity>, AppError>;
+	async fn get(&self, id: Uuid) -> Result<EventEntity, AppError>;
+	async fn create(&self, entity: EventEntity) -> Result<(), AppError>;
+	async fn update(&self, entity: EventEntity) -> Result<(), AppError>;
+	async fn delete(&self, id: Uuid) -> Result<(), AppError>;
 }

imphnen-cms/src/events/infrastructure/http/dto.rs

@@ -1,131 +1,131 @@
+use crate::events::domain::event::EventEntity;
 use chrono::{DateTime, Utc};
 use imphnen_libs::ZodValidate;
 use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
 use uuid::Uuid;
-use crate::events::domain::event::EventEntity;
 
 #[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
 pub struct EventsCreateRequestDto {
-    pub name: String,
-    pub description: String,
-    pub detail_link: String,
-    pub price: f64,
-    #[schema(example = "2025-09-20T13:00:00Z", value_type = String)]
-    pub end_date: DateTime<Utc>,
-    #[schema(example = "2025-09-20T13:00:00Z", value_type = String)]
-    pub start_date: DateTime<Utc>,
-    pub location: Option<String>,
-    pub is_online: bool,
+	pub name: String,
+	pub description: String,
+	pub detail_link: String,
+	pub price: f64,
+	#[schema(example = "2025-09-20T13:00:00Z", value_type = String)]
+	pub end_date: DateTime<Utc>,
+	#[schema(example = "2025-09-20T13:00:00Z", value_type = String)]
+	pub start_date: DateTime<Utc>,
+	pub location: Option<String>,
+	pub is_online: bool,
 }
 
 impl ZodValidate for EventsCreateRequestDto {
-    fn zod_validate(value: &serde_json::Value) -> Result<Self, String> {
-        serde_json::from_value(value.clone()).map_err(|e| e.to_string())
-    }
+	fn zod_validate(value: &serde_json::Value) -> Result<Self, String> {
+		serde_json::from_value(value.clone()).map_err(|e| e.to_string())
+	}
 }
 
 impl From<EventsCreateRequestDto> for EventEntity {
-    fn from(dto: EventsCreateRequestDto) -> Self {
-        EventEntity {
-            id: Uuid::new_v4(),
-            name: dto.name,
-            description: dto.description,
-            detail_link: dto.detail_link,
-            price: dto.price,
-            is_online: dto.is_online,
-            is_deleted: false,
-            location: dto.location,
-            start_date: dto.start_date,
-            end_date: dto.end_date,
-            created_at: chrono::Utc::now(),
-            updated_at: chrono::Utc::now(),
-        }
-    }
+	fn from(dto: EventsCreateRequestDto) -> Self {
+		EventEntity {
+			id: Uuid::new_v4(),
+			name: dto.name,
+			description: dto.description,
+			detail_link: dto.detail_link,
+			price: dto.price,
+			is_online: dto.is_online,
+			is_deleted: false,
+			location: dto.location,
+			start_date: dto.start_date,
+			end_date: dto.end_date,
+			created_at: chrono::Utc::now(),
+			updated_at: chrono::Utc::now(),
+		}
+	}
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
 pub struct EventsUpdateRequestDto {
-    pub name: String,
-    #[schema(example = "2025-09-20T13:00:00Z", value_type = String)]
-    pub end_date: DateTime<Utc>,
-    #[schema(example = "2025-09-20T13:00:00Z", value_type = String)]
-    pub start_date: DateTime<Utc>,
-    pub price: f64,
-    pub is_online: bool,
-    pub description: String,
-    pub detail_link: String,
-    pub location: Option<String>,
+	pub name: String,
+	#[schema(example = "2025-09-20T13:00:00Z", value_type = String)]
+	pub end_date: DateTime<Utc>,
+	#[schema(example = "2025-09-20T13:00:00Z", value_type = String)]
+	pub start_date: DateTime<Utc>,
+	pub price: f64,
+	pub is_online: bool,
+	pub description: String,
+	pub detail_link: String,
+	pub location: Option<String>,
 }
 
 impl ZodValidate for EventsUpdateRequestDto {
-    fn zod_validate(value: &serde_json::Value) -> Result<Self, String> {
-        serde_json::from_value(value.clone()).map_err(|e| e.to_string())
-    }
+	fn zod_validate(value: &serde_json::Value) -> Result<Self, String> {
+		serde_json::from_value(value.clone()).map_err(|e| e.to_string())
+	}
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
 pub struct EventsListItemDto {
-    pub id: String,
-    pub name: String,
-    pub description: String,
-    pub detail_link: String,
-    pub price: f64,
-    pub is_online: bool,
-    pub start_date: String,
-    pub end_date: String,
-    pub created_at: String,
-    pub location: Option<String>,
-    pub is_deleted: bool,
+	pub id: String,
+	pub name: String,
+	pub description: String,
+	pub detail_link: String,
+	pub price: f64,
+	pub is_online: bool,
+	pub start_date: String,
+	pub end_date: String,
+	pub created_at: String,
+	pub location: Option<String>,
+	pub is_deleted: bool,
 }
 
 impl From<EventEntity> for EventsListItemDto {
-    fn from(e: EventEntity) -> Self {
-        EventsListItemDto {
-            id: e.id.to_string(),
-            name: e.name,
-            description: e.description,
-            detail_link: e.detail_link,
-            price: e.price,
-            is_online: e.is_online,
-            start_date: e.start_date.to_rfc3339(),
-            end_date: e.end_date.to_rfc3339(),
-            created_at: e.created_at.to_rfc3339(),
-            location: e.location,
-            is_deleted: e.is_deleted,
-        }
-    }
+	fn from(e: EventEntity) -> Self {
+		EventsListItemDto {
+			id: e.id.to_string(),
+			name: e.name,
+			description: e.description,
+			detail_link: e.detail_link,
+			price: e.price,
+			is_online: e.is_online,
+			start_date: e.start_date.to_rfc3339(),
+			end_date: e.end_date.to_rfc3339(),
+			created_at: e.created_at.to_rfc3339(),
+			location: e.location,
+			is_deleted: e.is_deleted,
+		}
+	}
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
 pub struct EventsDetailItemDto {
-    pub id: String,
-    pub name: String,
-    pub description: String,
-    pub detail_link: String,
-    pub price: f64,
-    pub is_online: bool,
-    pub start_date: String,
-    pub end_date: String,
-    pub created_at: String,
-    pub updated_at: String,
-    pub location: Option<String>,
+	pub id: String,
+	pub name: String,
+	pub description: String,
+	pub detail_link: String,
+	pub price: f64,
+	pub is_online: bool,
+	pub start_date: String,
+	pub end_date: String,
+	pub created_at: String,
+	pub updated_at: String,
+	pub location: Option<String>,
 }
 
 impl From<EventEntity> for EventsDetailItemDto {
-    fn from(e: EventEntity) -> Self {
-        EventsDetailItemDto {
-            id: e.id.to_string(),
-            name: e.name,
-            description: e.description,
-            detail_link: e.detail_link,
-            price: e.price,
-            is_online: e.is_online,
-            start_date: e.start_date.to_rfc3339(),
-            end_date: e.end_date.to_rfc3339(),
-            created_at: e.created_at.to_rfc3339(),
-            updated_at: e.updated_at.to_rfc3339(),
-            location: e.location,
-        }
-    }
+	fn from(e: EventEntity) -> Self {
+		EventsDetailItemDto {
+			id: e.id.to_string(),
+			name: e.name,
+			description: e.description,
+			detail_link: e.detail_link,
+			price: e.price,
+			is_online: e.is_online,
+			start_date: e.start_date.to_rfc3339(),
+			end_date: e.end_date.to_rfc3339(),
+			created_at: e.created_at.to_rfc3339(),
+			updated_at: e.updated_at.to_rfc3339(),
+			location: e.location,
+		}
+	}
 }

imphnen-cms/src/events/infrastructure/http/handlers.rs

@@ -1,15 +1,23 @@
-use std::sync::Arc;
-use axum::{Extension, extract::Path, http::HeaderMap, response::{IntoResponse, Response}};
-use paginator_axum::PaginationQuery;
-use paginator_utils::PaginatorResponse;
-use uuid::Uuid;
-use imphnen_libs::{AppState, ValidatedJson};
-use imphnen_utils::{ApiSuccess, ApiPaginated, ApiMessage};
+use super::dto::{
+	EventsCreateRequestDto, EventsDetailItemDto, EventsListItemDto,
+	EventsUpdateRequestDto,
+};
+use crate::events::domain::EventService;
+use axum::{
+	Extension,
+	extract::Path,
+	http::HeaderMap,
+	response::{IntoResponse, Response},
+};
 use imphnen_entities::ResponseSuccessDto;
 use imphnen_iam::{PermissionsEnum, require_permissions};
+use imphnen_libs::{AppState, ValidatedJson};
 use imphnen_utils::AppError;
-use super::dto::{EventsCreateRequestDto, EventsDetailItemDto, EventsListItemDto, EventsUpdateRequestDto};
-use crate::events::domain::EventService;
+use imphnen_utils::{ApiMessage, ApiPaginated, ApiSuccess};
+use paginator_axum::PaginationQuery;
+use paginator_utils::PaginatorResponse;
+use std::sync::Arc;
+use uuid::Uuid;
 
 #[utoipa::path(
     get,
@@ -27,19 +35,24 @@ use crate::events::domain::EventService;
     tag = "Events"
 )]
 pub async fn get_event_list(
-    Extension(service): Extension<Arc<dyn EventService>>,
-    PaginationQuery(params): PaginationQuery,
+	Extension(service): Extension<Arc<dyn EventService>>,
+	PaginationQuery(params): PaginationQuery,
 ) -> Response {
-    match service.list(params).await {
-        Ok(result) => {
-            let mapped = PaginatorResponse {
-                data: result.data.into_iter().map(EventsListItemDto::from).collect::<Vec<_>>(),
-                meta: result.meta,
-            };
-            ApiPaginated(mapped).into_response()
-        }
-        Err(e) => ApiMessage::new(axum::http::StatusCode::BAD_REQUEST, e.to_string()).into_response(),
-    }
+	match service.list(params).await {
+		Ok(result) => {
+			let mapped = PaginatorResponse {
+				data: result
+					.data
+					.into_iter()
+					.map(EventsListItemDto::from)
+					.collect::<Vec<_>>(),
+				meta: result.meta,
+			};
+			ApiPaginated(mapped).into_response()
+		}
+		Err(e) => ApiMessage::new(axum::http::StatusCode::BAD_REQUEST, e.to_string())
+			.into_response(),
+	}
 }
 
 #[utoipa::path(
@@ -54,17 +67,24 @@ pub async fn get_event_list(
     tag = "Events"
 )]
 pub async fn get_event_by_id(
-    Extension(service): Extension<Arc<dyn EventService>>,
-    Path(id): Path<String>,
+	Extension(service): Extension<Arc<dyn EventService>>,
+	Path(id): Path<String>,
 ) -> Response {
-    let uuid = match Uuid::parse_str(&id) {
-        Ok(u) => u,
-        Err(e) => return ApiMessage::new(axum::http::StatusCode::BAD_REQUEST, format!("Invalid UUID: {e}")).into_response(),
-    };
-    match service.get(uuid).await {
-        Ok(event) => ApiSuccess(EventsDetailItemDto::from(event)).into_response(),
-        Err(e) => ApiMessage::new(axum::http::StatusCode::NOT_FOUND, e.to_string()).into_response(),
-    }
+	let uuid = match Uuid::parse_str(&id) {
+		Ok(u) => u,
+		Err(e) => {
+			return ApiMessage::new(
+				axum::http::StatusCode::BAD_REQUEST,
+				format!("Invalid UUID: {e}"),
+			)
+			.into_response();
+		}
+	};
+	match service.get(uuid).await {
+		Ok(event) => ApiSuccess(EventsDetailItemDto::from(event)).into_response(),
+		Err(e) => ApiMessage::new(axum::http::StatusCode::NOT_FOUND, e.to_string())
+			.into_response(),
+	}
 }
 
 #[utoipa::path(
@@ -78,16 +98,16 @@ pub async fn get_event_by_id(
     tag = "Events"
 )]
 pub async fn post_create_event(
-    headers: HeaderMap,
-    Extension(state): Extension<AppState>,
-    Extension(service): Extension<Arc<dyn EventService>>,
-    ValidatedJson(payload): ValidatedJson<EventsCreateRequestDto>,
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Extension(service): Extension<Arc<dyn EventService>>,
+	ValidatedJson(payload): ValidatedJson<EventsCreateRequestDto>,
 ) -> Result<impl IntoResponse, AppError> {
-    require_permissions!(headers, state, [PermissionsEnum::Administrator], {
-        let entity = payload.into();
-        service.create(entity).await?;
-        Ok(ApiMessage::created("Event created"))
-    })
+	require_permissions!(headers, state, [PermissionsEnum::Administrator], {
+		let entity = payload.into();
+		service.create(entity).await?;
+		Ok(ApiMessage::created("Event created"))
+	})
 }
 
 #[utoipa::path(
@@ -104,33 +124,33 @@ pub async fn post_create_event(
     tag = "Events"
 )]
 pub async fn patch_update_event(
-    headers: HeaderMap,
-    Extension(state): Extension<AppState>,
-    Extension(service): Extension<Arc<dyn EventService>>,
-    Path(id): Path<String>,
-    ValidatedJson(payload): ValidatedJson<EventsUpdateRequestDto>,
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Extension(service): Extension<Arc<dyn EventService>>,
+	Path(id): Path<String>,
+	ValidatedJson(payload): ValidatedJson<EventsUpdateRequestDto>,
 ) -> Result<impl IntoResponse, AppError> {
-    require_permissions!(headers, state, [PermissionsEnum::Administrator], {
-        let uuid = Uuid::parse_str(&id)
-            .map_err(|e| AppError::BadRequestError(format!("Invalid UUID: {e}")))?;
-        let existing = service.get(uuid).await?;
-        let entity = crate::events::domain::EventEntity {
-            id: existing.id,
-            name: payload.name,
-            description: payload.description,
-            detail_link: payload.detail_link,
-            price: payload.price,
-            is_online: payload.is_online,
-            location: payload.location,
-            start_date: payload.start_date,
-            end_date: payload.end_date,
-            is_deleted: existing.is_deleted,
-            created_at: existing.created_at,
-            updated_at: chrono::Utc::now(),
-        };
-        service.update(entity).await?;
-        Ok(ApiMessage::ok("Event updated"))
-    })
+	require_permissions!(headers, state, [PermissionsEnum::Administrator], {
+		let uuid = Uuid::parse_str(&id)
+			.map_err(|e| AppError::BadRequestError(format!("Invalid UUID: {e}")))?;
+		let existing = service.get(uuid).await?;
+		let entity = crate::events::domain::EventEntity {
+			id: existing.id,
+			name: payload.name,
+			description: payload.description,
+			detail_link: payload.detail_link,
+			price: payload.price,
+			is_online: payload.is_online,
+			location: payload.location,
+			start_date: payload.start_date,
+			end_date: payload.end_date,
+			is_deleted: existing.is_deleted,
+			created_at: existing.created_at,
+			updated_at: chrono::Utc::now(),
+		};
+		service.update(entity).await?;
+		Ok(ApiMessage::ok("Event updated"))
+	})
 }
 
 #[utoipa::path(
@@ -146,15 +166,15 @@ pub async fn patch_update_event(
     tag = "Events"
 )]
 pub async fn delete_event(
-    headers: HeaderMap,
-    Extension(state): Extension<AppState>,
-    Extension(service): Extension<Arc<dyn EventService>>,
-    Path(id): Path<String>,
+	headers: HeaderMap,
+	Extension(state): Extension<AppState>,
+	Extension(service): Extension<Arc<dyn EventService>>,
+	Path(id): Path<String>,
 ) -> Result<impl IntoResponse, AppError> {
-    require_permissions!(headers, state, [PermissionsEnum::Administrator], {
-        let uuid = Uuid::parse_str(&id)
-            .map_err(|e| AppError::BadRequestError(format!("Invalid UUID: {e}")))?;
-        service.delete(uuid).await?;
-        Ok(ApiMessage::ok("Event deleted"))
-    })
+	require_permissions!(headers, state, [PermissionsEnum::Administrator], {
+		let uuid = Uuid::parse_str(&id)
+			.map_err(|e| AppError::BadRequestError(format!("Invalid UUID: {e}")))?;
+		service.delete(uuid).await?;
+		Ok(ApiMessage::ok("Event deleted"))
+	})
 }

imphnen-cms/src/events/infrastructure/http/mod.rs

@@ -2,4 +2,4 @@ pub mod dto;
 pub mod handlers;
 pub mod routes;
 
-pub use routes::{events_public_routes, events_protected_routes};
+pub use routes::{events_protected_routes, events_public_routes};

imphnen-cms/src/events/infrastructure/http/routes.rs

@@ -1,31 +1,35 @@
-use std::sync::Arc;
-use axum::{Router, routing::{delete, get, patch, post}, Extension};
-use sea_orm::DatabaseConnection;
+use super::handlers::{
+	delete_event, get_event_by_id, get_event_list, patch_update_event,
+	post_create_event,
+};
 use crate::events::application::EventServiceImpl;
 use crate::events::domain::EventService;
 use crate::events::infrastructure::persistence::PostgresEventRepository;
-use super::handlers::{
-    delete_event, get_event_by_id, get_event_list, patch_update_event, post_create_event,
+use axum::{
+	Extension, Router,
+	routing::{delete, get, patch, post},
 };
+use sea_orm::DatabaseConnection;
+use std::sync::Arc;
 
 fn build_service(db: DatabaseConnection) -> Arc<dyn EventService> {
-    let repo = Arc::new(PostgresEventRepository::new(db));
-    Arc::new(EventServiceImpl::new(repo))
+	let repo = Arc::new(PostgresEventRepository::new(db));
+	Arc::new(EventServiceImpl::new(repo))
 }
 
 pub fn events_public_routes(db: DatabaseConnection) -> Router {
-    let service = build_service(db);
-    Router::new()
-        .route("/cms/landing/events", get(get_event_list))
-        .route("/cms/landing/events/detail/{id}", get(get_event_by_id))
-        .layer(Extension(service))
+	let service = build_service(db);
+	Router::new()
+		.route("/cms/landing/events", get(get_event_list))
+		.route("/cms/landing/events/detail/{id}", get(get_event_by_id))
+		.layer(Extension(service))
 }
 
 pub fn events_protected_routes(db: DatabaseConnection) -> Router {
-    let service = build_service(db);
-    Router::new()
-        .route("/cms/landing/events/create", post(post_create_event))
-        .route("/cms/landing/events/update/{id}", patch(patch_update_event))
-        .route("/cms/landing/events/delete/{id}", delete(delete_event))
-        .layer(Extension(service))
+	let service = build_service(db);
+	Router::new()
+		.route("/cms/landing/events/create", post(post_create_event))
+		.route("/cms/landing/events/update/{id}", patch(patch_update_event))
+		.route("/cms/landing/events/delete/{id}", delete(delete_event))
+		.layer(Extension(service))
 }

imphnen-cms/src/events/infrastructure/persistence/postgres_event_repository.rs

@@ -1,149 +1,161 @@
-use std::sync::Arc;
+use crate::events::domain::{event::EventEntity, repository::EventRepository};
 use async_trait::async_trait;
-use sea_orm::prelude::*;
-use sea_orm::{ActiveValue, Order, QueryOrder, PaginatorTrait};
+use imphnen_entities::seaorm::common::events::{
+	ActiveModel as EventsActiveModel, Column as EventsColumn, Entity as EventsEntity,
+	Model as EventsModel,
+};
+use imphnen_utils::AppError;
 use paginator_rs::{PaginationParams, SortDirection};
 use paginator_utils::{PaginatorResponse, PaginatorResponseMeta};
+use sea_orm::prelude::*;
+use sea_orm::{ActiveValue, Order, PaginatorTrait, QueryOrder};
+use std::sync::Arc;
 use uuid::Uuid;
-use imphnen_utils::AppError;
-use imphnen_entities::seaorm::common::events::{
-    Entity as EventsEntity, Column as EventsColumn,
-    ActiveModel as EventsActiveModel, Model as EventsModel,
-};
-use crate::events::domain::{event::EventEntity, repository::EventRepository};
 
 fn to_entity(model: EventsModel) -> EventEntity {
-    EventEntity {
-        id: model.id,
-        name: model.name,
-        description: model.description,
-        detail_link: model.detail_link,
-        price: model.price,
-        is_online: model.is_online,
-        is_deleted: model.is_deleted,
-        location: model.location,
-        start_date: model.start_date,
-        end_date: model.end_date,
-        created_at: model.created_at,
-        updated_at: model.updated_at,
-    }
+	EventEntity {
+		id: model.id,
+		name: model.name,
+		description: model.description,
+		detail_link: model.detail_link,
+		price: model.price,
+		is_online: model.is_online,
+		is_deleted: model.is_deleted,
+		location: model.location,
+		start_date: model.start_date,
+		end_date: model.end_date,
+		created_at: model.created_at,
+		updated_at: model.updated_at,
+	}
 }
 
 pub struct PostgresEventRepository {
-    db: Arc<DatabaseConnection>,
+	db: Arc<DatabaseConnection>,
 }
 
 impl PostgresEventRepository {
-    pub fn new(db: DatabaseConnection) -> Self {
-        Self { db: Arc::new(db) }
-    }
+	pub fn new(db: DatabaseConnection) -> Self {
+		Self { db: Arc::new(db) }
+	}
 }
 
 #[async_trait]
 impl EventRepository for PostgresEventRepository {
-    async fn find_all(&self, params: PaginationParams) -> Result<PaginatorResponse<EventEntity>, AppError> {
-        let page = params.page.max(1);
-        let per_page = params.per_page.clamp(1, 100);
+	async fn find_all(
+		&self,
+		params: PaginationParams,
+	) -> Result<PaginatorResponse<EventEntity>, AppError> {
+		let page = params.page.max(1);
+		let per_page = params.per_page.clamp(1, 100);
 
-        let mut query = EventsEntity::find()
-            .filter(EventsColumn::IsDeleted.eq(false));
+		let mut query = EventsEntity::find().filter(EventsColumn::IsDeleted.eq(false));
 
-        if let Some(ref search) = params.search {
-            query = query.filter(EventsColumn::Name.contains(&search.query));
-        }
+		if let Some(ref search) = params.search {
+			query = query.filter(EventsColumn::Name.contains(&search.query));
+		}
 
-        query = match params.sort_by.as_deref() {
-            Some("name") => match params.sort_direction {
-                Some(SortDirection::Desc) => query.order_by(EventsColumn::Name, Order::Desc),
-                _ => query.order_by(EventsColumn::Name, Order::Asc),
-            },
-            _ => match params.sort_direction {
-                Some(SortDirection::Asc) => query.order_by(EventsColumn::CreatedAt, Order::Asc),
-                _ => query.order_by(EventsColumn::CreatedAt, Order::Desc),
-            },
-        };
+		query = match params.sort_by.as_deref() {
+			Some("name") => match params.sort_direction {
+				Some(SortDirection::Desc) => query.order_by(EventsColumn::Name, Order::Desc),
+				_ => query.order_by(EventsColumn::Name, Order::Asc),
+			},
+			_ => match params.sort_direction {
+				Some(SortDirection::Asc) => {
+					query.order_by(EventsColumn::CreatedAt, Order::Asc)
+				}
+				_ => query.order_by(EventsColumn::CreatedAt, Order::Desc),
+			},
+		};
 
-        let paginator = query.paginate(self.db.as_ref(), per_page as u64);
-        let total = paginator.num_items().await
-            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
-        let events = paginator.fetch_page((page - 1) as u64).await
-            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+		let paginator = query.paginate(self.db.as_ref(), per_page as u64);
+		let total = paginator
+			.num_items()
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+		let events = paginator
+			.fetch_page((page - 1) as u64)
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
 
-        let data = events.into_iter().map(to_entity).collect();
-        let meta = PaginatorResponseMeta::new(page, per_page, total as u32);
-        Ok(PaginatorResponse { data, meta })
-    }
+		let data = events.into_iter().map(to_entity).collect();
+		let meta = PaginatorResponseMeta::new(page, per_page, total as u32);
+		Ok(PaginatorResponse { data, meta })
+	}
 
-    async fn find_by_id(&self, id: Uuid) -> Result<EventEntity, AppError> {
-        let event = EventsEntity::find_by_id(id)
-            .filter(EventsColumn::IsDeleted.eq(false))
-            .one(self.db.as_ref())
-            .await
-            .map_err(|e| AppError::InternalServerError(e.to_string()))?
-            .ok_or_else(|| AppError::NotFoundError("Event not found".to_string()))?;
+	async fn find_by_id(&self, id: Uuid) -> Result<EventEntity, AppError> {
+		let event = EventsEntity::find_by_id(id)
+			.filter(EventsColumn::IsDeleted.eq(false))
+			.one(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?
+			.ok_or_else(|| AppError::NotFoundError("Event not found".to_string()))?;
 
-        Ok(to_entity(event))
-    }
+		Ok(to_entity(event))
+	}
 
-    async fn create(&self, entity: EventEntity) -> Result<(), AppError> {
-        let active_model = EventsActiveModel {
-            id: ActiveValue::Set(entity.id),
-            name: ActiveValue::Set(entity.name),
-            description: ActiveValue::Set(entity.description),
-            detail_link: ActiveValue::Set(entity.detail_link),
-            price: ActiveValue::Set(entity.price),
-            is_online: ActiveValue::Set(entity.is_online),
-            is_deleted: ActiveValue::Set(false),
-            location: ActiveValue::Set(entity.location),
-            start_date: ActiveValue::Set(entity.start_date),
-            end_date: ActiveValue::Set(entity.end_date),
-            created_at: ActiveValue::Set(chrono::Utc::now()),
-            updated_at: ActiveValue::Set(chrono::Utc::now()),
-        };
+	async fn create(&self, entity: EventEntity) -> Result<(), AppError> {
+		let active_model = EventsActiveModel {
+			id: ActiveValue::Set(entity.id),
+			name: ActiveValue::Set(entity.name),
+			description: ActiveValue::Set(entity.description),
+			detail_link: ActiveValue::Set(entity.detail_link),
+			price: ActiveValue::Set(entity.price),
+			is_online: ActiveValue::Set(entity.is_online),
+			is_deleted: ActiveValue::Set(false),
+			location: ActiveValue::Set(entity.location),
+			start_date: ActiveValue::Set(entity.start_date),
+			end_date: ActiveValue::Set(entity.end_date),
+			created_at: ActiveValue::Set(chrono::Utc::now()),
+			updated_at: ActiveValue::Set(chrono::Utc::now()),
+		};
 
-        EventsEntity::insert(active_model)
-            .exec(self.db.as_ref())
-            .await
-            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+		EventsEntity::insert(active_model)
+			.exec(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
 
-        Ok(())
-    }
+		Ok(())
+	}
 
-    async fn update(&self, entity: EventEntity) -> Result<(), AppError> {
-        let mut active_model: EventsActiveModel = EventsEntity::find_by_id(entity.id)
-            .one(self.db.as_ref())
-            .await
-            .map_err(|e| AppError::InternalServerError(e.to_string()))?
-            .ok_or_else(|| AppError::NotFoundError("Event not found".to_string()))?
-            .into();
+	async fn update(&self, entity: EventEntity) -> Result<(), AppError> {
+		let mut active_model: EventsActiveModel = EventsEntity::find_by_id(entity.id)
+			.one(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?
+			.ok_or_else(|| AppError::NotFoundError("Event not found".to_string()))?
+			.into();
 
-        active_model.name = ActiveValue::Set(entity.name);
-        active_model.description = ActiveValue::Set(entity.description);
-        active_model.detail_link = ActiveValue::Set(entity.detail_link);
-        active_model.price = ActiveValue::Set(entity.price);
-        active_model.is_online = ActiveValue::Set(entity.is_online);
-        active_model.location = ActiveValue::Set(entity.location);
-        active_model.start_date = ActiveValue::Set(entity.start_date);
-        active_model.end_date = ActiveValue::Set(entity.end_date);
-        active_model.updated_at = ActiveValue::Set(chrono::Utc::now());
+		active_model.name = ActiveValue::Set(entity.name);
+		active_model.description = ActiveValue::Set(entity.description);
+		active_model.detail_link = ActiveValue::Set(entity.detail_link);
+		active_model.price = ActiveValue::Set(entity.price);
+		active_model.is_online = ActiveValue::Set(entity.is_online);
+		active_model.location = ActiveValue::Set(entity.location);
+		active_model.start_date = ActiveValue::Set(entity.start_date);
+		active_model.end_date = ActiveValue::Set(entity.end_date);
+		active_model.updated_at = ActiveValue::Set(chrono::Utc::now());
 
-        active_model.update(self.db.as_ref()).await
-            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
-        Ok(())
-    }
+		active_model
+			.update(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+		Ok(())
+	}
 
-    async fn delete(&self, id: Uuid) -> Result<(), AppError> {
-        let mut active_model: EventsActiveModel = EventsEntity::find_by_id(id)
-            .one(self.db.as_ref())
-            .await
-            .map_err(|e| AppError::InternalServerError(e.to_string()))?
-            .ok_or_else(|| AppError::NotFoundError("Event not found".to_string()))?
-            .into();
+	async fn delete(&self, id: Uuid) -> Result<(), AppError> {
+		let mut active_model: EventsActiveModel = EventsEntity::find_by_id(id)
+			.one(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?
+			.ok_or_else(|| AppError::NotFoundError("Event not found".to_string()))?
+			.into();
 
-        active_model.is_deleted = ActiveValue::Set(true);
-        active_model.updated_at = ActiveValue::Set(chrono::Utc::now());
-        active_model.update(self.db.as_ref()).await
-            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
-        Ok(())
-    }
+		active_model.is_deleted = ActiveValue::Set(true);
+		active_model.updated_at = ActiveValue::Set(chrono::Utc::now());
+		active_model
+			.update(self.db.as_ref())
+			.await
+			.map_err(|e| AppError::InternalServerError(e.to_string()))?;
+		Ok(())
+	}
 }

imphnen-cms/src/events/mod.rs

@@ -2,4 +2,4 @@ pub mod application;
 pub mod domain;
 pub mod infrastructure;
 
-pub use infrastructure::http::{events_public_routes, events_protected_routes};
+pub use infrastructure::http::{events_protected_routes, events_public_routes};