koprogo_api/application/use_cases/
work_report_use_cases.rs

1use crate::application::dto::{
2    AddDocumentDto, AddPhotoDto, CreateWorkReportDto, PageRequest, UpdateWorkReportDto,
3    WarrantyStatusDto, WorkReportFilters, WorkReportListResponseDto, WorkReportResponseDto,
4};
5use crate::application::ports::WorkReportRepository;
6use crate::domain::entities::WorkReport;
7use chrono::DateTime;
8use std::sync::Arc;
9use uuid::Uuid;
10
11pub struct WorkReportUseCases {
12    repository: Arc<dyn WorkReportRepository>,
13}
14
15impl WorkReportUseCases {
16    pub fn new(repository: Arc<dyn WorkReportRepository>) -> Self {
17        Self { repository }
18    }
19
20    pub async fn create_work_report(
21        &self,
22        dto: CreateWorkReportDto,
23    ) -> Result<WorkReportResponseDto, String> {
24        let organization_id = Uuid::parse_str(&dto.organization_id)
25            .map_err(|_| "Invalid organization_id format".to_string())?;
26        let building_id = Uuid::parse_str(&dto.building_id)
27            .map_err(|_| "Invalid building_id format".to_string())?;
28
29        let work_date = DateTime::parse_from_rfc3339(&dto.work_date)
30            .map_err(|_| "Invalid work_date format".to_string())?
31            .with_timezone(&chrono::Utc);
32
33        let completion_date = if let Some(ref date_str) = dto.completion_date {
34            Some(
35                DateTime::parse_from_rfc3339(date_str)
36                    .map_err(|_| "Invalid completion_date format".to_string())?
37                    .with_timezone(&chrono::Utc),
38            )
39        } else {
40            None
41        };
42
43        let work_report = WorkReport::new(
44            organization_id,
45            building_id,
46            dto.title,
47            dto.description,
48            dto.work_type,
49            dto.contractor_name,
50            work_date,
51            dto.cost,
52            dto.warranty_type.clone(),
53        );
54
55        let mut work_report = work_report;
56        work_report.contractor_contact = dto.contractor_contact;
57        work_report.completion_date = completion_date;
58        work_report.invoice_number = dto.invoice_number;
59        work_report.notes = dto.notes;
60
61        let created = self.repository.create(&work_report).await?;
62        Ok(self.to_response_dto(&created))
63    }
64
65    pub async fn get_work_report(&self, id: Uuid) -> Result<Option<WorkReportResponseDto>, String> {
66        let work_report = self.repository.find_by_id(id).await?;
67        Ok(work_report.map(|w| self.to_response_dto(&w)))
68    }
69
70    pub async fn list_work_reports_by_building(
71        &self,
72        building_id: Uuid,
73    ) -> Result<Vec<WorkReportResponseDto>, String> {
74        let work_reports = self.repository.find_by_building(building_id).await?;
75        Ok(work_reports
76            .iter()
77            .map(|w| self.to_response_dto(w))
78            .collect())
79    }
80
81    pub async fn list_work_reports_by_organization(
82        &self,
83        organization_id: Uuid,
84    ) -> Result<Vec<WorkReportResponseDto>, String> {
85        let work_reports = self
86            .repository
87            .find_by_organization(organization_id)
88            .await?;
89        Ok(work_reports
90            .iter()
91            .map(|w| self.to_response_dto(w))
92            .collect())
93    }
94
95    pub async fn list_work_reports_paginated(
96        &self,
97        page_request: &PageRequest,
98        filters: &WorkReportFilters,
99    ) -> Result<WorkReportListResponseDto, String> {
100        let (work_reports, total) = self
101            .repository
102            .find_all_paginated(page_request, filters)
103            .await?;
104
105        let dtos = work_reports
106            .iter()
107            .map(|w| self.to_response_dto(w))
108            .collect();
109
110        Ok(WorkReportListResponseDto {
111            work_reports: dtos,
112            total,
113            page: page_request.page,
114            page_size: page_request.per_page,
115        })
116    }
117
118    pub async fn get_active_warranties(
119        &self,
120        building_id: Uuid,
121    ) -> Result<Vec<WarrantyStatusDto>, String> {
122        let work_reports = self
123            .repository
124            .find_with_active_warranty(building_id)
125            .await?;
126
127        Ok(work_reports
128            .iter()
129            .map(|w| WarrantyStatusDto {
130                work_report_id: w.id.to_string(),
131                title: w.title.clone(),
132                warranty_type: w.warranty_type.clone(),
133                warranty_expiry: w.warranty_expiry.to_rfc3339(),
134                is_valid: w.is_warranty_valid(),
135                days_remaining: w.warranty_days_remaining(),
136            })
137            .collect())
138    }
139
140    pub async fn get_expiring_warranties(
141        &self,
142        building_id: Uuid,
143        days: i32,
144    ) -> Result<Vec<WarrantyStatusDto>, String> {
145        let work_reports = self
146            .repository
147            .find_with_expiring_warranty(building_id, days)
148            .await?;
149
150        Ok(work_reports
151            .iter()
152            .map(|w| WarrantyStatusDto {
153                work_report_id: w.id.to_string(),
154                title: w.title.clone(),
155                warranty_type: w.warranty_type.clone(),
156                warranty_expiry: w.warranty_expiry.to_rfc3339(),
157                is_valid: w.is_warranty_valid(),
158                days_remaining: w.warranty_days_remaining(),
159            })
160            .collect())
161    }
162
163    pub async fn update_work_report(
164        &self,
165        id: Uuid,
166        dto: UpdateWorkReportDto,
167    ) -> Result<WorkReportResponseDto, String> {
168        let mut work_report = self
169            .repository
170            .find_by_id(id)
171            .await?
172            .ok_or_else(|| "Work report not found".to_string())?;
173
174        if let Some(title) = dto.title {
175            work_report.title = title;
176        }
177        if let Some(description) = dto.description {
178            work_report.description = description;
179        }
180        if let Some(work_type) = dto.work_type {
181            work_report.work_type = work_type;
182        }
183        if let Some(contractor_name) = dto.contractor_name {
184            work_report.contractor_name = contractor_name;
185        }
186        if let Some(contractor_contact) = dto.contractor_contact {
187            work_report.contractor_contact = Some(contractor_contact);
188        }
189        if let Some(work_date_str) = dto.work_date {
190            let work_date = DateTime::parse_from_rfc3339(&work_date_str)
191                .map_err(|_| "Invalid work_date format".to_string())?
192                .with_timezone(&chrono::Utc);
193            work_report.work_date = work_date;
194        }
195        if let Some(completion_date_str) = dto.completion_date {
196            let completion_date = DateTime::parse_from_rfc3339(&completion_date_str)
197                .map_err(|_| "Invalid completion_date format".to_string())?
198                .with_timezone(&chrono::Utc);
199            work_report.completion_date = Some(completion_date);
200        }
201        if let Some(cost) = dto.cost {
202            work_report.cost = cost;
203        }
204        if let Some(invoice_number) = dto.invoice_number {
205            work_report.invoice_number = Some(invoice_number);
206        }
207        if let Some(notes) = dto.notes {
208            work_report.notes = Some(notes);
209        }
210        if let Some(warranty_type) = dto.warranty_type {
211            work_report.warranty_type = warranty_type;
212            // Recalculate warranty expiry when type changes
213            work_report.warranty_expiry = match work_report.warranty_type {
214                crate::domain::entities::WarrantyType::None => chrono::Utc::now(),
215                crate::domain::entities::WarrantyType::Standard => {
216                    work_report.work_date + chrono::Duration::days(2 * 365)
217                }
218                crate::domain::entities::WarrantyType::Decennial => {
219                    work_report.work_date + chrono::Duration::days(10 * 365)
220                }
221                crate::domain::entities::WarrantyType::Extended => {
222                    work_report.work_date + chrono::Duration::days(3 * 365)
223                }
224                crate::domain::entities::WarrantyType::Custom { years } => {
225                    work_report.work_date + chrono::Duration::days(years as i64 * 365)
226                }
227            };
228        }
229
230        work_report.updated_at = chrono::Utc::now();
231
232        let updated = self.repository.update(&work_report).await?;
233        Ok(self.to_response_dto(&updated))
234    }
235
236    pub async fn add_photo(
237        &self,
238        id: Uuid,
239        dto: AddPhotoDto,
240    ) -> Result<WorkReportResponseDto, String> {
241        let mut work_report = self
242            .repository
243            .find_by_id(id)
244            .await?
245            .ok_or_else(|| "Work report not found".to_string())?;
246
247        work_report.add_photo(dto.photo_path);
248
249        let updated = self.repository.update(&work_report).await?;
250        Ok(self.to_response_dto(&updated))
251    }
252
253    pub async fn add_document(
254        &self,
255        id: Uuid,
256        dto: AddDocumentDto,
257    ) -> Result<WorkReportResponseDto, String> {
258        let mut work_report = self
259            .repository
260            .find_by_id(id)
261            .await?
262            .ok_or_else(|| "Work report not found".to_string())?;
263
264        work_report.add_document(dto.document_path);
265
266        let updated = self.repository.update(&work_report).await?;
267        Ok(self.to_response_dto(&updated))
268    }
269
270    pub async fn delete_work_report(&self, id: Uuid) -> Result<bool, String> {
271        self.repository.delete(id).await
272    }
273
274    fn to_response_dto(&self, work_report: &WorkReport) -> WorkReportResponseDto {
275        WorkReportResponseDto {
276            id: work_report.id.to_string(),
277            organization_id: work_report.organization_id.to_string(),
278            building_id: work_report.building_id.to_string(),
279            title: work_report.title.clone(),
280            description: work_report.description.clone(),
281            work_type: work_report.work_type.clone(),
282            contractor_name: work_report.contractor_name.clone(),
283            contractor_contact: work_report.contractor_contact.clone(),
284            work_date: work_report.work_date.to_rfc3339(),
285            completion_date: work_report.completion_date.as_ref().map(|d| d.to_rfc3339()),
286            cost: work_report.cost,
287            invoice_number: work_report.invoice_number.clone(),
288            photos: work_report.photos.clone(),
289            documents: work_report.documents.clone(),
290            notes: work_report.notes.clone(),
291            warranty_type: work_report.warranty_type.clone(),
292            warranty_expiry: work_report.warranty_expiry.to_rfc3339(),
293            is_warranty_valid: work_report.is_warranty_valid(),
294            warranty_days_remaining: work_report.warranty_days_remaining(),
295            created_at: work_report.created_at.to_rfc3339(),
296            updated_at: work_report.updated_at.to_rfc3339(),
297        }
298    }
299}
koprogo_api/application/use_cases/work_report_use_cases.rs

koprogo_api/application/use_cases/
work_report_use_cases.rs
