Merge branch 'HAN-50' into HAN-55

Author: fjpacheco

.env.dist

@@ -13,4 +13,4 @@ DATABASE_URL=
 
 # RabbitMQ
 CLOUDAMQP_URL=
-QUEUE_NAME=
+QUEUE_NAME=

app/.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "python.analysis.autoImportCompletions": true,
+    "python.analysis.typeCheckingMode": "basic"
+}

app/controller/device_plant_controller.py

@@ -2,93 +2,175 @@
 from fastapi import Response, Request, status, HTTPException
 from database.models.device_plant import DevicePlant
 from schemas.device_plant import (
+    DevicePlantCreateSchema,
     DevicePlantPartialUpdateSchema,
-    DevicePlantSchema,
     DevicePlantUpdateSchema,
 )
 import logging
-from psycopg2.errors import UniqueViolation
 from sqlalchemy.exc import PendingRollbackError, IntegrityError, NoResultFound
 from fastapi.responses import JSONResponse
+from service.plant_service import PlantService
 
 logger = logging.getLogger("app")
 logger.setLevel("DEBUG")
 
 
-def withSQLExceptionsHandle(func):
-    def handleSQLException(*args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except IntegrityError as err:
-            if isinstance(err.orig, UniqueViolation):
-                parsed_error = err.orig.pgerror.split("\n")
-                raise HTTPException(
-                    status_code=status.HTTP_400_BAD_REQUEST,
-                    detail={"error": parsed_error[0], "detail": parsed_error[1]},
-                )
-
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=format(err)
-            )
+def handle_common_errors(err):
 
-        except PendingRollbackError as err:
-            logger.warning(format(err))
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=format(err)
-            )
+    if isinstance(err, IntegrityError):
+        parsed_error = err.orig.pgerror.split("\n")[1]
+        return JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content=parsed_error,
+        )
 
-        except NoResultFound as err:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST, detail=format(err)
-            )
+    if isinstance(err, PendingRollbackError):
+        logger.warning(format(err))
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=format(err)
+        )
+
+    if isinstance(err, NoResultFound):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=format(err)
+        )
+
+    logger.error(format(err))
+    raise HTTPException(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=format(err)
+    )
+
+
+def withSQLExceptionsHandle(async_mode: bool):
+
+    def decorator(func):
+        async def handleAsyncSQLException(*args, **kwargs):
+            try:
+                return await func(*args, **kwargs)
+            except Exception as err:
+                return handle_common_errors(err)
+
+        def handleSyncSQLException(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except Exception as err:
+                return handle_common_errors(err)
 
-    return handleSQLException
+        return (
+            handleAsyncSQLException if async_mode else handleSyncSQLException
+        )
+
+    return decorator
 
 
-@withSQLExceptionsHandle
-def create_device_plant_relation(req: Request, device_plant: DevicePlantSchema):
+@withSQLExceptionsHandle(async_mode=True)
+async def create_device_plant_relation(
+    req: Request, device_plant: DevicePlantCreateSchema
+):
     try:
-        req.app.database.add(DevicePlant.from_pydantic(device_plant))
-        return req.app.database.find_by_device_id(device_plant.id_device)
+        plant = await PlantService.get_plant(device_plant.id_plant)
+        if not plant:
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content={
+                    "plant_id": (
+                        "Could not found any plant "
+                        f"with id {device_plant.id_plant}"
+                    )
+                },
+            )
+
+        plant_type = await PlantService.get_plant_type(plant.scientific_name)
+        if not plant_type:
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content={
+                    "scientific_name": (
+                        "Could not found any plant type "
+                        f"with scientific name {plant.scientific_name}"
+                    )
+                },
+            )
+
+        device_plant = DevicePlant(
+            id_device=device_plant.id_device,
+            id_plant=device_plant.id_plant,
+            plant_type=plant_type.id,
+            id_user=plant.id_user,
+        )  # type: ignore
+        req.app.database.add(device_plant)
+        return device_plant
+
     except Exception as err:
         req.app.database.rollback()
         raise err
 
 
-@withSQLExceptionsHandle
-def update_device_plant(
+@withSQLExceptionsHandle(async_mode=True)
+async def update_device_plant(
     req: Request,
     id_device: str,
     device_plant_update_set: Union[
         DevicePlantUpdateSchema, DevicePlantPartialUpdateSchema
     ],
 ):
     try:
+        if not device_plant_update_set.id_plant:
+            return req.app.database.find_by_device_id(id_device)
+
+        plant = await PlantService.get_plant(device_plant_update_set.id_plant)
+        if not plant:
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content={
+                    "plant_id": (
+                        "Could not found any plant with "
+                        f"id {device_plant_update_set.id_plant}"
+                    )
+                },
+            )
+
+        plant_type = await PlantService.get_plant_type(plant.scientific_name)
+        if not plant_type:
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content={
+                    "scientific_name": (
+                        "Could not found any plant type "
+                        f"with scientific name {plant.scientific_name}"
+                    )
+                },
+            )
+
         req.app.database.update_device_plant(
             id_device,
-            device_plant_update_set.id_plant,
-            device_plant_update_set.plant_type,
-            device_plant_update_set.id_user,
+            plant.id,
+            plant_type.id,
+            plant.id_user,
         )
         return req.app.database.find_by_device_id(id_device)
     except Exception as err:
         req.app.database.rollback()
         raise err
 
 
