kunthawat/ALwrity
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Alwrity monitoring data service

Browse Source
This commit is contained in:
ajaysi
2025-08-28 11:11:55 +05:30
parent be88e931ea
commit f76381030b
14 changed files with 1000 additions and 320 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
backend/api/content_planning/api/router.py
View File

@@ -20,6 +20,9 @@ from .content_strategy.routes import router as content_strategy_router
# Import quality analysis routes # Import quality analysis routes
from ..quality_analysis_routes import router as quality_analysis_router from ..quality_analysis_routes import router as quality_analysis_router
# Import monitoring routes
from ..monitoring_routes import router as monitoring_routes_router
# Create main router # Create main router
router = APIRouter(prefix="/api/content-planning", tags=["content-planning"]) router = APIRouter(prefix="/api/content-planning", tags=["content-planning"])
@@ -41,6 +44,9 @@ router.include_router(content_strategy_router)
# Include quality analysis routes # Include quality analysis routes
router.include_router(quality_analysis_router) router.include_router(quality_analysis_router)
# Include monitoring routes
router.include_router(monitoring_routes_router)
# Add health check endpoint # Add health check endpoint
@router.get("/health") @router.get("/health")
async def content_planning_health_check(): async def content_planning_health_check():

305
backend/api/content_planning/monitoring_routes.py
View File

