Replace backend and update frontend

Author: WillSams

.husky/pre-commit

@@ -1,6 +1,10 @@
 #!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
 
-./node_modules/.bin/prettier frontend/src/**/*.js --single-quote --trailing-comma es5 --write
-./node_modules/.bin/eslint frontend/src --ignore-pattern 'frontend/src/public/' --fix 
+npm run format:backend
+npm run lint:backend
+
+npm run format:frontend
+npm run lint:frontend
+
 git add .

.husky/pre-push

@@ -1,6 +1,5 @@
 #!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
 
-npm run test:frontend
 npm run test:backend
-
+npm run test:frontend

backend/.flake8

@@ -0,0 +1,5 @@
+[flake8]
+max-line-length = 88
+ignore =
+    E203, 
+    W503

backend/.isort.cfg

@@ -0,0 +1,6 @@
+[settings]
+line_length=88
+multi_line_output=3
+include_trailing_comma=True
+use_parentheses=True
+force_grid_wrap=0

backend/api/__init__.py

@@ -0,0 +1,30 @@
+import asyncpg
+from asyncpg.pool import Pool
+
+from api.utils import log_api_message
+from settings import DB_URL, ENV
+
+
+class DummyPool:
+    async def close(self):
+        pass
+
+    async def fetch(self, *args, **kwargs):
+        pass
+
+    async def fetchval(self, *args, **kwargs):
+        pass
+
+
+async def DbSession() -> Pool:
+    if ENV == "test":
+        # see the a mock pool implemented in specs/resolvers/__init__.py
+        return DummyPool()
+
+    try:
+        pool = await asyncpg.create_pool(DB_URL)
+        return pool
+    except Exception as e:
+        message = f"Error initializing database connection: {e}"
+        log_api_message(__name__, message)
+        raise

backend/api/helpers.py

@@ -0,0 +1,15 @@
+from datetime import datetime
+
+from api.resolvers.constants import INVALID_DATE_RANGE
+
+
+def check_date_validity(checkin_date: datetime, checkout_date: datetime) -> None:
+    if checkout_date <= checkin_date:
+        raise ValueError(INVALID_DATE_RANGE)
+
+
+def calculate_total_charge(
+    daily_rate: int, checkin_date: datetime, checkout_date: datetime
+) -> int:
+    calculated_days = (checkout_date - checkin_date).days
+    return daily_rate * calculated_days

backend/api/models.py

@@ -0,0 +1,27 @@
+import datetime
+from typing import Any, Dict
+
+from pydantic import BaseModel
+
+from api import utils
+
+
+class Room(BaseModel):
+    id: str
+    num_beds: int
+    allow_smoking: bool
+    daily_rate: int
+    cleaning_fee: int
+
+
+class Reservation(BaseModel):
+    id: int
+    room_id: str
+    checkin_date: datetime.datetime
+    checkout_date: datetime.datetime
+    total_charge: int
+
+
+class ApiData(BaseModel):
+    data: Dict[str, Any]
+    status: utils.StatusCode

frontend/nginx.conf backend/api/resolvers/__init__.py

@@ -0,0 +1,4 @@
+INVALID_DATE_RANGE = "Check-out date must be greater than check-in date."
+INVALID_DATE_CHECK_IN = "Check-in date must be greater than today."
+INVALID_DATE_OVERLAP = "Dates overlap with an existing reservations."
+RESERVATION_EXISTS = "Reservation already exists."

backend/api/resolvers/constants.py

