Added MongoDB

.gitignore

@@ -1,2 +1,5 @@
 __pycache__/
-.idea/
+.idea/
+
+.env
+Barberia/

services/appointment_manager.py

@@ -1,115 +1,75 @@
+from dotenv import load_dotenv
 import os
+
 from datetime import datetime, timedelta
+from pymongo import MongoClient
+
 
 from models.client import Client
 from models.appointment import Appointment
-from services.utils import save_json, create_folder, load_json
 
 
 class AppointmentManager:
-    def __init__(self, saving_path: str = "Barberia", interval_hours: tuple[tuple[int]] = ((8, 12), (14, 18))):
-        self._saving_path = os.path.join(os.getcwd(), saving_path)
-        create_folder(self._saving_path)
+    def __init__(self, interval_hours=((8, 12), (14, 18))):
+        load_dotenv()
+        mongo_uri = os.getenv("MONGO_URI")
+        mongo_db = os.getenv("MONGO_DB", "barberia")
+
+        self.client = MongoClient(mongo_uri)
+        self.db = self.client[mongo_db]
+        self.collection = self.db["appointments"]
 
         self._opening_hours: list[str] = []
         self.set_opening_hours(interval_hours)
 
     def set_opening_hours(self, interval_hours: tuple[tuple[int]]) -> None:
         opening_hours = []
-
         for start, end in interval_hours:
-            start_hour = datetime.strptime(f"{start}:00", '%H:%M')
+            current_hour = datetime.strptime(f"{start}:00", '%H:%M')
             end_hour = datetime.strptime(f"{end}:00", '%H:%M')
-            current_hour = start_hour
-
             while current_hour < end_hour:
-                formatted_current_hour = current_hour.strftime('%H:%M')
-                opening_hours.append(formatted_current_hour)
+                opening_hours.append(current_hour.strftime('%H:%M'))
                 current_hour += timedelta(minutes=30)
-
         self._opening_hours = opening_hours
 
     def create_appointment(self, user_data: dict, date_data: dict) -> None:
         client = Client(**user_data)
         appointment = Appointment(client, **date_data)
-
-        # Save the appointment information
-        date_folder = os.path.join(self._saving_path, appointment.get_formatted_date())
-        create_folder(date_folder)
-        file_path = os.path.join(date_folder, f'{client.get_identification()}.json')
-        save_json(file_path, appointment.to_dict())
+        data = appointment.to_dict()
+        data["date"] = appointment.get_formatted_date()
+        data["hour"] = appointment.get_formatted_hour()
+        self.collection.insert_one(data)
 
     def get_available_appointments(self) -> dict[str, list[str]]:
-        """
-        :return: A dictionary with the keys being the date as (YYYY-MM-DD) and the value is a list
-        of all the available hours as HH:MM for that day.
-        """
         today = datetime.now()
-        next_days = [today + timedelta(days=i) for i in range(28)] # Get the next 4 weeks
+        next_days = [today + timedelta(days=i) for i in range(28)]
 
-        # Get all possible appointments for the next 4 weeks
         available_appointments = {
             day.strftime('%Y-%m-%d'): [hour for hour in self._opening_hours] for day in next_days
         }
 
-        # Delete hours from the current day that have already passed
         current_day = today.strftime('%Y-%m-%d')
         current_hour = today.strftime('%H:%M')
         available_appointments[current_day] = [hour for hour in available_appointments[current_day] if hour > current_hour]
 
-        # Remove reserved appointments
-        for reserved_day_folder in os.listdir(self._saving_path):
-            formatted_reserved_day_folder = datetime.strptime(reserved_day_folder, '%Y%m%d').strftime('%Y-%m-%d')
-            if formatted_reserved_day_folder not in available_appointments:
-                continue
-            for client_file in os.listdir(os.path.join(self._saving_path, reserved_day_folder)):
-                client_data = load_json(os.path.join(self._saving_path, reserved_day_folder, client_file))
-                for appointment_data in client_data['appointments']:
-                    appointment = Appointment.from_dict(appointment_data)
-                    reserved_hour = appointment.get_formatted_hour()
-                    if reserved_hour in available_appointments[formatted_reserved_day_folder]:
-                        available_appointments[formatted_reserved_day_folder].remove(reserved_hour)
-
-            if not available_appointments[formatted_reserved_day_folder]:
-                del available_appointments[formatted_reserved_day_folder]
+        for record in self.collection.find():
+            day = record.get("date")
+            hour = record.get("hour")
+            if day in available_appointments and hour in available_appointments[day]:
+                available_appointments[day].remove(hour)
 
-        return available_appointments
+        return {k: v for k, v in available_appointments.items() if v}
 
     def get_reserved_days(self) -> list[str]:
-        """
-        :return: list with the days that have appointments reserved. The format for the date is (YYYY-MM-DD)
-        """
-        reserved_appointments = list()
-
-        for day_folder in os.listdir(self._saving_path):
-            formatted_day = datetime.strptime(day_folder, '%Y%m%d').strftime('%Y-%m-%d')
-            reserved_appointments.append(formatted_day)
-
-        return reserved_appointments
+        return sorted(list(set(doc["date"] for doc in self.collection.find({}, {"date": 1}))))
 
     def get_appointments(self, date: str) -> list:
-        """
-        :return: A list of all the appointments for the given date. Each appointment is a dict as the following:
-            identification: user_identification
-            name: user_name
-            hour: hour of the appointment, format HH:MM
-        """
-        appointments = list()
-        formatted_date = datetime.strptime(date, '%Y-%m-%d').strftime('%Y%m%d')
-
-        for day_folder in os.listdir(self._saving_path):
-            if formatted_date != day_folder:
-                continue
-
-            for client_file in os.listdir(os.path.join(self._saving_path, day_folder)):
-                client_data = load_json(os.path.join(self._saving_path, day_folder, client_file))
-                for appointment_data in client_data['appointments']:
-                    appointment = Appointment.from_dict(appointment_data)
-                    appointment_info = {
-                        'identification': appointment.get_client_id(),
-                        'name': f'{appointment.get_client_name()} {appointment.get_client_last_name()}',
-                        'hour': appointment.get_formatted_hour()
-                    }
-                    appointments.append(appointment_info)
-
-        return appointments
+        results = self.collection.find({"date": date})
+        return [
+            {
+                "identification": r["client"]["identification"],
+                "name": f"{r['client']['name']} {r['client']['last_name']}",
+                "hour": r["hour"]
+            }
+            for r in results
+        ]