@@ -1,4 +1,4 @@
from fastapi import APIRouter, HTTPException, Depends, Query from fastapi import APIRouter, HTTPException, Depends, Query, Body
from typing import Dict, Any from typing import Dict, Any
import logging import logging
from datetime import datetime, timedelta from datetime import datetime, timedelta
@@ -8,6 +8,7 @@ import json
from services.monitoring_plan_generator import MonitoringPlanGenerator from services.monitoring_plan_generator import MonitoringPlanGenerator
from services.strategy_service import StrategyService from services.strategy_service import StrategyService
from services.monitoring_data_service import MonitoringDataService
from services.database import get_db from services.database import get_db
from models.monitoring_models import ( from models.monitoring_models import (
StrategyMonitoringPlan, MonitoringTask, TaskExecutionLog, StrategyMonitoringPlan, MonitoringTask, TaskExecutionLog,
@@ -42,11 +43,13 @@ async def generate_monitoring_plan(strategy_id: int):
@router.post("/{strategy_id}/activate-with-monitoring") @router.post("/{strategy_id}/activate-with-monitoring")
async def activate_strategy_with_monitoring( async def activate_strategy_with_monitoring(
strategy_id: int, strategy_id: int,
monitoring_plan: Dict[str, Any] monitoring_plan: Dict[str, Any] = Body(...),
db: Session = Depends(get_db)
): ):
"""Activate strategy with monitoring plan""" """Activate strategy with monitoring plan"""
try: try:
strategy_service = StrategyService() strategy_service = StrategyService()
monitoring_service = MonitoringDataService(db)
# Activate strategy # Activate strategy
activation_success = await strategy_service.activate_strategy(strategy_id) activation_success = await strategy_service.activate_strategy(strategy_id)
@@ -56,10 +59,10 @@ async def activate_strategy_with_monitoring(
detail=f"Failed to activate strategy {strategy_id}" detail=f"Failed to activate strategy {strategy_id}"
) )
# Save monitoring plan # Save monitoring data to database
plan_success = await strategy_service.save_monitoring_plan(strategy_id, monitoring_plan) monitoring_success = await monitoring_service.save_monitoring_data(strategy_id, monitoring_plan)
if not plan_success: if not monitoring_success:
logger.warning(f"Failed to save monitoring plan for strategy {strategy_id}") logger.warning(f"Failed to save monitoring data for strategy {strategy_id}")
logger.info(f"Successfully activated strategy {strategy_id} with monitoring") logger.info(f"Successfully activated strategy {strategy_id} with monitoring")
return { return {
@@ -77,16 +80,16 @@ async def activate_strategy_with_monitoring(
) )
@router.get("/{strategy_id}/monitoring-plan") @router.get("/{strategy_id}/monitoring-plan")
async def get_monitoring_plan(strategy_id: int): async def get_monitoring_plan(strategy_id: int, db: Session = Depends(get_db)):
"""Get monitoring plan for a strategy""" """Get monitoring plan for a strategy"""
try: try:
strategy_service = StrategyService() monitoring_service = MonitoringDataService(db)
monitoring_plan = await strategy_service.get_monitoring_plan(strategy_id) monitoring_data = await monitoring_service.get_monitoring_data(strategy_id)
if monitoring_plan: if monitoring_data:
return { return {
"success": True, "success": True,
"data": monitoring_plan "data": monitoring_data
} }
else: else:
raise HTTPException( raise HTTPException(
@@ -102,6 +105,25 @@ async def get_monitoring_plan(strategy_id: int):
detail=f"Failed to get monitoring plan: {str(e)}" detail=f"Failed to get monitoring plan: {str(e)}"
) )
@router.get("/{strategy_id}/analytics-data")
async def get_analytics_data(strategy_id: int, db: Session = Depends(get_db)):
"""Get analytics data from monitoring data (no external API calls)"""
try:
monitoring_service = MonitoringDataService(db)
analytics_data = await monitoring_service.get_analytics_data(strategy_id)
return {
"success": True,
"data": analytics_data,
"message": "Analytics data retrieved from monitoring database"
}
except Exception as e:
logger.error(f"Error getting analytics data for strategy {strategy_id}: {e}")
raise HTTPException(
status_code=500,
detail=f"Failed to get analytics data: {str(e)}"
)
@router.get("/{strategy_id}/performance-history") @router.get("/{strategy_id}/performance-history")
async def get_strategy_performance_history(strategy_id: int, days: int = 30): async def get_strategy_performance_history(strategy_id: int, days: int = 30):
"""Get performance history for a strategy""" """Get performance history for a strategy"""
@@ -496,194 +518,105 @@ async def get_transparency_data(
StrategyPerformanceMetrics.strategy_id == strategy_id StrategyPerformanceMetrics.strategy_id == strategy_id
).order_by(desc(StrategyPerformanceMetrics.created_at)).first() ).order_by(desc(StrategyPerformanceMetrics.created_at)).first()
# Build transparency data # Build transparency data from actual monitoring tasks
transparency_data = [] transparency_data = []
# Traffic Growth Metric # Group tasks by component for better organization
traffic_growth_data = { tasks_by_component = {}
"metricName": "Traffic Growth",
"currentValue": 15.7, # This would come from actual analytics
"unit": "%",
"dataFreshness": {
"lastUpdated": task_logs[0].execution_date.isoformat() if task_logs else datetime.now().isoformat(),
"updateFrequency": "Every 4 hours",
"dataSource": "Google Analytics + AI Analysis",
"confidence": 92
},
"measurementMethodology": {
"description": "Organic traffic growth compared to previous period",
"calculationMethod": "Percentage change in organic sessions over 30-day rolling period, weighted by content performance and user engagement",
"dataPoints": ["Organic Sessions", "Page Views", "Bounce Rate", "Time on Site", "Content Performance"],
"validationProcess": "Cross-validated with Google Search Console data and AI-powered content performance analysis"
},
"monitoringTasks": [],
"strategyMapping": {
"relatedComponents": ["Strategic Insights", "Content Strategy", "Audience Analysis"],
"impactAreas": ["Brand Awareness", "Lead Generation", "Market Reach"],
"dependencies": ["SEO Optimization", "Content Quality", "User Experience"]
},
"aiInsights": {
"trendAnalysis": "Traffic growth shows strong upward trend with 15.7% increase. Top-performing content categories are educational blog posts and case studies.",
"recommendations": [
"Increase content production in educational blog category by 25%",
"Optimize case study content for better search visibility",
"Implement A/B testing for content headlines",
"Focus on long-form content (2000+ words) which shows 40% higher engagement"
],
"riskFactors": ["Seasonal traffic fluctuations", "Competitor content strategy changes", "Algorithm updates"],
"opportunities": ["Video content expansion", "Guest posting opportunities", "Social media amplification"]
}
}
# Add real monitoring tasks - map based on task content and purpose
for task in monitoring_tasks: for task in monitoring_tasks:
task_title_lower = task.task_title.lower() component = task.component_name or 'General'
task_description_lower = task.task_description.lower() if component not in tasks_by_component:
tasks_by_component[component] = []
tasks_by_component[component].append(task)
# Traffic Growth related tasks # Create transparency data for each component
if any(keyword in task_title_lower or keyword in task_description_lower for component, tasks in tasks_by_component.items():
for keyword in ['traffic', 'organic', 'goal', 'strategic', 'performance', 'prediction']): component_data = {
task_data = { "metricName": component,
"title": task.task_title, "currentValue": len(tasks),
"description": task.task_description, "unit": "tasks",
"assignee": task.assignee, "dataFreshness": {
"frequency": task.frequency, "lastUpdated": task_logs[0].execution_date.isoformat() if task_logs else datetime.now().isoformat(),
"metric": task.metric, "updateFrequency": "Real-time",
"measurementMethod": task.measurement_method, "dataSource": "Monitoring System",
"successCriteria": task.success_criteria, "confidence": 95
"alertThreshold": task.alert_threshold, },
"actionableInsights": getattr(task, 'actionable_insights', None), "measurementMethodology": {
"status": "active", "description": f"AI-powered monitoring for {component} with {len(tasks)} active tasks",
"lastExecuted": task_logs[0].execution_date.isoformat() if task_logs else None "calculationMethod": "Automated monitoring with real-time data collection and analysis",
} "dataPoints": [task.metric for task in tasks if task.metric],
traffic_growth_data["monitoringTasks"].append(task_data) "validationProcess": "Cross-validated with multiple data sources and AI analysis"
},
transparency_data.append(traffic_growth_data) "monitoringTasks": [
{
# Engagement Rate Metric "title": task.task_title,
engagement_data = { "description": task.task_description,
"metricName": "Engagement Rate", "assignee": task.assignee,
"currentValue": 8.3, "frequency": task.frequency,
"unit": "%", "metric": task.metric,
"dataFreshness": { "measurementMethod": task.measurement_method,
"lastUpdated": task_logs[0].execution_date.isoformat() if task_logs else datetime.now().isoformat(), "successCriteria": task.success_criteria,
"updateFrequency": "Every 2 hours", "alertThreshold": task.alert_threshold,
"dataSource": "Social Media Analytics + Website Analytics", "status": task.status,
"confidence": 88 "lastExecuted": task.last_executed.isoformat() if task.last_executed else None
}, }
"measurementMethodology": { for task in tasks
"description": "Average engagement rate across all content and social media",
"calculationMethod": "Weighted average of likes, shares, comments, and time spent across all platforms",
"dataPoints": ["Social Media Engagement", "Website Comments", "Time on Page", "Social Shares", "Email Engagement"],
"validationProcess": "Cross-platform validation using multiple analytics tools and AI sentiment analysis"
},
"monitoringTasks": [],
"strategyMapping": {
"relatedComponents": ["Audience Analysis", "Content Strategy", "Social Media Strategy"],
"impactAreas": ["Brand Engagement", "Community Building", "Customer Loyalty"],
"dependencies": ["Content Quality", "Social Media Presence", "Community Management"]
},
"aiInsights": {
"trendAnalysis": "Engagement rate is stable at 8.3% with peak engagement during lunch hours and early evenings.",
"recommendations": [
"Increase video content production by 50%",
"Optimize posting times for peak engagement hours",
"Implement interactive content elements",
"Focus on community-building content"
], ],
"riskFactors": ["Platform algorithm changes", "Content fatigue", "Competition for attention"], "strategyMapping": {
"opportunities": ["Live streaming opportunities", "User-generated content campaigns", "Influencer collaborations"] "relatedComponents": [component],
} "impactAreas": ["Performance Monitoring", "Strategy Optimization", "Risk Management"],
} "dependencies": ["Data Collection", "AI Analysis", "Alert System"]
},
# Add engagement-related tasks "aiInsights": {
for task in monitoring_tasks: "trendAnalysis": f"Active monitoring for {component} with {len(tasks)} configured tasks",
task_title_lower = task.task_title.lower() "recommendations": [
task_description_lower = task.task_description.lower() "Monitor task execution status regularly",
"Review performance metrics weekly",
if any(keyword in task_title_lower or keyword in task_description_lower "Adjust thresholds based on performance trends"
for keyword in ['engagement', 'social', 'community', 'audience', 'insight', 'competitive']): ],
task_data = { "riskFactors": ["Task execution failures", "Data collection issues", "System downtime"],
"title": task.task_title, "opportunities": ["Automated optimization", "Predictive analytics", "Enhanced monitoring"]
"description": task.task_description,
"assignee": task.assignee,
"frequency": task.frequency,
"metric": task.metric,
"measurementMethod": task.measurement_method,
"successCriteria": task.success_criteria,
"alertThreshold": task.alert_threshold,
"actionableInsights": getattr(task, 'actionable_insights', None),
"status": "active",
"lastExecuted": task_logs[0].execution_date.isoformat() if task_logs else None
} }
engagement_data["monitoringTasks"].append(task_data)
transparency_data.append(engagement_data)
# Conversion Rate Metric
conversion_data = {
"metricName": "Conversion Rate",
"currentValue": 2.1,
"unit": "%",
"dataFreshness": {
"lastUpdated": task_logs[0].execution_date.isoformat() if task_logs else datetime.now().isoformat(),
"updateFrequency": "Every 6 hours",
"dataSource": "Google Analytics + CRM Data",
"confidence": 85
},
"measurementMethodology": {
"description": "Content-driven conversion rate across all touchpoints",
"calculationMethod": "Conversions divided by total visitors, weighted by content attribution and customer journey analysis",
"dataPoints": ["Website Conversions", "Email Signups", "Lead Form Submissions", "Content Downloads", "Sales Attribution"],
"validationProcess": "CRM integration validation and conversion funnel analysis"
},
"monitoringTasks": [],
"strategyMapping": {
"relatedComponents": ["Performance Predictions", "Implementation Roadmap", "Risk Assessment"],
"impactAreas": ["Revenue Generation", "Lead Quality", "Customer Acquisition"],
"dependencies": ["Content Quality", "User Experience", "Lead Nurturing"]
},
"aiInsights": {
"trendAnalysis": "Conversion rate is improving steadily with 2.1% current rate. Top-converting content includes case studies and product demos.",
"recommendations": [
"Increase case study and demo content production",
"Optimize mobile user experience further",
"Implement personalized content recommendations",
"A/B test call-to-action buttons and forms"
],
"riskFactors": ["Market competition", "Economic factors", "Technology changes"],
"opportunities": ["Personalization opportunities", "Automation implementation", "Cross-selling strategies"]
} }
} transparency_data.append(component_data)
# Add conversion-related tasks # If no monitoring tasks found, create a default transparency entry
for task in monitoring_tasks: if not transparency_data:
task_title_lower = task.task_title.lower() transparency_data = [{
task_description_lower = task.task_description.lower() "metricName": "Strategy Monitoring",
"currentValue": 0,
if any(keyword in task_title_lower or keyword in task_description_lower "unit": "tasks",
for keyword in ['conversion', 'funnel', 'implementation', 'resource', 'risk', 'mitigation']): "dataFreshness": {
task_data = { "lastUpdated": datetime.now().isoformat(),
"title": task.task_title, "updateFrequency": "Real-time",
"description": task.task_description, "dataSource": "Monitoring System",
"assignee": task.assignee, "confidence": 0
"frequency": task.frequency, },
"metric": task.metric, "measurementMethodology": {
"measurementMethod": task.measurement_method, "description": "No monitoring tasks configured yet",
"successCriteria": task.success_criteria, "calculationMethod": "Manual setup required",
"alertThreshold": task.alert_threshold, "dataPoints": [],
"actionableInsights": getattr(task, 'actionable_insights', None), "validationProcess": "Not applicable"
"status": "active", },
"lastExecuted": task_logs[0].execution_date.isoformat() if task_logs else None "monitoringTasks": [],
"strategyMapping": {
"relatedComponents": ["Strategy"],
"impactAreas": ["Monitoring"],
"dependencies": ["Setup"]
},
"aiInsights": {
"trendAnalysis": "No monitoring data available",
"recommendations": ["Set up monitoring tasks", "Configure alerts", "Enable data collection"],
"riskFactors": ["No monitoring in place"],
"opportunities": ["Implement comprehensive monitoring"]
} }
conversion_data["monitoringTasks"].append(task_data) }]
transparency_data.append(conversion_data)
# Return the transparency data
return { return {
"success": True, "success": True,
"data": transparency_data, "data": transparency_data,
"message": "Transparency data retrieved successfully" "message": f"Transparency data retrieved successfully for strategy {strategy_id}"
} }
except Exception as e: except Exception as e:

2
backend/services/ai_quality_analysis_service.py
View File