@@ -0,0 +1,124 @@
+from datetime import datetime
+from typing import Any, Dict
+
+import api.utils as utils
+from api.helpers import calculate_total_charge
+from api.models import Reservation, Room
+from api.resolvers.constants import INVALID_DATE_CHECK_IN, INVALID_DATE_OVERLAP
+
+
+async def create_reservation(
+    db, room_id: str, checkin_date: datetime, checkout_date: datetime
+) -> Dict[str, Any]:
+    available = await is_room_available(
+        db, room_id=room_id, checkin_date=checkin_date, checkout_date=checkout_date
+    )
+    if not available["success"]:
+        for message in available["errors"]:
+            utils.log_api_message(__name__, message)
+        return {"success": False, "errors": available["errors"]}
+
+    room_result = await fetch_room(db, room_id)
+    room = room_result["room"][0]
+    daily_rate = room.daily_rate
+    total_charge = calculate_total_charge(daily_rate, checkin_date, checkout_date)
+
+    reservation_insert_query = """
+            INSERT INTO reservations
+                (room_id, checkin_date, checkout_date, total_charge)
+            VALUES ($1, $2, $3, $4)
+            RETURNING id
+        """
+    await db.fetchval(
+        reservation_insert_query, room_id, checkin_date, checkout_date, total_charge
+    )
+    reservations = await fetch_all_rows(db, Reservation)
+    return reservations
+
+
+async def delete_reservation(db, reservation_id: str) -> Dict[str, Any]:
+    reservation = await fetch_reservation(db, reservation_id)
+    if reservation:
+        await db.execute("DELETE FROM reservations WHERE id = $1", reservation_id)
+        return await fetch_all_rows(db, Reservation)
+    else:
+        errors = ["Reservation not found"]
+        return {"success": False, "errors": errors, "reservations": None}
+
+
+async def is_room_available(
+    db, room_id: str, checkin_date: datetime, checkout_date: datetime
+) -> Dict[str, Any]:
+    try:
+        if checkin_date < datetime.now():
+            message: str = INVALID_DATE_CHECK_IN
+            utils.log_api_message(__name__, message)
+            return {"success": False, "errors": [message]}
+
+        query = """
+            SELECT COUNT(*) FROM reservations
+            WHERE room_id = $1
+            AND (
+                (checkin_date >= $2 AND checkin_date < $3)
+                OR (checkout_date > $2 AND checkout_date <= $3)
+                OR (checkin_date <= $2 AND checkout_date >= $3)
+            )
+        """
+        count = await db.fetchval(query, room_id, checkin_date, checkout_date)
+
+        if count == 0:
+            return {"success": True, "errors": None}
+        else:
+            return {"success": False, "errors": [INVALID_DATE_OVERLAP]}
+
+    except Exception as error:
+        utils.log_api_message(__name__, str(error))
+        return {"success": False, "errors": [str(error)]}
+
+
+async def fetch_all_rows(db, entity_type) -> Dict[str, Any]:
+    table_name = entity_type.__name__.lower() + "s"
+    query = f"SELECT * FROM {table_name}"
+    rows = await db.fetch(query)
+    if rows:
+        entities = [entity_type(**dict(row)) for row in rows]
+        return {"success": True, f"{table_name}": entities}
+    else:
+        raise ValueError("No reserved rooms found")
+
+
+async def fetch_by_id(db, entity_type, id) -> Dict[str, Any]:
+    table_name = entity_type.__name__.lower() + "s"
+    query = f"SELECT * FROM {table_name} WHERE id = $1"
+    rows = await db.fetch(query, id)
+    if rows:
+        entities = [entity_type(**dict(row)) for row in rows]
+        return {"success": True, f"{entity_type.__name__.lower()}": entities}
+    else:
+        return {"success": False, f"{entity_type.__name__.lower()}": None}
+
+
+async def fetch_available_rooms(db, checkin_date, checkout_date) -> Dict[str, Any]:
+    rooms = await fetch_all_rows(db, Room)
+    available_rooms = [
+        room
+        for room in rooms
+        if await is_room_available(db, room.id, checkin_date, checkout_date)
+    ]
+    return {"success": True, "rooms": available_rooms}
+
+
+async def fetch_room(db, room_id: str) -> Room:
+    result = await fetch_by_id(db, Room, id=room_id)
+    if result["success"]:
+        return result
+    else:
+        raise ValueError(f"Room with id {room_id} not found")
+
+
+async def fetch_reservation(db, reservation_id: id):
+    result = await fetch_by_id(db, Reservation, id=reservation_id)
+    if result["success"]:
+        return result
+    else:
+        raise ValueError(f"Reservation with id of {reservation_id} not found")

backend/api/resolvers/data.py

