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

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

@@ -74,6 +74,63 @@ const DataTransparencyPanel: React.FC<DataTransparencyPanelProps> = ({
};
}, [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 () => {
try {
setLoading(true);
@@ -87,7 +144,30 @@ const DataTransparencyPanel: React.FC<DataTransparencyPanelProps> = ({
return;
}
} 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
}

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

@@ -99,12 +99,55 @@ const EnhancedPerformanceVisualization: React.FC<EnhancedPerformanceVisualizatio
setLoadingQuality(true);
setError(null);
// Call the quality analysis API
const response = await strategyMonitoringApi.getQualityAnalysis(strategyId);
setQualityAnalysis(response.data);
// Try to get quality analysis from monitoring data first
const monitoringData = localStorage.getItem('strategy_analytics_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) {
setError(err.message || 'Failed to load quality analysis');
console.error('Error loading quality analysis:', err);
console.warn('⚠️ Error loading quality analysis from monitoring data:', err);
setQualityAnalysis(null);
} finally {
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 { useNavigationOrchestrator } from '../../../../../services/navigationOrchestrator';
interface EnhancedStrategyActivationButtonProps {
strategyData: any;
strategyConfirmed: boolean;
@@ -45,16 +46,7 @@ const EnhancedStrategyActivationButton: React.FC<EnhancedStrategyActivationButto
console.log('🎯 EnhancedStrategyActivationButton: handleActivation called');
if (isLoading || disabled) return;
// For now, directly call the activation function instead of opening the modal
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
// Open the activation modal to show monitoring setup
console.log('🎯 EnhancedStrategyActivationButton: Opening activation modal');
setShowActivationModal(true);
};
@@ -70,21 +62,59 @@ const EnhancedStrategyActivationButton: React.FC<EnhancedStrategyActivationButto
const handleSetupMonitoring = async (monitoringPlan: any) => {
try {
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()');
await onConfirmStrategy();
console.log('🎯 EnhancedStrategyActivationButton: onConfirmStrategy() completed');
// Update strategy state to confirmed/active
// This will trigger UI updates in parent components
// Step 4: Update analytics and monitoring data
console.log('🎯 Setting up analytics and monitoring...');
await setupAnalyticsAndMonitoring(strategyId, finalMonitoringPlan);
// Show success state
setIsSuccess(true);
setShowSuccessMessage(true);
// Use navigation orchestrator to handle successful activation
const strategyId = strategyData?.strategy_metadata?.user_id || strategyData?.metadata?.user_id || '1';
navigationOrchestrator.handleStrategyActivationSuccess(strategyId, strategyData);
const userId = strategyData?.strategy_metadata?.user_id || strategyData?.metadata?.user_id || '1';
navigationOrchestrator.handleStrategyActivationSuccess(userId, strategyData);
// Reset after success animation
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
const successVariants = {
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}
</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 item xs={12} sm={6}>
<Typography variant="caption" sx={{ fontWeight: 600, color: 'rgba(255,255,255,0.7)' }}>
@@ -310,6 +337,26 @@ const MetricTransparencyCard: React.FC<MetricTransparencyCardProps> = ({
{task.successCriteria}
</Typography>
</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>
</ListItem>
))}

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

@@ -57,11 +57,51 @@ const TrendAnalysis: React.FC<TrendAnalysisProps> = ({
try {
setLoading(true);
// Call the API to get trend data
const response = await strategyMonitoringApi.getTrendData(strategyId, timeRange);
setTrendData(response.data);
// Try to get trend data from monitoring data first
const monitoringData = localStorage.getItem('strategy_analytics_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) {
console.error('Error loading trend data:', error);
console.warn('⚠️ Error loading trend data from monitoring data:', error);
setTrendData([]);
} finally {
setLoading(false);
}

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

@@ -12,7 +12,8 @@ import {
CircularProgress,
LinearProgress,
Tabs,
Tab
Tab,
Button
} from '@mui/material';
import {
TrendingUp as TrendingUpIcon,
@@ -21,7 +22,8 @@ import {
Assessment as AssessmentIcon,
Visibility as VisibilityIcon,
Timeline as TimelineIcon,
AutoAwesome as AutoAwesomeIcon
AutoAwesome as AutoAwesomeIcon,
Refresh as RefreshIcon
} from '@mui/icons-material';
import { useContentPlanningStore } from '../../../stores/contentPlanningStore';
import { contentPlanningApi } from '../../../services/contentPlanningApi';
@@ -53,18 +55,18 @@ function TabPanel(props: TabPanelProps) {
const AnalyticsTab: React.FC = () => {
const {
performanceMetrics,
aiInsights,
currentStrategy,
loading,
error,
loadAIInsights,
loadAIRecommendations
error: storeError
} = useContentPlanningStore();
const [analyticsData, setAnalyticsData] = useState<any>(null);
const [dataLoading, setDataLoading] = useState(false);
const [error, setError] = useState<string | null>(null);
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(() => {
loadAnalyticsData();
@@ -72,35 +74,89 @@ const AnalyticsTab: React.FC = () => {
const loadAnalyticsData = async () => {
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);
setError(null);
console.log('Loading analytics data...');
console.log('🎯 Loading analytics data...');
// Load AI insights and recommendations
await Promise.all([
loadAIInsights(),
loadAIRecommendations()
]);
// Get strategy ID
const strategyId = Number(currentStrategy?.id) || currentStrategy?.user_id || 1;
// Load analytics data from backend
const response = await contentPlanningApi.getAIAnalyticsSafe();
// First, try to load from database (monitoring data)
try {
console.log('🎯 Fetching analytics data from database...');
const response = await fetch(`/api/content-planning/strategy/${strategyId}/analytics-data`);
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);
}
console.log('Analytics Response:', response);
// Fallback to cached monitoring data
const strategyAnalyticsData = localStorage.getItem('strategy_analytics_data');
const monitoringTasks = localStorage.getItem('strategy_monitoring_tasks');
if (response) {
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);
const analyticsData = {
performance_trends: response.performance_trends || {},
content_evolution: response.content_evolution || {},
engagement_patterns: response.engagement_patterns || {},
recommendations: response.recommendations || [],
insights: response.insights || []
performance_trends: cachedData.monitoring_plan?.performance_metrics || {},
content_evolution: cachedData.monitoring_plan?.content_evolution || {},
engagement_patterns: cachedData.monitoring_plan?.engagement_patterns || {},
recommendations: cachedData.monitoring_plan?.recommendations || [],
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);
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) {
console.error('Error loading analytics data:', error);
console.error('❌ Error loading analytics data:', error);
setError('Failed to load analytics data. Please try again.');
} finally {
setDataLoading(false);
}
@@ -110,6 +166,12 @@ const AnalyticsTab: React.FC = () => {
setActiveTab(newValue);
};
const handleRefresh = () => {
console.log('🔄 Manual refresh requested');
setLastLoadTime(0); // Reset cache
loadAnalyticsData();
};
const getPerformanceColor = (value: number) => {
if (value >= 80) return 'success';
if (value >= 60) return 'warning';
@@ -121,15 +183,48 @@ const AnalyticsTab: React.FC = () => {
return (
<Box sx={{ p: 3 }}>
<Typography variant="h4" gutterBottom>
Analytics Dashboard
</Typography>
<Box sx={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', mb: 2 }}>
<Typography variant="h4">
Analytics Dashboard
</Typography>
<Button
variant="outlined"
startIcon={<RefreshIcon />}
onClick={handleRefresh}
disabled={dataLoading}
sx={{ minWidth: 120 }}
>
{dataLoading ? 'Refreshing...' : 'Refresh'}
</Button>
</Box>
{error && (
<Alert severity="error" sx={{ mb: 2 }}>
{error}
</Alert>
)}
{(error || storeError) && (
<Alert severity="error" sx={{ mb: 2 }}>
{error || storeError}
</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 */}
<Box sx={{ borderBottom: 1, borderColor: 'divider', mb: 3 }}>
@@ -191,38 +286,38 @@ const AnalyticsTab: React.FC = () => {
</Typography>
<Divider sx={{ mb: 2 }} />
{performanceMetrics ? (
{analyticsData && analyticsData.performance_trends ? (
<Grid container spacing={2}>
<Grid item xs={6}>
<Typography variant="body2" color="text.secondary">
Engagement Rate
</Typography>
<Typography variant="h4" color={getPerformanceColor(performanceMetrics.engagement)}>
{performanceMetrics.engagement}%
<Typography variant="h4" color={getPerformanceColor(analyticsData.performance_trends.engagement_rate || 0)}>
{analyticsData.performance_trends.engagement_rate || 0}%
</Typography>
</Grid>
<Grid item xs={6}>
<Typography variant="body2" color="text.secondary">
Reach
Traffic Growth
</Typography>
<Typography variant="h4" color="primary">
{performanceMetrics.reach.toLocaleString()}
{analyticsData.performance_trends.traffic_growth || 0}%
</Typography>
</Grid>
<Grid item xs={6}>
<Typography variant="body2" color="text.secondary">
Conversion Rate
</Typography>
<Typography variant="h4" color={getPerformanceColor(performanceMetrics.conversion)}>
{performanceMetrics.conversion}%
<Typography variant="h4" color={getPerformanceColor(analyticsData.performance_trends.conversion_rate || 0)}>
{analyticsData.performance_trends.conversion_rate || 0}%
</Typography>
</Grid>
<Grid item xs={6}>
<Typography variant="body2" color="text.secondary">
ROI
Content Quality
</Typography>
<Typography variant="h4" color="success.main">
${performanceMetrics.roi.toLocaleString()}
{analyticsData.performance_trends.content_quality_score || 0}/100
</Typography>
</Grid>
</Grid>
@@ -243,18 +338,18 @@ const AnalyticsTab: React.FC = () => {
</Typography>
<Divider sx={{ mb: 2 }} />
{aiInsights && aiInsights.length > 0 ? (
{analyticsData && analyticsData.insights && analyticsData.insights.length > 0 ? (
<Box>
{aiInsights.slice(0, 3).map((insight, index) => (
{analyticsData.insights.slice(0, 3).map((insight: any, index: number) => (
<Box key={index} sx={{ mb: 2 }}>
<Typography variant="subtitle2" gutterBottom>
{insight.title}
{insight.title || `Insight ${index + 1}`}
</Typography>
<Typography variant="body2" color="text.secondary" sx={{ mb: 1 }}>
{insight.description}
{insight.description || insight}
</Typography>
<Chip
label={insight.priority}
label={insight.priority || 'medium'}
color={insight.priority === 'high' ? 'error' : insight.priority === 'medium' ? 'warning' : 'success'}
size="small"
/>
@@ -263,7 +358,7 @@ const AnalyticsTab: React.FC = () => {
</Box>
) : (
<Typography variant="body2" color="text.secondary">
No AI insights available
No insights available
</Typography>
)}
</Paper>

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

@@ -220,7 +220,23 @@ class NavigationOrchestrator {
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);
}

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';
export interface MonitoringTask {
@@ -154,7 +154,7 @@ export const strategyMonitoringApi = {
*/
async getTrendData(strategyId: number, timeRange: string = '30d'): Promise<{ success: boolean; data: any; message: string }> {
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;
} catch (error: any) {
console.error('Error getting trend data:', error);
@@ -196,7 +196,7 @@ export const strategyMonitoringApi = {
// Quality Analysis API methods
async getQualityAnalysis(strategyId: number): Promise<{ success: boolean; data: any; message: string }> {
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;
} catch (error: any) {
console.error('Error fetching quality analysis:', error);