@@ -177,7 +177,7 @@ class AIQualityAnalysisService:
Focus on strategic depth, clarity, and measurability. Focus on strategic depth, clarity, and measurability.
""" """
ai_response = await gemini_structured_json_response( ai_response = gemini_structured_json_response(
prompt=prompt, prompt=prompt,
schema=QUALITY_ANALYSIS_SCHEMA, schema=QUALITY_ANALYSIS_SCHEMA,
temperature=0.3, temperature=0.3,

359
backend/services/monitoring_data_service.py Normal file
View File

@@ -0,0 +1,359 @@
"""
Monitoring Data Service
Handles saving and retrieving monitoring data from database and cache.
"""
import logging
from typing import Dict, Any, List, Optional
from datetime import datetime
from sqlalchemy.orm import Session
from sqlalchemy import and_, desc
from models.monitoring_models import (
StrategyMonitoringPlan, MonitoringTask, TaskExecutionLog,
StrategyPerformanceMetrics, StrategyActivationStatus
)
from models.enhanced_strategy_models import EnhancedContentStrategy
logger = logging.getLogger(__name__)
class MonitoringDataService:
"""Service for managing monitoring data in database and cache."""
def __init__(self, db_session: Session):
self.db = db_session
async def save_monitoring_data(self, strategy_id: int, monitoring_plan: Dict[str, Any]) -> bool:
"""Save monitoring plan and tasks to database."""
try:
logger.info(f"Saving monitoring data for strategy {strategy_id}")
logger.info(f"Monitoring plan received: {monitoring_plan}")
# Save the complete monitoring plan
monitoring_plan_record = StrategyMonitoringPlan(
strategy_id=strategy_id,
plan_data=monitoring_plan
)
self.db.add(monitoring_plan_record)
# Save individual monitoring tasks
monitoring_tasks = monitoring_plan.get('monitoringTasks', [])
logger.info(f"Found {len(monitoring_tasks)} monitoring tasks to save")
for i, task_data in enumerate(monitoring_tasks):
logger.info(f"Saving task {i+1}: {task_data.get('title', 'Unknown')}")
task = MonitoringTask(
strategy_id=strategy_id,
component_name=task_data.get('component', ''),
task_title=task_data.get('title', ''),
task_description=task_data.get('description', ''),
assignee=task_data.get('assignee', 'ALwrity'),
frequency=task_data.get('frequency', 'Monthly'),
metric=task_data.get('metric', ''),
measurement_method=task_data.get('measurementMethod', ''),
success_criteria=task_data.get('successCriteria', ''),
alert_threshold=task_data.get('alertThreshold', ''),
status='active'
)
self.db.add(task)
# Save activation status
activation_status = StrategyActivationStatus(
strategy_id=strategy_id,
user_id=1, # Default user ID
activation_date=datetime.utcnow(),
status='active'
)
self.db.add(activation_status)
# Save initial performance metrics
performance_metrics = StrategyPerformanceMetrics(
strategy_id=strategy_id,
user_id=1, # Default user ID
metric_date=datetime.utcnow(),
data_source='monitoring_plan',
confidence_score=85 # High confidence for monitoring plan data
)
self.db.add(performance_metrics)
self.db.commit()
logger.info(f"Successfully saved monitoring data for strategy {strategy_id}")
return True
except Exception as e:
logger.error(f"Error saving monitoring data for strategy {strategy_id}: {e}")
self.db.rollback()
return False
async def get_monitoring_data(self, strategy_id: int) -> Optional[Dict[str, Any]]:
"""Get monitoring data from database."""
try:
logger.info(f"Retrieving monitoring data for strategy {strategy_id}")
# Get the monitoring plan
monitoring_plan = self.db.query(StrategyMonitoringPlan).filter(
StrategyMonitoringPlan.strategy_id == strategy_id
).order_by(desc(StrategyMonitoringPlan.created_at)).first()
if not monitoring_plan:
logger.warning(f"No monitoring plan found for strategy {strategy_id}")
return None
# Get monitoring tasks
tasks = self.db.query(MonitoringTask).filter(
MonitoringTask.strategy_id == strategy_id
).all()
# Get activation status
activation_status = self.db.query(StrategyActivationStatus).filter(
StrategyActivationStatus.strategy_id == strategy_id
).first()
# Get performance metrics
performance_metrics = self.db.query(StrategyPerformanceMetrics).filter(
StrategyPerformanceMetrics.strategy_id == strategy_id
).order_by(desc(StrategyPerformanceMetrics.metric_date)).first()
# Build comprehensive monitoring data
monitoring_data = {
'strategy_id': strategy_id,
'monitoring_plan': monitoring_plan.plan_data,
'monitoring_tasks': [
{
'id': task.id,
'component': task.component_name,
'title': task.task_title,
'description': task.task_description,
'assignee': task.assignee,
'frequency': task.frequency,
'metric': task.metric,
'measurementMethod': task.measurement_method,
'successCriteria': task.success_criteria,
'alertThreshold': task.alert_threshold,
'status': task.status,
'last_executed': task.last_executed.isoformat() if task.last_executed else None,
'next_execution': task.next_execution.isoformat() if task.next_execution else None
}
for task in tasks
],
'activation_status': {
'activation_date': activation_status.activation_date.isoformat() if activation_status else None,
'status': activation_status.status if activation_status else 'unknown',
'performance_score': activation_status.performance_score if activation_status else None
},
'performance_metrics': {
'traffic_growth': performance_metrics.traffic_growth_percentage if performance_metrics else None,
'engagement_rate': performance_metrics.engagement_rate_percentage if performance_metrics else None,
'conversion_rate': performance_metrics.conversion_rate_percentage if performance_metrics else None,
'roi_ratio': performance_metrics.roi_ratio if performance_metrics else None,
'content_quality_score': performance_metrics.content_quality_score if performance_metrics else None,
'data_source': performance_metrics.data_source if performance_metrics else None,
'confidence_score': performance_metrics.confidence_score if performance_metrics else None
},
'created_at': monitoring_plan.created_at.isoformat(),
'updated_at': monitoring_plan.updated_at.isoformat()
}
logger.info(f"Successfully retrieved monitoring data for strategy {strategy_id}")
return monitoring_data
except Exception as e:
logger.error(f"Error retrieving monitoring data for strategy {strategy_id}: {e}")
return None
async def get_analytics_data(self, strategy_id: int) -> Dict[str, Any]:
"""Get analytics data from monitoring data (no external API calls)."""
try:
logger.info(f"Generating analytics data for strategy {strategy_id}")
# Get monitoring data from database
monitoring_data = await self.get_monitoring_data(strategy_id)
if not monitoring_data:
logger.warning(f"No monitoring data found for strategy {strategy_id}")
return self._get_empty_analytics_data()
# Extract analytics from monitoring data
monitoring_plan = monitoring_data['monitoring_plan']
tasks = monitoring_data['monitoring_tasks']
performance_metrics = monitoring_data['performance_metrics']
# Always use monitoring tasks from the plan for rich data, fallback to database tasks
monitoring_tasks = []
if monitoring_plan.get('monitoringTasks'):
# Use rich data from monitoring plan
monitoring_tasks = [
{
'id': i + 1,
'component': task.get('component', ''),
'title': task.get('title', ''),
'description': task.get('description', ''),
'assignee': task.get('assignee', 'ALwrity'),
'frequency': task.get('frequency', 'Monthly'),
'metric': task.get('metric', ''),
'measurementMethod': task.get('measurementMethod', ''),
'successCriteria': task.get('successCriteria', ''),
'alertThreshold': task.get('alertThreshold', ''),
'actionableInsights': task.get('actionableInsights', ''),
'status': 'active',
'last_executed': None,
'next_execution': None
}
for i, task in enumerate(monitoring_plan.get('monitoringTasks', []))
]
elif tasks:
# Fallback to database tasks if plan doesn't have them
monitoring_tasks = [
{
'id': task.id,
'component': task.component_name,
'title': task.task_title,
'description': task.task_description,
'assignee': task.assignee,
'frequency': task.frequency,
'metric': task.metric,
'measurementMethod': task.measurement_method,
'successCriteria': task.success_criteria,
'alertThreshold': task.alert_threshold,
'actionableInsights': '',
'status': task.status,
'last_executed': task.last_executed.isoformat() if task.last_executed else None,
'next_execution': task.next_execution.isoformat() if task.next_execution else None
}
for task in tasks
]
# Always use performance metrics from success metrics for rich data
extracted_metrics = {}
if monitoring_plan.get('successMetrics'):
success_metrics = monitoring_plan['successMetrics']
extracted_metrics = {
'traffic_growth': self._extract_percentage(success_metrics.get('trafficGrowth', {}).get('current', '0%')),
'engagement_rate': self._extract_percentage(success_metrics.get('engagementRate', {}).get('current', '0%')),
'conversion_rate': self._extract_percentage(success_metrics.get('conversionRate', {}).get('current', '0%')),
'roi_ratio': self._extract_ratio(success_metrics.get('roi', {}).get('current', '0:1')),
'content_quality_score': self._extract_percentage(success_metrics.get('contentQuality', {}).get('current', '0%')),
'data_source': 'monitoring_plan',
'confidence_score': 85
}
else:
# Fallback to database metrics if plan doesn't have them
extracted_metrics = {
'traffic_growth': performance_metrics.get('traffic_growth', 0),
'engagement_rate': performance_metrics.get('engagement_rate', 0),
'conversion_rate': performance_metrics.get('conversion_rate', 0),
'roi_ratio': performance_metrics.get('roi_ratio', 0),
'content_quality_score': performance_metrics.get('content_quality_score', 0),
'data_source': performance_metrics.get('data_source', 'database'),
'confidence_score': performance_metrics.get('confidence_score', 70)
}
# Build analytics data from monitoring plan
analytics_data = {
'performance_trends': {
'traffic_growth': extracted_metrics.get('traffic_growth', 0),
'engagement_rate': extracted_metrics.get('engagement_rate', 0),
'conversion_rate': extracted_metrics.get('conversion_rate', 0),
'roi_ratio': extracted_metrics.get('roi_ratio', 0),
'content_quality_score': extracted_metrics.get('content_quality_score', 0)
},
'content_evolution': {
'content_pillars': monitoring_plan.get('contentPillars', []),
'content_mix': monitoring_plan.get('contentMix', {}),
'publishing_frequency': monitoring_plan.get('publishingFrequency', ''),
'quality_metrics': monitoring_plan.get('qualityMetrics', [])
},
'engagement_patterns': {
'audience_segments': monitoring_plan.get('audienceSegments', []),
'engagement_metrics': monitoring_plan.get('engagementMetrics', {}),
'optimal_timing': monitoring_plan.get('optimalTiming', {}),
'platform_performance': monitoring_plan.get('platformPerformance', {})
},
'recommendations': monitoring_plan.get('recommendations', []),
'insights': monitoring_plan.get('insights', []),
'monitoring_data': monitoring_data,
'monitoring_tasks': monitoring_tasks,
'monitoring_plan': monitoring_plan, # Include full monitoring plan for rich data
'success_metrics': monitoring_plan.get('successMetrics', {}), # Include success metrics
'monitoring_schedule': monitoring_plan.get('monitoringSchedule', {}), # Include monitoring schedule
'_source': 'database_monitoring',
'data_freshness': monitoring_data['updated_at'],
'confidence_score': extracted_metrics.get('confidence_score', 85)
}
logger.info(f"Successfully generated analytics data for strategy {strategy_id}")
return analytics_data
except Exception as e:
logger.error(f"Error generating analytics data for strategy {strategy_id}: {e}")
return self._get_empty_analytics_data()
def _get_empty_analytics_data(self) -> Dict[str, Any]:
"""Return empty analytics data structure."""
return {
'performance_trends': {},
'content_evolution': {},
'engagement_patterns': {},
'recommendations': [],
'insights': [],
'monitoring_data': None,
'monitoring_tasks': [],
'_source': 'empty',
'data_freshness': datetime.utcnow().isoformat(),
'confidence_score': 0
}
def _extract_percentage(self, value: str) -> float:
"""Extract percentage value from string like '15%'."""
try:
if isinstance(value, str) and '%' in value:
return float(value.replace('%', ''))
elif isinstance(value, (int, float)):
return float(value)
else:
return 0.0
except (ValueError, TypeError):
return 0.0
def _extract_ratio(self, value: str) -> float:
"""Extract ratio value from string like '3:1'."""
try:
if isinstance(value, str) and ':' in value:
parts = value.split(':')
if len(parts) == 2:
return float(parts[0]) / float(parts[1])
elif isinstance(value, (int, float)):
return float(value)
else:
return 0.0
except (ValueError, TypeError):
return 0.0
async def update_performance_metrics(self, strategy_id: int, metrics: Dict[str, Any]) -> bool:
"""Update performance metrics for a strategy."""
try:
logger.info(f"Updating performance metrics for strategy {strategy_id}")
performance_metrics = StrategyPerformanceMetrics(
strategy_id=strategy_id,
user_id=1, # Default user ID
metric_date=datetime.utcnow(),
traffic_growth_percentage=metrics.get('traffic_growth'),
engagement_rate_percentage=metrics.get('engagement_rate'),
conversion_rate_percentage=metrics.get('conversion_rate'),
roi_ratio=metrics.get('roi_ratio'),
content_quality_score=metrics.get('content_quality_score'),
data_source='manual_update',
confidence_score=metrics.get('confidence_score', 70)
)
self.db.add(performance_metrics)
self.db.commit()
logger.info(f"Successfully updated performance metrics for strategy {strategy_id}")
return True
except Exception as e:
logger.error(f"Error updating performance metrics for strategy {strategy_id}: {e}")
self.db.rollback()
return False

61
backend/start_alwrity_backend.py
View File

@@ -9,6 +9,7 @@ import os
import sys import sys
import subprocess import subprocess
import time import time
import argparse
from pathlib import Path from pathlib import Path
def install_requirements(): def install_requirements():
@@ -213,18 +214,25 @@ def setup_environment():
print("✅ Environment setup complete") print("✅ Environment setup complete")
def start_backend(): def start_backend(enable_reload=False):
"""Start the backend server.""" """Start the backend server."""
print("🚀 Starting ALwrity Backend...") print("🚀 Starting ALwrity Backend...")
# Set environment variables # Set environment variables
os.environ.setdefault("HOST", "0.0.0.0") os.environ.setdefault("HOST", "0.0.0.0")
os.environ.setdefault("PORT", "8000") os.environ.setdefault("PORT", "8000")
os.environ.setdefault("RELOAD", "true")
# Set reload based on argument or environment variable
if enable_reload:
os.environ.setdefault("RELOAD", "true")
print(" 🔄 Development mode: Auto-reload enabled")
else:
os.environ.setdefault("RELOAD", "false")
print(" 🏭 Production mode: Auto-reload disabled")
host = os.getenv("HOST", "0.0.0.0") host = os.getenv("HOST", "0.0.0.0")
port = int(os.getenv("PORT", "8000")) port = int(os.getenv("PORT", "8000"))
reload = os.getenv("RELOAD", "true").lower() == "true" reload = os.getenv("RELOAD", "false").lower() == "true"
print(f" 📍 Host: {host}") print(f" 📍 Host: {host}")
print(f" 🔌 Port: {port}") print(f" 🔌 Port: {port}")
@@ -242,12 +250,48 @@ def start_backend():
print(" 📈 API Monitoring: http://localhost:8000/api/content-planning/monitoring/health") print(" 📈 API Monitoring: http://localhost:8000/api/content-planning/monitoring/health")
print("\n⏹️ Press Ctrl+C to stop the server") print("\n⏹️ Press Ctrl+C to stop the server")
print("=" * 60) print("=" * 60)
print("\n💡 Usage:")
print(" Production mode (default): python start_alwrity_backend.py")
print(" Development mode: python start_alwrity_backend.py --dev")
print(" With auto-reload: python start_alwrity_backend.py --reload")
print("=" * 60)
uvicorn.run( uvicorn.run(
"app:app", "app:app",
host=host, host=host,
port=port, port=port,
reload=reload, reload=reload,
reload_excludes=[
"*.pyc",
"*.pyo",
"*.pyd",
"__pycache__",
"*.log",
"*.sqlite",
"*.db",
"*.tmp",
"*.temp",
"test_*.py",
"temp_*.py",
"monitoring_data_service.py",
"test_monitoring_save.py",
"*.json",
"*.yaml",
"*.yml",
".env*",
"logs/*",
"cache/*",
"tmp/*",
"temp/*",
"middleware/*",
"models/*",
"scripts/*"
],
reload_includes=[
"app.py",
"api/**/*.py",
"services/**/*.py"
],
log_level="info" log_level="info"
) )
@@ -261,6 +305,12 @@ def start_backend():
def main(): def main():
"""Main function to set up and start the backend.""" """Main function to set up and start the backend."""
# Parse command line arguments
parser = argparse.ArgumentParser(description="ALwrity Backend Server")
parser.add_argument("--reload", action="store_true", help="Enable auto-reload for development")
parser.add_argument("--dev", action="store_true", help="Enable development mode (auto-reload)")
args = parser.parse_args()
print("🎯 ALwrity Backend Server") print("🎯 ALwrity Backend Server")
print("=" * 40) print("=" * 40)
@@ -279,8 +329,9 @@ def main():
# Setup environment # Setup environment
setup_environment() setup_environment()
# Start backend # Start backend with reload option
return start_backend() enable_reload = args.reload or args.dev
return start_backend(enable_reload=enable_reload)
if __name__ == "__main__": if __name__ == "__main__":
success = main() success = main()

48
fix_imports.py
View File

@@ -1,48 +0,0 @@
#!/usr/bin/env python3
"""
Script to fix import paths in step files
"""
import os
import re
def fix_imports_in_file(file_path):
"""Fix import paths in a file."""
try:
with open(file_path, 'r', encoding='utf-8') as f:
content = f.read()
# Fix the base_step import path
# Change from ..base_step to ...base_step for subdirectories
if '/step9_content_recommendations/' in file_path or '/step10_performance_optimization/' in file_path or '/step11_strategy_alignment_validation/' in file_path or '/step12_final_calendar_assembly/' in file_path:
content = re.sub(r'from \.\.base_step import', 'from ...base_step import', content)
with open(file_path, 'w', encoding='utf-8') as f:
f.write(content)
print(f"✅ Fixed imports in {file_path}")
return True
except Exception as e:
print(f"❌ Error fixing {file_path}: {e}")
return False
def main():
"""Main function to fix all import paths."""
base_path = "services/calendar_generation_datasource_framework/prompt_chaining/steps"
# Files that need fixing
files_to_fix = [
f"{base_path}/phase3/step9_content_recommendations/step9_main.py",
f"{base_path}/phase4/step10_performance_optimization/step10_main.py",
f"{base_path}/phase4/step11_strategy_alignment_validation/step11_main.py",
f"{base_path}/phase4/step12_final_calendar_assembly/step12_main.py",
]
for file_path in files_to_fix:
if os.path.exists(file_path):
fix_imports_in_file(file_path)
else:
print(f"⚠️ File not found: {file_path}")
if __name__ == "__main__":
main()

82
frontend/src/components/ContentPlanningDashboard/components/StrategyIntelligence/components/DataTransparencyPanel.tsx
View File

@@ -74,6 +74,63 @@ const DataTransparencyPanel: React.FC<DataTransparencyPanelProps> = ({
}; };
}, [refreshInterval]); }, [refreshInterval]);
const convertMonitoringTasksToTransparencyData = (monitoringTasks: any[]) => {
try {
// Group tasks by component
const tasksByComponent = monitoringTasks.reduce((acc, task) => {
const component = task.component || 'General';
if (!acc[component]) {
acc[component] = [];
}
acc[component].push(task);
return acc;
}, {});
// Convert to transparency data format
return Object.entries(tasksByComponent).map(([component, tasks]: [string, any]) => ({
metricName: component,
currentValue: tasks.length,
unit: "tasks",
dataFreshness: {
lastUpdated: new Date().toISOString(),
updateFrequency: "Real-time",
dataSource: "Monitoring Tasks"
},
measurementMethod: "AI-powered monitoring",
successCriteria: `${tasks.length} active monitoring tasks`,
monitoringTasks: tasks.map((task: any) => ({
title: task.title,
description: task.description,
assignee: task.assignee,
frequency: task.frequency,
metric: task.metric,
measurementMethod: task.measurementMethod,
successCriteria: task.successCriteria,
alertThreshold: task.alertThreshold,
actionableInsights: task.actionableInsights,
status: task.status || 'active',
lastExecuted: task.last_executed,
nextExecution: task.next_execution
})),
insights: [
`Active monitoring for ${component} with ${tasks.length} tasks`,
"AI-powered performance tracking enabled",
"Real-time alerts and notifications configured",
`Monitoring frequency: ${tasks[0]?.frequency || 'Monthly'}`
],
recommendations: [
"Monitor task execution status regularly",
"Review performance metrics weekly",
"Adjust thresholds based on performance trends",
`Focus on ${tasks.filter((t: any) => t.assignee === 'ALwrity').length} AI-managed tasks`
]
}));
} catch (error) {
console.error('Error converting monitoring tasks to transparency data:', error);
return [];
}
};
const loadTransparencyData = async () => { const loadTransparencyData = async () => {
try { try {
setLoading(true); setLoading(true);
@@ -87,7 +144,30 @@ const DataTransparencyPanel: React.FC<DataTransparencyPanelProps> = ({
return; return;
} }
} catch (apiError) { } catch (apiError) {
console.warn('API call failed, falling back to mock data:', apiError); console.warn('API call failed, trying localStorage:', apiError);
// Try to load from localStorage
const analyticsData = localStorage.getItem('strategy_analytics_data');
if (analyticsData) {
try {
const data = JSON.parse(analyticsData);
console.log('Loaded analytics data from localStorage:', data);
// Extract monitoring tasks from analytics data
const monitoringTasks = data.monitoring_tasks || [];
console.log('Extracted monitoring tasks:', monitoringTasks);
if (monitoringTasks.length > 0) {
// Convert monitoring tasks to transparency data format
const transparencyDataFromTasks = convertMonitoringTasksToTransparencyData(monitoringTasks);
setTransparencyData(transparencyDataFromTasks);
return;
} else {
console.warn('No monitoring tasks found in analytics data');
}
} catch (parseError) {
console.warn('Failed to parse analytics data from localStorage:', parseError);
}
}
// Continue to mock data as fallback // Continue to mock data as fallback
} }

53
frontend/src/components/ContentPlanningDashboard/components/StrategyIntelligence/components/EnhancedPerformanceVisualization.tsx
View File

@@ -99,12 +99,55 @@ const EnhancedPerformanceVisualization: React.FC<EnhancedPerformanceVisualizatio
setLoadingQuality(true); setLoadingQuality(true);
setError(null); setError(null);
// Call the quality analysis API // Try to get quality analysis from monitoring data first
const response = await strategyMonitoringApi.getQualityAnalysis(strategyId); const monitoringData = localStorage.getItem('strategy_analytics_data');
setQualityAnalysis(response.data);
if (monitoringData) {
const data = JSON.parse(monitoringData);
const monitoringPlan = data.monitoring_plan;
// Extract quality metrics from monitoring plan
const qualityData: QualityAnalysisData = {
overall_score: data.performance_metrics?.confidence_score || 75,
overall_status: data.performance_metrics?.confidence_score >= 80 ? 'excellent' :
data.performance_metrics?.confidence_score >= 60 ? 'good' : 'needs_attention',
metrics: [
{
name: 'Strategic Completeness',
score: 85,
status: 'excellent',
description: 'Strategy covers all key components',
recommendations: monitoringPlan?.recommendations || []
},
{
name: 'Content Quality',
score: data.performance_metrics?.content_quality_score || 75,
status: data.performance_metrics?.content_quality_score >= 80 ? 'excellent' : 'good',
description: 'Content meets quality standards',
recommendations: ['Continue monitoring content performance']
},
{
name: 'Engagement Metrics',
score: data.performance_metrics?.engagement_rate || 70,
status: data.performance_metrics?.engagement_rate >= 75 ? 'good' : 'needs_attention',
description: 'Audience engagement levels',
recommendations: ['Focus on improving engagement rates']
}
],
recommendations: monitoringPlan?.recommendations || [],
confidence_score: data.performance_metrics?.confidence_score || 75
};
setQualityAnalysis(qualityData);
console.log('✅ Quality analysis loaded from monitoring data');
} else {
// Fallback to API call if no monitoring data
console.log('⚠️ No monitoring data found, skipping quality analysis');
setQualityAnalysis(null);
}
} catch (err: any) { } catch (err: any) {
setError(err.message || 'Failed to load quality analysis'); console.warn('⚠️ Error loading quality analysis from monitoring data:', err);
console.error('Error loading quality analysis:', err); setQualityAnalysis(null);
} finally { } finally {
setLoadingQuality(false); setLoadingQuality(false);
} }

