Enhancement/sorted competition by upcoming and outdated

.gitignore

@@ -2,6 +2,7 @@ bin
 include
 lib
 .Python
-tests/
 .envrc
-__pycache__
+__pycache__
+.env
+.flake8

clubs.json

@@ -1,15 +1,19 @@
 {"clubs":[
     {
+        "id": "25e97c3f-844b-4200-a3cb-7f0a09c0f623",
         "name":"Simply Lift",
         "email":"[email protected]",
         "points":"13"
     },
     {
+        "id": "d5c2bc91-2171-40ef-a9bc-49af8e6518c9",
         "name":"Iron Temple",
         "email": "[email protected]",
         "points":"4"
     },
-    {   "name":"She Lifts",
+    { 
+        "id": "006a09e0-9325-471c-970b-6fb81c3146d4",
+        "name":"She Lifts",
         "email": "[email protected]",
         "points":"12"
     }

competitions.json

@@ -1,14 +1,22 @@
 {
     "competitions": [
         {
+            "id": "89bee937-7503-431a-bb1c-d2a05998170a",
             "name": "Spring Festival",
             "date": "2020-03-27 10:00:00",
-            "numberOfPlaces": "25"
+            "available_places": "25"
         },
         {
+            "id": "0684ecc2-80ca-4057-a144-3357298689d9",
             "name": "Fall Classic",
             "date": "2020-10-22 13:30:00",
-            "numberOfPlaces": "13"
+            "available_places": "13"
+        },
+        {
+            "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+            "name": "Summer Challenge",
+            "date": "2025-08-27 10:00:00",
+            "available_places": "20"
         }
     ]
 }

entities/club.py

@@ -0,0 +1,68 @@
+import uuid
+
+
+class Club:
+    """Class representing a club with a name, email, and points system for reservation."""
+
+    def __init__(self, name: str, email: str, points: int):
+        self._id = str(uuid.uuid4())
+        self._name = name
+        self._email = email
+        self._points = points
+
+    def has_enough_points(self, points: int) -> bool:
+        """Check if the club has enough points."""
+        return self._points >= points
+
+    def consume_points(self, points: int) -> None:
+        """Consume points from the club."""
+        if not self.has_enough_points(points):
+            raise ValueError("Not enough points to consume.")
+        self._points -= points
+
+    def reserve(self, competition, places, date):
+        """Reserve places for the club in a competition."""
+        return competition.reserve_places(self, places, date)
+
+    @property
+    def id(self) -> str:
+        """Get the ID of the club."""
+        return self._id
+
+    @property
+    def name(self) -> str:
+        """Get the name of the club."""
+        return self._name
+
+    @property
+    def email(self) -> str:
+        """Get the email of the club."""
+        return self._email
+
+    @property
+    def points(self) -> int:
+        """Get the points of the club."""
+        return self._points
+
+    @classmethod
+    def deserialize(cls, data: dict):
+        """Deserialize data into the Club object."""
+        club = cls(
+            name=data.get("name"),
+            email=data.get("email"),
+            points=int(data.get("points")),
+        )
+        club._id = data.get("id")
+        return club
+
+    def serialize(self) -> dict:
+        """Serialize the Club object into a dictionary."""
+        return {
+            "id": self._id,
+            "name": self._name,
+            "email": self._email,
+            "points": str(self._points),
+        }
+
+    def __str__(self) -> str:
+        return f"Club(id={self._id}, name={self._name}, email={self._email}, points={self._points})"

entities/competition.py

@@ -0,0 +1,94 @@
+import uuid
+from datetime import datetime
+
+from entities.reservation import Reservation
+
+
+class Competition:
+    """Class representing a competition with a name, date, available places and maximum places per reservation."""
+
+    MAX_PLACES_PER_RESERVATION = 12
+
+    def __init__(
+        self,
+        name: str,
+        date: datetime,
+        available_places: int,
+        max_places_per_reservation: int = MAX_PLACES_PER_RESERVATION,
+    ):
+        self._id = str(uuid.uuid4())
+        self._name = name
+        self._date = date
+        self._available_places = available_places
+        self._max_places_per_reservation = max_places_per_reservation
+
+    def can_reserve(self, places: int) -> bool:
+        """Check if there are enough available places to reserve."""
+        return self._available_places >= places
+
+    def is_within_reservation_limit(self, places: int, total_already_reserved: int) -> bool:
+        """Check if the total reserved places stay within the allowed limit."""
+        return total_already_reserved + places <= self._max_places_per_reservation
+
+    def reserve_places(self, club, places, date):
+        """Reserve places for a club in the competition."""
+        if not self.can_reserve(places):
+            raise ValueError("Not enough available places to reserve.")
+        if not club.has_enough_points(places):
+            raise ValueError("Not enough points to reserve places.")
+
+        club.consume_points(places)
+        self._available_places -= places
+
+        return Reservation(club.id, self._id, places, date)
+
+    @property
+    def id(self) -> str:
+        """Get the ID of the competition."""
+        return self._id
+
+    @property
+    def name(self) -> str:
+        """Get the name of the competition."""
+        return self._name
+
+    @property
+    def date(self) -> datetime:
+        """Get the date of the competition."""
+        return self._date
+
+    @property
+    def available_places(self) -> int:
+        """Get the number of available places."""
+        return self._available_places
+
+    @property
+    def max_places_per_reservation(self) -> int:
+        """Get the maximum places per reservation."""
+        return self._max_places_per_reservation
+
+    @classmethod
+    def deserialize(cls, data: dict):
+        """Deserialize data into the Competition object."""
+        competition = cls(
+            name=data.get("name"),
+            date=datetime.strptime(data.get("date"), "%Y-%m-%d %H:%M:%S"),
+            available_places=int(data.get("available_places")),
+        )
+        competition._id = data.get("id")
+        return competition
+
+    def serialize(self) -> dict:
+        """Serialize the Competition object into a dictionary."""
+        return {
+            "id": self._id,
+            "name": self._name,
+            "date": self._date.strftime("%Y-%m-%d %H:%M:%S"),
+            "available_places": str(self._available_places),
+        }
+
+    def __str__(self) -> str:
+        return (
+            f"Competition(id={self._id}, name={self._name}, "
+            f"date={self._date}, available_places={self._available_places})"
+        )

entities/reservation.py

@@ -0,0 +1,61 @@
+import uuid
+from datetime import datetime
+
+
+class Reservation:
+    """Class representing a reservation for a club in a competition."""
+
+    def __init__(self, club_id: str, competition_id: str, reserved_places: int, date: datetime):
+        self._id = str(uuid.uuid4())
+        self._club_id = club_id
+        self._competition_id = competition_id
+        self._reserved_places = reserved_places
+        self._date = date
+
+    @property
+    def club_id(self) -> str:
+        """Get the ID of the club."""
+        return self._club_id
+
+    @property
+    def competition_id(self) -> str:
+        """Get the ID of the competition."""
+        return self._competition_id
+
+    @property
+    def reserved_places(self) -> int:
+        """Get the number of reserved places."""
+        return self._reserved_places
+
+    @property
+    def date(self) -> datetime:
+        """Get the date of the reservation."""
+        return self._date
+
+    @classmethod
+    def deserialize(cls, data: dict):
+        """Deserialize data into the Reservation object."""
+        reservation = cls(
+            club_id=data.get("club_id"),
+            competition_id=data.get("competition_id"),
+            reserved_places=int(data.get("reserved_places")),
+            date=datetime.strptime(data.get("date"), "%Y-%m-%d %H:%M:%S"),
+        )
+        reservation._id = data.get("id")
+        return reservation
+
+    def serialize(self) -> dict:
+        """Serialize the Reservation object into a dictionary."""
+        return {
+            "id": self._id,
+            "club_id": self._club_id,
+            "competition_id": self._competition_id,
+            "reserved_places": str(self._reserved_places),
+            "date": self._date.strftime("%Y-%m-%d %H:%M:%S"),
+        }
+
+    def __str__(self) -> str:
+        return (
+            f"Reservation(id={self._id}, club_id={self._club_id}, "
+            f"competition_id={self._competition_id}, reserved_places={self._reserved_places}, date={self._date})"
+        )

globals.py

@@ -0,0 +1 @@
+LIMITED_BOOKING_PLACE = 12

json_services.py

@@ -0,0 +1,16 @@
+import json
+
+
+class JSONServices:
+    @staticmethod
+    def load(filename: str):
+        try:
+            with open(filename) as file:
+                return json.load(file)
+        except FileNotFoundError:
+            raise FileNotFoundError(f"File {filename} not found.")
+
+    @staticmethod
+    def save(file_name, data):
+        with open(file_name, "w") as file:
+            json.dump(data, file, indent=4)

repositories/club_json_repository.py

@@ -0,0 +1,46 @@
+import os
+
+from entities.club import Club
+from json_services import JSONServices
+from repository_protocols.club_repository import ClubRepository
+
+
+class ClubJsonRepository(ClubRepository):
+    """Repository for managing clubs stored in a JSON file."""
+
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+        self._clubs: list[Club] = self._load()
+
+    def _load(self) -> list[Club]:
+        """Load clubs from the JSON file. If the file does not exist, return an empty list."""
+        if not os.path.exists(self.file_path):
+            return []
+
+        data = JSONServices.load(self.file_path).get("clubs", [])
+        return [Club.deserialize(club) for club in data]
+
+    def reload(self) -> None:
+        """Reload the clubs from the JSON file."""
+        self._clubs = self._load()
+
+    def all(self) -> list[Club]:
+        """Get all clubs from the repository."""
+        return self._clubs
+
+    def find_by_name(self, name: str) -> Club | None:
+        """Find a club by its name."""
+        return next((club for club in self._clubs if club.name == name), None)
+
+    def find_by_email(self, email: str) -> Club | None:
+        """Find a club by its email."""
+        return next((club for club in self._clubs if club.email == email), None)
+
+    def update(self, club: Club) -> None:
+        """Update an existing club in the repository."""
+        for i, existing_club in enumerate(self._clubs):
+            if existing_club.name == club.name:
+                self._clubs[i] = club
+                break
+        serialized_data = [club.serialize() for club in self._clubs]
+        JSONServices.save(self.file_path, {"clubs": serialized_data})

repositories/competition_json_repository.py

@@ -0,0 +1,46 @@
+import os
+from datetime import datetime
+
+from entities.competition import Competition
+from json_services import JSONServices
+from repository_protocols.competition_repository import CompetitionRepository
+
+
+class CompetitionJsonRepository(CompetitionRepository):
+    """Repository for managing competitions stored in a JSON file."""
+
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+        self._competitions: list[Competition] = self._load()
+
+    def _load(self) -> list[Competition]:
+        """Load competitions from the JSON file. If the file does not exist, return an empty list."""
+        if not os.path.exists(self.file_path):
+            return []
+
+        data = JSONServices.load(self.file_path).get("competitions", [])
+        return [Competition.deserialize(competition) for competition in data]
+
+    def reload(self) -> None:
+        """Reload the competitions from the JSON file."""
+        self._competitions = self._load()
+
+    def all(self) -> list[Competition]:
+        """Get all competitions sorted by upcoming first, then outdated."""
+        now = datetime.now()
+        upcoming = [competition for competition in self._competitions if competition.date >= now]
+        outdated = [competition for competition in self._competitions if competition.date < now]
+        return sorted(upcoming, key=lambda c: c.date) + sorted(outdated, key=lambda c: c.date)
+
+    def find_by_name(self, name: str) -> Competition | None:
+        """Find a competition by its name."""
+        return next((competition for competition in self._competitions if competition.name == name), None)
+
+    def update(self, competition: Competition) -> None:
+        """Update an existing competition in the repository."""
+        for i, existing_competition in enumerate(self._competitions):
+            if existing_competition.name == competition.name:
+                self._competitions[i] = competition
+                break
+        serialized_data = [competition.serialize() for competition in self._competitions]
+        JSONServices.save(self.file_path, {"competitions": serialized_data})