Model/backend/app/db/functions/property_functions.py

###
# This script contains methods for interacting with the property table in the database
###
import datetime
import pytz
from sqlalchemy.orm import sessionmaker
from backend.app.db.models.portfolio import (
    PropertyModel, PropertyCreationStatus, PortfolioStatus, PropertyTargetsModel, PropertyDetailsEpcModel
)
from backend.app.db.connection import db_engine
from sqlalchemy.orm.exc import NoResultFound


def create_property(portfolio_id: int, address: str, postcode: str) -> (int, bool):
    """
    This function will create a record for the property in the database if it does not exist.
    If it does exist, it will just update the updated_at field.
    :param portfolio_id: The ID of the portfolio the property belongs to
    :param address: The address of the property
    :param postcode: The postcode of the property
    :return: The ID of the property and a boolean indicating whether it was created or not
    """
    Session = sessionmaker(bind=db_engine)
    with Session() as session:

        try:
            # Attempt to fetch the existing property
            existing_property = session.query(PropertyModel).filter_by(
                address=address, postcode=postcode, portfolio_id=portfolio_id
            ).one()

            # Update the 'updated_at' field
            existing_property.updated_at = datetime.datetime.now(pytz.utc)

            # Merge the updated property back into the session
            session.merge(existing_property)
            session.commit()

            return existing_property.id, False

        except NoResultFound:
            # Property doesn't exist, create a new one
            new_property = PropertyModel(
                address=address,
                postcode=postcode,
                portfolio_id=portfolio_id,
                creation_status=PropertyCreationStatus.LOADING,
                status=PortfolioStatus.ASSESSMENT.value,
                has_pre_condition_report=False,
                has_recommendations=False
            )

            # Add the new property to the session
            session.add(new_property)

            session.commit()

            return new_property.id, True


def create_property_targets(property_id: int, portfolio_id: int, epc_target=None, heat_demand_target=None):
    """
    This function will create a record for the property targets in the database if it does not exist.
    :param property_id: The ID of the property the targets belong to
    :param portfolio_id: The ID of the portfolio the property belongs to
    :param epc_target: Goal EPC value for the property
    :param heat_demand_target: Heat demand target for the property in kwh/m^2/year
    :return:
    """
    Session = sessionmaker(bind=db_engine)
    with Session() as session:
        new_target = PropertyTargetsModel(
            property_id=property_id,
            portfolio_id=portfolio_id,
            epc=epc_target,
            heat_demand=heat_demand_target
        )
        session.add(new_target)
        session.commit()

    return True


def update_property_data(property_id: int, portfolio_id: int, property_data: dict):
    Session = sessionmaker(bind=db_engine)
    now = datetime.datetime.now(pytz.utc)
    with Session() as session:
        try:
            # Attempt to fetch the existing property
            existing_property = session.query(PropertyModel).filter_by(
                id=property_id, portfolio_id=portfolio_id
            ).one()

            # Update the fields with the data in property_data
            for key, value in property_data.items():
                setattr(existing_property, key, value)

            existing_property.updated_at = now

            # Merge the updated property back into the session and commit
            session.merge(existing_property)
            session.commit()

        except NoResultFound:
            raise Exception(f"Property with property_id {property_id} and portfolio_id {portfolio_id} not found")

    return True


def create_property_details_epc(property_details_epc: dict):
    """
    This function will create a record for the property details EPC in the database.
    :param property_details_epc: A dictionary containing details about the property EPC.
    :return: True if successful, False otherwise.
    """
    Session = sessionmaker(bind=db_engine)
    with Session() as session:
        new_property_details_epc = PropertyDetailsEpcModel(**property_details_epc)
        session.add(new_property_details_epc)
        session.commit()

    return True