koprogo_api/infrastructure/database/repositories/
building_repository_impl.rs

1use crate::application::dto::{BuildingFilters, PageRequest};
2use crate::application::ports::BuildingRepository;
3use crate::domain::entities::Building;
4use crate::infrastructure::database::pool::DbPool;
5use async_trait::async_trait;
6use sqlx::Row;
7use uuid::Uuid;
8
9pub struct PostgresBuildingRepository {
10    pool: DbPool,
11}
12
13impl PostgresBuildingRepository {
14    pub fn new(pool: DbPool) -> Self {
15        Self { pool }
16    }
17}
18
19#[async_trait]
20impl BuildingRepository for PostgresBuildingRepository {
21    async fn create(&self, building: &Building) -> Result<Building, String> {
22        sqlx::query(
23            r#"
24            INSERT INTO buildings (id, organization_id, name, address, city, postal_code, country, total_units, total_tantiemes, construction_year, syndic_name, syndic_email, syndic_phone, syndic_address, syndic_office_hours, syndic_emergency_contact, slug, created_at, updated_at)
25            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19)
26            "#,
27        )
28        .bind(building.id)
29        .bind(building.organization_id)
30        .bind(&building.name)
31        .bind(&building.address)
32        .bind(&building.city)
33        .bind(&building.postal_code)
34        .bind(&building.country)
35        .bind(building.total_units)
36        .bind(building.total_tantiemes)
37        .bind(building.construction_year)
38        .bind(&building.syndic_name)
39        .bind(&building.syndic_email)
40        .bind(&building.syndic_phone)
41        .bind(&building.syndic_address)
42        .bind(&building.syndic_office_hours)
43        .bind(&building.syndic_emergency_contact)
44        .bind(&building.slug)
45        .bind(building.created_at)
46        .bind(building.updated_at)
47        .execute(&self.pool)
48        .await
49        .map_err(|e| format!("Database error: {}", e))?;
50
51        Ok(building.clone())
52    }
53
54    async fn find_by_id(&self, id: Uuid) -> Result<Option<Building>, String> {
55        let row = sqlx::query(
56            r#"
57            SELECT id, organization_id, name, address, city, postal_code, country, total_units, total_tantiemes, construction_year, syndic_name, syndic_email, syndic_phone, syndic_address, syndic_office_hours, syndic_emergency_contact, slug, created_at, updated_at
58            FROM buildings
59            WHERE id = $1
60            "#,
61        )
62        .bind(id)
63        .fetch_optional(&self.pool)
64        .await
65        .map_err(|e| format!("Database error: {}", e))?;
66
67        Ok(row.map(|row| Building {
68            id: row.get("id"),
69            organization_id: row.get("organization_id"),
70            name: row.get("name"),
71            address: row.get("address"),
72            city: row.get("city"),
73            postal_code: row.get("postal_code"),
74            country: row.get("country"),
75            total_units: row.get("total_units"),
76            total_tantiemes: row.get("total_tantiemes"),
77            construction_year: row.get("construction_year"),
78            syndic_name: row.get("syndic_name"),
79            syndic_email: row.get("syndic_email"),
80            syndic_phone: row.get("syndic_phone"),
81            syndic_address: row.get("syndic_address"),
82            syndic_office_hours: row.get("syndic_office_hours"),
83            syndic_emergency_contact: row.get("syndic_emergency_contact"),
84            slug: row.get("slug"),
85            created_at: row.get("created_at"),
86            updated_at: row.get("updated_at"),
87        }))
88    }
89
90    async fn find_all(&self) -> Result<Vec<Building>, String> {
91        let rows = sqlx::query(
92            r#"
93            SELECT id, organization_id, name, address, city, postal_code, country, total_units, total_tantiemes, construction_year, syndic_name, syndic_email, syndic_phone, syndic_address, syndic_office_hours, syndic_emergency_contact, slug, created_at, updated_at
94            FROM buildings
95            ORDER BY created_at DESC
96            "#,
97        )
98        .fetch_all(&self.pool)
99        .await
100        .map_err(|e| format!("Database error: {}", e))?;
101
102        Ok(rows
103            .iter()
104            .map(|row| Building {
105                id: row.get("id"),
106                organization_id: row.get("organization_id"),
107                name: row.get("name"),
108                address: row.get("address"),
109                city: row.get("city"),
110                postal_code: row.get("postal_code"),
111                country: row.get("country"),
112                total_units: row.get("total_units"),
113                total_tantiemes: row.get("total_tantiemes"),
114                construction_year: row.get("construction_year"),
115                syndic_name: row.get("syndic_name"),
116                syndic_email: row.get("syndic_email"),
117                syndic_phone: row.get("syndic_phone"),
118                syndic_address: row.get("syndic_address"),
119                syndic_office_hours: row.get("syndic_office_hours"),
120                syndic_emergency_contact: row.get("syndic_emergency_contact"),
121                slug: row.get("slug"),
122                created_at: row.get("created_at"),
123                updated_at: row.get("updated_at"),
124            })
125            .collect())
126    }
127
128    async fn find_all_paginated(
129        &self,
130        page_request: &PageRequest,
131        filters: &BuildingFilters,
132    ) -> Result<(Vec<Building>, i64), String> {
133        // Validate page request
134        page_request.validate()?;
135
136        // Build WHERE clause dynamically
137        let mut where_clauses = Vec::new();
138        let mut param_count = 0;
139
140        if filters.organization_id.is_some() {
141            param_count += 1;
142            where_clauses.push(format!("organization_id = ${}", param_count));
143        }
144
145        if filters.city.is_some() {
146            param_count += 1;
147            where_clauses.push(format!("city ILIKE ${}", param_count));
148        }
149
150        if filters.construction_year.is_some() {
151            param_count += 1;
152            where_clauses.push(format!("construction_year = ${}", param_count));
153        }
154
155        if filters.min_units.is_some() {
156            param_count += 1;
157            where_clauses.push(format!("total_units >= ${}", param_count));
158        }
159
160        if filters.max_units.is_some() {
161            param_count += 1;
162            where_clauses.push(format!("total_units <= ${}", param_count));
163        }
164
165        let where_clause = if where_clauses.is_empty() {
166            String::new()
167        } else {
168            format!("WHERE {}", where_clauses.join(" AND "))
169        };
170
171        // Validate sort column (whitelist)
172        let allowed_columns = [
173            "name",
174            "created_at",
175            "total_units",
176            "city",
177            "construction_year",
178        ];
179        let sort_column = page_request.sort_by.as_deref().unwrap_or("created_at");
180
181        if !allowed_columns.contains(&sort_column) {
182            return Err(format!("Invalid sort column: {}", sort_column));
183        }
184
185        // Count total items
186        let count_query = format!("SELECT COUNT(*) FROM buildings {}", where_clause);
187        let mut count_query = sqlx::query_scalar::<_, i64>(&count_query);
188
189        if let Some(org_id) = filters.organization_id {
190            count_query = count_query.bind(org_id);
191        }
192        if let Some(city) = &filters.city {
193            count_query = count_query.bind(format!("%{}%", city));
194        }
195        if let Some(year) = filters.construction_year {
196            count_query = count_query.bind(year);
197        }
198        if let Some(min) = filters.min_units {
199            count_query = count_query.bind(min);
200        }
201        if let Some(max) = filters.max_units {
202            count_query = count_query.bind(max);
203        }
204
205        let total_items = count_query
206            .fetch_one(&self.pool)
207            .await
208            .map_err(|e| format!("Database error: {}", e))?;
209
210        // Fetch paginated data
211        param_count += 1;
212        let limit_param = param_count;
213        param_count += 1;
214        let offset_param = param_count;
215
216        let data_query = format!(
217            "SELECT id, organization_id, name, address, city, postal_code, country, total_units, total_tantiemes, construction_year, syndic_name, syndic_email, syndic_phone, syndic_address, syndic_office_hours, syndic_emergency_contact, slug, created_at, updated_at \
218             FROM buildings {} ORDER BY {} {} LIMIT ${} OFFSET ${}",
219            where_clause,
220            sort_column,
221            page_request.order.to_sql(),
222            limit_param,
223            offset_param
224        );
225
226        let mut data_query = sqlx::query(&data_query);
227
228        if let Some(org_id) = filters.organization_id {
229            data_query = data_query.bind(org_id);
230        }
231        if let Some(city) = &filters.city {
232            data_query = data_query.bind(format!("%{}%", city));
233        }
234        if let Some(year) = filters.construction_year {
235            data_query = data_query.bind(year);
236        }
237        if let Some(min) = filters.min_units {
238            data_query = data_query.bind(min);
239        }
240        if let Some(max) = filters.max_units {
241            data_query = data_query.bind(max);
242        }
243
244        data_query = data_query
245            .bind(page_request.limit())
246            .bind(page_request.offset());
247
248        let rows = data_query
249            .fetch_all(&self.pool)
250            .await
251            .map_err(|e| format!("Database error: {}", e))?;
252
253        let buildings: Vec<Building> = rows
254            .iter()
255            .map(|row| Building {
256                id: row.get("id"),
257                organization_id: row.get("organization_id"),
258                name: row.get("name"),
259                address: row.get("address"),
260                city: row.get("city"),
261                postal_code: row.get("postal_code"),
262                country: row.get("country"),
263                total_units: row.get("total_units"),
264                total_tantiemes: row.get("total_tantiemes"),
265                construction_year: row.get("construction_year"),
266                syndic_name: row.get("syndic_name"),
267                syndic_email: row.get("syndic_email"),
268                syndic_phone: row.get("syndic_phone"),
269                syndic_address: row.get("syndic_address"),
270                syndic_office_hours: row.get("syndic_office_hours"),
271                syndic_emergency_contact: row.get("syndic_emergency_contact"),
272                slug: row.get("slug"),
273                created_at: row.get("created_at"),
274                updated_at: row.get("updated_at"),
275            })
276            .collect();
277
278        Ok((buildings, total_items))
279    }
280
281    async fn update(&self, building: &Building) -> Result<Building, String> {
282        sqlx::query(
283            r#"
284            UPDATE buildings
285            SET organization_id = $2, name = $3, address = $4, city = $5, postal_code = $6, country = $7, total_units = $8, total_tantiemes = $9, construction_year = $10, syndic_name = $11, syndic_email = $12, syndic_phone = $13, syndic_address = $14, syndic_office_hours = $15, syndic_emergency_contact = $16, slug = $17, updated_at = $18
286            WHERE id = $1
287            "#,
288        )
289        .bind(building.id)
290        .bind(building.organization_id)
291        .bind(&building.name)
292        .bind(&building.address)
293        .bind(&building.city)
294        .bind(&building.postal_code)
295        .bind(&building.country)
296        .bind(building.total_units)
297        .bind(building.total_tantiemes)
298        .bind(building.construction_year)
299        .bind(&building.syndic_name)
300        .bind(&building.syndic_email)
301        .bind(&building.syndic_phone)
302        .bind(&building.syndic_address)
303        .bind(&building.syndic_office_hours)
304        .bind(&building.syndic_emergency_contact)
305        .bind(&building.slug)
306        .bind(building.updated_at)
307        .execute(&self.pool)
308        .await
309        .map_err(|e| format!("Database error: {}", e))?;
310
311        Ok(building.clone())
312    }
313
314    async fn delete(&self, id: Uuid) -> Result<bool, String> {
315        let result = sqlx::query("DELETE FROM buildings WHERE id = $1")
316            .bind(id)
317            .execute(&self.pool)
318            .await
319            .map_err(|e| format!("Database error: {}", e))?;
320
321        Ok(result.rows_affected() > 0)
322    }
323
324    async fn find_by_slug(&self, slug: &str) -> Result<Option<Building>, String> {
325        let row = sqlx::query(
326            r#"
327            SELECT id, organization_id, name, address, city, postal_code, country, total_units, total_tantiemes, construction_year, syndic_name, syndic_email, syndic_phone, syndic_address, syndic_office_hours, syndic_emergency_contact, slug, created_at, updated_at
328            FROM buildings
329            WHERE slug = $1
330            "#,
331        )
332        .bind(slug)
333        .fetch_optional(&self.pool)
334        .await
335        .map_err(|e| format!("Database error: {}", e))?;
336
337        Ok(row.map(|row| Building {
338            id: row.get("id"),
339            organization_id: row.get("organization_id"),
340            name: row.get("name"),
341            address: row.get("address"),
342            city: row.get("city"),
343            postal_code: row.get("postal_code"),
344            country: row.get("country"),
345            total_units: row.get("total_units"),
346            total_tantiemes: row.get("total_tantiemes"),
347            construction_year: row.get("construction_year"),
348            syndic_name: row.get("syndic_name"),
349            syndic_email: row.get("syndic_email"),
350            syndic_phone: row.get("syndic_phone"),
351            syndic_address: row.get("syndic_address"),
352            syndic_office_hours: row.get("syndic_office_hours"),
353            syndic_emergency_contact: row.get("syndic_emergency_contact"),
354            slug: row.get("slug"),
355            created_at: row.get("created_at"),
356            updated_at: row.get("updated_at"),
357        }))
358    }
359}
koprogo_api/infrastructure/database/repositories/building_repository_impl.rs

koprogo_api/infrastructure/database/repositories/
building_repository_impl.rs