@@ -0,0 +1,48 @@
+from typing import Any, Dict, cast
+
+import api.utils as utils
+from api import DbSession
+from api.helpers import check_date_validity
+from api.resolvers.data import create_reservation, delete_reservation
+
+
+async def create_reservation_resolver(obj, info, input: dict) -> Dict[str, Any]:
+    db = await DbSession()
+    try:
+        room_id = cast(str, input.get("room_id"))
+        checkin_date = utils.convert_to_local_date_from_str(
+            str(input.get("checkin_date"))
+        )
+        checkout_date = utils.convert_to_local_date_from_str(
+            str(input.get("checkout_date"))
+        )
+
+        check_date_validity(checkin_date, checkout_date)
+
+        result = await create_reservation(db, room_id, checkin_date, checkout_date)
+        return result
+    except ValueError as error:
+        utils.log_api_message(__name__, str(error))
+        return {"success": False, "errors": [str(error)]}
+    except Exception as e:
+        error = f"Unexpected error: {str(e)}"
+        utils.log_api_message(__name__, f"Unexpected error: {error}")
+        return {"success": False, "errors": [error]}
+    finally:
+        await db.close()
+
+
+async def delete_reservation_resolver(obj, info, reservationId: int) -> Dict[str, Any]:
+    db = await DbSession()
+    try:
+        result = await delete_reservation(db, reservationId)
+        return result
+    except ValueError as error:
+        utils.log_api_message(__name__, str(error))
+        return {"success": False, "errors": [str(error)]}
+    except Exception as e:
+        error = f"Unexpected error: {str(e)}"
+        utils.log_api_message(__name__, f"Unexpected error: {error}")
+        return {"success": False, "errors": [error]}
+    finally:
+        await db.close()

backend/api/resolvers/mutations.py

@@ -0,0 +1,79 @@
+from typing import Any, Dict
+
+import api.utils as utils
+from api import DbSession
+from api.models import Reservation, Room
+from api.resolvers.data import fetch_all_rows, fetch_available_rooms, fetch_reservation
+
+
+async def get_reservation_resolver(obj, info, id) -> Dict[str, Any]:
+    try:
+        db = await DbSession()
+
+        result = await fetch_reservation(db, id)
+        return result
+    except ValueError as error:
+        message = f"Error retrieving reservation: {str(error)}"
+        utils.log_api_message(__name__, message)
+        return {
+            "success": False,
+            "errors": [message],
+        }
+    except Exception as e:
+        error = f"Unexpected error: {str(e)}"
+        utils.log_api_message(__name__, f"Unexpected error: {error}")
+        return {"success": False, "errors": [error]}
+    finally:
+        await db.close()
+
+
+async def get_all_reservations_resolver(obj, info) -> Dict[str, Any]:
+    db = await DbSession()
+    try:
+        return await fetch_all_rows(db, Reservation)
+    except ValueError as error:
+        utils.log_api_message(__name__, str(error))
+        return {"success": False, "errors": [str(error)]}
+    except Exception as e:
+        error = f"Unexpected error: {str(e)}"
+        utils.log_api_message(__name__, f"Unexpected error: {error}")
+        return {"success": False, "errors": [error]}
+    finally:
+        await db.close()
+
+
+async def get_all_rooms_resolver(obj, info) -> Dict[str, Any]:
+    db = await DbSession()
+    try:
+        return await fetch_all_rows(db, Room)
+    except ValueError as error:
+        utils.log_api_message(__name__, str(error))
+        return {"success": False, "errors": [str(error)]}
+    except Exception as e:
+        error = f"Unexpected error: {str(e)}"
+        utils.log_api_message(__name__, f"Unexpected error: {error}")
+        return {"success": False, "errors": [error]}
+    finally:
+        await db.close()
+
+
+async def get_available_rooms_resolver(obj, info, input: dict) -> Dict[str, Any]:
+    db = await DbSession()
+    try:
+        checkin_date = utils.convert_to_local_date_from_str(
+            str(input.get("checkin_date"))
+        )
+        checkout_date = utils.convert_to_local_date_from_str(
+            str(input.get("checkout_date"))
+        )
+
+        return await fetch_available_rooms(db, checkin_date, checkout_date)
+    except ValueError as error:
+        utils.log_api_message(__name__, str(error))
+        return {"success": False, "errors": [str(error)]}
+    except Exception as e:
+        error = f"Unexpected error: {str(e)}"
+        utils.log_api_message(__name__, f"Unexpected error: {error}")
+        return {"success": False, "errors": [error]}
+    finally:
+        await db.close()