mirror of
https://github.com/Hestia-Homes/Model.git
synced 2026-06-08 11:17:27 +00:00
408 lines
15 KiB
Python
408 lines
15 KiB
Python
from sqlalchemy import insert, delete, text
|
|
from sqlalchemy.orm import Session
|
|
from sqlalchemy.exc import SQLAlchemyError
|
|
from backend.app.db.models.recommendations import (
|
|
Plan, Recommendation, RecommendationMaterials, PlanRecommendations, Scenario
|
|
)
|
|
from backend.app.db.models.portfolio import (
|
|
PropertyModel, PropertyTargetsModel, PropertyDetailsEpcModel
|
|
)
|
|
from backend.app.db.models.funding import FundingPackageMeasures, FundingPackage
|
|
from backend.app.db.models.inspections import InspectionModel
|
|
|
|
|
|
def prepare_plan_data(
|
|
p, body, scenario_id, eco_packages, valuations, new_sap_points, new_epc, default_recommendations
|
|
):
|
|
"""
|
|
Utility function to prepare the data that goes into the production of a plan. Is a fairly rough and unstructured
|
|
function that will need improving in the future
|
|
:param p: Instantiated property
|
|
:param body: request body, PlanTriggerRequest
|
|
:param scenario_id: unique identifier for the scenario
|
|
:param eco_packages: Pre-constructed eco packages for a property
|
|
:param valuations: valuation improvement data
|
|
:param new_sap_points: sap points, post default recommendations
|
|
:param new_epc: new epc rating, post default recommendations
|
|
:param default_recommendations: list of default recommendations for a property
|
|
:return:
|
|
"""
|
|
# Plan carbon savings
|
|
co2_savings = sum([r["co2_equivalent_savings"] for r in default_recommendations])
|
|
post_co2_emissions = p.data["co2-emissions-current"] - co2_savings
|
|
|
|
# Plan bill savings
|
|
energy_bill_savings = sum([r["energy_cost_savings"] for r in default_recommendations])
|
|
post_energy_bill = sum(p.current_energy_bill.values()) - energy_bill_savings
|
|
|
|
# energy consumption
|
|
energy_consumption_savings = sum([r["kwh_savings"] for r in default_recommendations])
|
|
post_energy_consumption = p.current_energy_consumption - energy_consumption_savings
|
|
|
|
valuation_post_retrofit, valuation_increase = None, None
|
|
if valuations["current_value"]:
|
|
valuation_increase = valuations["average_increase"]
|
|
valuation_post_retrofit = valuations["average_increased_value"]
|
|
|
|
return {
|
|
"portfolio_id": body.portfolio_id,
|
|
"property_id": p.id,
|
|
"scenario_id": scenario_id,
|
|
"is_default": True if p.is_new else False,
|
|
"name": body.scenario_name,
|
|
"valuation_increase_lower_bound": (
|
|
valuations["lower_bound_increased_value"] - valuations["current_value"]
|
|
),
|
|
"valuation_increase_upper_bound": (
|
|
valuations["upper_bound_increased_value"] - valuations["current_value"]
|
|
),
|
|
"valuation_increase_average": (
|
|
valuations["average_increased_value"] - valuations["current_value"]
|
|
),
|
|
"post_sap_points": float(new_sap_points),
|
|
"post_epc_rating": new_epc,
|
|
"post_co2_emissions": float(post_co2_emissions),
|
|
"co2_savings": float(co2_savings),
|
|
"post_energy_bill": float(post_energy_bill),
|
|
"energy_bill_savings": float(energy_bill_savings),
|
|
"post_energy_consumption": float(post_energy_consumption),
|
|
"energy_consumption_savings": float(energy_consumption_savings),
|
|
"valuation_post_retrofit": valuation_post_retrofit,
|
|
"valuation_increase": valuation_increase,
|
|
"plan_type": eco_packages.get(p.id, (None, None, None))[2]
|
|
}
|
|
|
|
|
|
def create_plan(session: Session, plan):
|
|
"""
|
|
This function will create a record for the plan in the database if it does not exist.
|
|
:param session: The database session
|
|
:param plan: dictionary of data representing a plan to be created
|
|
"""
|
|
try:
|
|
new_plan = Plan(**plan)
|
|
session.add(new_plan)
|
|
session.flush()
|
|
session.commit()
|
|
return new_plan.id
|
|
except SQLAlchemyError as e:
|
|
session.rollback()
|
|
raise e
|
|
|
|
|
|
def create_scenario(session: Session, scenario):
|
|
"""
|
|
This function will create a record for the scenario in the database if it does not exist.
|
|
:param session: The database session
|
|
:param scenario: dictionary of data representing a scenario to be created
|
|
"""
|
|
try:
|
|
|
|
# Before creating a new scenario, we check if there is a scenario for this portfolio id already
|
|
# If there is, it means that any new scnario created will NOT be the default scenario
|
|
existing_scenario = session.query(Scenario).filter_by(portfolio_id=scenario["portfolio_id"]).first()
|
|
scenario["is_default"] = True if not existing_scenario else False
|
|
|
|
new_scenario = Scenario(**scenario)
|
|
session.add(new_scenario)
|
|
session.flush()
|
|
session.commit()
|
|
return new_scenario
|
|
except SQLAlchemyError as e:
|
|
session.rollback()
|
|
raise e
|
|
|
|
|
|
def create_recommendation(session: Session, recommendation):
|
|
"""
|
|
This function will create a record for the recommendation in the database if it does not exist.
|
|
:param session: The database session
|
|
:param recommendation: dictionary of data representing a recommendation to be created
|
|
"""
|
|
try:
|
|
new_recommendation = Recommendation(**recommendation)
|
|
session.add(new_recommendation)
|
|
session.flush()
|
|
session.commit()
|
|
return new_recommendation.id
|
|
except SQLAlchemyError as e:
|
|
session.rollback()
|
|
raise e
|
|
|
|
|
|
def create_recommendation_material(session: Session, recommendation_id, material_id, depth):
|
|
"""
|
|
This function will create a record for the recommendation_material in the database if it does not exist.
|
|
:param session: The databse session
|
|
:param recommendation_id: ID of the recommendation
|
|
:param material_id: ID of the material
|
|
:param depth: depth of the material, may be null if a material where depth is not applicable
|
|
"""
|
|
|
|
new_recommendation_material = RecommendationMaterials(
|
|
recommendation_id=recommendation_id,
|
|
material_id=material_id,
|
|
depth=depth
|
|
)
|
|
session.add(new_recommendation_material)
|
|
session.flush()
|
|
|
|
return new_recommendation_material.id
|
|
|
|
|
|
def create_plan_recommendations(session: Session, plan_id, recommendation_ids):
|
|
"""
|
|
This function will create records for the plan_recommendation in the database.
|
|
:param session: The database session
|
|
:param plan_id: ID of the plan
|
|
:param recommendation_ids: list of recommendation IDs
|
|
"""
|
|
|
|
# Prepare a list of dictionaries for bulk insert
|
|
data = [{"plan_id": plan_id, "recommendation_id": rid} for rid in recommendation_ids]
|
|
|
|
# Bulk insert using SQLAlchemy's core API
|
|
session.execute(insert(PlanRecommendations).values(data))
|
|
|
|
|
|
def upload_recommendations(session: Session, recommendations_to_upload, property_id, new_plan_id):
|
|
try:
|
|
# Prepare data for bulk insert for Recommendation
|
|
recommendations_data = [
|
|
{
|
|
"property_id": property_id,
|
|
"type": rec["type"],
|
|
"measure_type": rec["measure_type"],
|
|
"description": rec["description"],
|
|
"estimated_cost": float(rec["total"]),
|
|
"default": rec["default"],
|
|
"starting_u_value": float(rec.get("starting_u_value")) if rec.get("starting_u_value") else None,
|
|
"new_u_value": float(rec.get("new_u_value")) if rec.get("new_u_value") else None,
|
|
"sap_points": float(rec["sap_points"]),
|
|
"energy_savings": float(rec["heat_demand"]),
|
|
"kwh_savings": float(rec["kwh_savings"]),
|
|
"co2_equivalent_savings": float(rec["co2_equivalent_savings"]),
|
|
"total_work_hours": float(rec["labour_hours"]),
|
|
"energy_cost_savings": float(rec["energy_cost_savings"]),
|
|
"labour_days": float(rec["labour_days"]),
|
|
"already_installed": rec["already_installed"],
|
|
"heat_demand": float(rec["heat_demand"])
|
|
}
|
|
for rec in recommendations_to_upload
|
|
]
|
|
|
|
# Insert the recommendations, get back the IDs
|
|
stmt = insert(Recommendation).returning(Recommendation.id).values(recommendations_data)
|
|
result = session.execute(stmt)
|
|
uploaded_recommendation_ids = [row[0] for row in result]
|
|
|
|
# Prepare data for bulk insert for RecommendationMaterials
|
|
recommendation_materials_data = [
|
|
{
|
|
"recommendation_id": recommendation_id,
|
|
"material_id": part["id"],
|
|
"depth": int(part["depth"]) if part["depth"] else None,
|
|
"quantity": float(part["quantity"]) if part.get("quantity") else None,
|
|
"quantity_unit": part.get("quantity_unit", None),
|
|
"estimated_cost": float(part.get("total", part.get("total_cost"))),
|
|
}
|
|
for rec, recommendation_id in zip(recommendations_to_upload, uploaded_recommendation_ids)
|
|
for part in rec["parts"]
|
|
]
|
|
|
|
session.bulk_insert_mappings(RecommendationMaterials, recommendation_materials_data)
|
|
|
|
# flush the changes to get the newly created IDs
|
|
session.flush()
|
|
|
|
create_plan_recommendations(
|
|
session, plan_id=new_plan_id, recommendation_ids=uploaded_recommendation_ids
|
|
)
|
|
|
|
# Commit the transaction
|
|
session.commit()
|
|
|
|
return True
|
|
|
|
except SQLAlchemyError as e:
|
|
# Rollback the transaction in case of an error
|
|
session.rollback()
|
|
print(f"An error occurred: {e}")
|
|
return False
|
|
|
|
|
|
def chunked(iterable, size=100):
|
|
for i in range(0, len(iterable), size):
|
|
yield iterable[i:i + size]
|
|
|
|
|
|
def fast_delete_recommendations(session, chunk):
|
|
placeholders = ",".join(["(:p{})".format(i) for i in range(len(chunk))])
|
|
params = {f"p{i}": chunk[i] for i in range(len(chunk))}
|
|
|
|
sql = text(f"""
|
|
WITH ids(property_id) AS (
|
|
VALUES {placeholders}
|
|
)
|
|
DELETE FROM recommendation r
|
|
USING ids
|
|
WHERE r.property_id = ids.property_id;
|
|
""")
|
|
|
|
session.execute(sql, params, execution_options={"synchronize_session": False})
|
|
|
|
|
|
def clear_portfolio(session: Session, portfolio_id: int, batch_size=100):
|
|
def print_progress(prefix, i, total):
|
|
print(f"{prefix} ({i}/{total})")
|
|
|
|
# --------------------------
|
|
# Collect IDs up-front
|
|
# --------------------------
|
|
property_ids = [
|
|
p.id for p in session.query(PropertyModel.id)
|
|
.filter(PropertyModel.portfolio_id == portfolio_id)
|
|
]
|
|
|
|
recommendation_ids = [
|
|
r.id for r in session.query(Recommendation.id)
|
|
.filter(Recommendation.property_id.in_(property_ids))
|
|
]
|
|
|
|
plan_ids = [
|
|
p.id for p in session.query(Plan.id)
|
|
.filter(Plan.portfolio_id == portfolio_id)
|
|
]
|
|
|
|
funding_package_ids = [
|
|
fp.id for fp in session.query(FundingPackage.id)
|
|
.filter(FundingPackage.plan_id.in_(plan_ids))
|
|
]
|
|
|
|
# ========== BATCH HELPERS ==========
|
|
def chunked(lst, n):
|
|
for i in range(0, len(lst), n):
|
|
yield lst[i:i + n]
|
|
|
|
# --------------------------
|
|
# Deleting RecommendationMaterials
|
|
# --------------------------
|
|
rm_chunks = list(chunked(recommendation_ids, batch_size))
|
|
total = len(rm_chunks)
|
|
for i, chunk in enumerate(rm_chunks, start=1):
|
|
print_progress("Deleting RecommendationMaterials", i, total)
|
|
session.execute(
|
|
delete(RecommendationMaterials)
|
|
.where(RecommendationMaterials.recommendation_id.in_(chunk))
|
|
)
|
|
|
|
# --------------------------
|
|
# PlanRecommendations
|
|
# --------------------------
|
|
pr_chunks = list(chunked(plan_ids, batch_size))
|
|
total = len(pr_chunks)
|
|
for i, chunk in enumerate(pr_chunks, start=1):
|
|
print_progress("Deleting PlanRecommendations", i, total)
|
|
session.execute(
|
|
delete(PlanRecommendations)
|
|
.where(PlanRecommendations.plan_id.in_(chunk))
|
|
)
|
|
|
|
# --------------------------
|
|
# FundingPackageMeasures
|
|
# --------------------------
|
|
fpm_chunks = list(chunked(funding_package_ids, batch_size))
|
|
total = len(fpm_chunks)
|
|
for i, chunk in enumerate(fpm_chunks, start=1):
|
|
print_progress("Deleting FundingPackageMeasures", i, total)
|
|
session.execute(
|
|
delete(FundingPackageMeasures)
|
|
.where(FundingPackageMeasures.funding_package_id.in_(chunk))
|
|
)
|
|
|
|
# --------------------------
|
|
# FundingPackages
|
|
# --------------------------
|
|
fp_chunks = list(chunked(plan_ids, batch_size))
|
|
total = len(fp_chunks)
|
|
for i, chunk in enumerate(fp_chunks, start=1):
|
|
print_progress("Deleting FundingPackages", i, total)
|
|
session.execute(
|
|
delete(FundingPackage)
|
|
.where(FundingPackage.plan_id.in_(chunk))
|
|
)
|
|
|
|
# --------------------------
|
|
# Plans
|
|
# --------------------------
|
|
plan_chunks = list(chunked(plan_ids, batch_size))
|
|
total = len(plan_chunks)
|
|
for i, chunk in enumerate(plan_chunks, start=1):
|
|
print_progress("Deleting Plans", i, total)
|
|
session.execute(
|
|
delete(Plan)
|
|
.where(Plan.id.in_(chunk))
|
|
)
|
|
|
|
# --------------------------
|
|
# Scenarios
|
|
# --------------------------
|
|
print("Deleting Scenarios…")
|
|
session.execute(
|
|
delete(Scenario)
|
|
.where(Scenario.portfolio_id == portfolio_id)
|
|
)
|
|
|
|
# --------------------------
|
|
# Recommendations (fast delete)
|
|
# --------------------------
|
|
rec_chunks = list(chunked(property_ids, batch_size))
|
|
total = len(rec_chunks)
|
|
for i, chunk in enumerate(rec_chunks, start=1):
|
|
print_progress("Deleting Recommendations", i, total)
|
|
fast_delete_recommendations(session, chunk)
|
|
|
|
# --------------------------
|
|
# Inspections
|
|
# --------------------------
|
|
insp_chunks = list(chunked(property_ids, batch_size))
|
|
total = len(insp_chunks)
|
|
for i, chunk in enumerate(insp_chunks, start=1):
|
|
print_progress("Deleting Inspections", i, total)
|
|
session.execute(
|
|
delete(InspectionModel)
|
|
.where(InspectionModel.property_id.in_(chunk))
|
|
)
|
|
|
|
# --------------------------
|
|
# PropertyTargetsModel
|
|
# --------------------------
|
|
print("Deleting PropertyTargetsModel…")
|
|
session.execute(
|
|
delete(PropertyTargetsModel)
|
|
.where(PropertyTargetsModel.portfolio_id == portfolio_id)
|
|
)
|
|
|
|
# --------------------------
|
|
# PropertyDetailsEpcModel
|
|
# --------------------------
|
|
print("Deleting PropertyDetailsEpcModel…")
|
|
session.execute(
|
|
delete(PropertyDetailsEpcModel)
|
|
.where(PropertyDetailsEpcModel.portfolio_id == portfolio_id)
|
|
)
|
|
|
|
# --------------------------
|
|
# Properties
|
|
# --------------------------
|
|
prop_chunks = list(chunked(property_ids, batch_size))
|
|
total = len(prop_chunks)
|
|
for i, chunk in enumerate(prop_chunks, start=1):
|
|
print_progress("Deleting Properties", i, total)
|
|
session.execute(
|
|
delete(PropertyModel)
|
|
.where(PropertyModel.id.in_(chunk))
|
|
)
|
|
|
|
session.commit()
|
|
print("Portfolio cleared.")
|