622 lines
22 KiB
TypeScript
622 lines
22 KiB
TypeScript
// =====================================================
|
|
// 資料庫服務層
|
|
// =====================================================
|
|
|
|
import { db } from '../database';
|
|
import type {
|
|
User,
|
|
Judge,
|
|
Team,
|
|
TeamMember,
|
|
Competition,
|
|
CompetitionRule,
|
|
CompetitionAwardType,
|
|
App,
|
|
Proposal,
|
|
AppJudgeScore,
|
|
ProposalJudgeScore,
|
|
Award,
|
|
UserFavorite,
|
|
UserLike,
|
|
UserView,
|
|
UserRating,
|
|
ChatSession,
|
|
ChatMessage,
|
|
AIAssistantConfig,
|
|
SystemSetting,
|
|
ActivityLog,
|
|
UserStatistics,
|
|
AppStatistics,
|
|
CompetitionStatistics
|
|
} from '../models';
|
|
|
|
// =====================================================
|
|
// 用戶服務
|
|
// =====================================================
|
|
export class UserService {
|
|
// 創建用戶
|
|
async create(userData: Omit<User, 'id' | 'created_at' | 'updated_at'>): Promise<User> {
|
|
const sql = `
|
|
INSERT INTO users (id, name, email, password_hash, avatar, department, role, join_date, total_likes, total_views, is_active, last_login)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
`;
|
|
const params = [
|
|
userData.id,
|
|
userData.name,
|
|
userData.email,
|
|
userData.password_hash,
|
|
userData.avatar || null,
|
|
userData.department,
|
|
userData.role,
|
|
userData.join_date,
|
|
userData.total_likes,
|
|
userData.total_views,
|
|
userData.is_active,
|
|
userData.last_login || null
|
|
];
|
|
|
|
await db.insert(sql, params);
|
|
return await this.findByEmail(userData.email) as User;
|
|
}
|
|
|
|
// 根據郵箱獲取用戶
|
|
async findByEmail(email: string): Promise<User | null> {
|
|
const sql = 'SELECT * FROM users WHERE email = ? AND is_active = TRUE';
|
|
return await db.queryOne<User>(sql, [email]);
|
|
}
|
|
|
|
// 根據ID獲取用戶
|
|
async findById(id: string): Promise<User | null> {
|
|
const sql = 'SELECT * FROM users WHERE id = ? AND is_active = TRUE';
|
|
return await db.queryOne<User>(sql, [id]);
|
|
}
|
|
|
|
// 更新用戶
|
|
async update(id: string, updates: Partial<User>): Promise<User | null> {
|
|
const fields = Object.keys(updates).filter(key => key !== 'id' && key !== 'created_at');
|
|
const setClause = fields.map(field => `${field} = ?`).join(', ');
|
|
const values = fields.map(field => (updates as any)[field]);
|
|
|
|
const sql = `UPDATE users SET ${setClause}, updated_at = CURRENT_TIMESTAMP WHERE id = ?`;
|
|
const result = await db.update(sql, [...values, id]);
|
|
|
|
if (result.affectedRows > 0) {
|
|
return await this.findById(id);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// 更新最後登入時間
|
|
async updateLastLogin(id: string): Promise<boolean> {
|
|
const sql = 'UPDATE users SET last_login = CURRENT_TIMESTAMP WHERE id = ?';
|
|
const result = await db.update(sql, [id]);
|
|
return result.affectedRows > 0;
|
|
}
|
|
|
|
// 獲取用戶統計
|
|
async getUserStatistics(id: string): Promise<UserStatistics | null> {
|
|
const sql = 'SELECT * FROM user_statistics WHERE id = ?';
|
|
return await db.queryOne<UserStatistics>(sql, [id]);
|
|
}
|
|
|
|
// 獲取所有用戶（管理員用）
|
|
async findAll(filters: {
|
|
search?: string;
|
|
department?: string;
|
|
role?: string;
|
|
status?: string;
|
|
page?: number;
|
|
limit?: number;
|
|
} = {}): Promise<{ users: User[]; total: number }> {
|
|
const { search, department, role, status, page = 1, limit = 10 } = filters;
|
|
|
|
// 構建查詢條件
|
|
let whereConditions = ['is_active = TRUE'];
|
|
let params: any[] = [];
|
|
|
|
if (search) {
|
|
whereConditions.push('(name LIKE ? OR email LIKE ?)');
|
|
params.push(`%${search}%`, `%${search}%`);
|
|
}
|
|
|
|
if (department && department !== 'all') {
|
|
whereConditions.push('department = ?');
|
|
params.push(department);
|
|
}
|
|
|
|
if (role && role !== 'all') {
|
|
whereConditions.push('role = ?');
|
|
params.push(role);
|
|
}
|
|
|
|
if (status && status !== 'all') {
|
|
if (status === 'active') {
|
|
whereConditions.push('last_login IS NOT NULL AND last_login >= DATE_SUB(NOW(), INTERVAL 30 DAY)');
|
|
} else if (status === 'inactive') {
|
|
whereConditions.push('last_login IS NULL OR last_login < DATE_SUB(NOW(), INTERVAL 30 DAY)');
|
|
}
|
|
}
|
|
|
|
const whereClause = whereConditions.length > 0 ? `WHERE ${whereConditions.join(' AND ')}` : '';
|
|
|
|
// 獲取總數
|
|
const countSql = `SELECT COUNT(*) as total FROM users ${whereClause}`;
|
|
const countResult = await this.query(countSql, params);
|
|
const total = countResult[0]?.total || 0;
|
|
|
|
// 獲取用戶列表
|
|
const offset = (page - 1) * limit;
|
|
const usersSql = `
|
|
SELECT
|
|
id, name, email, avatar, department, role, join_date,
|
|
total_likes, total_views, is_active, last_login, created_at, updated_at
|
|
FROM users
|
|
${whereClause}
|
|
ORDER BY created_at DESC
|
|
LIMIT ${offset}, ${limit}
|
|
`;
|
|
const users = await this.query<User>(usersSql, params);
|
|
|
|
return { users, total };
|
|
}
|
|
|
|
// 獲取用戶統計數據
|
|
async getUserStats(): Promise<{
|
|
totalUsers: number;
|
|
activeUsers: number;
|
|
adminCount: number;
|
|
developerCount: number;
|
|
inactiveUsers: number;
|
|
newThisMonth: number;
|
|
}> {
|
|
const sql = `
|
|
SELECT
|
|
COUNT(*) as total_users,
|
|
COUNT(CASE WHEN last_login IS NOT NULL AND last_login >= DATE_SUB(NOW(), INTERVAL 30 DAY) THEN 1 END) as active_users,
|
|
COUNT(CASE WHEN role = 'admin' THEN 1 END) as admin_count,
|
|
COUNT(CASE WHEN role = 'developer' THEN 1 END) as developer_count,
|
|
COUNT(CASE WHEN last_login IS NULL OR last_login < DATE_SUB(NOW(), INTERVAL 30 DAY) THEN 1 END) as inactive_users,
|
|
COUNT(CASE WHEN created_at >= DATE_SUB(NOW(), INTERVAL 30 DAY) THEN 1 END) as new_this_month
|
|
FROM users
|
|
WHERE is_active = TRUE
|
|
`;
|
|
const result = await this.query(sql);
|
|
const stats = result[0] || {};
|
|
|
|
return {
|
|
totalUsers: stats.total_users || 0,
|
|
activeUsers: stats.active_users || 0,
|
|
adminCount: stats.admin_count || 0,
|
|
developerCount: stats.developer_count || 0,
|
|
inactiveUsers: stats.inactive_users || 0,
|
|
newThisMonth: stats.new_this_month || 0
|
|
};
|
|
}
|
|
|
|
// 通用查詢方法
|
|
async query<T = any>(sql: string, params: any[] = []): Promise<T[]> {
|
|
return await db.query<T>(sql, params);
|
|
}
|
|
|
|
// 通用單一查詢方法
|
|
async queryOne<T = any>(sql: string, params: any[] = []): Promise<T | null> {
|
|
return await db.queryOne<T>(sql, params);
|
|
}
|
|
|
|
// 獲取所有用戶
|
|
async getAllUsers(limit = 50, offset = 0): Promise<User[]> {
|
|
const sql = 'SELECT * FROM users WHERE is_active = TRUE ORDER BY created_at DESC LIMIT ? OFFSET ?';
|
|
return await db.query<User>(sql, [limit, offset]);
|
|
}
|
|
|
|
// 靜態方法保持向後兼容
|
|
static async createUser(userData: Omit<User, 'id' | 'created_at' | 'updated_at'>): Promise<User> {
|
|
const service = new UserService();
|
|
return await service.create(userData);
|
|
}
|
|
|
|
static async getUserByEmail(email: string): Promise<User | null> {
|
|
const service = new UserService();
|
|
return await service.findByEmail(email);
|
|
}
|
|
|
|
static async getUserById(id: string): Promise<User | null> {
|
|
const service = new UserService();
|
|
return await service.findById(id);
|
|
}
|
|
|
|
static async updateUser(id: string, updates: Partial<User>): Promise<boolean> {
|
|
const service = new UserService();
|
|
const result = await service.update(id, updates);
|
|
return result !== null;
|
|
}
|
|
|
|
static async getUserStatistics(id: string): Promise<UserStatistics | null> {
|
|
const service = new UserService();
|
|
return await service.getUserStatistics(id);
|
|
}
|
|
|
|
static async getAllUsers(limit = 50, offset = 0): Promise<User[]> {
|
|
const service = new UserService();
|
|
return await service.getAllUsers(limit, offset);
|
|
}
|
|
}
|
|
|
|
// =====================================================
|
|
// 評審服務
|
|
// =====================================================
|
|
export class JudgeService {
|
|
// 創建評審
|
|
static async createJudge(judgeData: Omit<Judge, 'id' | 'created_at' | 'updated_at'>): Promise<Judge> {
|
|
const sql = `
|
|
INSERT INTO judges (id, name, title, department, expertise, avatar, is_active)
|
|
VALUES (UUID(), ?, ?, ?, ?, ?, ?)
|
|
`;
|
|
const params = [
|
|
judgeData.name,
|
|
judgeData.title,
|
|
judgeData.department,
|
|
JSON.stringify(judgeData.expertise),
|
|
judgeData.avatar || null,
|
|
judgeData.is_active
|
|
];
|
|
|
|
await db.insert(sql, params);
|
|
return await this.getJudgeByName(judgeData.name) as Judge;
|
|
}
|
|
|
|
// 根據姓名獲取評審
|
|
static async getJudgeByName(name: string): Promise<Judge | null> {
|
|
const sql = 'SELECT * FROM judges WHERE name = ? AND is_active = TRUE';
|
|
const result = await db.queryOne<Judge>(sql, [name]);
|
|
if (result) {
|
|
result.expertise = JSON.parse(result.expertise as any);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// 根據ID獲取評審
|
|
static async getJudgeById(id: string): Promise<Judge | null> {
|
|
const sql = 'SELECT * FROM judges WHERE id = ? AND is_active = TRUE';
|
|
const result = await db.queryOne<Judge>(sql, [id]);
|
|
if (result) {
|
|
result.expertise = JSON.parse(result.expertise as any);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// 獲取所有評審
|
|
static async getAllJudges(): Promise<Judge[]> {
|
|
const sql = 'SELECT * FROM judges WHERE is_active = TRUE ORDER BY created_at DESC';
|
|
const results = await db.query<Judge>(sql);
|
|
return results.map(judge => ({
|
|
...judge,
|
|
expertise: JSON.parse(judge.expertise as any)
|
|
}));
|
|
}
|
|
|
|
// 更新評審
|
|
static async updateJudge(id: string, updates: Partial<Judge>): Promise<boolean> {
|
|
const fields = Object.keys(updates).filter(key => key !== 'id' && key !== 'created_at');
|
|
const setClause = fields.map(field => `${field} = ?`).join(', ');
|
|
const values = fields.map(field => {
|
|
if (field === 'expertise') {
|
|
return JSON.stringify((updates as any)[field]);
|
|
}
|
|
return (updates as any)[field];
|
|
});
|
|
|
|
const sql = `UPDATE judges SET ${setClause}, updated_at = CURRENT_TIMESTAMP WHERE id = ?`;
|
|
const result = await db.update(sql, [...values, id]);
|
|
return result.affectedRows > 0;
|
|
}
|
|
}
|
|
|
|
// =====================================================
|
|
// 競賽服務
|
|
// =====================================================
|
|
export class CompetitionService {
|
|
// 創建競賽
|
|
static async createCompetition(competitionData: Omit<Competition, 'id' | 'created_at' | 'updated_at'>): Promise<Competition> {
|
|
const sql = `
|
|
INSERT INTO competitions (id, name, year, month, start_date, end_date, status, description, type, evaluation_focus, max_team_size, is_active)
|
|
VALUES (UUID(), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
`;
|
|
const params = [
|
|
competitionData.name,
|
|
competitionData.year,
|
|
competitionData.month,
|
|
competitionData.start_date,
|
|
competitionData.end_date,
|
|
competitionData.status,
|
|
competitionData.description || null,
|
|
competitionData.type,
|
|
competitionData.evaluation_focus || null,
|
|
competitionData.max_team_size || null,
|
|
competitionData.is_active
|
|
];
|
|
|
|
await db.insert(sql, params);
|
|
return await this.getCompetitionByName(competitionData.name) as Competition;
|
|
}
|
|
|
|
// 根據名稱獲取競賽
|
|
static async getCompetitionByName(name: string): Promise<Competition | null> {
|
|
const sql = 'SELECT * FROM competitions WHERE name = ? AND is_active = TRUE';
|
|
return await db.queryOne<Competition>(sql, [name]);
|
|
}
|
|
|
|
// 根據ID獲取競賽
|
|
static async getCompetitionById(id: string): Promise<Competition | null> {
|
|
const sql = 'SELECT * FROM competitions WHERE id = ? AND is_active = TRUE';
|
|
return await db.queryOne<Competition>(sql, [id]);
|
|
}
|
|
|
|
// 獲取所有競賽
|
|
static async getAllCompetitions(): Promise<Competition[]> {
|
|
const sql = 'SELECT * FROM competitions WHERE is_active = TRUE ORDER BY year DESC, month DESC';
|
|
return await db.query<Competition>(sql);
|
|
}
|
|
|
|
// 獲取競賽統計
|
|
static async getCompetitionStatistics(id: string): Promise<CompetitionStatistics | null> {
|
|
const sql = 'SELECT * FROM competition_statistics WHERE id = ?';
|
|
return await db.queryOne<CompetitionStatistics>(sql, [id]);
|
|
}
|
|
|
|
// 更新競賽
|
|
static async updateCompetition(id: string, updates: Partial<Competition>): Promise<boolean> {
|
|
const fields = Object.keys(updates).filter(key => key !== 'id' && key !== 'created_at');
|
|
const setClause = fields.map(field => `${field} = ?`).join(', ');
|
|
const values = fields.map(field => (updates as any)[field]);
|
|
|
|
const sql = `UPDATE competitions SET ${setClause}, updated_at = CURRENT_TIMESTAMP WHERE id = ?`;
|
|
const result = await db.update(sql, [...values, id]);
|
|
return result.affectedRows > 0;
|
|
}
|
|
}
|
|
|
|
// =====================================================
|
|
// 應用服務
|
|
// =====================================================
|
|
export class AppService {
|
|
// 創建應用
|
|
static async createApp(appData: Omit<App, 'id' | 'created_at' | 'updated_at'>): Promise<App> {
|
|
const sql = `
|
|
INSERT INTO apps (id, name, description, creator_id, team_id, category, type, likes_count, views_count, rating, is_active)
|
|
VALUES (UUID(), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
`;
|
|
const params = [
|
|
appData.name,
|
|
appData.description || null,
|
|
appData.creator_id,
|
|
appData.team_id || null,
|
|
appData.category,
|
|
appData.type,
|
|
appData.likes_count,
|
|
appData.views_count,
|
|
appData.rating,
|
|
appData.is_active
|
|
];
|
|
|
|
await db.insert(sql, params);
|
|
return await this.getAppByName(appData.name) as App;
|
|
}
|
|
|
|
// 根據名稱獲取應用
|
|
static async getAppByName(name: string): Promise<App | null> {
|
|
const sql = 'SELECT * FROM apps WHERE name = ? AND is_active = TRUE';
|
|
return await db.queryOne<App>(sql, [name]);
|
|
}
|
|
|
|
// 根據ID獲取應用
|
|
static async getAppById(id: string): Promise<App | null> {
|
|
const sql = 'SELECT * FROM apps WHERE id = ? AND is_active = TRUE';
|
|
return await db.queryOne<App>(sql, [id]);
|
|
}
|
|
|
|
// 獲取所有應用
|
|
static async getAllApps(limit = 50, offset = 0): Promise<App[]> {
|
|
const sql = 'SELECT * FROM apps WHERE is_active = TRUE ORDER BY created_at DESC LIMIT ? OFFSET ?';
|
|
return await db.query<App>(sql, [limit, offset]);
|
|
}
|
|
|
|
// 獲取應用統計
|
|
static async getAppStatistics(id: string): Promise<AppStatistics | null> {
|
|
const sql = 'SELECT * FROM app_statistics WHERE id = ?';
|
|
return await db.queryOne<AppStatistics>(sql, [id]);
|
|
}
|
|
|
|
// 更新應用
|
|
static async updateApp(id: string, updates: Partial<App>): Promise<boolean> {
|
|
const fields = Object.keys(updates).filter(key => key !== 'id' && key !== 'created_at');
|
|
const setClause = fields.map(field => `${field} = ?`).join(', ');
|
|
const values = fields.map(field => (updates as any)[field]);
|
|
|
|
const sql = `UPDATE apps SET ${setClause}, updated_at = CURRENT_TIMESTAMP WHERE id = ?`;
|
|
const result = await db.update(sql, [...values, id]);
|
|
return result.affectedRows > 0;
|
|
}
|
|
}
|
|
|
|
// =====================================================
|
|
// 評分服務
|
|
// =====================================================
|
|
export class ScoringService {
|
|
// 提交應用評分
|
|
static async submitAppScore(scoreData: Omit<AppJudgeScore, 'id' | 'submitted_at'>): Promise<AppJudgeScore> {
|
|
const sql = `
|
|
INSERT INTO app_judge_scores (id, judge_id, app_id, innovation_score, technical_score, usability_score, presentation_score, impact_score, total_score, comments)
|
|
VALUES (UUID(), ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
ON DUPLICATE KEY UPDATE
|
|
innovation_score = VALUES(innovation_score),
|
|
technical_score = VALUES(technical_score),
|
|
usability_score = VALUES(usability_score),
|
|
presentation_score = VALUES(presentation_score),
|
|
impact_score = VALUES(impact_score),
|
|
total_score = VALUES(total_score),
|
|
comments = VALUES(comments),
|
|
submitted_at = CURRENT_TIMESTAMP
|
|
`;
|
|
const params = [
|
|
scoreData.judge_id,
|
|
scoreData.app_id,
|
|
scoreData.innovation_score,
|
|
scoreData.technical_score,
|
|
scoreData.usability_score,
|
|
scoreData.presentation_score,
|
|
scoreData.impact_score,
|
|
scoreData.total_score,
|
|
scoreData.comments || null
|
|
];
|
|
|
|
await db.insert(sql, params);
|
|
return await this.getAppScore(scoreData.judge_id, scoreData.app_id) as AppJudgeScore;
|
|
}
|
|
|
|
// 獲取應用評分
|
|
static async getAppScore(judgeId: string, appId: string): Promise<AppJudgeScore | null> {
|
|
const sql = 'SELECT * FROM app_judge_scores WHERE judge_id = ? AND app_id = ?';
|
|
return await db.queryOne<AppJudgeScore>(sql, [judgeId, appId]);
|
|
}
|
|
|
|
// 獲取應用的所有評分
|
|
static async getAppScores(appId: string): Promise<AppJudgeScore[]> {
|
|
const sql = 'SELECT * FROM app_judge_scores WHERE app_id = ? ORDER BY submitted_at DESC';
|
|
return await db.query<AppJudgeScore>(sql, [appId]);
|
|
}
|
|
|
|
// 提交提案評分
|
|
static async submitProposalScore(scoreData: Omit<ProposalJudgeScore, 'id' | 'submitted_at'>): Promise<ProposalJudgeScore> {
|
|
const sql = `
|
|
INSERT INTO proposal_judge_scores (id, judge_id, proposal_id, problem_identification_score, solution_feasibility_score, innovation_score, impact_score, presentation_score, total_score, comments)
|
|
VALUES (UUID(), ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
ON DUPLICATE KEY UPDATE
|
|
problem_identification_score = VALUES(problem_identification_score),
|
|
solution_feasibility_score = VALUES(solution_feasibility_score),
|
|
innovation_score = VALUES(innovation_score),
|
|
impact_score = VALUES(impact_score),
|
|
presentation_score = VALUES(presentation_score),
|
|
total_score = VALUES(total_score),
|
|
comments = VALUES(comments),
|
|
submitted_at = CURRENT_TIMESTAMP
|
|
`;
|
|
const params = [
|
|
scoreData.judge_id,
|
|
scoreData.proposal_id,
|
|
scoreData.problem_identification_score,
|
|
scoreData.solution_feasibility_score,
|
|
scoreData.innovation_score,
|
|
scoreData.impact_score,
|
|
scoreData.presentation_score,
|
|
scoreData.total_score,
|
|
scoreData.comments || null
|
|
];
|
|
|
|
await db.insert(sql, params);
|
|
return await this.getProposalScore(scoreData.judge_id, scoreData.proposal_id) as ProposalJudgeScore;
|
|
}
|
|
|
|
// 獲取提案評分
|
|
static async getProposalScore(judgeId: string, proposalId: string): Promise<ProposalJudgeScore | null> {
|
|
const sql = 'SELECT * FROM proposal_judge_scores WHERE judge_id = ? AND proposal_id = ?';
|
|
return await db.queryOne<ProposalJudgeScore>(sql, [judgeId, proposalId]);
|
|
}
|
|
|
|
// 獲取提案的所有評分
|
|
static async getProposalScores(proposalId: string): Promise<ProposalJudgeScore[]> {
|
|
const sql = 'SELECT * FROM proposal_judge_scores WHERE proposal_id = ? ORDER BY submitted_at DESC';
|
|
return await db.query<ProposalJudgeScore>(sql, [proposalId]);
|
|
}
|
|
}
|
|
|
|
// =====================================================
|
|
// 獎項服務
|
|
// =====================================================
|
|
export class AwardService {
|
|
// 創建獎項
|
|
static async createAward(awardData: Omit<Award, 'id' | 'created_at'>): Promise<Award> {
|
|
const sql = `
|
|
INSERT INTO awards (id, competition_id, app_id, team_id, proposal_id, app_name, team_name, proposal_title, creator, award_type, award_name, score, year, month, icon, custom_award_type_id, competition_type, rank, category)
|
|
VALUES (UUID(), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
`;
|
|
const params = [
|
|
awardData.competition_id,
|
|
awardData.app_id || null,
|
|
awardData.team_id || null,
|
|
awardData.proposal_id || null,
|
|
awardData.app_name || null,
|
|
awardData.team_name || null,
|
|
awardData.proposal_title || null,
|
|
awardData.creator,
|
|
awardData.award_type,
|
|
awardData.award_name,
|
|
awardData.score,
|
|
awardData.year,
|
|
awardData.month,
|
|
awardData.icon,
|
|
awardData.custom_award_type_id || null,
|
|
awardData.competition_type,
|
|
awardData.rank,
|
|
awardData.category
|
|
];
|
|
|
|
await db.insert(sql, params);
|
|
return await this.getAwardByCompetitionAndCreator(awardData.competition_id, awardData.creator) as Award;
|
|
}
|
|
|
|
// 根據競賽和創作者獲取獎項
|
|
static async getAwardByCompetitionAndCreator(competitionId: string, creator: string): Promise<Award | null> {
|
|
const sql = 'SELECT * FROM awards WHERE competition_id = ? AND creator = ? ORDER BY created_at DESC LIMIT 1';
|
|
return await db.queryOne<Award>(sql, [competitionId, creator]);
|
|
}
|
|
|
|
// 根據年份獲取獎項
|
|
static async getAwardsByYear(year: number): Promise<Award[]> {
|
|
const sql = 'SELECT * FROM awards WHERE year = ? ORDER BY month DESC, rank ASC';
|
|
return await db.query<Award>(sql, [year]);
|
|
}
|
|
|
|
// 根據競賽獲取獎項
|
|
static async getAwardsByCompetition(competitionId: string): Promise<Award[]> {
|
|
const sql = 'SELECT * FROM awards WHERE competition_id = ? ORDER BY rank ASC';
|
|
return await db.query<Award>(sql, [competitionId]);
|
|
}
|
|
}
|
|
|
|
// =====================================================
|
|
// 系統設定服務
|
|
// =====================================================
|
|
export class SystemSettingService {
|
|
// 獲取設定值
|
|
static async getSetting(key: string): Promise<string | null> {
|
|
const sql = 'SELECT value FROM system_settings WHERE `key` = ?';
|
|
const result = await db.queryOne<{ value: string }>(sql, [key]);
|
|
return result?.value || null;
|
|
}
|
|
|
|
// 設定值
|
|
static async setSetting(key: string, value: string, description?: string, category = 'general', isPublic = false): Promise<boolean> {
|
|
const sql = `
|
|
INSERT INTO system_settings (id, \`key\`, value, description, category, is_public)
|
|
VALUES (UUID(), ?, ?, ?, ?, ?)
|
|
ON DUPLICATE KEY UPDATE
|
|
value = VALUES(value),
|
|
description = VALUES(description),
|
|
category = VALUES(category),
|
|
is_public = VALUES(is_public),
|
|
updated_at = CURRENT_TIMESTAMP
|
|
`;
|
|
const params = [key, value, description || null, category, isPublic];
|
|
|
|
const result = await db.insert(sql, params);
|
|
return result.affectedRows > 0;
|
|
}
|
|
|
|
// 獲取所有公開設定
|
|
static async getPublicSettings(): Promise<SystemSetting[]> {
|
|
const sql = 'SELECT * FROM system_settings WHERE is_public = TRUE ORDER BY category, `key`';
|
|
return await db.query<SystemSetting>(sql);
|
|
}
|
|
}
|