fish_lib/game/repositories/
specimen_repository.rs

1use crate::database::DatabaseInterface;
2use crate::game::errors::repository::GameRepositoryError;
3use crate::models::specimen::{NewSpecimen, Specimen};
4use crate::models::user::User;
5use crate::schema::fish_specimens;
6use crate::traits::repository::Repository;
7use chrono::Utc;
8use diesel::prelude::*;
9use std::sync::{Arc, RwLock};
10
11pub trait SpecimenRepositoryInterface: Repository<Specimen> + Send + Sync {
12    fn find_by_user(&self, owner_user: &User) -> Result<Vec<Specimen>, GameRepositoryError>;
13}
14
15pub struct SpecimenRepository {
16    db: Arc<RwLock<dyn DatabaseInterface>>,
17}
18
19impl SpecimenRepository {
20    pub fn new(db: Arc<RwLock<dyn DatabaseInterface>>) -> Self {
21        Self { db }
22    }
23}
24
25impl SpecimenRepositoryInterface for SpecimenRepository {
26    fn find_by_user(&self, owner_user: &User) -> Result<Vec<Specimen>, GameRepositoryError> {
27        let mut connection = self.get_connection()?;
28
29        let specimens = fish_specimens::table
30            .filter(fish_specimens::user_id.eq(owner_user.id))
31            .load::<Specimen>(&mut connection)?;
32
33        Ok(specimens)
34    }
35}
36
37impl Repository<Specimen> for SpecimenRepository {
38    fn get_db(&self) -> Arc<RwLock<dyn DatabaseInterface>> {
39        self.db.clone()
40    }
41
42    fn create(&self, new_entity: NewSpecimen) -> Result<Specimen, GameRepositoryError> {
43        let mut connection = self.get_connection()?;
44
45        let specimen = diesel::insert_into(fish_specimens::table)
46            .values(new_entity)
47            .get_result::<Specimen>(&mut connection)?;
48
49        Ok(specimen)
50    }
51
52    fn find(&self, id: i64) -> Result<Option<Specimen>, GameRepositoryError> {
53        let mut connection = self.get_connection()?;
54        let specimen = fish_specimens::table
55            .find(id)
56            .first::<Specimen>(&mut connection)
57            .optional()?;
58        Ok(specimen)
59    }
60
61    fn save(&self, mut entity: Specimen) -> Result<Specimen, GameRepositoryError> {
62        let mut connection = self.get_connection()?;
63        entity.updated_at = Utc::now();
64
65        let updated_specimen = diesel::update(fish_specimens::table)
66            .filter(fish_specimens::id.eq(entity.id))
67            .set(entity)
68            .get_result::<Specimen>(&mut connection)?;
69
70        Ok(updated_specimen)
71    }
72
73    fn delete(&self, entity: Specimen) -> Result<bool, GameRepositoryError> {
74        let mut connection = self.get_connection()?;
75
76        let deleted_count = diesel::delete(fish_specimens::table)
77            .filter(fish_specimens::id.eq(entity.id))
78            .execute(&mut connection)?;
79
80        Ok(deleted_count > 0)
81    }
82}