Merge pull request #3 from Hanagotchi/HAN-22/postgres-config-and-service

HAN-22: postgres config and service

Author: Agustinefe

.github/docs/pull_request_template.md renamed to .github/pull_request_template.md

@@ -0,0 +1,75 @@
+from sqlalchemy import create_engine, select, delete, engine
+from sqlalchemy.orm import Session
+from dotenv import load_dotenv
+from os import environ
+from typing import Optional, Union
+
+from app.database.models.DevicePlant import DevicePlant
+from app.database.models.Measurement import Measurement
+
+load_dotenv()
+
+
+class SQLAlchemyClient():
+
+    db_url = engine.URL.create(
+        "postgresql",
+        database=environ["POSTGRES_DB"],
+        username=environ["POSTGRES_USER"],
+        password=environ["POSTGRES_PASSWORD"],
+        host=environ["POSTGRES_HOST"],
+        port=environ["POSTGRES_PORT"]
+    )
+
+    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)
+        self.session.execute(query)
+        self.session.commit()
+
+    def add_new(self, record: Union[DevicePlant, Measurement]):
+        self.session.add(record)
+        self.session.commit()
+
+    def find_device_plant(self, id_device: str) -> DevicePlant:
+        query = select(DevicePlant).where(DevicePlant.id_device == id_device)
+        result = self.session.scalars(query).one()
+        return result
+
+    def update_device_plant(self,
+                            id_device: str,
+                            id_plant: Optional[int],
+                            plant_type: Optional[int],
+                            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.id_plant = 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

README.md

@@ -0,0 +1,5 @@
+from sqlalchemy.orm import DeclarativeBase
+
+
+class Base(DeclarativeBase):
+    pass

app/database/database.py

@@ -0,0 +1,32 @@
+from sqlalchemy import Integer, String, SmallInteger
+from sqlalchemy.orm import Mapped, mapped_column
+from app.database.models.Base import Base
+from app.schemas.DevicePlant import DevicePlantSchema
+
+
+class DevicePlant(Base):
+    __tablename__ = "device_plant"
+    __table_args__ = {'schema': 'dev'}
+
+    id_device: Mapped[str] = mapped_column(String(32), primary_key=True)
+    id_plant: Mapped[int] = mapped_column(Integer, unique=True)
+    plant_type: Mapped[int] = mapped_column(SmallInteger)
+    id_user: Mapped[int] = mapped_column(Integer)
+
+    def __repr__(self) -> str:
+        return format(
+            "DevicePlant(id_device={0}, id_plant={1}, plant_type={2}, id_user={3})",
+            self.id_device,
+            self.id_plant,
+            self.plant_type,
+            self.id_user,
+        )
+
+    @classmethod
+    def from_pydantic(cls, pydantic_obj: DevicePlantSchema):
+        return DevicePlant(
+            id_device=pydantic_obj.id_device,
+            id_plant=pydantic_obj.id_plant,
+            plant_type=pydantic_obj.plant_type,
+            id_user=pydantic_obj.id_user,
+        )

app/database/models/Base.py

@@ -0,0 +1,41 @@
+from sqlalchemy import CheckConstraint, Integer, String, SmallInteger
+from sqlalchemy.orm import Mapped, mapped_column
+from typing import Optional
+from app.database.models.Base import Base
+
+
+class Measurement(Base):
+    __tablename__ = "measurements"
+    __table_args__ = {'schema': 'dev'}
+
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    id_plant: Mapped[int] = mapped_column(Integer, unique=True)
+    plant_type: Mapped[int] = mapped_column(SmallInteger)
+    time_stamp: Mapped[str] = mapped_column(String(50))
+    temperature: Mapped[Optional[int]] = mapped_column(SmallInteger)
+    humidity: Mapped[Optional[int]] = mapped_column(SmallInteger)
+    light: Mapped[Optional[int]] = mapped_column(SmallInteger)
+    watering: Mapped[Optional[int]] = mapped_column(SmallInteger)
+
+    __table_args__ = (
+        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': 'dev'}
+    )
+
+    def __repr__(self):
+        return format(
+            ("Measurement(id={0!r}, id_plant={1!r}, "
+             "plant_type={2!r}, time_stamp={3!r}, "
+             "temperature={4!r}, humidity={5!r}, "
+             "light={6!r}, watering={7!r})"),
+            self.id,
+            self.id_plant,
+            self.plant_type,
+            self.time_stamp,
+            self.temperature,
+            self.humidity,
+            self.light,
+            self.watering
+        )

app/database/models/DevicePlant.py

@@ -1,8 +1,44 @@
-from fastapi import FastAPI
+from fastapi import Body, FastAPI, Request
+from app.database.database import SQLAlchemyClient
+from app.database.models.DevicePlant import DevicePlant
+from app.schemas.DevicePlant import DevicePlantSchema
+import logging
 
 app = FastAPI()
+logger = logging.getLogger("measurements")
+logger.setLevel("DEBUG")
+
+
+@app.on_event("startup")
+async def start_up():
+    app.logger = logger
+
+    try:
+        app.database = SQLAlchemyClient()
+        app.logger.info("Postgres connection established")
+    except Exception as e:
+        app.logger.error(e)
+        app.logger.error("Could not connect to Postgres client")
+
+
+@app.on_event("shutdown")
+async def shutdown_db_client():
+    app.database.shutdown()
+    app.logger.info("Postgres shutdown succesfully")
 
 
 @app.get("/")
 async def root():
     return {"message": "Hello World"}
+
+
+# Endpoint only for DB conection testing.
+@app.post("/device-plant")
+async def add_new_device_plant(req: Request,
+                               device_plant: DevicePlantSchema = Body(...)):
+    try:
+        req.app.database.add_new(DevicePlant.from_pydantic(device_plant))
+        return req.app.database.find_device_plant(device_plant.id_device)
+    except Exception as e:
+        req.app.database.rollback()
+        raise e

app/database/models/Measurement.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+
+
+class DevicePlantSchema(BaseModel):
+    id_device: str
+    id_plant: int
+    plant_type: int
+    id_user: int

app/main.py

@@ -5,5 +5,24 @@ services:
     build:
       context: .
     container_name: app
+    env_file:
+      - .env
     ports:
       - "8080:8080"
+    depends_on:
+      - db
+
+  rabbitmq:
+    image: rabbitmq:3.12-management
+    ports:
+      - "5672:5672"
+      - "15672:15672"
+
+  db:
+    image: postgres:latest
+    env_file:
+      - .env
+    ports:
+      - "5432:5432"
+    volumes:
+      - ./sql:/docker-entrypoint-initdb.d

app/schemas/DevicePlant.py

@@ -13,7 +13,7 @@ CREATE TABLE IF NOT EXISTS dev.measurements (
     plant_type SMALLINT,
     time_stamp VARCHAR(50),
     temperature SMALLINT,
-    humidity SMALLINT,
-    light SMALLINT,
-    watering SMALLINT
+    humidity SMALLINT CHECK (humidity >= 0 AND humidity <= 100),
+    light SMALLINT CHECK (light >= 0),
+    watering SMALLINT CHECK (watering >= 0 AND watering <= 100)
 );