forked from xiangwang25/whale-town-end-v2
437 lines
13 KiB
TypeScript
437 lines
13 KiB
TypeScript
import { BadGatewayException, Injectable, Logger, OnModuleInit } from '@nestjs/common';
|
||
import { Cron } from '@nestjs/schedule';
|
||
import axios from 'axios';
|
||
import {
|
||
DatawhaleCommitStats,
|
||
DatawhaleHonorRankingPayload,
|
||
DatawhaleMemberRow,
|
||
DatawhaleWeeklyCommitsPayload,
|
||
RankingCategory,
|
||
RankingCategoryId,
|
||
RankingEntry,
|
||
RankingUser,
|
||
} from './rankings.types';
|
||
|
||
const DATAWHALE_MEMBERS_URL = 'https://mv.datawhale.cc/data/members.json';
|
||
const DATAWHALE_WEEKLY_COMMITS_URL = 'https://mv.datawhale.cc/data/commits_weekly.json';
|
||
const DATAWHALE_ASSET_BASE_URL = 'https://mv.datawhale.cc/';
|
||
const DEFAULT_CATEGORY: RankingCategoryId = 'weekly_commits';
|
||
const DEFAULT_LIMIT = 10;
|
||
|
||
const CATEGORIES: RankingCategory[] = [
|
||
{
|
||
id: 'weekly_commits',
|
||
label: '一周卷王',
|
||
title: '一周卷王',
|
||
description: '近 7 天 commit 数 + 连续性、多仓库、质量奖励',
|
||
icon: '🔥',
|
||
},
|
||
{
|
||
id: 'night_owl',
|
||
label: '夜猫榜',
|
||
title: '夜猫榜',
|
||
description: '深夜提交数量与深夜活跃比例排行',
|
||
icon: '🌙',
|
||
},
|
||
{
|
||
id: 'popularity',
|
||
label: '人气王',
|
||
title: '人气王',
|
||
description: 'Followers 与组织仓库 Stars 的综合影响力',
|
||
icon: '👑',
|
||
},
|
||
{
|
||
id: 'productive',
|
||
label: '多产榜',
|
||
title: '多产榜',
|
||
description: '参与 Datawhale 组织仓库数量排行',
|
||
icon: '🏆',
|
||
},
|
||
{
|
||
id: 'social',
|
||
label: '社交达人',
|
||
title: '社交达人',
|
||
description: 'GitHub Following 数量排行',
|
||
icon: '💬',
|
||
},
|
||
{
|
||
id: 'rising',
|
||
label: '新星榜',
|
||
title: '新星榜',
|
||
description: '按仓库数量归一后的潜力新星排行',
|
||
icon: '🌠',
|
||
},
|
||
{
|
||
id: 'comprehensive',
|
||
label: '综合实力',
|
||
title: '综合实力',
|
||
description: 'Stars、Followers、仓库数、社交和贡献数综合评分',
|
||
icon: '🌟',
|
||
},
|
||
];
|
||
|
||
@Injectable()
|
||
export class RankingsService implements OnModuleInit {
|
||
private readonly logger = new Logger(RankingsService.name);
|
||
private members: DatawhaleMemberRow[] = [];
|
||
private weeklyCommits: DatawhaleWeeklyCommitsPayload | null = null;
|
||
private syncedAt: Date | null = null;
|
||
private syncing: Promise<void> | null = null;
|
||
|
||
async onModuleInit(): Promise<void> {
|
||
this.syncNow().catch(error => {
|
||
this.logger.warn(`Datawhale荣誉榜启动同步失败：${this.errorMessage(error)}`);
|
||
});
|
||
}
|
||
|
||
@Cron('15 3 * * *')
|
||
async syncDaily(): Promise<void> {
|
||
await this.syncNow();
|
||
}
|
||
|
||
async getDatawhaleHonorRanking(
|
||
category: RankingCategoryId = DEFAULT_CATEGORY,
|
||
limit: number = DEFAULT_LIMIT,
|
||
refresh = false,
|
||
): Promise<DatawhaleHonorRankingPayload> {
|
||
if (refresh || this.members.length === 0) {
|
||
await this.syncNow();
|
||
}
|
||
return this.getCachedPayload(category, limit);
|
||
}
|
||
|
||
async syncNow(): Promise<DatawhaleHonorRankingPayload> {
|
||
if (this.syncing) {
|
||
await this.syncing;
|
||
return this.getCachedPayload(DEFAULT_CATEGORY, DEFAULT_LIMIT);
|
||
}
|
||
|
||
this.syncing = this.fetchAndReplace();
|
||
try {
|
||
await this.syncing;
|
||
} finally {
|
||
this.syncing = null;
|
||
}
|
||
return this.getCachedPayload(DEFAULT_CATEGORY, DEFAULT_LIMIT);
|
||
}
|
||
|
||
private getCachedPayload(
|
||
category: RankingCategoryId,
|
||
limit: number,
|
||
): DatawhaleHonorRankingPayload {
|
||
const normalizedCategory = this.normalizeCategory(category);
|
||
const normalizedLimit = this.normalizeLimit(limit);
|
||
const entries = this.buildEntries(normalizedCategory, normalizedLimit);
|
||
return {
|
||
source: 'datawhale-members-visualization',
|
||
activeCategory: normalizedCategory,
|
||
categories: CATEGORIES,
|
||
topRankers: entries.slice(0, 3),
|
||
rankers: entries.slice(3, normalizedLimit),
|
||
myRank: {
|
||
rank: null,
|
||
score: 0,
|
||
reward: 0,
|
||
},
|
||
total: entries.length,
|
||
syncedAt: this.syncedAt ? this.syncedAt.toISOString() : null,
|
||
sourceUpdatedAt: this.weeklyCommits?.update_time ?? null,
|
||
};
|
||
}
|
||
|
||
private async fetchAndReplace(): Promise<void> {
|
||
try {
|
||
const [membersResponse, commitsResponse] = await Promise.all([
|
||
axios.get(DATAWHALE_MEMBERS_URL, { timeout: 15000 }),
|
||
axios.get(DATAWHALE_WEEKLY_COMMITS_URL, { timeout: 15000 }),
|
||
]);
|
||
|
||
if (!Array.isArray(membersResponse.data)) {
|
||
throw new BadGatewayException('Datawhale成员接口返回格式异常');
|
||
}
|
||
const commitsPayload = commitsResponse.data as DatawhaleWeeklyCommitsPayload;
|
||
if (!commitsPayload || typeof commitsPayload !== 'object' || !commitsPayload.user_commits) {
|
||
throw new BadGatewayException('Datawhale周贡献接口返回格式异常');
|
||
}
|
||
|
||
this.members = membersResponse.data as DatawhaleMemberRow[];
|
||
this.weeklyCommits = commitsPayload;
|
||
this.syncedAt = new Date();
|
||
this.logger.log(`Datawhale荣誉榜同步完成，共 ${this.members.length} 位成员`);
|
||
} catch (error) {
|
||
if (this.members.length > 0) {
|
||
this.logger.warn(`Datawhale荣誉榜同步失败，继续使用缓存：${this.errorMessage(error)}`);
|
||
return;
|
||
}
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
private buildEntries(category: RankingCategoryId, limit: number): RankingEntry[] {
|
||
const users = category === 'weekly_commits' || category === 'night_owl'
|
||
? this.buildCommitDrivenUsers(category)
|
||
: this.members.map(member => this.toRankingUser(member, category));
|
||
|
||
return users
|
||
.filter(user => user.score > 0)
|
||
.sort((a, b) => b.score - a.score)
|
||
.slice(0, limit)
|
||
.map((user, index) => ({
|
||
...user,
|
||
rank: index + 1,
|
||
}));
|
||
}
|
||
|
||
private buildCommitDrivenUsers(category: RankingCategoryId): RankingUser[] {
|
||
const memberById = new Map(
|
||
this.members
|
||
.map(member => [this.cleanString(member.id), member] as const)
|
||
.filter(([id]) => id.length > 0),
|
||
);
|
||
const userCommits = this.weeklyCommits?.user_commits ?? {};
|
||
|
||
return Object.entries(userCommits).map(([rawId, commits]) => {
|
||
const id = this.cleanString(rawId);
|
||
const member = memberById.get(id) ?? { id };
|
||
return this.toRankingUser(member, category, commits);
|
||
});
|
||
}
|
||
|
||
private toRankingUser(
|
||
member: DatawhaleMemberRow,
|
||
category: RankingCategoryId,
|
||
commitsOverride?: DatawhaleCommitStats,
|
||
): RankingUser {
|
||
const id = this.cleanString(member.id);
|
||
const commits = commitsOverride ?? this.weeklyCommits?.user_commits?.[id] ?? {};
|
||
const score = this.scoreMember(member, commits, category);
|
||
const domains = this.domainList(member);
|
||
return {
|
||
id,
|
||
name: this.displayName(member),
|
||
avatarText: this.avatarText(member),
|
||
avatarUrl: this.avatarUrl(member),
|
||
githubUrl: this.githubUrl(member),
|
||
domain: domains[0] ?? '',
|
||
domains,
|
||
location: this.cleanString(member.location),
|
||
score,
|
||
scoreLabel: this.scoreLabel(member, commits, category),
|
||
contrib: this.numberValue(member.org_total_contributions) || this.numberValue(commits.total_commits),
|
||
answers: this.numberValue(commits.repo_count) || this.numberValue(member.org_repos_count),
|
||
likes: this.numberValue(member.org_total_stars),
|
||
reward: this.rewardForScore(score),
|
||
};
|
||
}
|
||
|
||
private scoreMember(
|
||
member: DatawhaleMemberRow,
|
||
commits: DatawhaleCommitStats,
|
||
category: RankingCategoryId,
|
||
): number {
|
||
switch (category) {
|
||
case 'weekly_commits':
|
||
return this.weeklyCommitScore(commits);
|
||
case 'night_owl':
|
||
return this.nightOwlScore(commits);
|
||
case 'popularity':
|
||
return Math.round(
|
||
this.numberValue(member.followers ?? member.followers_count) * 0.6 +
|
||
this.numberValue(member.org_total_stars) * 0.4,
|
||
);
|
||
case 'productive':
|
||
return this.numberValue(member.org_repos_count);
|
||
case 'social':
|
||
return this.numberValue(member.following);
|
||
case 'rising': {
|
||
const repoCount = Math.max(this.numberValue(member.org_repos_count), 1);
|
||
const bonus = repoCount < 5 ? 1.5 : 1.0;
|
||
return Math.round((this.numberValue(member.followers ?? member.followers_count) + this.numberValue(member.org_total_stars)) / repoCount * bonus);
|
||
}
|
||
case 'comprehensive':
|
||
return Math.round(
|
||
this.numberValue(member.org_total_stars) * 0.3 +
|
||
this.numberValue(member.followers ?? member.followers_count) * 0.25 +
|
||
this.numberValue(member.org_repos_count) * 0.2 +
|
||
this.numberValue(member.following) * 0.15 +
|
||
this.numberValue(member.org_total_contributions) * 0.1,
|
||
);
|
||
default:
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
private weeklyCommitScore(commits: DatawhaleCommitStats): number {
|
||
let score = this.numberValue(commits.total_commits);
|
||
const activeDays = this.numberValue(commits.active_days);
|
||
if (activeDays >= 7) {
|
||
score += 10;
|
||
} else if (activeDays >= 5) {
|
||
score += 5;
|
||
} else if (activeDays >= 3) {
|
||
score += 2;
|
||
}
|
||
|
||
const repoCount = this.numberValue(commits.repo_count);
|
||
if (repoCount >= 5) {
|
||
score += 5;
|
||
} else if (repoCount >= 3) {
|
||
score += 3;
|
||
} else if (repoCount >= 2) {
|
||
score += 1;
|
||
}
|
||
|
||
const avgCommitsPerDay = this.numberValue(commits.avg_commits_per_day);
|
||
if (avgCommitsPerDay >= 5) {
|
||
score += 8;
|
||
} else if (avgCommitsPerDay >= 3) {
|
||
score += 5;
|
||
} else if (avgCommitsPerDay >= 2) {
|
||
score += 2;
|
||
}
|
||
return Math.round(score);
|
||
}
|
||
|
||
private nightOwlScore(commits: DatawhaleCommitStats): number {
|
||
let score = this.numberValue(commits.night_owl_commits) * 2;
|
||
const percentage = this.numberValue(commits.night_owl_percentage);
|
||
if (percentage >= 50) {
|
||
score += 10;
|
||
} else if (percentage >= 30) {
|
||
score += 5;
|
||
} else if (percentage >= 20) {
|
||
score += 2;
|
||
}
|
||
const activeDays = this.numberValue(commits.active_days);
|
||
if (activeDays >= 5) {
|
||
score += 8;
|
||
} else if (activeDays >= 3) {
|
||
score += 4;
|
||
}
|
||
const repoCount = this.numberValue(commits.repo_count);
|
||
if (repoCount >= 3) {
|
||
score += 3;
|
||
} else if (repoCount >= 2) {
|
||
score += 1;
|
||
}
|
||
return Math.round(score);
|
||
}
|
||
|
||
private scoreLabel(
|
||
member: DatawhaleMemberRow,
|
||
commits: DatawhaleCommitStats,
|
||
category: RankingCategoryId,
|
||
): string {
|
||
switch (category) {
|
||
case 'weekly_commits':
|
||
return `${this.numberValue(commits.total_commits)} commits`;
|
||
case 'night_owl':
|
||
return `${this.numberValue(commits.night_owl_commits)} 深夜`;
|
||
case 'popularity':
|
||
return `${this.numberValue(member.followers ?? member.followers_count)} followers`;
|
||
case 'productive':
|
||
return `${this.numberValue(member.org_repos_count)} 仓库`;
|
||
case 'social':
|
||
return `${this.numberValue(member.following)} following`;
|
||
case 'rising':
|
||
return '活跃度';
|
||
case 'comprehensive':
|
||
return '综合分';
|
||
default:
|
||
return '分数';
|
||
}
|
||
}
|
||
|
||
private domainList(member: DatawhaleMemberRow): string[] {
|
||
const primaryDomain = this.cleanString(member.primary_domain);
|
||
const domains = this.cleanString(member.domain)
|
||
.split(';')
|
||
.map(domain => this.cleanString(domain))
|
||
.filter(Boolean);
|
||
const result = primaryDomain ? [primaryDomain, ...domains] : domains;
|
||
return [...new Set(result)].slice(0, 3);
|
||
}
|
||
|
||
private displayName(member: DatawhaleMemberRow): string {
|
||
const name = this.cleanString(member.name);
|
||
if (name && !['null', 'undefined', 'none'].includes(name.toLowerCase())) {
|
||
return name;
|
||
}
|
||
return this.cleanString(member.id) || '未知用户';
|
||
}
|
||
|
||
private avatarText(member: DatawhaleMemberRow): string {
|
||
const name = this.displayName(member);
|
||
return name.length > 0 ? name.slice(0, 1).toUpperCase() : '鲸';
|
||
}
|
||
|
||
private avatarUrl(member: DatawhaleMemberRow): string {
|
||
const avatar = this.cleanString(member.avatar);
|
||
if (!avatar) {
|
||
return '';
|
||
}
|
||
if (avatar.startsWith('http://') || avatar.startsWith('https://')) {
|
||
return avatar;
|
||
}
|
||
if (avatar.startsWith('/')) {
|
||
return `${DATAWHALE_ASSET_BASE_URL.replace(/\/$/, '')}${avatar}`;
|
||
}
|
||
return `${DATAWHALE_ASSET_BASE_URL}${avatar}`;
|
||
}
|
||
|
||
private githubUrl(member: DatawhaleMemberRow): string {
|
||
const github = this.cleanString(member.github);
|
||
if (github.startsWith('http')) {
|
||
return github;
|
||
}
|
||
const id = this.cleanString(member.id);
|
||
return id ? `https://github.com/${id}` : '';
|
||
}
|
||
|
||
private normalizeCategory(category: RankingCategoryId): RankingCategoryId {
|
||
return CATEGORIES.some(item => item.id === category) ? category : DEFAULT_CATEGORY;
|
||
}
|
||
|
||
private normalizeLimit(limit: number): number {
|
||
if (!Number.isFinite(limit)) {
|
||
return DEFAULT_LIMIT;
|
||
}
|
||
return Math.min(Math.max(Math.floor(limit), 3), DEFAULT_LIMIT);
|
||
}
|
||
|
||
private rewardForScore(score: number): number {
|
||
if (score >= 1000) {
|
||
return 80;
|
||
}
|
||
if (score >= 500) {
|
||
return 60;
|
||
}
|
||
if (score >= 120) {
|
||
return 50;
|
||
}
|
||
if (score >= 50) {
|
||
return 40;
|
||
}
|
||
if (score >= 20) {
|
||
return 30;
|
||
}
|
||
return 20;
|
||
}
|
||
|
||
private numberValue(value: unknown): number {
|
||
const parsed = Number(value || 0);
|
||
return Number.isFinite(parsed) ? parsed : 0;
|
||
}
|
||
|
||
private cleanString(value: unknown): string {
|
||
return String(value ?? '').trim();
|
||
}
|
||
|
||
private errorMessage(error: unknown): string {
|
||
if (error instanceof Error) {
|
||
return error.message;
|
||
}
|
||
return String(error);
|
||
}
|
||
}
|