Score calc fix and filters disable

Author: LyeZinho

app/api/banner/[username]/route.tsx

@@ -1,13 +1,11 @@
 import { type NextRequest, NextResponse } from "next/server"
-import { fetchGitHubUser, fetchUserRepos } from "@/lib/github-api"
-import { calculateGitScore, generateBadges } from "@/lib/score-calculator"
+import { fetchGitHubUser, fetchUserRepos, getCachedScore } from "@/lib/github-api"
 
 export async function GET(request: NextRequest, { params }: { params: { username: string } }) {
   try {
     const userData = await fetchGitHubUser(params.username)
     const reposData = await fetchUserRepos(params.username)
-    const score = calculateGitScore(userData, reposData)
-    const badges = generateBadges(userData, reposData).slice(0, 3) // Mostrar apenas 3 badges no banner
+    const { score, badges } = await getCachedScore(params.username)
 
     const svg = generateScoreCard({
       username: userData.login,
@@ -16,8 +14,8 @@ export async function GET(request: NextRequest, { params }: { params: { username
       avatar: userData.avatar_url,
       followers: userData.followers,
       repos: userData.public_repos,
-      stars: reposData.reduce((acc, repo) => acc + repo.stargazers_count, 0),
-      badges,
+      stars: reposData.reduce((acc: number, repo: any) => acc + repo.stargazers_count, 0),
+      badges: badges.slice(0, 3),
     })
 
     return new NextResponse(svg, {

app/leaderboard/page.tsx

@@ -27,9 +27,10 @@ export default function LeaderboardPage({ searchParams }: PageProps) {
         </div>
 
         {/* Filters */}
-        <div className="mb-8">
+        {/* Desativado temporariamente */}
+        {/* <div className="mb-8 mx-auto max-w-6xl">
           <LeaderboardFilters />
-        </div>
+        </div> */}
 
         {/* Content */}
         <Suspense fallback={<LeaderboardSkeleton />}>

app/user/[username]/page.tsx

@@ -4,8 +4,7 @@ import { UserBadges } from "@/components/user-badges"
 import { UserStats } from "@/components/user-stats"
 import { UserRepos } from "@/components/user-repos"
 import { ReadmeMD } from "@/components/readme-md"
-import { calculateGitScore, generateBadges } from "@/lib/score-calculator"
-import { fetchGitHubUser, fetchUserRepos } from "@/lib/github-api"
+import { fetchGitHubUser, fetchUserRepos, getCachedScore } from "@/lib/github-api"
 
 interface PageProps {
   params: {
@@ -18,8 +17,7 @@ export default async function UserPage({ params }: PageProps) {
     const userData = await fetchGitHubUser(params.username)
     const reposData = await fetchUserRepos(params.username)
 
-    const score = calculateGitScore(userData, reposData)
-    const badges = generateBadges(userData, reposData)
+    const { score, badges } = await getCachedScore(params.username)
 
     return (
       <div className="min-h-screen bg-gradient-to-br from-slate-50 to-slate-100 dark:from-slate-900 dark:to-slate-800">

components/leaderboard-filters.tsx

@@ -83,7 +83,7 @@ export function LeaderboardFilters() {
     <div className="space-y-4">
       {/* Filter Toggle */}
       <div className="flex items-center justify-between">
-        <Button variant="outline" onClick={() => setShowFilters(!showFilters)} className="flex items-center space-x-2">
+        <Button variant="outline" onClick={() => setShowFilters(!showFilters)} className="flex items-center space-x-4">
           <Filter className="h-4 w-4" />
           <span>Filtros Avançados</span>
         </Button>

lib/github-api.ts

@@ -1,3 +1,5 @@
+import { calculateGitScore, generateBadges } from "@/lib/score-calculator"
+
 const GITHUB_TOKEN = process.env.GITHUB_TOKEN || "";
 
 interface NextFetchRequestConfig {
@@ -9,6 +11,63 @@ interface ExtendedRequestInit extends RequestInit {
   next?: NextFetchRequestConfig;
 }
 
+// Cache para scores calculados
+const scoreCache = new Map<string, { 
+  score: number; 
+  badges: any[]; 
+  timestamp: number; 
+  userDataHash: string; 
+}>()
+
+const CACHE_DURATION = 1000 * 60 * 60 * 24 // 24 horas
+
+// Função para gerar hash dos dados do usuário (para detectar mudanças)
+function generateUserDataHash(userData: any, reposData: any[]): string {
+  const hashData = {
+    followers: userData.followers,
+    public_repos: userData.public_repos,
+    public_gists: userData.public_gists,
+    stars: reposData.reduce((acc: number, repo: any) => acc + repo.stargazers_count, 0),
+    forks: reposData.reduce((acc: number, repo: any) => acc + repo.forks_count, 0),
+    lastPush: reposData.length > 0 ? reposData[0].pushed_at : null,
+  }
+  return JSON.stringify(hashData)
+}
+
+// Função para obter score com cache
+export async function getCachedScore(username: string): Promise<{ score: number; badges: any[] }> {
+  const now = Date.now()
+  const userKey = username.toLowerCase()
+  
+  const userData = await fetchGitHubUser(username)
+  const reposData = await fetchUserRepos(username)
+  const currentHash = generateUserDataHash(userData, reposData)
+  
+  // Verificar se existe cache válido
+  const cached = scoreCache.get(userKey)
+  if (cached && 
+      (now - cached.timestamp) < CACHE_DURATION && 
+      cached.userDataHash === currentHash) {
+    console.log(`Using cached score for ${username}`)
+    return { score: cached.score, badges: cached.badges }
+  }
+  
+  // Calcular novo score
+  // console.log(`Calculating new score for ${username}`)
+  const score = calculateGitScore(userData, reposData)
+  const badges = generateBadges(userData, reposData)
+  
+  // Armazenar no cache
+  scoreCache.set(userKey, {
+    score,
+    badges,
+    timestamp: now,
+    userDataHash: currentHash
+  })
+  
+  return { score, badges }
+}
+
 export async function fetchGitHubUser(username: string) {
   const response = await fetch(`https://api.github.com/users/${username}`, {
     headers: {
@@ -103,27 +162,6 @@ export async function fetchPopularDevelopers(location?: string, language?: strin
   return response.json()
 }
 
-// Função para calcular GitScore baseado nos dados do usuário e repositórios
-export function calculateGitScore(user: any, repos: any[]) {
-  const totalStars = repos.reduce((acc, repo) => acc + repo.stargazers_count, 0)
-  const totalForks = repos.reduce((acc, repo) => acc + repo.forks_count, 0)
-  const publicRepos = user.public_repos || repos.length
-  const followers = user.followers || 0
-  const accountAge = Math.max(1, Math.floor((Date.now() - new Date(user.created_at).getTime()) / (1000 * 60 * 60 * 24 * 365)))
-
-  // Cálculo do score baseado em múltiplos fatores
-  const starScore = Math.sqrt(totalStars) * 10
-  const forkScore = Math.sqrt(totalForks) * 8
-  const repoScore = Math.sqrt(publicRepos) * 15
-  const followerScore = Math.sqrt(followers) * 12
-  const consistencyBonus = Math.min(100, (publicRepos / accountAge) * 20)
-
-  const rawScore = starScore + forkScore + repoScore + followerScore + consistencyBonus
-  
-  // Normalizar para uma escala mais intuitiva
-  return Math.round(rawScore)
-}
-
 // Função para obter rank baseado no score
 export function getRankFromScore(score: number): string {
   if (score >= 4000) return "SS+"
@@ -160,7 +198,7 @@ export async function fetchLeaderboardData(filters: {
           fetchUserRepos(dev.login)
         ])
 
-        const score = calculateGitScore(userDetails, repos)
+        const { score, badges } = await getCachedScore(dev.login)
         const rank = getRankFromScore(score)
 
         // Filtrar por score se especificado

lib/score-calculator.ts

@@ -5,11 +5,24 @@ export function calculateGitScore(userData: any, reposData: any[]) {
   const publicRepos = userData.public_repos
   const publicGists = userData.public_gists
 
-  // Simular contribuições (em uma implementação real, usaria GraphQL)
-  const contributions = Math.floor(Math.random() * 1000) + 200
+  // Calcular contribuições baseado em dados existentes ao invés de aleatório
+  const contributions = Math.min(
+    reposData.reduce((acc, repo) => acc + repo.open_issues_count, 0) * 10 + 
+    publicRepos * 15 + 
+    publicGists * 5,
+    2000
+  )
 
-  // Calcular dias desde último commit (simulado)
-  const daysSinceLastCommit = Math.floor(Math.random() * 30)
+  // Calcular "frescor" baseado na data do último push (ao invés de aleatório)
+  const now = new Date()
+  const lastPushDates = reposData
+    .filter(repo => repo.pushed_at)
+    .map(repo => new Date(repo.pushed_at))
+    .sort((a, b) => b.getTime() - a.getTime())
+  
+  const daysSinceLastCommit = lastPushDates.length > 0 
+    ? Math.min(Math.floor((now.getTime() - lastPushDates[0].getTime()) / (1000 * 60 * 60 * 24)), 365)
+    : 365
 
   const score = Math.max(
     0,
@@ -28,7 +41,14 @@ export function calculateGitScore(userData: any, reposData: any[]) {
 export function generateBadges(userData: any, reposData: any[]) {
   const stars = reposData.reduce((acc, repo) => acc + repo.stargazers_count, 0)
   const forks = reposData.reduce((acc, repo) => acc + repo.forks_count, 0)
-  const contributions = Math.floor(Math.random() * 1000) + 200
+  
+  // Calcular contribuições baseado em dados existentes ao invés de aleatório
+  const contributions = Math.min(
+    reposData.reduce((acc, repo) => acc + repo.open_issues_count, 0) * 10 + 
+    userData.public_repos * 15 + 
+    userData.public_gists * 5,
+    2000
+  )
 
   // Calcular linguagens únicas
   const languages = new Set(reposData.filter((repo) => repo.language).map((repo) => repo.language))