shindo_coding_utils 0.4.1

use async_trait::async_trait;
use sea_orm::sea_query::OnConflict;
use sea_orm::*;
use std::sync::Arc;

use crate::schemas::experiment::{self, ActiveModel, Entity, Model};
use crate::types::Experiment;

#[async_trait]
pub trait ExperimentRepository: Send + Sync {
    async fn insert_many(&self, rows: &Vec<Experiment>)
    -> Result<InsertResult<ActiveModel>, DbErr>;

    async fn find_many(&self) -> Result<Vec<Model>, DbErr>;
}

pub struct SeaOrmExperimentRepository {
    db_conn: Arc<DatabaseConnection>,
}

impl SeaOrmExperimentRepository {
    pub fn new(db_conn: Arc<DatabaseConnection>) -> Self {
        Self { db_conn }
    }
}

#[async_trait]
impl ExperimentRepository for SeaOrmExperimentRepository {
    async fn insert_many(
        &self,
        rows: &Vec<Experiment>,
    ) -> Result<InsertResult<ActiveModel>, DbErr> {
        let unique_columns = [experiment::Column::Ticker, experiment::Column::Date];
        let on_conflict = OnConflict::columns(unique_columns)
            .update_columns([
                experiment::Column::JsonString,
                experiment::Column::Reviewed,
                experiment::Column::CreatedAt,
            ])
            .to_owned();

        let active_models = rows.iter().map(move |row| {
            let active_model = ActiveModel {
                ticker: Set(row.ticker.clone()),
                reviewed: Set(false),
                json_string: Set(row.json_string.clone()),
                created_at: Set(row.created_at.clone()),
                ..Default::default()
            };

            return active_model;
        });

        let res = Entity::insert_many(active_models)
            .on_conflict(on_conflict.clone())
            .exec(&*self.db_conn)
            .await?;
        Ok(res)
    }

    async fn find_many(&self) -> Result<Vec<Model>, DbErr> {
        Entity::find().all(&*self.db_conn).await
    }
}