mirror of
https://github.com/th30d4y/OpenLearnX.git
synced 2026-05-26 19:26:33 +00:00
Stalin
1011 lines
42 KiB
Python
1011 lines
42 KiB
Python
from flask import Blueprint, request, jsonify
|
|
from datetime import datetime, timedelta, timezone
|
|
from pymongo import MongoClient
|
|
import os
|
|
from bson import ObjectId
|
|
import logging
|
|
import uuid
|
|
import jwt # ✅ Add proper JWT import at top level
|
|
|
|
bp = Blueprint('dashboard', __name__)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# MongoDB connection
|
|
mongo_uri = os.getenv('MONGODB_URI', 'mongodb://localhost:27017/')
|
|
client = MongoClient(mongo_uri)
|
|
db = client.openlearnx
|
|
|
|
def verify_wallet_authentication():
|
|
"""✅ FIXED: Verify MetaMask wallet authentication with proper JWT handling"""
|
|
user_id = None
|
|
wallet_address = None
|
|
|
|
# ✅ Try JWT token first with proper algorithm specification
|
|
auth_header = request.headers.get('Authorization', '')
|
|
if auth_header.startswith('Bearer '):
|
|
try:
|
|
token = auth_header.split(' ')[1]
|
|
# ✅ FIXED: Add algorithms parameter to fix JWT decode error
|
|
decoded = jwt.decode(
|
|
token,
|
|
options={"verify_signature": False}, # For development
|
|
algorithms=["HS256", "RS256"] # This fixes the JWT error
|
|
)
|
|
user_id = decoded.get('sub') or decoded.get('user_id') or decoded.get('uid') or decoded.get('wallet_address')
|
|
wallet_address = decoded.get('wallet_address') or user_id
|
|
|
|
if user_id:
|
|
logger.info(f"✅ JWT authentication verified: {user_id}")
|
|
return user_id, wallet_address
|
|
except Exception as e:
|
|
logger.warning(f"⚠️ JWT decode failed: {e}")
|
|
|
|
# ✅ Enhanced fallback: Try multiple header sources and request data
|
|
wallet_address = (
|
|
request.headers.get('X-Wallet-Address') or
|
|
request.headers.get('X-User-ID') or
|
|
request.args.get('wallet_address') or
|
|
(request.json.get('wallet_address') if request.is_json else None)
|
|
)
|
|
|
|
if wallet_address:
|
|
user_id = wallet_address
|
|
logger.info(f"✅ Wallet address authentication verified: {user_id}")
|
|
return user_id, wallet_address
|
|
|
|
# ✅ Enhanced debug logging for troubleshooting
|
|
logger.error("❌ No MetaMask wallet authentication found")
|
|
logger.debug(f"Auth header: {auth_header[:50]}...")
|
|
logger.debug(f"Headers: X-Wallet-Address={request.headers.get('X-Wallet-Address')}, X-User-ID={request.headers.get('X-User-ID')}")
|
|
return None, None
|
|
|
|
@bp.route('/comprehensive-stats', methods=['GET', 'OPTIONS'])
|
|
def get_comprehensive_stats():
|
|
"""Get ONLY REAL data from MongoDB - NO FAKE/DEMO DATA"""
|
|
if request.method == "OPTIONS":
|
|
return jsonify({'status': 'ok'})
|
|
|
|
try:
|
|
# ✅ VERIFY WALLET AUTHENTICATION
|
|
user_id, wallet_address = verify_wallet_authentication()
|
|
if not user_id:
|
|
return jsonify({
|
|
"success": False,
|
|
"error": "MetaMask wallet authentication required",
|
|
"auth_required": True,
|
|
"debug_hint": "Ensure JWT token is sent in Authorization header or wallet address in X-Wallet-Address header"
|
|
}), 401
|
|
|
|
logger.info(f"📊 Fetching REAL MongoDB data for wallet: {user_id}")
|
|
|
|
# Database connection check
|
|
try:
|
|
db.command('ping')
|
|
logger.info("✅ Database connection verified")
|
|
except Exception as e:
|
|
logger.error(f"❌ Database connection failed: {e}")
|
|
raise Exception("Database connection failed")
|
|
|
|
# ✅ GET USER PROFILE (REAL DATA ONLY)
|
|
user_profile = db.user_profiles.find_one({"user_id": user_id})
|
|
if not user_profile:
|
|
# ✅ Create basic profile for new users to prevent loops
|
|
basic_profile = {
|
|
"user_id": user_id,
|
|
"wallet_address": wallet_address,
|
|
"display_name": None,
|
|
"username_set": False,
|
|
"avatar_url": f"https://api.dicebear.com/7.x/avataaars/svg?seed={user_id}",
|
|
"created_at": datetime.now()
|
|
}
|
|
|
|
try:
|
|
db.user_profiles.insert_one(basic_profile.copy())
|
|
logger.info(f"✅ Created basic profile for new user: {user_id}")
|
|
except Exception as e:
|
|
logger.warning(f"⚠️ Failed to create user profile: {e}")
|
|
|
|
return jsonify({
|
|
"success": True,
|
|
"username_required": True,
|
|
"user_profile": basic_profile,
|
|
"message": "Please set your username to continue",
|
|
"user_id": user_id,
|
|
"wallet_address": wallet_address
|
|
})
|
|
|
|
# Convert ObjectId to string for JSON serialization
|
|
if '_id' in user_profile:
|
|
user_profile['_id'] = str(user_profile['_id'])
|
|
|
|
# Check if username is set
|
|
if not user_profile.get('display_name') or not user_profile.get('username_set', False):
|
|
return jsonify({
|
|
"success": True,
|
|
"username_required": True,
|
|
"user_profile": user_profile,
|
|
"message": "Please set your username to continue",
|
|
"user_id": user_id,
|
|
"wallet_address": wallet_address
|
|
})
|
|
|
|
# ✅ FETCH ONLY REAL DATA FROM MONGODB
|
|
user_stats = db.user_stats.find_one({"user_id": user_id})
|
|
courses = list(db.user_courses.find({"user_id": user_id}))
|
|
quizzes = list(db.user_quizzes.find({"user_id": user_id}))
|
|
coding_submissions = list(db.user_submissions.find({"user_id": user_id}))
|
|
blockchain_data = db.user_blockchain.find_one({"user_id": user_id})
|
|
achievements = list(db.user_achievements.find({"user_id": user_id}))
|
|
|
|
# Convert ObjectIds to strings for JSON serialization
|
|
for collection in [courses, quizzes, coding_submissions, achievements]:
|
|
for item in collection:
|
|
if '_id' in item:
|
|
item['_id'] = str(item['_id'])
|
|
|
|
if user_stats and '_id' in user_stats:
|
|
user_stats['_id'] = str(user_stats['_id'])
|
|
if blockchain_data and '_id' in blockchain_data:
|
|
blockchain_data['_id'] = str(blockchain_data['_id'])
|
|
|
|
logger.info(f"📊 REAL MongoDB data found:")
|
|
logger.info(f" - User stats: {'✅' if user_stats else '❌'}")
|
|
logger.info(f" - Courses: {len(courses)}")
|
|
logger.info(f" - Quizzes: {len(quizzes)}")
|
|
logger.info(f" - Coding submissions: {len(coding_submissions)}")
|
|
logger.info(f" - Achievements: {len(achievements)}")
|
|
|
|
# ✅ IF NO REAL DATA EXISTS, RETURN EMPTY STATE (NO FAKE DATA)
|
|
if not user_stats and not courses and not quizzes and not coding_submissions and not achievements:
|
|
logger.info(f"📊 No real learning data found for wallet {user_id}")
|
|
return jsonify({
|
|
"success": True,
|
|
"data": get_empty_stats(wallet_address),
|
|
"user_profile": user_profile,
|
|
"timestamp": datetime.now().isoformat(),
|
|
"user_id": user_id,
|
|
"wallet_address": wallet_address,
|
|
"data_source": "empty_real_data",
|
|
"message": "No learning data found. Start learning to see your real progress!"
|
|
})
|
|
|
|
# ✅ CALCULATE STATISTICS FROM ONLY REAL DATA
|
|
current_time = datetime.now()
|
|
|
|
# Real calculations (no fake data)
|
|
total_xp = calculate_real_total_xp(courses, quizzes, coding_submissions, achievements)
|
|
courses_completed = len([c for c in courses if c.get('completed', False)])
|
|
coding_problems_solved = len(coding_submissions)
|
|
quiz_accuracy = calculate_real_quiz_accuracy(quizzes)
|
|
coding_streak = calculate_real_coding_streak(coding_submissions)
|
|
longest_streak = user_stats.get('longest_streak', coding_streak) if user_stats else coding_streak
|
|
weekly_activity = calculate_real_weekly_activity(courses, quizzes, coding_submissions)
|
|
skill_levels = calculate_real_skill_levels(courses, quizzes, coding_submissions)
|
|
|
|
# ✅ REAL COMPREHENSIVE STATISTICS
|
|
comprehensive_stats = {
|
|
"total_xp": total_xp,
|
|
"courses_completed": courses_completed,
|
|
"coding_problems_solved": coding_problems_solved,
|
|
"quiz_accuracy": quiz_accuracy,
|
|
"streak_data": {
|
|
"current_streak": coding_streak,
|
|
"best_streak": max(longest_streak, coding_streak),
|
|
"last_active_date": datetime.now().isoformat()
|
|
},
|
|
"total_courses": len(courses),
|
|
"total_quizzes": len(quizzes),
|
|
"global_rank": calculate_real_global_rank(user_stats, user_id) if user_stats else 0,
|
|
"weekly_activity": weekly_activity,
|
|
"monthly_goals": {
|
|
"target": user_stats.get('monthly_target', 0) if user_stats else 0,
|
|
"completed": calculate_real_monthly_completed(courses, quizzes, coding_submissions, current_time)
|
|
},
|
|
"blockchain": {
|
|
"wallet_connected": True,
|
|
"wallet_address": wallet_address,
|
|
"total_earned": blockchain_data.get('total_earned', 0) if blockchain_data else 0,
|
|
"transactions": len(blockchain_data.get('transactions', [])) if blockchain_data else 0,
|
|
"certificates": len([a for a in achievements if a.get('type') == 'certificate']),
|
|
"verified_achievements": len([a for a in achievements if a.get('blockchain_verified', False)])
|
|
},
|
|
"learning_analytics": {
|
|
"time_spent_hours": calculate_real_time_spent(courses, quizzes, coding_submissions),
|
|
"average_session_minutes": user_stats.get('avg_session_minutes', 0) if user_stats else 0,
|
|
"completion_rate": calculate_real_completion_rate(courses, quizzes),
|
|
"favorite_topics": calculate_real_favorite_topics(courses, quizzes),
|
|
"skill_levels": skill_levels
|
|
},
|
|
"recent_achievements": [
|
|
{
|
|
"id": str(a.get('_id', uuid.uuid4())),
|
|
"title": a.get('title', ''),
|
|
"description": a.get('description', ''),
|
|
"earned_at": a.get('earned_at', current_time).isoformat() if isinstance(a.get('earned_at'), datetime) else str(a.get('earned_at', current_time.isoformat())),
|
|
"points": a.get('points', 0),
|
|
"rarity": a.get('rarity', 'common')
|
|
} for a in achievements[-5:] # Only last 5 REAL achievements
|
|
]
|
|
}
|
|
|
|
logger.info(f"✅ REAL statistics calculated for wallet {user_id}")
|
|
|
|
return jsonify({
|
|
"success": True,
|
|
"data": comprehensive_stats,
|
|
"user_profile": user_profile,
|
|
"username_required": False,
|
|
"timestamp": current_time.isoformat(),
|
|
"user_id": user_id,
|
|
"wallet_address": wallet_address,
|
|
"data_source": "pure_mongodb_data", # Indicates real data only
|
|
"collections_count": {
|
|
"courses": len(courses),
|
|
"quizzes": len(quizzes),
|
|
"coding_submissions": len(coding_submissions),
|
|
"achievements": len(achievements)
|
|
}
|
|
})
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Error fetching real stats: {str(e)}")
|
|
import traceback
|
|
logger.error(f"❌ Full traceback: {traceback.format_exc()}")
|
|
return jsonify({
|
|
"success": False,
|
|
"error": str(e),
|
|
"data_source": "error"
|
|
}), 500
|
|
|
|
@bp.route('/recent-activity', methods=['GET', 'OPTIONS'])
|
|
def get_recent_activity():
|
|
"""Get ONLY REAL recent activity from MongoDB"""
|
|
if request.method == "OPTIONS":
|
|
return jsonify({'status': 'ok'})
|
|
|
|
try:
|
|
user_id, wallet_address = verify_wallet_authentication()
|
|
if not user_id:
|
|
return jsonify({
|
|
"success": False,
|
|
"error": "MetaMask wallet authentication required",
|
|
"auth_required": True
|
|
}), 401
|
|
|
|
logger.info(f"📋 Fetching REAL activity for wallet: {user_id}")
|
|
|
|
identity_candidates = {str(user_id)}
|
|
if wallet_address:
|
|
identity_candidates.add(str(wallet_address).lower())
|
|
|
|
# Resolve user identity aliases to avoid missing activity across auth methods.
|
|
user_doc = None
|
|
try:
|
|
maybe_oid = ObjectId(str(user_id))
|
|
user_doc = db.users.find_one({"_id": maybe_oid})
|
|
except Exception:
|
|
user_doc = db.users.find_one({"wallet_address": str(user_id).lower()}) or db.users.find_one({"email": str(user_id).lower()})
|
|
|
|
if user_doc:
|
|
if user_doc.get("_id"):
|
|
identity_candidates.add(str(user_doc.get("_id")))
|
|
if user_doc.get("wallet_address"):
|
|
identity_candidates.add(str(user_doc.get("wallet_address")).lower())
|
|
if user_doc.get("email"):
|
|
identity_candidates.add(str(user_doc.get("email")).lower())
|
|
|
|
logger.info(f"📋 Recent activity identity candidates: {sorted(identity_candidates)}")
|
|
|
|
activities = []
|
|
|
|
def parse_datetime(value):
|
|
if isinstance(value, datetime):
|
|
return value
|
|
if isinstance(value, str):
|
|
candidate = value.replace("Z", "+00:00")
|
|
try:
|
|
return datetime.fromisoformat(candidate)
|
|
except Exception:
|
|
return None
|
|
return None
|
|
|
|
def to_utc_display(value):
|
|
dt = parse_datetime(value) or datetime.now(timezone.utc)
|
|
if dt.tzinfo is None:
|
|
dt = dt.replace(tzinfo=timezone.utc)
|
|
else:
|
|
dt = dt.astimezone(timezone.utc)
|
|
return dt.strftime("%Y-%m-%d %H:%M:%S UTC")
|
|
|
|
# Primary source: explicit user activity event log.
|
|
event_docs = list(
|
|
db.user_activity_events.find({"user_id": {"$in": list(identity_candidates)}}).sort("occurred_at", -1).limit(150)
|
|
)
|
|
for item in event_docs:
|
|
occurred_at = item.get("occurred_at") or item.get("completed_at") or datetime.now(timezone.utc)
|
|
activities.append({
|
|
"id": str(item.get("_id", uuid.uuid4())),
|
|
"type": item.get("type", "activity"),
|
|
"title": item.get("title", "User Activity"),
|
|
"description": item.get("description", "Activity recorded"),
|
|
"completed_at": parse_datetime(occurred_at).isoformat() if parse_datetime(occurred_at) else datetime.now(timezone.utc).isoformat(),
|
|
"timestamp_utc": item.get("timestamp_utc") or to_utc_display(occurred_at),
|
|
"points_earned": int(item.get("points_earned", 0) or 0),
|
|
"success_rate": item.get("success_rate", 0),
|
|
"difficulty": item.get("difficulty", ""),
|
|
"blockchain_verified": item.get("blockchain_verified", False)
|
|
})
|
|
|
|
# Include admin/account status events from security logs as real activity fallback.
|
|
admin_status_logs = list(
|
|
db.security_logs.find({
|
|
"event_type": "admin_user_status",
|
|
"metadata.user_id": {"$in": list(identity_candidates)}
|
|
}).sort("timestamp", -1).limit(50)
|
|
)
|
|
for item in admin_status_logs:
|
|
occurred_at = item.get("timestamp", datetime.now(timezone.utc))
|
|
metadata = item.get("metadata") or {}
|
|
new_status = metadata.get("status") or metadata.get("new_status") or "updated"
|
|
activities.append({
|
|
"id": str(item.get("_id", uuid.uuid4())),
|
|
"type": "account_status",
|
|
"title": f"Account status changed to {new_status}",
|
|
"description": f"Admin changed your account status to {new_status}",
|
|
"completed_at": parse_datetime(occurred_at).isoformat() if parse_datetime(occurred_at) else datetime.now(timezone.utc).isoformat(),
|
|
"timestamp_utc": to_utc_display(occurred_at),
|
|
"points_earned": 0,
|
|
"success_rate": 0,
|
|
"difficulty": "",
|
|
"blockchain_verified": False,
|
|
})
|
|
|
|
# Fallback source: authenticated request audit logs for this user.
|
|
audit_logs = list(
|
|
db.security_logs.find({
|
|
"$or": [
|
|
{"metadata.auth_user_id": {"$in": list(identity_candidates)}},
|
|
{"metadata.auth_wallet_address": {"$in": list(identity_candidates)}},
|
|
{"metadata.auth_email": {"$in": list(identity_candidates)}},
|
|
]
|
|
}).sort("timestamp", -1).limit(150)
|
|
)
|
|
for item in audit_logs:
|
|
path = str(item.get("path") or "")
|
|
method = str(item.get("method") or "")
|
|
ts = item.get("timestamp", datetime.now(timezone.utc))
|
|
if not any(segment in path for segment in ["/api/quizzes", "/api/exam", "/api/coding", "/api/courses", "/api/auth"]):
|
|
continue
|
|
|
|
if any(noise in path for noise in ["/api/auth/verify-token", "/api/health"]):
|
|
continue
|
|
|
|
log_type = "activity"
|
|
title = "Learning activity"
|
|
description = "Activity recorded"
|
|
if "/api/quizzes" in path:
|
|
log_type = "quiz"
|
|
if "/join-room" in path:
|
|
title = "Joined quiz room"
|
|
description = "Entered a live quiz room"
|
|
elif "/submit-answer" in path or "/submit" in path:
|
|
title = "Attempted quiz question"
|
|
description = "Submitted a quiz answer"
|
|
else:
|
|
title = "Quiz activity"
|
|
description = "Interacted with quizzes"
|
|
elif "/api/exam" in path or "/api/coding" in path:
|
|
log_type = "coding"
|
|
if "/join-exam" in path:
|
|
title = "Joined coding exam"
|
|
description = "Entered a coding exam"
|
|
elif "/submit" in path:
|
|
title = "Submitted coding solution"
|
|
description = "Submitted code for evaluation"
|
|
else:
|
|
title = "Coding activity"
|
|
description = "Interacted with coding workspace"
|
|
elif "/api/courses" in path:
|
|
log_type = "course"
|
|
if "/activity" in path:
|
|
title = "Course activity"
|
|
description = "Visited or started a course lesson"
|
|
elif "/complete" in path:
|
|
title = "Completed lesson"
|
|
description = "Marked lesson as completed"
|
|
else:
|
|
title = "Course activity"
|
|
description = "Viewed course content"
|
|
elif "/api/auth" in path:
|
|
log_type = "auth_login"
|
|
if "/login" in path or "/verify" in path:
|
|
title = "Authentication activity"
|
|
description = "Signed in to account"
|
|
else:
|
|
title = "Account activity"
|
|
description = "Authentication event recorded"
|
|
|
|
activities.append({
|
|
"id": str(item.get("_id", uuid.uuid4())),
|
|
"type": log_type,
|
|
"title": title,
|
|
"description": description,
|
|
"completed_at": parse_datetime(ts).isoformat() if parse_datetime(ts) else datetime.now(timezone.utc).isoformat(),
|
|
"timestamp_utc": to_utc_display(ts),
|
|
"points_earned": 0,
|
|
"success_rate": 0,
|
|
"difficulty": "",
|
|
"blockchain_verified": False,
|
|
})
|
|
|
|
# ✅ ONLY REAL ACTIVITY SOURCES
|
|
activity_sources = [
|
|
(db.user_courses, "course", "Course Activity", "completed_at"),
|
|
(db.user_quizzes, "quiz", "Quiz Activity", "completed_at"),
|
|
(db.user_submissions, "coding", "Coding Challenge", "submitted_at"),
|
|
(db.user_achievements, "achievement", "Achievement", "earned_at"),
|
|
]
|
|
|
|
for collection, activity_type, default_title, date_field in activity_sources:
|
|
try:
|
|
# Get ONLY real MongoDB data
|
|
recent_items = list(collection.find(
|
|
{"user_id": {"$in": list(identity_candidates)}}
|
|
).sort(date_field, -1).limit(20))
|
|
|
|
for item in recent_items:
|
|
completed_at = item.get(date_field, datetime.now())
|
|
|
|
if isinstance(completed_at, str):
|
|
try:
|
|
completed_at = datetime.fromisoformat(completed_at)
|
|
except:
|
|
completed_at = datetime.now()
|
|
elif not isinstance(completed_at, datetime):
|
|
completed_at = datetime.now()
|
|
|
|
activities.append({
|
|
"id": str(item.get('_id', uuid.uuid4())),
|
|
"type": activity_type,
|
|
"title": item.get('title', item.get('name', default_title)),
|
|
"description": format_real_activity_description(item, activity_type),
|
|
"completed_at": completed_at.isoformat(),
|
|
"timestamp_utc": to_utc_display(completed_at),
|
|
"points_earned": item.get('points', item.get('points_earned', 0)),
|
|
"success_rate": item.get('score', item.get('completion_percentage', 0)),
|
|
"difficulty": item.get('difficulty', ''),
|
|
"blockchain_verified": item.get('blockchain_verified', False)
|
|
})
|
|
except Exception as e:
|
|
logger.warning(f"⚠️ Failed to fetch {activity_type} activities: {e}")
|
|
continue
|
|
|
|
# Exclude known placeholder/demo activity content from older seeded data.
|
|
fake_markers = {
|
|
"completed react fundamentals",
|
|
"scored 95% on javascript quiz",
|
|
"7-day learning streak achieved",
|
|
"moved up 5 positions in leaderboard",
|
|
}
|
|
|
|
filtered_activities = []
|
|
for entry in activities:
|
|
entry_text = f"{entry.get('title', '')} {entry.get('description', '')}".strip().lower()
|
|
if any(marker in entry_text for marker in fake_markers):
|
|
continue
|
|
filtered_activities.append(entry)
|
|
|
|
activities = filtered_activities
|
|
|
|
# Sort by completion date
|
|
activities.sort(key=lambda x: x['completed_at'], reverse=True)
|
|
activities = activities[:100]
|
|
|
|
logger.info(f"✅ Found {len(activities)} REAL activities for wallet {user_id}")
|
|
return jsonify({
|
|
"success": True,
|
|
"data": activities,
|
|
"total_count": len(activities),
|
|
"data_source": "pure_mongodb_data"
|
|
})
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Error fetching real activity: {str(e)}")
|
|
return jsonify({
|
|
"success": False,
|
|
"error": str(e)
|
|
}), 500
|
|
|
|
@bp.route('/global-leaderboard', methods=['GET', 'OPTIONS'])
|
|
def get_global_leaderboard():
|
|
"""Get ONLY REAL global leaderboard from MongoDB - NO AUTH REQUIRED"""
|
|
if request.method == "OPTIONS":
|
|
return jsonify({'status': 'ok'})
|
|
|
|
try:
|
|
logger.info("🏆 Fetching REAL global leaderboard from MongoDB")
|
|
|
|
# ✅ GET ONLY REAL USER STATS - NO AUTH REQUIRED FOR LEADERBOARD
|
|
user_stats_cursor = db.user_stats.find({}).sort("total_xp", -1).limit(100)
|
|
user_stats_list = list(user_stats_cursor)
|
|
|
|
logger.info(f"📊 Found {len(user_stats_list)} REAL users in MongoDB")
|
|
|
|
if not user_stats_list:
|
|
logger.info("📊 No real users found in MongoDB")
|
|
return jsonify({
|
|
"success": True,
|
|
"data": [],
|
|
"message": "No users found. Be the first to start learning!"
|
|
})
|
|
|
|
leaderboard = []
|
|
for rank, user_stat in enumerate(user_stats_list, 1):
|
|
# Get real user profile
|
|
user_profile = db.user_profiles.find_one({"user_id": user_stat["user_id"]})
|
|
|
|
# Real user data only
|
|
username = "Anonymous User"
|
|
avatar = f"https://api.dicebear.com/7.x/avataaars/svg?seed={user_stat['user_id']}"
|
|
display_name = None
|
|
badges = []
|
|
|
|
if user_profile:
|
|
display_name = user_profile.get("display_name")
|
|
username = display_name or f"User_{user_stat['user_id'][-6:]}"
|
|
avatar = user_profile.get("avatar_url", avatar)
|
|
badges = user_profile.get("badges", [])
|
|
|
|
leaderboard.append({
|
|
"rank": rank,
|
|
"user_id": user_stat["user_id"],
|
|
"username": username,
|
|
"display_name": display_name,
|
|
"total_xp": user_stat.get("total_xp", 0),
|
|
"streak": user_stat.get("current_streak", 0),
|
|
"avatar": avatar,
|
|
"badges": badges,
|
|
"wallet_address": user_profile.get("wallet_address") if user_profile else None
|
|
})
|
|
|
|
logger.info(f"✅ REAL leaderboard generated with {len(leaderboard)} users")
|
|
return jsonify({
|
|
"success": True,
|
|
"data": leaderboard,
|
|
"data_source": "pure_mongodb_data"
|
|
})
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Error fetching real leaderboard: {str(e)}")
|
|
return jsonify({
|
|
"success": False,
|
|
"error": str(e)
|
|
}), 500
|
|
|
|
# ✅ Add username setup endpoints to prevent frontend errors
|
|
@bp.route('/set-username', methods=['POST', 'OPTIONS'])
|
|
def set_username():
|
|
"""Set username for authenticated user"""
|
|
if request.method == "OPTIONS":
|
|
return jsonify({'status': 'ok'})
|
|
|
|
try:
|
|
user_id, wallet_address = verify_wallet_authentication()
|
|
if not user_id:
|
|
return jsonify({
|
|
"success": False,
|
|
"error": "Authentication required",
|
|
"auth_required": True
|
|
}), 401
|
|
|
|
data = request.get_json()
|
|
username = data.get('username', '').strip()
|
|
|
|
if not username or len(username) < 3:
|
|
return jsonify({
|
|
"success": False,
|
|
"error": "Username must be at least 3 characters long"
|
|
}), 400
|
|
|
|
# Check if username already exists
|
|
existing_user = db.user_profiles.find_one({
|
|
"display_name": username,
|
|
"user_id": {"$ne": user_id}
|
|
})
|
|
|
|
if existing_user:
|
|
return jsonify({
|
|
"success": False,
|
|
"error": "Username already taken"
|
|
}), 400
|
|
|
|
# Update or create user profile
|
|
profile_data = {
|
|
"user_id": user_id,
|
|
"wallet_address": wallet_address,
|
|
"display_name": username,
|
|
"username_set": True,
|
|
"updated_at": datetime.now()
|
|
}
|
|
|
|
result = db.user_profiles.update_one(
|
|
{"user_id": user_id},
|
|
{"$set": profile_data, "$setOnInsert": {"created_at": datetime.now()}},
|
|
upsert=True
|
|
)
|
|
|
|
# Get updated profile
|
|
updated_profile = db.user_profiles.find_one({"user_id": user_id})
|
|
if updated_profile and '_id' in updated_profile:
|
|
updated_profile['_id'] = str(updated_profile['_id'])
|
|
|
|
logger.info(f"✅ Username set for user {user_id}: {username}")
|
|
|
|
return jsonify({
|
|
"success": True,
|
|
"message": f"Username '{username}' set successfully",
|
|
"profile": updated_profile
|
|
})
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Error setting username: {str(e)}")
|
|
return jsonify({
|
|
"success": False,
|
|
"error": str(e)
|
|
}), 500
|
|
|
|
@bp.route('/update-profile', methods=['POST', 'OPTIONS'])
|
|
def update_profile():
|
|
"""Update user profile (fallback for username setup)"""
|
|
if request.method == "OPTIONS":
|
|
return jsonify({'status': 'ok'})
|
|
|
|
try:
|
|
user_id, wallet_address = verify_wallet_authentication()
|
|
if not user_id:
|
|
return jsonify({
|
|
"success": False,
|
|
"error": "Authentication required",
|
|
"auth_required": True
|
|
}), 401
|
|
|
|
data = request.get_json()
|
|
display_name = data.get('display_name', '').strip()
|
|
|
|
if not display_name:
|
|
return jsonify({
|
|
"success": False,
|
|
"error": "Display name is required"
|
|
}), 400
|
|
|
|
# Update profile
|
|
profile_data = {
|
|
"user_id": user_id,
|
|
"wallet_address": wallet_address,
|
|
"display_name": display_name,
|
|
"username_set": True,
|
|
"updated_at": datetime.now()
|
|
}
|
|
|
|
db.user_profiles.update_one(
|
|
{"user_id": user_id},
|
|
{"$set": profile_data, "$setOnInsert": {"created_at": datetime.now()}},
|
|
upsert=True
|
|
)
|
|
|
|
# Get updated profile
|
|
updated_profile = db.user_profiles.find_one({"user_id": user_id})
|
|
if updated_profile and '_id' in updated_profile:
|
|
updated_profile['_id'] = str(updated_profile['_id'])
|
|
|
|
return jsonify({
|
|
"success": True,
|
|
"message": "Profile updated successfully",
|
|
"profile": updated_profile
|
|
})
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Error updating profile: {str(e)}")
|
|
return jsonify({
|
|
"success": False,
|
|
"error": str(e)
|
|
}), 500
|
|
|
|
# ===================================================================
|
|
# ✅ REAL DATA CALCULATION FUNCTIONS (NO FAKE DATA)
|
|
# ===================================================================
|
|
|
|
def get_empty_stats(wallet_address=None):
|
|
"""Return empty stats structure for users with no data"""
|
|
return {
|
|
"total_xp": 0,
|
|
"courses_completed": 0,
|
|
"coding_problems_solved": 0,
|
|
"quiz_accuracy": 0,
|
|
"coding_streak": 0,
|
|
"longest_streak": 0,
|
|
"total_courses": 0,
|
|
"total_quizzes": 0,
|
|
"global_rank": 0,
|
|
"weekly_activity": [0, 0, 0, 0, 0, 0, 0],
|
|
"monthly_goals": {"target": 0, "completed": 0},
|
|
"blockchain": {
|
|
"wallet_connected": True,
|
|
"wallet_address": wallet_address,
|
|
"total_earned": 0,
|
|
"transactions": 0,
|
|
"certificates": 0,
|
|
"verified_achievements": 0
|
|
},
|
|
"learning_analytics": {
|
|
"time_spent_hours": 0,
|
|
"average_session_minutes": 0,
|
|
"completion_rate": 0,
|
|
"favorite_topics": [],
|
|
"skill_levels": {
|
|
'Frontend': 0,
|
|
'Backend': 0,
|
|
'Blockchain': 0,
|
|
'AI/ML': 0,
|
|
'DevOps': 0
|
|
}
|
|
},
|
|
"recent_achievements": []
|
|
}
|
|
|
|
def calculate_real_total_xp(courses, quizzes, submissions, achievements):
|
|
"""Calculate total XP from ONLY real MongoDB data"""
|
|
course_xp = sum([c.get('points', 0) for c in courses if c.get('completed', False)])
|
|
quiz_xp = sum([q.get('points', 0) for q in quizzes])
|
|
coding_xp = sum([s.get('points_earned', 0) for s in submissions])
|
|
achievement_xp = sum([a.get('points', 0) for a in achievements])
|
|
|
|
total = course_xp + quiz_xp + coding_xp + achievement_xp
|
|
logger.info(f"📊 Real XP calculation: courses={course_xp}, quizzes={quiz_xp}, coding={coding_xp}, achievements={achievement_xp}, total={total}")
|
|
return total
|
|
|
|
def calculate_real_coding_streak(submissions):
|
|
"""Calculate coding streak from ONLY real submissions"""
|
|
if not submissions:
|
|
return 0
|
|
|
|
sorted_submissions = sorted(submissions, key=lambda x: x.get('submitted_at', datetime.min), reverse=True)
|
|
current_date = datetime.now().date()
|
|
streak = 0
|
|
checked_dates = set()
|
|
|
|
for submission in sorted_submissions:
|
|
submission_date = submission.get('submitted_at')
|
|
if isinstance(submission_date, str):
|
|
try:
|
|
submission_date = datetime.fromisoformat(submission_date).date()
|
|
except:
|
|
continue
|
|
elif isinstance(submission_date, datetime):
|
|
submission_date = submission_date.date()
|
|
else:
|
|
continue
|
|
|
|
if submission_date in checked_dates:
|
|
continue
|
|
checked_dates.add(submission_date)
|
|
|
|
expected_date = current_date - timedelta(days=streak)
|
|
if submission_date == expected_date:
|
|
streak += 1
|
|
else:
|
|
break
|
|
|
|
logger.info(f"📊 Real coding streak calculated: {streak} days from {len(submissions)} submissions")
|
|
return streak
|
|
|
|
def calculate_real_weekly_activity(courses, quizzes, submissions):
|
|
"""Calculate weekly activity from ONLY real MongoDB data"""
|
|
current_date = datetime.now()
|
|
weekly_activity = []
|
|
|
|
for i in range(7):
|
|
day_start = current_date - timedelta(days=6-i)
|
|
day_start = day_start.replace(hour=0, minute=0, second=0, microsecond=0)
|
|
day_end = day_start + timedelta(days=1)
|
|
|
|
activity_count = 0
|
|
|
|
# Count ONLY real activities
|
|
for course in courses:
|
|
completed_at = course.get('completed_at')
|
|
if completed_at and isinstance(completed_at, datetime) and day_start <= completed_at < day_end:
|
|
activity_count += 1
|
|
|
|
for quiz in quizzes:
|
|
completed_at = quiz.get('completed_at')
|
|
if completed_at and isinstance(completed_at, datetime) and day_start <= completed_at < day_end:
|
|
activity_count += 1
|
|
|
|
for submission in submissions:
|
|
submitted_at = submission.get('submitted_at')
|
|
if submitted_at and isinstance(submitted_at, datetime) and day_start <= submitted_at < day_end:
|
|
activity_count += 1
|
|
|
|
weekly_activity.append(activity_count)
|
|
|
|
logger.info(f"📊 Real weekly activity: {weekly_activity}")
|
|
return weekly_activity
|
|
|
|
def calculate_real_quiz_accuracy(quizzes):
|
|
"""Calculate quiz accuracy from ONLY real quiz data"""
|
|
if not quizzes:
|
|
return 0
|
|
|
|
scores = [q.get('score', 0) for q in quizzes if q.get('score') is not None]
|
|
accuracy = sum(scores) / len(scores) if scores else 0
|
|
logger.info(f"📊 Real quiz accuracy: {accuracy}% from {len(quizzes)} quizzes")
|
|
return accuracy
|
|
|
|
def calculate_real_global_rank(user_stats, user_id):
|
|
"""Calculate global rank from ONLY real MongoDB data"""
|
|
if not user_stats:
|
|
return 0
|
|
|
|
user_xp = user_stats.get('total_xp', 0)
|
|
|
|
try:
|
|
higher_ranked = db.user_stats.count_documents({"total_xp": {"$gt": user_xp}})
|
|
rank = higher_ranked + 1
|
|
logger.info(f"📊 Real global rank: {rank} (XP: {user_xp})")
|
|
return rank
|
|
except Exception as e:
|
|
logger.error(f"Error calculating real global rank: {e}")
|
|
return 0
|
|
|
|
def calculate_real_monthly_completed(courses, quizzes, submissions, current_time):
|
|
"""Calculate monthly completions from ONLY real data"""
|
|
current_month = current_time.month
|
|
current_year = current_time.year
|
|
completed = 0
|
|
|
|
for course in courses:
|
|
completed_at = course.get('completed_at')
|
|
if (completed_at and isinstance(completed_at, datetime) and
|
|
completed_at.month == current_month and completed_at.year == current_year):
|
|
completed += 1
|
|
|
|
for quiz in quizzes:
|
|
completed_at = quiz.get('completed_at')
|
|
if (completed_at and isinstance(completed_at, datetime) and
|
|
completed_at.month == current_month and completed_at.year == current_year):
|
|
completed += 1
|
|
|
|
for submission in submissions:
|
|
submitted_at = submission.get('submitted_at')
|
|
if (submitted_at and isinstance(submitted_at, datetime) and
|
|
submitted_at.month == current_month and submitted_at.year == current_year):
|
|
completed += 1
|
|
|
|
logger.info(f"📊 Real monthly completed: {completed} this month")
|
|
return completed
|
|
|
|
def calculate_real_skill_levels(courses, quizzes, submissions):
|
|
"""Calculate skill levels from ONLY real MongoDB data"""
|
|
skills = {'Frontend': 0, 'Backend': 0, 'Blockchain': 0, 'AI/ML': 0, 'DevOps': 0}
|
|
|
|
# Calculate from ONLY real course data
|
|
for course in courses:
|
|
if not course.get('completed', False):
|
|
continue
|
|
|
|
topic = course.get('topic', '').lower()
|
|
points = course.get('points', 0)
|
|
|
|
if any(keyword in topic for keyword in ['react', 'frontend', 'css', 'html', 'javascript']):
|
|
skills['Frontend'] += points * 0.1
|
|
elif any(keyword in topic for keyword in ['backend', 'api', 'server', 'node', 'python']):
|
|
skills['Backend'] += points * 0.1
|
|
elif any(keyword in topic for keyword in ['blockchain', 'web3', 'smart', 'solidity']):
|
|
skills['Blockchain'] += points * 0.1
|
|
elif any(keyword in topic for keyword in ['ai', 'ml', 'machine', 'learning']):
|
|
skills['AI/ML'] += points * 0.1
|
|
elif any(keyword in topic for keyword in ['devops', 'docker', 'deploy']):
|
|
skills['DevOps'] += points * 0.1
|
|
|
|
# Calculate from ONLY real coding submissions
|
|
for submission in submissions:
|
|
language = submission.get('language', '').lower()
|
|
points = submission.get('points_earned', 0)
|
|
|
|
if language in ['javascript', 'typescript']:
|
|
skills['Frontend'] += points * 0.05
|
|
elif language in ['python', 'java']:
|
|
skills['Backend'] += points * 0.05
|
|
elif language in ['solidity']:
|
|
skills['Blockchain'] += points * 0.05
|
|
|
|
# Normalize to 0-100 scale
|
|
max_skill = max(skills.values()) if any(skills.values()) else 1
|
|
for skill in skills:
|
|
skills[skill] = min(100, int((skills[skill] / max_skill) * 100)) if max_skill > 0 else 0
|
|
|
|
logger.info(f"📊 Real skill levels: {skills}")
|
|
return skills
|
|
|
|
def calculate_real_time_spent(courses, quizzes, submissions):
|
|
"""Calculate time spent from ONLY real data"""
|
|
completed_courses = [c for c in courses if c.get('completed', False)]
|
|
total_time = len(completed_courses) * 2 + len(quizzes) * 0.5 + len(submissions) * 1
|
|
logger.info(f"📊 Real time spent: {int(total_time)} hours")
|
|
return int(total_time)
|
|
|
|
def calculate_real_completion_rate(courses, quizzes):
|
|
"""Calculate completion rate from ONLY real data"""
|
|
total_started = len(courses)
|
|
if total_started == 0:
|
|
return 0
|
|
|
|
completed_courses = len([c for c in courses if c.get('completed', False)])
|
|
rate = (completed_courses / total_started * 100) if total_started > 0 else 0
|
|
logger.info(f"📊 Real completion rate: {rate}% ({completed_courses}/{total_started})")
|
|
return rate
|
|
|
|
def calculate_real_favorite_topics(courses, quizzes):
|
|
"""Calculate favorite topics from ONLY real data"""
|
|
topics = {}
|
|
|
|
for course in courses:
|
|
topic = course.get('topic', 'General')
|
|
if topic and topic != 'General':
|
|
weight = 2 if course.get('completed', False) else 1
|
|
topics[topic] = topics.get(topic, 0) + weight
|
|
|
|
for quiz in quizzes:
|
|
topic = quiz.get('topic', 'General')
|
|
if topic and topic != 'General':
|
|
topics[topic] = topics.get(topic, 0) + 1
|
|
|
|
sorted_topics = sorted(topics.items(), key=lambda x: x[1], reverse=True)
|
|
favorite_topics = [topic for topic, count in sorted_topics[:3] if count > 0]
|
|
logger.info(f"📊 Real favorite topics: {favorite_topics}")
|
|
return favorite_topics
|
|
|
|
def format_real_activity_description(item, activity_type):
|
|
"""Format activity description from real data"""
|
|
if activity_type == "course":
|
|
return f"Completed: {item.get('description', 'Course module')}"
|
|
elif activity_type == "quiz":
|
|
score = item.get('score', 0)
|
|
return f"Quiz score: {score}%"
|
|
elif activity_type == "coding":
|
|
language = item.get('language', 'Unknown')
|
|
return f"Solved in {language}"
|
|
elif activity_type == "achievement":
|
|
return item.get('description', 'Achievement unlocked')
|
|
else:
|
|
return "Activity completed"
|
|
|
|
# ✅ Root route
|
|
@bp.route('/', methods=['GET'])
|
|
def dashboard_root():
|
|
"""MongoDB-Only Dashboard API"""
|
|
return jsonify({
|
|
"message": "OpenLearnX MongoDB-Only Dashboard API",
|
|
"version": "4.1.0-fixed-auth",
|
|
"features": [
|
|
"🎯 ONLY Real MongoDB Data",
|
|
"❌ NO Fake/Demo/Temp Data",
|
|
"🦊 MetaMask Wallet Authentication",
|
|
"👤 Real User Profiles with Custom Names",
|
|
"📊 Authentic Learning Analytics",
|
|
"🏆 Real Achievement System",
|
|
"🔗 Blockchain Verification",
|
|
"📈 Pure Progress Tracking",
|
|
"✅ Fixed JWT Authentication"
|
|
],
|
|
"data_policy": "100% Real MongoDB Data Only - No Artificial Content",
|
|
"endpoints": [
|
|
"/api/dashboard/comprehensive-stats",
|
|
"/api/dashboard/recent-activity",
|
|
"/api/dashboard/global-leaderboard",
|
|
"/api/dashboard/set-username",
|
|
"/api/dashboard/update-profile"
|
|
],
|
|
"authentication": "JWT Token in Authorization header OR Wallet address in X-Wallet-Address header"
|
|
}) |