Merge branch 'main' into HAN-98

Author: violetaperezandrade

app/database/database.py

@@ -0,0 +1,81 @@
+from sqlalchemy import create_engine, select, delete, column
+from sqlalchemy.orm import Session
+from dotenv import load_dotenv
+from os import environ
+from typing import Optional, Sequence, Union
+
+from database.models.device_plant import DevicePlant
+from database.models.measurement import Measurement
+
+load_dotenv()
+
+
+class SQLAlchemyClient():
+    db_url = environ.get("DATABASE_URL").replace("postgres://", "postgresql://", 1)
+
+    engine = create_engine(db_url)
+
+    def __init__(self):
+        self.conn = self.engine.connect()
+        self.session = Session(self.engine)
+
+    def shutdown(self):
+        self.conn.close()
+        self.session.close()
+
+    def rollback(self):
+        self.session.rollback()
+
+    def clean_table(self, table: Union[DevicePlant, Measurement]):
+        query = delete(table)  # type: ignore
+        self.session.execute(query)
+        self.session.commit()
+
+    def add(self, record: Union[DevicePlant, Measurement]):
+        self.session.add(record)
+        self.session.commit()
+
+    def find_by_device_id(self, id_device: str) -> DevicePlant:
+        query = select(DevicePlant).where(DevicePlant.id_device == id_device)
+        result = self.session.scalars(query).one()
+        return result
+
+    def find_by_plant_id(self, id_plant: str) -> DevicePlant:
+        query = select(DevicePlant).where(DevicePlant.id_plant == id_plant)
+        result = self.session.scalars(query).one()
+        return result
+
+    def find_all(self, limit: int) -> Sequence[DevicePlant]:
+        query = select(DevicePlant).limit(limit)
+        result = self.session.scalars(query).all()
+        return result
+
+    def update_device_plant(self,
+                            id_device: str,
+                            id_plant: Optional[int],
+                            plant_type: Optional[str],
+                            id_user: Optional[int]):
+
+        query = select(DevicePlant).where(DevicePlant.id_device == id_device)
+
+        device_plant = self.session.scalars(query).one()
+        if id_plant:
+            device_plant.id_plant = id_plant
+        if plant_type:
+            device_plant.plant_type = plant_type
+        if id_user:
+            device_plant.id_user = id_user
+        self.session.commit()
+
+    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:
+        query = delete(DevicePlant).where(column(field) == value)
+        result = self.session.execute(query)
+        self.session.commit()
+        return result.rowcount

app/resources/__init__.py

@@ -1,6 +1,10 @@
+from typing import Literal, Optional
 import pandas as pd
 from datetime import datetime
 
+
+from schemas.measurement import DeviatedParametersSchema, Measurement
+
 file_path = 'resources/plants_dataset.csv'
 df = pd.read_csv(file_path)
 DELTA = 5
@@ -10,11 +14,24 @@ def is_in_range(value, min, max):
     return min <= value <= max
 
 
-def check_t_rule(register, night_value, day_value):
+def is_deviated(value, min, max) -> Optional[Literal["lower", "higher"]]:
+    if value < min:
+        return "lower"
+
+    if value > max:
+        return "higher"
+
+    return None
+
+
+def check_t_rule(
+        register,
+        night_value,
+        day_value) -> Optional[Literal["lower", "higher"]]:
     if is_daytime():
-        return is_in_range(register, day_value - DELTA, day_value + DELTA)
+        return is_deviated(register, day_value - DELTA, day_value + DELTA)
     else:
-        return is_in_range(register, night_value - DELTA, night_value + DELTA)
+        return is_deviated(register, night_value - DELTA, night_value + DELTA)
 
 
 TEMP_RULES_MAP = {
@@ -24,22 +41,22 @@ def check_t_rule(register, night_value, day_value):
 }
 
 HUMIDITY_RULES_MAP = {
-    1: (is_in_range, (50, 100)),
-    2: (is_in_range, (25, 50)),
-    3: (is_in_range, (5, 25)),
+    1: (is_deviated, (50, 100)),
+    2: (is_deviated, (25, 50)),
+    3: (is_deviated, (5, 25)),
 }
 
 LIGHT_RULES_MAP = {
-    1: (is_in_range, (350, 500)),
-    2: (is_in_range, (200, 350)),
-    3: (is_in_range, (75, 200)),
-    4: (is_in_range, (25, 75)),
+    1: (is_deviated, (350, 500)),
+    2: (is_deviated, (200, 350)),
+    3: (is_deviated, (75, 200)),
+    4: (is_deviated, (25, 75)),
 }
 
 WATERING_RULES_MAP = {
-    1: (is_in_range, (70, 100)),
-    2: (is_in_range, (40, 70)),
-    3: (is_in_range, (10, 40)),
+    1: (is_deviated, (70, 100)),
+    2: (is_deviated, (40, 70)),
+    3: (is_deviated, (10, 40)),
 }
 
 
@@ -48,52 +65,47 @@ def parse_values(string):
     return [int(value) for value in values]
 
 
