Allen
294 lines
8.7 KiB
JavaScript
294 lines
8.7 KiB
JavaScript
const express = require('express');
|
|
const Games = require('../models/games');
|
|
const { DeveloperEarnings } = require('../models/plays');
|
|
const { pool } = require('../models/db');
|
|
const { authenticate } = require('../middleware/auth');
|
|
|
|
const router = express.Router();
|
|
|
|
// Get developer dashboard
|
|
router.get('/dashboard',
|
|
authenticate,
|
|
async (req, res, next) => {
|
|
try {
|
|
const games = await Games.findByCreator(req.user.id);
|
|
const earnings = await DeveloperEarnings.getByDeveloper(req.user.id);
|
|
|
|
const totalPlays = games.reduce((sum, g) => sum + g.play_count, 0);
|
|
const publishedGames = games.filter(g => g.status === 'published');
|
|
const pendingGames = games.filter(g => g.status === 'pending_review');
|
|
const draftGames = games.filter(g => g.status === 'draft');
|
|
|
|
res.json({
|
|
stats: {
|
|
totalGames: games.length,
|
|
publishedGames: publishedGames.length,
|
|
pendingReview: pendingGames.length,
|
|
drafts: draftGames.length,
|
|
totalPlays: totalPlays,
|
|
tokensEarned: parseInt(earnings.total_earned) || 0,
|
|
currentBalance: req.user.tokens_balance
|
|
}
|
|
});
|
|
} catch (error) {
|
|
next(error);
|
|
}
|
|
}
|
|
);
|
|
|
|
// Get developer's games with detailed stats
|
|
router.get('/games',
|
|
authenticate,
|
|
async (req, res, next) => {
|
|
try {
|
|
const games = await Games.findByCreator(req.user.id);
|
|
|
|
res.json({
|
|
games: games.map(g => ({
|
|
id: g.id,
|
|
title: g.title,
|
|
description: g.description,
|
|
status: g.status,
|
|
playCount: g.play_count,
|
|
tokensEarned: g.tokens_earned,
|
|
averageRating: g.total_ratings > 0
|
|
? (g.rating_sum / g.total_ratings).toFixed(1)
|
|
: null,
|
|
totalRatings: g.total_ratings,
|
|
createdAt: g.created_at,
|
|
publishedAt: g.published_at,
|
|
rejectionReason: g.rejection_reason
|
|
}))
|
|
});
|
|
} catch (error) {
|
|
next(error);
|
|
}
|
|
}
|
|
);
|
|
|
|
// Request payout (placeholder - would integrate with payment system)
|
|
router.post('/request-payout',
|
|
authenticate,
|
|
async (req, res, next) => {
|
|
try {
|
|
const minPayout = 100;
|
|
|
|
if (req.user.tokens_balance < minPayout) {
|
|
return res.status(400).json({
|
|
error: `Minimum payout is ${minPayout} tokens`,
|
|
currentBalance: req.user.tokens_balance
|
|
});
|
|
}
|
|
|
|
// TODO: Integrate with payment system
|
|
// For now, just acknowledge the request
|
|
|
|
res.json({
|
|
message: 'Payout request received',
|
|
amount: req.user.tokens_balance,
|
|
note: 'Payout processing coming soon!'
|
|
});
|
|
} catch (error) {
|
|
next(error);
|
|
}
|
|
}
|
|
);
|
|
|
|
// Get game analytics (creator only)
|
|
router.get('/games/:gameId/analytics',
|
|
authenticate,
|
|
async (req, res, next) => {
|
|
try {
|
|
const { gameId } = req.params;
|
|
|
|
// Get the game and verify ownership
|
|
const game = await Games.findById(gameId);
|
|
|
|
if (!game) {
|
|
return res.status(404).json({ error: 'Game not found' });
|
|
}
|
|
|
|
if (game.creator_id !== req.user.id) {
|
|
return res.status(403).json({ error: 'You can only view analytics for your own games' });
|
|
}
|
|
|
|
// Run all analytics queries in parallel for performance
|
|
const [
|
|
dailyPlaysResult,
|
|
ratingDistributionResult,
|
|
sessionStatsResult,
|
|
uniquePlayersResult,
|
|
highScoreDistributionResult,
|
|
peakHoursResult,
|
|
highestScoreResult
|
|
] = await Promise.all([
|
|
// Daily play counts for last 30 days
|
|
pool.query(
|
|
`SELECT DATE(started_at) as date, COUNT(*) as count
|
|
FROM plays
|
|
WHERE game_id = $1
|
|
AND started_at >= CURRENT_DATE - INTERVAL '30 days'
|
|
GROUP BY DATE(started_at)
|
|
ORDER BY date ASC`,
|
|
[gameId]
|
|
),
|
|
|
|
// Rating distribution (1-5 stars breakdown)
|
|
pool.query(
|
|
`SELECT rating, COUNT(*) as count
|
|
FROM ratings
|
|
WHERE game_id = $1
|
|
GROUP BY rating
|
|
ORDER BY rating ASC`,
|
|
[gameId]
|
|
),
|
|
|
|
// Average session duration
|
|
pool.query(
|
|
`SELECT
|
|
AVG(duration_seconds) as avg_duration,
|
|
MIN(duration_seconds) as min_duration,
|
|
MAX(duration_seconds) as max_duration,
|
|
COUNT(*) as total_sessions
|
|
FROM plays
|
|
WHERE game_id = $1 AND duration_seconds IS NOT NULL`,
|
|
[gameId]
|
|
),
|
|
|
|
// Total unique players
|
|
pool.query(
|
|
`SELECT COUNT(DISTINCT player_id) as unique_players
|
|
FROM plays
|
|
WHERE game_id = $1`,
|
|
[gameId]
|
|
),
|
|
|
|
// High score distribution (buckets)
|
|
pool.query(
|
|
`SELECT
|
|
CASE
|
|
WHEN score < 100 THEN '0-99'
|
|
WHEN score < 500 THEN '100-499'
|
|
WHEN score < 1000 THEN '500-999'
|
|
WHEN score < 5000 THEN '1000-4999'
|
|
WHEN score < 10000 THEN '5000-9999'
|
|
ELSE '10000+'
|
|
END as score_range,
|
|
COUNT(*) as count
|
|
FROM high_scores
|
|
WHERE game_id = $1
|
|
GROUP BY
|
|
CASE
|
|
WHEN score < 100 THEN '0-99'
|
|
WHEN score < 500 THEN '100-499'
|
|
WHEN score < 1000 THEN '500-999'
|
|
WHEN score < 5000 THEN '1000-4999'
|
|
WHEN score < 10000 THEN '5000-9999'
|
|
ELSE '10000+'
|
|
END
|
|
ORDER BY MIN(score) ASC`,
|
|
[gameId]
|
|
),
|
|
|
|
// Peak play hours (hour of day distribution)
|
|
pool.query(
|
|
`SELECT EXTRACT(HOUR FROM started_at) as hour, COUNT(*) as count
|
|
FROM plays
|
|
WHERE game_id = $1
|
|
GROUP BY EXTRACT(HOUR FROM started_at)
|
|
ORDER BY hour ASC`,
|
|
[gameId]
|
|
),
|
|
|
|
// Highest score
|
|
pool.query(
|
|
`SELECT MAX(score) as highest_score FROM high_scores WHERE game_id = $1`,
|
|
[gameId]
|
|
)
|
|
]);
|
|
|
|
// Build daily plays with date labels (last 30 days filled in)
|
|
const today = new Date();
|
|
const thirtyDaysAgo = new Date(today);
|
|
thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
|
|
|
|
const dailyPlaysMap = new Map(
|
|
dailyPlaysResult.rows.map(row => [
|
|
row.date.toISOString().split('T')[0],
|
|
parseInt(row.count)
|
|
])
|
|
);
|
|
|
|
const dailyPlays = [];
|
|
for (let d = new Date(thirtyDaysAgo); d <= today; d.setDate(d.getDate() + 1)) {
|
|
const dateStr = d.toISOString().split('T')[0];
|
|
const dayNum = d.getDate();
|
|
dailyPlays.push({
|
|
date: dateStr,
|
|
plays: dailyPlaysMap.get(dateStr) || 0,
|
|
label: dayNum.toString()
|
|
});
|
|
}
|
|
|
|
// Build rating distribution as object {1: count, 2: count, ...}
|
|
const ratingDistribution = { 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 };
|
|
ratingDistributionResult.rows.forEach(row => {
|
|
ratingDistribution[row.rating] = parseInt(row.count);
|
|
});
|
|
|
|
// Build peak hours as object {0: count, 1: count, ...23: count}
|
|
const peakHours = {};
|
|
for (let hour = 0; hour < 24; hour++) {
|
|
peakHours[hour] = 0;
|
|
}
|
|
peakHoursResult.rows.forEach(row => {
|
|
peakHours[parseInt(row.hour)] = parseInt(row.count);
|
|
});
|
|
|
|
// Build score distribution as object with range labels
|
|
const scoreRanges = ['0-99', '100-499', '500-999', '1000-4999', '5000-9999', '10000+'];
|
|
const scoreDistribution = {};
|
|
scoreRanges.forEach(range => { scoreDistribution[range] = 0; });
|
|
highScoreDistributionResult.rows.forEach(row => {
|
|
scoreDistribution[row.score_range] = parseInt(row.count);
|
|
});
|
|
|
|
const sessionStats = sessionStatsResult.rows[0];
|
|
const avgSessionDuration = sessionStats.avg_duration
|
|
? Math.round(parseFloat(sessionStats.avg_duration))
|
|
: 0;
|
|
|
|
const uniquePlayers = parseInt(uniquePlayersResult.rows[0].unique_players);
|
|
const highestScore = highestScoreResult.rows[0].highest_score
|
|
? parseInt(highestScoreResult.rows[0].highest_score)
|
|
: null;
|
|
|
|
const avgRating = game.total_ratings > 0
|
|
? parseFloat((game.rating_sum / game.total_ratings).toFixed(2))
|
|
: null;
|
|
|
|
res.json({
|
|
dailyPlays,
|
|
ratingDistribution,
|
|
peakHours,
|
|
scoreDistribution,
|
|
summary: {
|
|
totalPlays: game.play_count || 0,
|
|
uniquePlayers,
|
|
avgSessionDuration,
|
|
favoriteCount: game.favorite_count || 0,
|
|
avgRating,
|
|
totalRatings: game.total_ratings || 0,
|
|
highestScore,
|
|
remixCount: game.remix_count || 0,
|
|
tokensEarned: game.tokens_earned || 0
|
|
}
|
|
});
|
|
} catch (error) {
|
|
next(error);
|
|
}
|
|
}
|
|
);
|
|
|
|
module.exports = router;
|