748 lines
26 KiB
Python
748 lines
26 KiB
Python
"""
|
|
Demand Response Service - Core Business Logic
|
|
Handles DR invitations, event execution, auto-response, and flexibility calculation
|
|
"""
|
|
|
|
import asyncio
|
|
import json
|
|
import uuid
|
|
from datetime import datetime, timedelta
|
|
from typing import List, Dict, Optional, Any
|
|
import logging
|
|
|
|
from motor.motor_asyncio import AsyncIOMotorDatabase
|
|
import redis.asyncio as redis
|
|
|
|
# Configure logging
|
|
logging.basicConfig(level=logging.INFO)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class DemandResponseService:
|
|
"""Core Demand Response service business logic"""
|
|
|
|
def __init__(self, db: AsyncIOMotorDatabase, redis_client: redis.Redis):
|
|
self.db = db
|
|
self.redis = redis_client
|
|
self.active_events: Dict[str, asyncio.Task] = {} # event_id -> task
|
|
self.device_power_cache: Dict[str, float] = {} # device_id -> power_kw (updated by Redis subscriber)
|
|
|
|
# ===== INVITATION MANAGEMENT =====
|
|
|
|
async def send_invitation(
|
|
self,
|
|
event_time: datetime,
|
|
load_kwh: float,
|
|
load_percentage: float,
|
|
iots: List[str],
|
|
duration_minutes: int = 59
|
|
) -> Dict[str, Any]:
|
|
"""
|
|
Create and send DR invitation
|
|
Returns: {"event_id": str, "response": str, "message": str}
|
|
"""
|
|
logger.info(f"Creating DR invitation for {len(iots)} devices at {event_time}")
|
|
|
|
# Generate unique event ID
|
|
event_id = str(uuid.uuid4())
|
|
|
|
# Check auto-response configuration
|
|
auto_config = await self.get_auto_response_config()
|
|
response = "YES" if auto_config.get("enabled", False) else "WAITING"
|
|
|
|
# Create invitation document
|
|
invitation = {
|
|
"event_id": event_id,
|
|
"created_at": datetime.utcnow(),
|
|
"event_time": event_time,
|
|
"load_kwh": load_kwh,
|
|
"load_percentage": load_percentage,
|
|
"iots": iots,
|
|
"duration_minutes": duration_minutes,
|
|
"response": response,
|
|
"status": "pending"
|
|
}
|
|
|
|
# Store in MongoDB
|
|
await self.db.demand_response_invitations.insert_one(invitation)
|
|
|
|
# Cache in Redis for fast access (24 hour TTL)
|
|
cache_key = f"dr:invitation:{event_id}"
|
|
await self.redis.setex(
|
|
cache_key,
|
|
86400,
|
|
json.dumps(invitation, default=str)
|
|
)
|
|
|
|
# Publish event to Redis pub/sub
|
|
await self.redis.publish("dr_events", json.dumps({
|
|
"event": "invitation_created",
|
|
"event_id": event_id,
|
|
"event_time": event_time.isoformat(),
|
|
"load_kwh": load_kwh,
|
|
"response": response
|
|
}))
|
|
|
|
logger.info(f"Invitation {event_id} created with response: {response}")
|
|
|
|
return {
|
|
"event_id": event_id,
|
|
"response": response,
|
|
"message": "Invitation created successfully"
|
|
}
|
|
|
|
async def answer_invitation(
|
|
self,
|
|
event_id: str,
|
|
iot_id: str,
|
|
response: str,
|
|
committed_reduction_kw: Optional[float] = None
|
|
) -> Dict[str, Any]:
|
|
"""
|
|
Record device response to invitation
|
|
Returns: {"success": bool, "message": str}
|
|
"""
|
|
logger.info(f"Recording response for invitation {event_id}, device {iot_id}: {response}")
|
|
|
|
# Validate invitation exists
|
|
invitation = await self.get_invitation(event_id)
|
|
if not invitation:
|
|
return {"success": False, "message": f"Invitation {event_id} not found"}
|
|
|
|
if iot_id not in invitation["iots"]:
|
|
return {"success": False, "message": f"Device {iot_id} not in invitation"}
|
|
|
|
# Check if already responded
|
|
existing = await self.db.demand_response_responses.find_one({
|
|
"event_id": event_id,
|
|
"device_id": iot_id
|
|
})
|
|
|
|
if existing:
|
|
return {"success": False, "message": f"Device {iot_id} has already responded"}
|
|
|
|
# Store response
|
|
response_doc = {
|
|
"event_id": event_id,
|
|
"device_id": iot_id,
|
|
"response": response,
|
|
"committed_reduction_kw": committed_reduction_kw,
|
|
"responded_at": datetime.utcnow()
|
|
}
|
|
|
|
await self.db.demand_response_responses.insert_one(response_doc)
|
|
|
|
# Check if all devices have responded
|
|
total_devices = len(invitation["iots"])
|
|
total_responses = await self.db.demand_response_responses.count_documents({"event_id": event_id})
|
|
|
|
if total_responses == total_devices:
|
|
# All devices responded - update invitation status
|
|
yes_count = await self.db.demand_response_responses.count_documents({
|
|
"event_id": event_id,
|
|
"response": "YES"
|
|
})
|
|
|
|
all_yes = yes_count == total_devices
|
|
new_response = "YES" if all_yes else "NO"
|
|
new_status = "scheduled" if all_yes else "cancelled"
|
|
|
|
await self.db.demand_response_invitations.update_one(
|
|
{"event_id": event_id},
|
|
{"$set": {"response": new_response, "status": new_status}}
|
|
)
|
|
|
|
logger.info(f"Invitation {event_id} final response: {new_response} (status: {new_status})")
|
|
|
|
# Clear cache
|
|
await self.redis.delete(f"dr:invitation:{event_id}")
|
|
|
|
# Publish event
|
|
await self.redis.publish("dr_events", json.dumps({
|
|
"event": "invitation_answered",
|
|
"event_id": event_id,
|
|
"device_id": iot_id,
|
|
"response": response
|
|
}))
|
|
|
|
return {"success": True, "message": "Response recorded successfully"}
|
|
|
|
async def get_invitation(self, event_id: str) -> Optional[Dict[str, Any]]:
|
|
"""
|
|
Get invitation by event_id (with Redis caching)
|
|
"""
|
|
# Try cache first
|
|
cache_key = f"dr:invitation:{event_id}"
|
|
cached = await self.redis.get(cache_key)
|
|
if cached:
|
|
invitation = json.loads(cached)
|
|
return invitation
|
|
|
|
# Fallback to MongoDB
|
|
invitation = await self.db.demand_response_invitations.find_one({"event_id": event_id})
|
|
if invitation:
|
|
invitation["_id"] = str(invitation["_id"])
|
|
|
|
# Cache for 24 hours
|
|
await self.redis.setex(
|
|
cache_key,
|
|
86400,
|
|
json.dumps(invitation, default=str)
|
|
)
|
|
|
|
return invitation
|
|
|
|
return None
|
|
|
|
async def get_unanswered_invitations(self) -> List[Dict[str, Any]]:
|
|
"""Get all pending invitations awaiting response"""
|
|
cursor = self.db.demand_response_invitations.find({
|
|
"response": "WAITING",
|
|
"status": "pending"
|
|
}).sort("created_at", -1)
|
|
|
|
invitations = []
|
|
async for inv in cursor:
|
|
inv["_id"] = str(inv["_id"])
|
|
invitations.append(inv)
|
|
|
|
return invitations
|
|
|
|
async def get_answered_invitations(self, hours: int = 24, limit: int = 50) -> List[Dict[str, Any]]:
|
|
"""Get recent answered invitations"""
|
|
start_time = datetime.utcnow() - timedelta(hours=hours)
|
|
|
|
cursor = self.db.demand_response_invitations.find({
|
|
"response": {"$ne": "WAITING"},
|
|
"created_at": {"$gte": start_time}
|
|
}).sort("created_at", -1).limit(limit)
|
|
|
|
invitations = []
|
|
async for inv in cursor:
|
|
inv["_id"] = str(inv["_id"])
|
|
invitations.append(inv)
|
|
|
|
return invitations
|
|
|
|
# ===== EVENT EXECUTION =====
|
|
|
|
async def schedule_event(
|
|
self,
|
|
event_time: datetime,
|
|
iots: List[str],
|
|
load_reduction_kw: float,
|
|
duration_minutes: int = 59
|
|
) -> Dict[str, Any]:
|
|
"""
|
|
Schedule a DR event for execution
|
|
Returns: {"event_id": str, "message": str}
|
|
"""
|
|
logger.info(f"Scheduling DR event for {len(iots)} devices at {event_time}")
|
|
|
|
# Create event document
|
|
event_id = str(uuid.uuid4())
|
|
end_time = event_time + timedelta(minutes=duration_minutes)
|
|
|
|
event = {
|
|
"event_id": event_id,
|
|
"start_time": event_time,
|
|
"end_time": end_time,
|
|
"status": "scheduled",
|
|
"participating_devices": iots,
|
|
"target_reduction_kw": load_reduction_kw,
|
|
"actual_reduction_kw": 0.0,
|
|
"power_samples": []
|
|
}
|
|
|
|
await self.db.demand_response_events.insert_one(event)
|
|
|
|
# Publish scheduled event
|
|
await self.redis.publish("dr_events", json.dumps({
|
|
"event": "event_scheduled",
|
|
"event_id": event_id,
|
|
"start_time": event_time.isoformat(),
|
|
"end_time": end_time.isoformat(),
|
|
"devices": iots
|
|
}))
|
|
|
|
logger.info(f"Event {event_id} scheduled successfully")
|
|
|
|
return {
|
|
"event_id": event_id,
|
|
"message": "Event scheduled successfully"
|
|
}
|
|
|
|
async def execute_event(self, event_id: str):
|
|
"""
|
|
Execute a DR event (spawns background task)
|
|
"""
|
|
logger.info(f"Executing DR event {event_id}")
|
|
|
|
# Get event details
|
|
event = await self.db.demand_response_events.find_one({"event_id": event_id})
|
|
if not event:
|
|
logger.error(f"Event {event_id} not found")
|
|
return
|
|
|
|
# Update status to active
|
|
await self.db.demand_response_events.update_one(
|
|
{"event_id": event_id},
|
|
{"$set": {"status": "active", "actual_start_time": datetime.utcnow()}}
|
|
)
|
|
|
|
# Publish event started
|
|
await self.redis.publish("dr_events", json.dumps({
|
|
"event": "event_started",
|
|
"event_id": event_id,
|
|
"devices": event["participating_devices"]
|
|
}))
|
|
|
|
# Create and store async task for this event
|
|
task = asyncio.create_task(self._run_event_loop(event))
|
|
self.active_events[event_id] = task
|
|
|
|
logger.info(f"DR event {event_id} started successfully")
|
|
|
|
async def _run_event_loop(self, event: Dict[str, Any]):
|
|
"""
|
|
CRITICAL: Core event execution loop - runs for duration_minutes
|
|
Samples power every 5 seconds, accumulates reduction, handles cancellation
|
|
"""
|
|
event_id = event["event_id"]
|
|
end_time = event["end_time"]
|
|
devices = event["participating_devices"]
|
|
|
|
total_reduction_kwh = 0.0
|
|
sample_count = 0
|
|
|
|
logger.info(f"Starting event loop for {event_id}, ending at {end_time}")
|
|
|
|
try:
|
|
while datetime.utcnow() < end_time:
|
|
# Get current power for all participating devices from cache
|
|
device_powers = {
|
|
device_id: self.device_power_cache.get(device_id, 0.0)
|
|
for device_id in devices
|
|
}
|
|
|
|
# Calculate reduction for this 5-second interval
|
|
# interval_hours = 5.0 / 3600.0 = 0.00139 hours
|
|
interval_reduction_kwh = sum(device_powers.values()) * (5.0 / 3600.0)
|
|
total_reduction_kwh += interval_reduction_kwh
|
|
|
|
sample_count += 1
|
|
|
|
# Store sample in MongoDB (every sample to maintain accuracy)
|
|
sample = {
|
|
"timestamp": datetime.utcnow(),
|
|
"device_powers": device_powers,
|
|
"interval_reduction_kwh": interval_reduction_kwh
|
|
}
|
|
|
|
await self.db.demand_response_events.update_one(
|
|
{"event_id": event_id},
|
|
{
|
|
"$push": {"power_samples": sample},
|
|
"$set": {"actual_reduction_kw": total_reduction_kwh}
|
|
}
|
|
)
|
|
|
|
# Update Redis cache for fast access to current reduction
|
|
cache_key = f"dr:event:active:{event_id}"
|
|
await self.redis.setex(
|
|
cache_key,
|
|
300, # 5 minute TTL
|
|
json.dumps({
|
|
"event_id": event_id,
|
|
"current_reduction_kwh": total_reduction_kwh,
|
|
"devices": device_powers,
|
|
"last_update": datetime.utcnow().isoformat()
|
|
}, default=str)
|
|
)
|
|
|
|
# Publish progress every 10 samples (50 seconds)
|
|
if sample_count % 10 == 0:
|
|
await self.redis.publish("dr_events", json.dumps({
|
|
"event": "event_progress",
|
|
"event_id": event_id,
|
|
"total_reduction_kwh": round(total_reduction_kwh, 3),
|
|
"device_powers": device_powers,
|
|
"timestamp": datetime.utcnow().isoformat()
|
|
}))
|
|
logger.info(f"Event {event_id} progress: {total_reduction_kwh:.3f} kWh ({sample_count} samples)")
|
|
|
|
# Sleep for 5 seconds
|
|
await asyncio.sleep(5)
|
|
|
|
# Event completed successfully
|
|
logger.info(f"Event {event_id} completed with {total_reduction_kwh:.3f} kWh reduction")
|
|
await self._complete_event(event_id, total_reduction_kwh)
|
|
|
|
except asyncio.CancelledError:
|
|
logger.info(f"Event {event_id} cancelled by user")
|
|
await self._cancel_event(event_id)
|
|
raise
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error in event {event_id}: {e}", exc_info=True)
|
|
await self._cancel_event(event_id)
|
|
|
|
async def _complete_event(self, event_id: str, total_reduction_kwh: float):
|
|
"""Mark event as completed"""
|
|
await self.db.demand_response_events.update_one(
|
|
{"event_id": event_id},
|
|
{
|
|
"$set": {
|
|
"status": "completed",
|
|
"actual_end_time": datetime.utcnow(),
|
|
"actual_reduction_kw": total_reduction_kwh
|
|
}
|
|
}
|
|
)
|
|
|
|
# Remove from active events
|
|
self.active_events.pop(event_id, None)
|
|
|
|
# Clear cache
|
|
await self.redis.delete(f"dr:event:active:{event_id}")
|
|
|
|
# Publish completion
|
|
await self.redis.publish("dr_events", json.dumps({
|
|
"event": "event_completed",
|
|
"event_id": event_id,
|
|
"total_reduction_kwh": total_reduction_kwh
|
|
}))
|
|
|
|
logger.info(f"DR event {event_id} marked as completed")
|
|
|
|
async def _cancel_event(self, event_id: str):
|
|
"""Internal method to cancel an event"""
|
|
await self.db.demand_response_events.update_one(
|
|
{"event_id": event_id},
|
|
{
|
|
"$set": {
|
|
"status": "cancelled",
|
|
"cancelled_at": datetime.utcnow()
|
|
}
|
|
}
|
|
)
|
|
|
|
self.active_events.pop(event_id, None)
|
|
await self.redis.delete(f"dr:event:active:{event_id}")
|
|
|
|
# Publish cancellation
|
|
await self.redis.publish("dr_events", json.dumps({
|
|
"event": "event_cancelled",
|
|
"event_id": event_id,
|
|
"timestamp": datetime.utcnow().isoformat()
|
|
}))
|
|
|
|
async def cancel_event(self, event_id: str):
|
|
"""
|
|
Public method to cancel a running DR event gracefully
|
|
"""
|
|
logger.info(f"Cancelling DR event {event_id}")
|
|
|
|
# Cancel the async task
|
|
task = self.active_events.get(event_id)
|
|
if task and not task.done():
|
|
task.cancel()
|
|
try:
|
|
await task
|
|
except asyncio.CancelledError:
|
|
# Expected - task cancelled successfully
|
|
pass
|
|
except Exception as e:
|
|
logger.error(f"Error cancelling event task {event_id}: {e}")
|
|
|
|
# Update database status (if not already done by _cancel_event)
|
|
event = await self.db.demand_response_events.find_one({"event_id": event_id})
|
|
if event and event.get("status") != "cancelled":
|
|
await self._cancel_event(event_id)
|
|
|
|
logger.info(f"DR event {event_id} cancelled successfully")
|
|
|
|
async def get_active_events(self) -> List[Dict[str, Any]]:
|
|
"""Get currently running events with real-time data"""
|
|
cursor = self.db.demand_response_events.find({
|
|
"status": "active"
|
|
}).sort("start_time", -1)
|
|
|
|
events = []
|
|
async for event in cursor:
|
|
event["_id"] = str(event["_id"])
|
|
|
|
# Add real-time data from cache
|
|
cache_key = f"dr:event:active:{event['event_id']}"
|
|
cached = await self.redis.get(cache_key)
|
|
if cached:
|
|
realtime_data = json.loads(cached)
|
|
event["current_reduction_kwh"] = realtime_data.get("current_reduction_kwh")
|
|
event["current_device_powers"] = realtime_data.get("devices")
|
|
|
|
events.append(event)
|
|
|
|
return events
|
|
|
|
# ===== DEVICE POWER INTEGRATION =====
|
|
|
|
def update_device_power_cache(self, device_id: str, power_kw: float):
|
|
"""
|
|
Update device power cache (called by Redis subscriber)
|
|
This is synchronous because it's just updating a dict
|
|
"""
|
|
self.device_power_cache[device_id] = power_kw
|
|
# No logging here to avoid spam (called every few seconds per device)
|
|
|
|
async def get_device_power(self, device_id: str) -> float:
|
|
"""Get current power for a device from cache"""
|
|
return self.device_power_cache.get(device_id, 0.0)
|
|
|
|
# ===== AUTO-RESPONSE CONFIGURATION =====
|
|
|
|
async def get_auto_response_config(self) -> Dict[str, Any]:
|
|
"""Get auto-response configuration"""
|
|
config = await self.db.auto_response_config.find_one({"config_id": "default"})
|
|
|
|
if not config:
|
|
# Create default config
|
|
default_config = {
|
|
"config_id": "default",
|
|
"enabled": False,
|
|
"max_reduction_percentage": 20.0,
|
|
"response_delay_seconds": 300,
|
|
"min_notice_minutes": 60,
|
|
"updated_at": datetime.utcnow()
|
|
}
|
|
await self.db.auto_response_config.insert_one(default_config)
|
|
return default_config
|
|
|
|
return config
|
|
|
|
async def set_auto_response_config(
|
|
self,
|
|
enabled: bool,
|
|
max_reduction_percentage: float = 20.0,
|
|
response_delay_seconds: int = 300,
|
|
min_notice_minutes: int = 60
|
|
) -> Dict[str, Any]:
|
|
"""Update auto-response configuration"""
|
|
await self.db.auto_response_config.update_one(
|
|
{"config_id": "default"},
|
|
{
|
|
"$set": {
|
|
"enabled": enabled,
|
|
"max_reduction_percentage": max_reduction_percentage,
|
|
"response_delay_seconds": response_delay_seconds,
|
|
"min_notice_minutes": min_notice_minutes,
|
|
"updated_at": datetime.utcnow()
|
|
}
|
|
},
|
|
upsert=True
|
|
)
|
|
|
|
# Clear cache
|
|
await self.redis.delete("dr:config:auto_response")
|
|
|
|
logger.info(f"Auto-response config updated: enabled={enabled}")
|
|
|
|
return await self.get_auto_response_config()
|
|
|
|
async def process_auto_responses(self):
|
|
"""
|
|
Process pending invitations with auto-response (called by background task)
|
|
"""
|
|
# Get auto-response configuration
|
|
auto_config = await self.get_auto_response_config()
|
|
|
|
if not auto_config.get("enabled"):
|
|
return
|
|
|
|
# Find unanswered invitations
|
|
invitations = await self.get_unanswered_invitations()
|
|
|
|
for invitation in invitations:
|
|
event_id = invitation["event_id"]
|
|
event_time = invitation["event_time"]
|
|
|
|
# Parse event_time (might be string from cache)
|
|
if isinstance(event_time, str):
|
|
event_time = datetime.fromisoformat(event_time.replace('Z', '+00:00'))
|
|
|
|
# Check if event is within auto-response criteria
|
|
time_until_event = (event_time - datetime.utcnow()).total_seconds() / 60 # minutes
|
|
min_notice = auto_config.get("min_notice_minutes", 60)
|
|
|
|
if time_until_event >= min_notice:
|
|
logger.info(f"Auto-responding to invitation {event_id}")
|
|
|
|
# Auto-accept for all devices
|
|
for device_id in invitation["iots"]:
|
|
# Check if already responded
|
|
existing = await self.db.demand_response_responses.find_one({
|
|
"event_id": event_id,
|
|
"device_id": device_id
|
|
})
|
|
|
|
if not existing:
|
|
# Get device current power
|
|
device_power = await self.get_device_power(device_id)
|
|
|
|
# Calculate committed reduction based on max_reduction_percentage
|
|
max_reduction_pct = auto_config.get("max_reduction_percentage", 20.0)
|
|
committed_reduction = device_power * (max_reduction_pct / 100) if device_power > 0 else 0.5
|
|
|
|
# Submit auto-response
|
|
try:
|
|
await self.answer_invitation(event_id, device_id, "YES", committed_reduction)
|
|
logger.info(f"Auto-accepted for device {device_id} with {committed_reduction:.2f} kW commitment")
|
|
except Exception as e:
|
|
logger.error(f"Error auto-responding for {device_id}: {e}")
|
|
else:
|
|
logger.debug(f"Invitation {event_id} too soon ({time_until_event:.0f}m < {min_notice}m)")
|
|
|
|
# ===== BACKGROUND TASK SUPPORT =====
|
|
|
|
async def check_scheduled_events(self):
|
|
"""
|
|
Check for events that need to be started (called by scheduler task)
|
|
"""
|
|
now = datetime.utcnow()
|
|
threshold = now + timedelta(minutes=1) # Start events within next minute
|
|
|
|
# Find scheduled events that should start
|
|
cursor = self.db.demand_response_events.find({
|
|
"status": "scheduled",
|
|
"start_time": {"$lte": threshold, "$gte": now}
|
|
})
|
|
|
|
async for event in cursor:
|
|
event_id = event["event_id"]
|
|
|
|
# Check if not already active
|
|
if event_id not in self.active_events:
|
|
logger.info(f"Starting scheduled DR event {event_id}")
|
|
await self.execute_event(event_id)
|
|
|
|
# ===== BASIC FLEXIBILITY CALCULATION =====
|
|
|
|
async def get_current_flexibility(self) -> Dict[str, Any]:
|
|
"""
|
|
Calculate current available flexibility from device power cache
|
|
"""
|
|
total_flexibility_kw = 0.0
|
|
devices = []
|
|
|
|
# Get all devices with instructions
|
|
cursor = self.db.device_instructions.find({})
|
|
current_hour = datetime.utcnow().hour
|
|
|
|
async for device_doc in cursor:
|
|
device_id = device_doc["device_id"]
|
|
instruction = device_doc["instructions"].get(str(current_hour), "off")
|
|
|
|
if instruction != "off":
|
|
# Get device current power from cache
|
|
device_power = self.device_power_cache.get(device_id, 0.0)
|
|
|
|
if instruction == "participation":
|
|
# Full flexibility (100%)
|
|
flexibility = device_power
|
|
elif instruction == "shifting":
|
|
# Partial flexibility (20%)
|
|
flexibility = device_power * 0.20
|
|
else:
|
|
flexibility = 0.0
|
|
|
|
if flexibility > 0:
|
|
devices.append({
|
|
"device_id": device_id,
|
|
"available_kw": round(flexibility, 2),
|
|
"instruction": instruction,
|
|
"current_power": round(device_power, 2)
|
|
})
|
|
total_flexibility_kw += flexibility
|
|
|
|
snapshot = {
|
|
"timestamp": datetime.utcnow(),
|
|
"total_flexibility_kw": round(total_flexibility_kw, 2),
|
|
"devices": devices
|
|
}
|
|
|
|
# Store snapshot
|
|
await self.db.flexibility_snapshots.insert_one(dict(snapshot))
|
|
|
|
# Cache for 5 minutes
|
|
await self.redis.setex(
|
|
"dr:flexibility:current",
|
|
300,
|
|
json.dumps(snapshot, default=str)
|
|
)
|
|
|
|
return snapshot
|
|
|
|
async def get_device_instructions(self, device_id: Optional[str] = None) -> Dict[str, Any]:
|
|
"""Get DR instructions for device(s)"""
|
|
if device_id:
|
|
doc = await self.db.device_instructions.find_one({"device_id": device_id})
|
|
return doc if doc else {"device_id": device_id, "instructions": {}}
|
|
else:
|
|
cursor = self.db.device_instructions.find({})
|
|
instructions = {}
|
|
async for doc in cursor:
|
|
instructions[doc["device_id"]] = doc["instructions"]
|
|
return instructions
|
|
|
|
async def update_device_instructions(self, device_id: str, instructions: Dict[str, str]):
|
|
"""Update hourly instructions for a device"""
|
|
await self.db.device_instructions.update_one(
|
|
{"device_id": device_id},
|
|
{
|
|
"$set": {
|
|
"instructions": instructions,
|
|
"updated_at": datetime.utcnow()
|
|
}
|
|
},
|
|
upsert=True
|
|
)
|
|
|
|
logger.info(f"Updated instructions for device {device_id}")
|
|
|
|
# ===== ANALYTICS =====
|
|
|
|
async def get_performance_analytics(self, days: int = 30) -> Dict[str, Any]:
|
|
"""Get DR performance analytics"""
|
|
start_date = datetime.utcnow() - timedelta(days=days)
|
|
|
|
# Query completed events
|
|
cursor = self.db.demand_response_events.find({
|
|
"status": "completed",
|
|
"start_time": {"$gte": start_date}
|
|
})
|
|
|
|
events = await cursor.to_list(length=None)
|
|
|
|
if not events:
|
|
return {
|
|
"period_days": days,
|
|
"total_events": 0,
|
|
"total_reduction_kwh": 0.0,
|
|
"total_target_kwh": 0.0,
|
|
"average_reduction_kwh": 0.0,
|
|
"achievement_rate": 0.0,
|
|
"average_event_duration_minutes": 59
|
|
}
|
|
|
|
total_reduction = sum(e.get("actual_reduction_kw", 0) for e in events)
|
|
total_target = sum(e.get("target_reduction_kw", 0) for e in events)
|
|
|
|
return {
|
|
"period_days": days,
|
|
"total_events": len(events),
|
|
"total_reduction_kwh": round(total_reduction, 2),
|
|
"total_target_kwh": round(total_target, 2),
|
|
"average_reduction_kwh": round(total_reduction / len(events), 2),
|
|
"achievement_rate": round((total_reduction / total_target * 100) if total_target > 0 else 0, 2),
|
|
"average_event_duration_minutes": 59
|
|
}
|