-def apply_rules(register, plant_name):
+def eval_deviation(
+        values: list[int],
+        apply_rule_fn) -> Optional[Literal["lower", "higher"]]:
+
+    results = list(map(lambda v: apply_rule_fn(v), values))
+    return None if any(map(lambda v: v is None, results)) else results[0]
+
+
+def apply_rules(
+        register: Measurement,
+        plant_name: str) -> DeviatedParametersSchema:
     plant_data = df[df['Botanical_Name'] == plant_name]
     h_value = plant_data['H'].values[0]
     l_value = plant_data['L'].values[0]
     t_value = plant_data['T'].values[0]
     w_value = plant_data['W'].values[0]
 
-    parameters = []
-
     t_values = parse_values(t_value)
     h_values = parse_values(h_value)
     l_values = parse_values(l_value)
     w_values = parse_values(w_value)
 
-    is_temperature_deviated = all(
-        not apply_temperature_rule(t_value, register.temperature)
-        for t_value in t_values
-    )
-    if is_temperature_deviated:
-        parameters.append('temperature')
-
-    is_watering_deviated = all(
-        not apply_watering_rule(w_value, register.watering)
-        for w_value in w_values
-    )
-    if is_watering_deviated:
-        parameters.append('watering')
-
-    is_light_deviated = all(
-        not apply_light_rule(l_value, register.light)
-        for l_value in l_values
-    )
-    if is_light_deviated:
-        parameters.append('light')
-
-    is_humidity_deviated = all(
-        not apply_humidity_rule(h_value, register.humidity)
-        for h_value in h_values
+    return DeviatedParametersSchema(
+        temperature=eval_deviation(
+            t_values,
+            lambda x: apply_temperature_rule(x, register.temperature)),
+        humidity=eval_deviation(
+            h_values,
+            lambda x: apply_humidity_rule(x, register.humidity)),
+        light=eval_deviation(
+            l_values,
+            lambda x: apply_light_rule(x, register.light)),
+        watering=eval_deviation(
+            w_values,
+            lambda x: apply_watering_rule(x, register.watering)),
     )
-    if is_humidity_deviated:
-        parameters.append('humidity')
-
-    return parameters
 
 
-def apply_temperature_rule(rule, register):
+def apply_temperature_rule(
+        rule,
+        register) -> Optional[Literal["lower", "higher"]]:
     rule_function, rule_values = TEMP_RULES_MAP.get(rule, None)
     return rule_function(register, *rule_values)
 

app/resources/parser.py

@@ -1,26 +1,39 @@
-from pydantic import BaseModel
-from typing import Optional
+from pydantic import BaseModel, Field
+from typing import Optional, Literal
 
 
-class MeasurementSavedSchema(BaseModel):
-    id: int
-    id_plant: int
-    plant_type: str
-    time_stamp: str
+class DeviatedParametersSchema(BaseModel):
+    temperature: Optional[Literal['lower', "higher"]] = Field(default=None)
+    humidity: Optional[Literal['lower', "higher"]] = Field(default=None)
+    light: Optional[Literal['lower', "higher"]] = Field(default=None)
+    watering: Optional[Literal['lower', "higher"]] = Field(default=None)
+
+    def hasDeviations(self) -> bool:
+        return (self.temperature is not None or
+                self.humidity is not None or
+                self.light is not None or
+                self.watering is not None)
+
+
+class Measurement(BaseModel):
     temperature: Optional[int]
     humidity: Optional[int]
     light: Optional[int]
     watering: Optional[int]
 
 
-class MeasurementReadingSchema(BaseModel):
+class MeasurementSavedSchema(Measurement):
+    id: int
+    id_plant: int
+    plant_type: str
+    time_stamp: str
+    deviations: Optional[DeviatedParametersSchema] = Field(None)
+
+
+class MeasurementReadingSchema(Measurement):
     """
         Schema used to parse the data from measurements obtained via RabbitMQ.
     """
-    temperature: Optional[int]
-    humidity: Optional[int]
-    light: Optional[int]
-    watering: Optional[int]
     id_device: str
     time_stamp: str
     device_token: Optional[str]

app/schemas/measurement.py

@@ -2,6 +2,8 @@
 from fastapi.responses import JSONResponse
 from repository.measurements import MeasurementsRepository
 from exceptions.MeasurementsException import PlantNotFound
+from schemas.measurement import MeasurementSavedSchema
+from resources.parser import apply_rules
 
 
 class MeasurementsService:
@@ -13,6 +15,12 @@ def get_plant_last_measurement(self, id_plant):
             id_plant)
         if not last_measurement:
             return JSONResponse(status_code=status.HTTP_204_NO_CONTENT, content={})
+        last_measurement = MeasurementSavedSchema.model_validate(
+            last_measurement.__dict__)
+        last_measurement.deviations = apply_rules(
+            last_measurement,
+            last_measurement.plant_type
+        )
         return last_measurement
 
     def create_device_plant_relation(self, plant, device_plant):

app/service/measurements.py

@@ -19,7 +19,6 @@
 from os import environ
 from firebase_admin import messaging
 
-
 Base = declarative_base(
     metadata=MetaData(schema=environ.get("POSTGRES_SCHEMA", "measurements_service"))
 )
@@ -84,7 +83,7 @@ def send_notification(self, id_user, measurement, error, details):
 
     def apply_rules(self, measurement,  device_plant):
         deviated_parameters = apply_rules(measurement, device_plant.plant_type)
-        if len(deviated_parameters) > 0:
+        if deviated_parameters.hasDeviations():
             raise DeviatedParametersError(deviated_parameters)
 
     def save_measurement(self, measurement_from_rabbit, device_plant):