-@withSQLExceptionsHandle
-def get_device_plant_relation(req: Request, id_plant: str):
+@withSQLExceptionsHandle(async_mode=False)
+def get_device_plant_relation(req: Request, id_plant: int):
     return req.app.database.find_by_plant_id(id_plant)
 
 
-@withSQLExceptionsHandle
+@withSQLExceptionsHandle(async_mode=False)
 def get_all_device_plant_relations(req: Request, limit: int):
     return req.app.database.find_all(limit)
 
 
-@withSQLExceptionsHandle
+@withSQLExceptionsHandle(async_mode=False)
 def delete_device_plant_relation(
-    req: Request, response: Response, type_id: Literal["id_device", "id_plant"], id: str
+    req: Request,
+    response: Response,
+    type_id: Literal["id_device", "id_plant"],
+    id: str
 ):
     result_rowcount = 0
     if type_id == "id_device":

app/controller/measurement_controller.py

@@ -1,11 +1,11 @@
-from controller.device_plant_controller import withSQLExceptionsHandle
-from fastapi import Request
-
-
-@withSQLExceptionsHandle
-def last_measurement_made_by_plant(req: Request, id_plant: int):
-    try:
-        return req.app.database.get_last_measurement(id_plant)
-    except Exception as err:
-        req.app.database.rollback()
-        raise err
+from controller.device_plant_controller import withSQLExceptionsHandle
+from fastapi import Request
+
+
+@withSQLExceptionsHandle(async_mode=False)
+def last_measurement_made_by_plant(req: Request, id_plant: int):
+    try:
+        return req.app.database.get_last_measurement(id_plant)
+    except Exception as err:
+        req.app.database.rollback()
+        raise err

app/database/database.py

@@ -2,11 +2,10 @@
 from sqlalchemy.orm import Session
 from dotenv import load_dotenv
 from os import environ
-from typing import Optional, Union
+from typing import Optional, Sequence, Union
 
 from database.models.device_plant import DevicePlant
 from database.models.measurement import Measurement
-from typing import List
 
 load_dotenv()
 
@@ -28,7 +27,7 @@ def rollback(self):
         self.session.rollback()
 
     def clean_table(self, table: Union[DevicePlant, Measurement]):
-        query = delete(table)
+        query = delete(table)  # type: ignore
         self.session.execute(query)
         self.session.commit()
 
@@ -46,9 +45,9 @@ def find_by_plant_id(self, id_plant: str) -> DevicePlant:
         result = self.session.scalars(query).one()
         return result
 
-    def find_all(self, limit: int) -> List[DevicePlant]:
+    def find_all(self, limit: int) -> Sequence[DevicePlant]:
         query = select(DevicePlant).limit(limit)
-        result = self.session.scalars(query)
+        result = self.session.scalars(query).all()
         return result
 
     def update_device_plant(self,
@@ -72,9 +71,7 @@ def get_last_measurement(self, id_plant: int) -> Measurement:
         query = select(Measurement).where(
             Measurement.id_plant == id_plant
         ).order_by(Measurement.id.desc()).limit(1)
-
         result: Measurement = self.session.scalars(query).one()
-
         return result
 
     def delete_by_field(self, field: str, value: str) -> int:

app/database/models/measurement.py

@@ -3,11 +3,11 @@
 from typing import Optional
 from database.models.base import Base
 from os import environ
-
+SCHEMA = environ.get("POSTGRES_SCHEMA", "measurements")
 
 class Measurement(Base):
     __tablename__ = "measurements"
-    __table_args__ = {'schema': environ.get("POSTGRES_SCHEMA", "measurements")}
+    __table_args__ = {'schema': SCHEMA}
 
     id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
     id_plant: Mapped[int] = mapped_column(Integer, unique=True)
@@ -19,10 +19,13 @@ class Measurement(Base):
     watering: Mapped[Optional[int]] = mapped_column(SmallInteger)
 
     __table_args__ = (
-        CheckConstraint('humidity >= 0 AND humidity <= 100', name='check_humidity'),
+        CheckConstraint(
+            'humidity >= 0 AND humidity <= 100',
+            name='check_humidity'
+        ),
         CheckConstraint('humidity >= 0 ', name='check_light'),
         CheckConstraint('humidity >= 0 AND humidity <= 100', name='check_watering'),
-        {'schema': environ.get("POSTGRES_SCHEMA", "measurements")}
+        {'schema': SCHEMA}
     )
 
     def __repr__(self):

app/exceptions/empty_package.py

@@ -1,4 +1,7 @@
-class EmptyPackageError(Exception):
-    def __init__(self, empty_folds: list):
-        self.empty_folds = empty_folds
-        super().__init__(f"Package received with empty folds: {self.empty_folds}.")
+class EmptyPackageError(Exception):
+    def __init__(self, empty_folds: list):
+        self.empty_folds = empty_folds
+        super().__init__((
+            "Package received with empty "
+            f"folds: {self.empty_folds}."
+        ))