88
frontend/src/components/ContentPlanningDashboard/components/StrategyIntelligence/components/EnhancedStrategyActivationButton.tsx
View File

@@ -17,6 +17,7 @@ import { motion, AnimatePresence, easeOut } from 'framer-motion';
import StrategyActivationModal from '../../StrategyActivationModal'; import StrategyActivationModal from '../../StrategyActivationModal';
import { useNavigationOrchestrator } from '../../../../../services/navigationOrchestrator'; import { useNavigationOrchestrator } from '../../../../../services/navigationOrchestrator';
interface EnhancedStrategyActivationButtonProps { interface EnhancedStrategyActivationButtonProps {
strategyData: any; strategyData: any;
strategyConfirmed: boolean; strategyConfirmed: boolean;
@@ -45,16 +46,7 @@ const EnhancedStrategyActivationButton: React.FC<EnhancedStrategyActivationButto
console.log('🎯 EnhancedStrategyActivationButton: handleActivation called'); console.log('🎯 EnhancedStrategyActivationButton: handleActivation called');
if (isLoading || disabled) return; if (isLoading || disabled) return;
// For now, directly call the activation function instead of opening the modal // Open the activation modal to show monitoring setup
console.log('🎯 EnhancedStrategyActivationButton: Directly calling onConfirmStrategy');
try {
await onConfirmStrategy();
console.log('🎯 EnhancedStrategyActivationButton: onConfirmStrategy completed successfully');
} catch (error) {
console.error('🎯 EnhancedStrategyActivationButton: onConfirmStrategy failed:', error);
}
// Open the activation modal instead of calling onConfirmStrategy directly
console.log('🎯 EnhancedStrategyActivationButton: Opening activation modal'); console.log('🎯 EnhancedStrategyActivationButton: Opening activation modal');
setShowActivationModal(true); setShowActivationModal(true);
}; };
@@ -70,21 +62,59 @@ const EnhancedStrategyActivationButton: React.FC<EnhancedStrategyActivationButto
const handleSetupMonitoring = async (monitoringPlan: any) => { const handleSetupMonitoring = async (monitoringPlan: any) => {
try { try {
console.log('🎯 EnhancedStrategyActivationButton: handleSetupMonitoring called'); console.log('🎯 EnhancedStrategyActivationButton: handleSetupMonitoring called');
// Call the actual activation function
// Get strategy ID
const strategyId = strategyData?.id || 1;
// Step 1: Generate monitoring plan if not provided
let finalMonitoringPlan = monitoringPlan;
if (!finalMonitoringPlan) {
console.log('🎯 Generating monitoring plan...');
try {
const response = await fetch(`/api/content-planning/strategy/${strategyId}/generate-monitoring-plan`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' }
});
const planResponse = await response.json();
finalMonitoringPlan = planResponse.data;
console.log('🎯 Monitoring plan generated:', finalMonitoringPlan);
} catch (error) {
console.warn('Could not generate monitoring plan:', error);
// Continue without monitoring plan
}
}
// Step 2: Activate strategy with monitoring plan
console.log('🎯 Activating strategy with monitoring...');
try {
const response = await fetch(`/api/content-planning/strategy/${strategyId}/activate-with-monitoring`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(finalMonitoringPlan)
});
const activationResponse = await response.json();
console.log('🎯 Strategy activated with monitoring:', activationResponse);
} catch (error) {
console.warn('Could not activate strategy with monitoring:', error);
// Continue with local activation only
}
// Step 3: Call the local confirmation function
console.log('🎯 EnhancedStrategyActivationButton: Calling onConfirmStrategy()'); console.log('🎯 EnhancedStrategyActivationButton: Calling onConfirmStrategy()');
await onConfirmStrategy(); await onConfirmStrategy();
console.log('🎯 EnhancedStrategyActivationButton: onConfirmStrategy() completed'); console.log('🎯 EnhancedStrategyActivationButton: onConfirmStrategy() completed');
// Update strategy state to confirmed/active // Step 4: Update analytics and monitoring data
// This will trigger UI updates in parent components console.log('🎯 Setting up analytics and monitoring...');
await setupAnalyticsAndMonitoring(strategyId, finalMonitoringPlan);
// Show success state // Show success state
setIsSuccess(true); setIsSuccess(true);
setShowSuccessMessage(true); setShowSuccessMessage(true);
// Use navigation orchestrator to handle successful activation // Use navigation orchestrator to handle successful activation
const strategyId = strategyData?.strategy_metadata?.user_id || strategyData?.metadata?.user_id || '1'; const userId = strategyData?.strategy_metadata?.user_id || strategyData?.metadata?.user_id || '1';
navigationOrchestrator.handleStrategyActivationSuccess(strategyId, strategyData); navigationOrchestrator.handleStrategyActivationSuccess(userId, strategyData);
// Reset after success animation // Reset after success animation
setTimeout(() => { setTimeout(() => {
@@ -98,6 +128,34 @@ const EnhancedStrategyActivationButton: React.FC<EnhancedStrategyActivationButto
} }
}; };
const setupAnalyticsAndMonitoring = async (strategyId: number, monitoringPlan: any) => {
try {
console.log('🎯 Setting up analytics and monitoring for strategy:', strategyId);
// Update analytics page with monitoring data
// This will populate the analytics dashboard with the new monitoring tasks
const analyticsData = {
strategy_id: strategyId,
monitoring_plan: monitoringPlan,
activation_date: new Date().toISOString(),
status: 'active'
};
// Store analytics data in localStorage for the analytics page to access
localStorage.setItem('strategy_analytics_data', JSON.stringify(analyticsData));
// Also store monitoring tasks for the data transparency panel
const monitoringTasks = monitoringPlan?.monitoringTasks || [];
localStorage.setItem('strategy_monitoring_tasks', JSON.stringify(monitoringTasks));
console.log('🎯 Analytics and monitoring setup completed');
} catch (error) {
console.error('Error setting up analytics and monitoring:', error);
// Don't fail the activation if analytics setup fails
}
};
// Success animation variants // Success animation variants
const successVariants = { const successVariants = {
initial: { scale: 0, opacity: 0 }, initial: { scale: 0, opacity: 0 },

47
frontend/src/components/ContentPlanningDashboard/components/StrategyIntelligence/components/MetricTransparencyCard.tsx
View File

@@ -293,6 +293,33 @@ const MetricTransparencyCard: React.FC<MetricTransparencyCardProps> = ({
{task.description} {task.description}
</Typography> </Typography>
<Box display="flex" gap={2} mb={1}>
{task.frequency && (
<Chip
label={`${task.frequency}`}
size="small"
icon={<ScheduleIcon />}
sx={{
background: 'rgba(255,255,255,0.1)',
color: 'white',
fontSize: '0.6rem'
}}
/>
)}
{task.metric && (
<Chip
label={`${task.metric}`}
size="small"
icon={<AssessmentIcon />}
sx={{
background: 'rgba(255,255,255,0.1)',
color: 'white',
fontSize: '0.6rem'
}}
/>
)}
</Box>
<Grid container spacing={2} sx={{ width: '100%' }}> <Grid container spacing={2} sx={{ width: '100%' }}>
<Grid item xs={12} sm={6}> <Grid item xs={12} sm={6}>
<Typography variant="caption" sx={{ fontWeight: 600, color: 'rgba(255,255,255,0.7)' }}> <Typography variant="caption" sx={{ fontWeight: 600, color: 'rgba(255,255,255,0.7)' }}>
@@ -310,6 +337,26 @@ const MetricTransparencyCard: React.FC<MetricTransparencyCardProps> = ({
{task.successCriteria} {task.successCriteria}
</Typography> </Typography>
</Grid> </Grid>
{task.alertThreshold && (
<Grid item xs={12} sm={6}>
<Typography variant="caption" sx={{ fontWeight: 600, color: 'rgba(255,255,255,0.7)' }}>
Alert Threshold
</Typography>
<Typography variant="body2" sx={{ fontSize: '0.75rem', opacity: 0.8 }}>
{task.alertThreshold}
</Typography>
</Grid>
)}
{task.actionableInsights && (
<Grid item xs={12} sm={6}>
<Typography variant="caption" sx={{ fontWeight: 600, color: 'rgba(255,255,255,0.7)' }}>
Actionable Insights
</Typography>
<Typography variant="body2" sx={{ fontSize: '0.75rem', opacity: 0.8 }}>
{task.actionableInsights}
</Typography>
</Grid>
)}
</Grid> </Grid>
</ListItem> </ListItem>
))} ))}

48
frontend/src/components/ContentPlanningDashboard/components/StrategyIntelligence/components/TrendAnalysis.tsx
View File

@@ -57,11 +57,51 @@ const TrendAnalysis: React.FC<TrendAnalysisProps> = ({
try { try {
setLoading(true); setLoading(true);
// Call the API to get trend data // Try to get trend data from monitoring data first
const response = await strategyMonitoringApi.getTrendData(strategyId, timeRange); const monitoringData = localStorage.getItem('strategy_analytics_data');
setTrendData(response.data);
if (monitoringData) {
const data = JSON.parse(monitoringData);
const performanceMetrics = data.performance_metrics;
// Generate trend data from monitoring metrics
const trendData: TrendData[] = [
{
date: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString().split('T')[0], // 30 days ago
traffic_growth: (performanceMetrics?.traffic_growth || 0) - 5,
engagement_rate: (performanceMetrics?.engagement_rate || 0) - 3,
conversion_rate: (performanceMetrics?.conversion_rate || 0) - 2,
content_quality_score: (performanceMetrics?.content_quality_score || 0) - 5,
strategy_adoption_rate: 75
},
{
date: new Date(Date.now() - 15 * 24 * 60 * 60 * 1000).toISOString().split('T')[0], // 15 days ago
traffic_growth: (performanceMetrics?.traffic_growth || 0) - 2,
engagement_rate: (performanceMetrics?.engagement_rate || 0) - 1,
conversion_rate: (performanceMetrics?.conversion_rate || 0) - 1,
content_quality_score: (performanceMetrics?.content_quality_score || 0) - 2,
strategy_adoption_rate: 80
},
{
date: new Date().toISOString().split('T')[0], // Today
traffic_growth: performanceMetrics?.traffic_growth || 0,
engagement_rate: performanceMetrics?.engagement_rate || 0,
conversion_rate: performanceMetrics?.conversion_rate || 0,
content_quality_score: performanceMetrics?.content_quality_score || 0,
strategy_adoption_rate: 85
}
];
setTrendData(trendData);
console.log('✅ Trend data loaded from monitoring data');
} else {
// Fallback to empty data if no monitoring data
console.log('⚠️ No monitoring data found, using empty trend data');
setTrendData([]);
}
} catch (error) { } catch (error) {
console.error('Error loading trend data:', error); console.warn('⚠️ Error loading trend data from monitoring data:', error);
setTrendData([]);
} finally { } finally {
setLoading(false); setLoading(false);
} }

191
frontend/src/components/ContentPlanningDashboard/tabs/AnalyticsTab.tsx
View File

@@ -12,7 +12,8 @@ import {
CircularProgress, CircularProgress,
LinearProgress, LinearProgress,
Tabs, Tabs,
Tab Tab,
Button
} from '@mui/material'; } from '@mui/material';
import { import {
TrendingUp as TrendingUpIcon, TrendingUp as TrendingUpIcon,
@@ -21,7 +22,8 @@ import {
Assessment as AssessmentIcon, Assessment as AssessmentIcon,
Visibility as VisibilityIcon, Visibility as VisibilityIcon,
Timeline as TimelineIcon, Timeline as TimelineIcon,
AutoAwesome as AutoAwesomeIcon AutoAwesome as AutoAwesomeIcon,
Refresh as RefreshIcon
} from '@mui/icons-material'; } from '@mui/icons-material';
import { useContentPlanningStore } from '../../../stores/contentPlanningStore'; import { useContentPlanningStore } from '../../../stores/contentPlanningStore';
import { contentPlanningApi } from '../../../services/contentPlanningApi'; import { contentPlanningApi } from '../../../services/contentPlanningApi';
@@ -53,54 +55,108 @@ function TabPanel(props: TabPanelProps) {
const AnalyticsTab: React.FC = () => { const AnalyticsTab: React.FC = () => {
const { const {
performanceMetrics,
aiInsights,
currentStrategy, currentStrategy,
loading, error: storeError
error,
loadAIInsights,
loadAIRecommendations
} = useContentPlanningStore(); } = useContentPlanningStore();
const [analyticsData, setAnalyticsData] = useState<any>(null); const [analyticsData, setAnalyticsData] = useState<any>(null);
const [dataLoading, setDataLoading] = useState(false); const [dataLoading, setDataLoading] = useState(false);
const [error, setError] = useState<string | null>(null);
const [activeTab, setActiveTab] = useState(0); const [activeTab, setActiveTab] = useState(0);
// Cache for analytics data to prevent redundant calls
const [lastLoadTime, setLastLoadTime] = useState<number>(0);
const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
useEffect(() => { useEffect(() => {
loadAnalyticsData(); loadAnalyticsData();
}, []); }, []);
const loadAnalyticsData = async () => { const loadAnalyticsData = async () => {
try { try {
// Check if we have recent cached data to avoid redundant calls
const now = Date.now();
if (analyticsData && (now - lastLoadTime) < CACHE_DURATION) {
console.log('🎯 Using cached analytics data (cache valid for', Math.round((CACHE_DURATION - (now - lastLoadTime)) / 1000), 'seconds)');
return;
}
setDataLoading(true); setDataLoading(true);
setError(null);
console.log('Loading analytics data...'); console.log('🎯 Loading analytics data...');
// Load AI insights and recommendations // Get strategy ID
await Promise.all([ const strategyId = Number(currentStrategy?.id) || currentStrategy?.user_id || 1;
loadAIInsights(),
loadAIRecommendations()
]);
// Load analytics data from backend // First, try to load from database (monitoring data)
const response = await contentPlanningApi.getAIAnalyticsSafe(); try {
console.log('🎯 Fetching analytics data from database...');
const response = await fetch(`/api/content-planning/strategy/${strategyId}/analytics-data`);
console.log('Analytics Response:', response); if (response.ok) {
const result = await response.json();
const dbAnalyticsData = result.data;
console.log('✅ Analytics data from database:', dbAnalyticsData);
setAnalyticsData(dbAnalyticsData);
setLastLoadTime(Date.now());
return;
} else {
console.warn('⚠️ Database fetch failed, trying cache...');
}
} catch (dbError) {
console.warn('⚠️ Database fetch error, trying cache:', dbError);
}
// Fallback to cached monitoring data
const strategyAnalyticsData = localStorage.getItem('strategy_analytics_data');
const monitoringTasks = localStorage.getItem('strategy_monitoring_tasks');
console.log('🎯 Checking cached monitoring data...');
if (strategyAnalyticsData && monitoringTasks) {
console.log('✅ Found cached monitoring data');
const cachedData = JSON.parse(strategyAnalyticsData);
const tasks = JSON.parse(monitoringTasks);
if (response) {
const analyticsData = { const analyticsData = {
performance_trends: response.performance_trends || {}, performance_trends: cachedData.monitoring_plan?.performance_metrics || {},
content_evolution: response.content_evolution || {}, content_evolution: cachedData.monitoring_plan?.content_evolution || {},
engagement_patterns: response.engagement_patterns || {}, engagement_patterns: cachedData.monitoring_plan?.engagement_patterns || {},
recommendations: response.recommendations || [], recommendations: cachedData.monitoring_plan?.recommendations || [],
insights: response.insights || [] insights: cachedData.monitoring_plan?.insights || [],
monitoring_data: cachedData,
monitoring_tasks: tasks,
_source: 'cached_monitoring'
}; };
console.log('Analytics Data:', analyticsData); console.log('✅ Analytics Data from cache:', analyticsData);
setAnalyticsData(analyticsData); setAnalyticsData(analyticsData);
setLastLoadTime(Date.now());
} else {
// No data available
console.log('⚠️ No monitoring data found in database or cache');
const emptyData = {
performance_trends: {},
content_evolution: {},
engagement_patterns: {},
recommendations: [],
insights: [],
monitoring_data: null,
monitoring_tasks: [],
_source: 'empty'
};
setAnalyticsData(emptyData);
setLastLoadTime(Date.now());
setError('No monitoring data available. Please activate a strategy first.');
} }
} catch (error) { } catch (error) {
console.error('Error loading analytics data:', error); console.error('❌ Error loading analytics data:', error);
setError('Failed to load analytics data. Please try again.');
} finally { } finally {
setDataLoading(false); setDataLoading(false);
} }
@@ -110,6 +166,12 @@ const AnalyticsTab: React.FC = () => {
setActiveTab(newValue); setActiveTab(newValue);
}; };
const handleRefresh = () => {
console.log('🔄 Manual refresh requested');
setLastLoadTime(0); // Reset cache
loadAnalyticsData();
};
const getPerformanceColor = (value: number) => { const getPerformanceColor = (value: number) => {
if (value >= 80) return 'success'; if (value >= 80) return 'success';
if (value >= 60) return 'warning'; if (value >= 60) return 'warning';
@@ -121,15 +183,48 @@ const AnalyticsTab: React.FC = () => {
return ( return (
<Box sx={{ p: 3 }}> <Box sx={{ p: 3 }}>
<Typography variant="h4" gutterBottom> <Box sx={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', mb: 2 }}>
Analytics Dashboard <Typography variant="h4">
</Typography> Analytics Dashboard
</Typography>
<Button
variant="outlined"
startIcon={<RefreshIcon />}
onClick={handleRefresh}
disabled={dataLoading}
sx={{ minWidth: 120 }}
>
{dataLoading ? 'Refreshing...' : 'Refresh'}
</Button>
</Box>
{error && ( {(error || storeError) && (
<Alert severity="error" sx={{ mb: 2 }}> <Alert severity="error" sx={{ mb: 2 }}>
{error} {error || storeError}
</Alert> </Alert>
)} )}
{/* Data Source Indicator */}
{analyticsData && (
<Alert
severity="info"
sx={{ mb: 2 }}
action={
<Chip
label={analyticsData._source === 'database_monitoring' ? 'Database' :
analyticsData._source === 'cached_monitoring' ? 'Cache' :
analyticsData._source === 'empty' ? 'No Data' : 'Unknown'}
size="small"
color="primary"
variant="outlined"
/>
}
>
Data source: {analyticsData._source === 'database_monitoring' ? 'Monitoring database' :
analyticsData._source === 'cached_monitoring' ? 'Local cache' :
analyticsData._source === 'empty' ? 'No monitoring data available' : 'Unknown source'}
</Alert>
)}
{/* Tabs Navigation */} {/* Tabs Navigation */}
<Box sx={{ borderBottom: 1, borderColor: 'divider', mb: 3 }}> <Box sx={{ borderBottom: 1, borderColor: 'divider', mb: 3 }}>
@@ -191,38 +286,38 @@ const AnalyticsTab: React.FC = () => {
</Typography> </Typography>
<Divider sx={{ mb: 2 }} /> <Divider sx={{ mb: 2 }} />
{performanceMetrics ? ( {analyticsData && analyticsData.performance_trends ? (
<Grid container spacing={2}> <Grid container spacing={2}>
<Grid item xs={6}> <Grid item xs={6}>
<Typography variant="body2" color="text.secondary"> <Typography variant="body2" color="text.secondary">
Engagement Rate Engagement Rate
</Typography> </Typography>
<Typography variant="h4" color={getPerformanceColor(performanceMetrics.engagement)}> <Typography variant="h4" color={getPerformanceColor(analyticsData.performance_trends.engagement_rate || 0)}>
{performanceMetrics.engagement}% {analyticsData.performance_trends.engagement_rate || 0}%
</Typography> </Typography>
</Grid> </Grid>
<Grid item xs={6}> <Grid item xs={6}>
<Typography variant="body2" color="text.secondary"> <Typography variant="body2" color="text.secondary">
Reach Traffic Growth
</Typography> </Typography>
<Typography variant="h4" color="primary"> <Typography variant="h4" color="primary">
{performanceMetrics.reach.toLocaleString()} {analyticsData.performance_trends.traffic_growth || 0}%
</Typography> </Typography>
</Grid> </Grid>
<Grid item xs={6}> <Grid item xs={6}>
<Typography variant="body2" color="text.secondary"> <Typography variant="body2" color="text.secondary">
Conversion Rate Conversion Rate
</Typography> </Typography>
<Typography variant="h4" color={getPerformanceColor(performanceMetrics.conversion)}> <Typography variant="h4" color={getPerformanceColor(analyticsData.performance_trends.conversion_rate || 0)}>
{performanceMetrics.conversion}% {analyticsData.performance_trends.conversion_rate || 0}%
</Typography> </Typography>
</Grid> </Grid>
<Grid item xs={6}> <Grid item xs={6}>
<Typography variant="body2" color="text.secondary"> <Typography variant="body2" color="text.secondary">
ROI Content Quality
</Typography> </Typography>
<Typography variant="h4" color="success.main"> <Typography variant="h4" color="success.main">
${performanceMetrics.roi.toLocaleString()} {analyticsData.performance_trends.content_quality_score || 0}/100
</Typography> </Typography>
</Grid> </Grid>
</Grid> </Grid>
@@ -243,18 +338,18 @@ const AnalyticsTab: React.FC = () => {
</Typography> </Typography>
<Divider sx={{ mb: 2 }} /> <Divider sx={{ mb: 2 }} />
{aiInsights && aiInsights.length > 0 ? ( {analyticsData && analyticsData.insights && analyticsData.insights.length > 0 ? (
<Box> <Box>
{aiInsights.slice(0, 3).map((insight, index) => ( {analyticsData.insights.slice(0, 3).map((insight: any, index: number) => (
<Box key={index} sx={{ mb: 2 }}> <Box key={index} sx={{ mb: 2 }}>
<Typography variant="subtitle2" gutterBottom> <Typography variant="subtitle2" gutterBottom>
{insight.title} {insight.title || `Insight ${index + 1}`}
</Typography> </Typography>
<Typography variant="body2" color="text.secondary" sx={{ mb: 1 }}> <Typography variant="body2" color="text.secondary" sx={{ mb: 1 }}>
{insight.description} {insight.description || insight}
</Typography> </Typography>
<Chip <Chip
label={insight.priority} label={insight.priority || 'medium'}
color={insight.priority === 'high' ? 'error' : insight.priority === 'medium' ? 'warning' : 'success'} color={insight.priority === 'high' ? 'error' : insight.priority === 'medium' ? 'warning' : 'success'}
size="small" size="small"
/> />
@@ -263,7 +358,7 @@ const AnalyticsTab: React.FC = () => {
</Box> </Box>
) : ( ) : (
<Typography variant="body2" color="text.secondary"> <Typography variant="body2" color="text.secondary">
No AI insights available No insights available
</Typography> </Typography>
)} )}
</Paper> </Paper>

18
frontend/src/services/navigationOrchestrator.ts
View File

@@ -220,7 +220,23 @@ class NavigationOrchestrator {
strategicIntelligence: strategyData.strategicIntelligence || {} strategicIntelligence: strategyData.strategicIntelligence || {}
}; };
// Navigate to calendar wizard // Store strategy context for analytics page
this.preserveContext('strategy', strategyContext);
// Navigate to analytics page first to show monitoring setup
const navigate = this.getNavigateFunction();
if (navigate) {
navigate('/content-planning', {
state: {
activeTab: 2, // Analytics tab
strategyContext,
fromStrategyActivation: true,
showMonitoringSetup: true
}
});
}
// Also preserve context for calendar wizard navigation
this.navigateToCalendarWizard(strategyId, strategyContext); this.navigateToCalendarWizard(strategyId, strategyContext);
} }

6
frontend/src/services/strategyMonitoringApi.ts
View File

@@ -1,4 +1,4 @@
import { apiClient } from '../api/client'; import { apiClient, aiApiClient } from '../api/client';
import { useState } from 'react'; import { useState } from 'react';
export interface MonitoringTask { export interface MonitoringTask {
@@ -154,7 +154,7 @@ export const strategyMonitoringApi = {
*/ */
async getTrendData(strategyId: number, timeRange: string = '30d'): Promise<{ success: boolean; data: any; message: string }> { async getTrendData(strategyId: number, timeRange: string = '30d'): Promise<{ success: boolean; data: any; message: string }> {
try { try {
const response = await apiClient.get(`/api/content-planning/strategy/${strategyId}/trend-data?time_range=${timeRange}`); const response = await aiApiClient.get(`/api/content-planning/strategy/${strategyId}/trend-data?time_range=${timeRange}`);
return response.data; return response.data;
} catch (error: any) { } catch (error: any) {
console.error('Error getting trend data:', error); console.error('Error getting trend data:', error);
@@ -196,7 +196,7 @@ export const strategyMonitoringApi = {
// Quality Analysis API methods // Quality Analysis API methods
async getQualityAnalysis(strategyId: number): Promise<{ success: boolean; data: any; message: string }> { async getQualityAnalysis(strategyId: number): Promise<{ success: boolean; data: any; message: string }> {
try { try {
const response = await apiClient.post(`/api/content-planning/quality-analysis/${strategyId}/analyze`); const response = await aiApiClient.post(`/api/content-planning/quality-analysis/${strategyId}/analyze`);
return response.data; return response.data;
} catch (error: any) { } catch (error: any) {
console.error('Error fetching quality analysis:', error); console.error('Error fetching quality analysis:', error);