imphnen-backend-service/imphnen-cms/src/testimonials/infrastructure/persistence/postgres_testimonial_repository.rs

use std::sync::Arc;
use async_trait::async_trait;
use sea_orm::prelude::*;
use sea_orm::{ActiveValue, QueryOrder, PaginatorTrait};
use paginator_rs::{PaginationParams, SortDirection};
use paginator_utils::{PaginatorResponse, PaginatorResponseMeta};
use uuid::Uuid;
use imphnen_utils::AppError;
use imphnen_entities::seaorm::common::testimonials::{
    Entity as TestimonialsEntity, Column as TestimonialsColumn, ActiveModel as TestimonialsActiveModel,
};
use imphnen_entities::seaorm::auth::users::Entity as UsersEntity;
use crate::testimonials::domain::{testimonial::TestimonialEntity, repository::TestimonialRepository};

pub struct PostgresTestimonialRepository {
    db: Arc<DatabaseConnection>,
}

impl PostgresTestimonialRepository {
    pub fn new(db: DatabaseConnection) -> Self {
        Self { db: Arc::new(db) }
    }
}

#[async_trait]
impl TestimonialRepository for PostgresTestimonialRepository {
    async fn find_all(&self, params: PaginationParams) -> Result<PaginatorResponse<TestimonialEntity>, AppError> {
        let page = params.page.max(1);
        let per_page = params.per_page.clamp(1, 100);

        let mut query = TestimonialsEntity::find()
            .filter(TestimonialsColumn::IsDeleted.eq(false))
            .find_also_related(UsersEntity);

        query = match params.sort_by.as_deref() {
            Some("updated_at") => match params.sort_direction {
                Some(SortDirection::Asc) => query.order_by_asc(TestimonialsColumn::UpdatedAt),
                _ => query.order_by_desc(TestimonialsColumn::UpdatedAt),
            },
            _ => match params.sort_direction {
                Some(SortDirection::Asc) => query.order_by_asc(TestimonialsColumn::CreatedAt),
                _ => query.order_by_desc(TestimonialsColumn::CreatedAt),
            },
        };

        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 rows = paginator.fetch_page((page - 1) as u64).await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;

        let data: Vec<TestimonialEntity> = rows.into_iter()
            .filter_map(|(t, u)| {
                u.map(|user| TestimonialEntity {
                    id: t.id,
                    user_id: t.user_id,
                    user_fullname: format!(
                        "{} {}",
                        user.first_name.as_deref().unwrap_or(""),
                        user.last_name.as_deref().unwrap_or("")
                    ).trim().to_string(),
                    role: t.role,
                    content: t.content,
                    is_deleted: t.is_deleted,
                    created_at: t.created_at.to_rfc3339(),
                    updated_at: t.updated_at.to_rfc3339(),
                })
            })
            .collect();

        let meta = PaginatorResponseMeta::new(page, per_page, total as u32);
        Ok(PaginatorResponse { data, meta })
    }

    async fn find_by_id(&self, id: Uuid) -> Result<TestimonialEntity, AppError> {
        let (testimonial, user) = TestimonialsEntity::find_by_id(id)
            .filter(TestimonialsColumn::IsDeleted.eq(false))
            .find_also_related(UsersEntity)
            .one(self.db.as_ref())
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?
            .ok_or_else(|| AppError::NotFoundError("Testimonial not found".to_string()))?;

        let user = user.ok_or_else(|| AppError::NotFoundError("User not found for testimonial".to_string()))?;

        Ok(TestimonialEntity {
            id: testimonial.id,
            user_id: testimonial.user_id,
            user_fullname: format!(
                "{} {}",
                user.first_name.as_deref().unwrap_or(""),
                user.last_name.as_deref().unwrap_or("")
            ).trim().to_string(),
            role: testimonial.role,
            content: testimonial.content,
            is_deleted: testimonial.is_deleted,
            created_at: testimonial.created_at.to_rfc3339(),
            updated_at: testimonial.updated_at.to_rfc3339(),
        })
    }

    async fn create(&self, entity: TestimonialEntity) -> Result<TestimonialEntity, AppError> {
        let active_model = TestimonialsActiveModel {
            id: ActiveValue::Set(entity.id),
            user_id: ActiveValue::Set(entity.user_id),
            role: ActiveValue::Set(entity.role.clone()),
            content: ActiveValue::Set(entity.content.clone()),
            is_deleted: ActiveValue::Set(false),
            created_at: ActiveValue::Set(chrono::Utc::now()),
            updated_at: ActiveValue::Set(chrono::Utc::now()),
        };

        let inserted = active_model.insert(self.db.as_ref()).await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;

        Ok(TestimonialEntity {
            id: inserted.id,
            user_id: inserted.user_id,
            user_fullname: entity.user_fullname,
            role: inserted.role,
            content: inserted.content,
            is_deleted: inserted.is_deleted,
            created_at: inserted.created_at.to_rfc3339(),
            updated_at: inserted.updated_at.to_rfc3339(),
        })
    }

    async fn update(&self, entity: TestimonialEntity) -> Result<(), AppError> {
        let mut active_model: TestimonialsActiveModel = TestimonialsEntity::find_by_id(entity.id)
            .one(self.db.as_ref())
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?
            .ok_or_else(|| AppError::NotFoundError("Testimonial not found".to_string()))?
            .into();

        active_model.role = ActiveValue::Set(entity.role);
        active_model.content = ActiveValue::Set(entity.content);
        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(())
    }

    async fn delete(&self, id: Uuid) -> Result<(), AppError> {
        let mut active_model: TestimonialsActiveModel = TestimonialsEntity::find_by_id(id)
            .one(self.db.as_ref())
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?
            .ok_or_else(|| AppError::NotFoundError("Testimonial 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(())
    }
}