441 lines
18 KiB
JavaScript
441 lines
18 KiB
JavaScript
// publicController.js
|
|
// 공개 이벤트 관련 API만 담당 (비밀번호 인증, 점수입력 등)
|
|
const { Event, EventParticipant, Member, Club, EventScore, ClubMember, EventTeam, EventTeamMember, sequelize } = require('../models');
|
|
const { Op } = require('sequelize');
|
|
const { signPublicEventToken, verifyPublicEventToken } = require('../utils/publicJwt');
|
|
const averageService = require('../services/averageService');
|
|
|
|
// 공개 이벤트 최초 진입 (토큰 또는 비밀번호 인증)
|
|
exports.publicEventEntry = async (req, res) => {
|
|
const { publicHash } = req.params;
|
|
const { password } = req.body || {};
|
|
|
|
// 팀 핸디캡 수정
|
|
exports.updateTeamHandicap = async (req, res) => {
|
|
const { publicHash } = req.params;
|
|
const { teamNumber, handicap } = req.body || {};
|
|
try {
|
|
const event = await Event.findOne({ where: { publicHash } });
|
|
if (!event) return res.status(404).json({ message: '이벤트를 찾을 수 없습니다.' });
|
|
if (event.status !== 'ready' && event.status !== 'active') return res.status(403).json({ message: '팀 핸디캡 수정이 불가능한 상태입니다.' });
|
|
|
|
const team = await EventTeam.findOne({ where: { eventId: event.id, teamNumber } });
|
|
if (!team) return res.status(404).json({ message: '팀을 찾을 수 없습니다.' });
|
|
|
|
const hc = Number(handicap) || 0;
|
|
await team.update({ handicap: hc });
|
|
return res.json({ message: '팀 핸디캡이 저장되었습니다.', data: { teamNumber, handicap: hc } });
|
|
} catch (e) {
|
|
console.error('팀 핸디캡 수정 오류:', e);
|
|
res.status(500).json({ message: '팀 핸디캡 저장 중 오류가 발생했습니다.' });
|
|
}
|
|
};
|
|
const auth = req.headers.authorization;
|
|
let event;
|
|
try {
|
|
event = await Event.findOne({
|
|
where: { publicHash },
|
|
include: [{ model: Club, attributes: ['id', 'name'] }]
|
|
});
|
|
if (!event) {
|
|
return res.status(404).json({ message: '이벤트를 찾을 수 없습니다.' });
|
|
}
|
|
if (event.status === 'canceled') {
|
|
return res.status(403).json({ message: '취소된 이벤트입니다.' });
|
|
}
|
|
|
|
// 클럽의 구독 활성 여부 확인 - 가장 최근 구독 정보 가져오기
|
|
const clubSubscription = await sequelize.models.ClubSubscription.findOne({
|
|
where: { clubId: event.clubId },
|
|
include: [{ model: sequelize.models.SubscriptionPlan }],
|
|
order: [['endDate', 'DESC']] // 가장 최근 구독 정보를 가져오기 위해 만료일 기준 내림차순 정렬
|
|
});
|
|
|
|
// 구독이 없거나 만료된 경우 접근 제한
|
|
const now = new Date();
|
|
if (!clubSubscription || new Date(clubSubscription.endDate) < now) {
|
|
return res.status(403).json({ message: '클럽의 구독이 만료되어 이벤트에 접근할 수 없습니다. 클럽 관리자에게 문의하세요.' });
|
|
}
|
|
|
|
let token = null;
|
|
let isAuthenticated = false;
|
|
|
|
// 1. 토큰 인증 우선
|
|
if (auth && auth.startsWith('Bearer ')) {
|
|
try {
|
|
const payload = verifyPublicEventToken(auth.slice(7));
|
|
if (payload.publicHash === event.publicHash) {
|
|
isAuthenticated = true;
|
|
}
|
|
} catch (e) {
|
|
// 토큰 인증 실패: isAuthenticated는 false
|
|
}
|
|
}
|
|
|
|
// 2. 토큰 인증 실패 시
|
|
if (!isAuthenticated) {
|
|
// 비밀번호가 필요한 이벤트
|
|
if (event.accessPassword) {
|
|
if (!password) {
|
|
return res.status(401).json({ message: '비밀번호가 필요합니다.' });
|
|
}
|
|
if (password !== event.accessPassword) {
|
|
return res.status(401).json({ message: '비밀번호가 일치하지 않습니다.' });
|
|
}
|
|
}
|
|
// 비밀번호가 없거나(공개 이벤트) or 비밀번호 인증 성공
|
|
isAuthenticated = true;
|
|
token = signPublicEventToken({ publicHash: event.publicHash });
|
|
}
|
|
|
|
// 3. 인증 성공 시 데이터 반환
|
|
if (isAuthenticated) {
|
|
const data = await exports.getEventByPublicHash(event, token);
|
|
return res.json(data);
|
|
}
|
|
// 4. 나머지는 모두 인증 실패
|
|
return res.status(401).json({ message: '인증이 필요합니다.' });
|
|
} catch (e) {
|
|
console.error('[publicEventEntry] 공개 이벤트 최초 진입 오류', { publicHash, error: e });
|
|
res.status(500).json({ message: '이벤트 정보를 가져오는 중 오류가 발생했습니다.' });
|
|
}
|
|
};
|
|
|
|
// 공개 이벤트 조회 (내부 데이터 반환 전용)
|
|
exports.getEventByPublicHash = async (event, token = null) => {
|
|
try {
|
|
const allMembers = await Member.findAll({
|
|
where: { clubId: event.clubId },
|
|
attributes: [[sequelize.col('id'), 'memberId'], 'name', 'memberType', 'gender', 'handicap']
|
|
});
|
|
const participants = await EventParticipant.findAll({
|
|
where: { eventId: event.id, status: { [Op.ne]: 'canceled' } },
|
|
include: [ { model: Member, attributes: [[sequelize.col('id'), 'memberId'], 'name', 'memberType', 'gender', 'handicap'] } ]
|
|
});
|
|
// 모든 회원에 대한 에버리지 계산
|
|
const allMemberObjs = await Promise.all(allMembers.map(async m => {
|
|
const memberData = m.dataValues;
|
|
try {
|
|
const averageData = await averageService.calculateMemberAverageByClubSetting(memberData.memberId, event.clubId);
|
|
memberData.average = averageData.average;
|
|
} catch (error) {
|
|
console.error(`회원 ${memberData.memberId}의 에버리지 계산 중 오류:`, error);
|
|
memberData.average = 0;
|
|
}
|
|
return memberData;
|
|
}));
|
|
|
|
// 참가자에 대한 에버리지 추가
|
|
for (const participant of participants) {
|
|
if (participant.Member) {
|
|
try {
|
|
const averageData = await averageService.calculateMemberAverageByClubSetting(participant.Member.dataValues.memberId, event.clubId);
|
|
participant.Member.dataValues.average = averageData.average;
|
|
} catch (error) {
|
|
console.error(`참가자 ${participant.Member.dataValues.memberId}의 에버리지 계산 중 오류:`, error);
|
|
participant.Member.dataValues.average = 0;
|
|
}
|
|
}
|
|
}
|
|
const participantMemberIds = [
|
|
...new Set(participants.filter(p => p.dataValues.status !== 'canceled').map(p => parseInt(p.dataValues.memberId)))
|
|
];
|
|
// 상태별로 미참가자/게스트 추가 제한
|
|
let availableMembers = [];
|
|
if (event.status === 'ready') {
|
|
availableMembers = allMemberObjs.filter(m => !participantMemberIds.includes(parseInt(m.memberId)));
|
|
} // 준비 아닐 땐 빈 배열(신청/게스트 추가 불가)
|
|
// 팀 정보
|
|
const teams = await EventTeam.findAll({
|
|
where: { eventId: event.id },
|
|
order: [['teamNumber', 'ASC']],
|
|
include: [{
|
|
model: EventTeamMember,
|
|
include: [{
|
|
model: EventParticipant,
|
|
where: { status: { [Op.ne]: 'canceled' } },
|
|
include: [{ model: Member, attributes: [[sequelize.col('id'), 'memberId'], 'name', 'memberType', 'gender', 'handicap'] }]
|
|
}]
|
|
}]
|
|
});
|
|
|
|
// 팀 멤버들에게 에버리지 정보 추가
|
|
for (const team of teams) {
|
|
for (const teamMember of team.EventTeamMembers || []) {
|
|
if (teamMember.EventParticipant?.Member) {
|
|
const member = teamMember.EventParticipant.Member;
|
|
try {
|
|
const averageData = await averageService.calculateMemberAverageByClubSetting(member.dataValues.memberId, event.clubId);
|
|
member.dataValues.average = averageData.average;
|
|
} catch (error) {
|
|
console.error(`팀 멤버 ${member.dataValues.memberId}의 에버리지 계산 중 오류:`, error);
|
|
member.dataValues.average = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const scores = await EventScore.findAll({ where: { eventId: event.id } });
|
|
// 참가자 id → 참가자 객체 Map
|
|
const participantMap = new Map();
|
|
participants.forEach(p => participantMap.set(p.id, p));
|
|
|
|
// 팀에 소속된 참가자 id Set
|
|
const assignedParticipantIds = new Set();
|
|
const teamList = teams.map(team => ({
|
|
teamId: team.id,
|
|
teamNumber: team.teamNumber,
|
|
handicap: team.handicap,
|
|
members: (team.EventTeamMembers || []).map(tm => {
|
|
const participant = tm.EventParticipant;
|
|
if (participant?.id) assignedParticipantIds.add(participant.id);
|
|
const member = participant?.Member;
|
|
// 각 게임별 점수 배열 생성
|
|
const scoresArr = Array(event.gameCount).fill(null);
|
|
scores.filter(s => s.participantId === participant?.id).forEach(s => {
|
|
if (s.gameNumber && s.gameNumber >= 1 && s.gameNumber <= event.gameCount) {
|
|
scoresArr[s.gameNumber - 1] = { score: s.score, handicap: s.handicap };
|
|
}
|
|
});
|
|
return {
|
|
participantId: participant?.id,
|
|
memberId: member?.memberId,
|
|
name: member?.name || `참가자 ${participant?.id}`,
|
|
gender: member?.gender,
|
|
memberType: member?.memberType,
|
|
average: allMemberObjs.find(m => Number(m.memberId) === Number(member?.memberId))?.average,
|
|
handicap: member?.handicap || 0,
|
|
status: participant?.status,
|
|
paymentStatus: participant?.paymentStatus,
|
|
comment: participant?.comment,
|
|
isGuest: member?.memberType === 'guest',
|
|
scores: scoresArr
|
|
};
|
|
})
|
|
}));
|
|
|
|
// 팀에 소속되지 않은 참가자(미배정)
|
|
const unassignedMembers = participants
|
|
.filter(p => !assignedParticipantIds.has(p.id))
|
|
.map(p => {
|
|
const member = p.Member;
|
|
// 각 게임별 점수 배열 생성
|
|
const scoresArr = Array(event.gameCount).fill(null);
|
|
scores.filter(s => s.participantId === p.id).forEach(s => {
|
|
if (s.gameNumber && s.gameNumber >= 1 && s.gameNumber <= event.gameCount) {
|
|
scoresArr[s.gameNumber - 1] = { score: s.score, handicap: s.handicap };
|
|
}
|
|
});
|
|
return {
|
|
participantId: p.id,
|
|
memberId: p.memberId,
|
|
name: member?.name || `참가자 ${p.id}`,
|
|
gender: member?.gender,
|
|
memberType: member?.memberType,
|
|
handicap: member?.handicap || 0,
|
|
average: allMemberObjs.find(m => Number(m.memberId) === Number(p?.memberId))?.average,
|
|
status: p.status,
|
|
paymentStatus: p.paymentStatus,
|
|
comment: p.comment,
|
|
isGuest: member?.memberType === 'guest',
|
|
scores: scoresArr
|
|
};
|
|
});
|
|
let participantList = participants.map(p => {
|
|
const member = p.Member;
|
|
// 각 게임별 점수 배열 생성
|
|
const scoresArr = Array(event.gameCount).fill(null);
|
|
scores.filter(s => s.participantId === p.id).forEach(s => {
|
|
if (s.gameNumber && s.gameNumber >= 1 && s.gameNumber <= event.gameCount) {
|
|
scoresArr[s.gameNumber - 1] = s.score;
|
|
}
|
|
});
|
|
return {
|
|
participantId: p.id,
|
|
memberId: p.memberId,
|
|
name: member?.name || `참가자 ${p.id}`,
|
|
gender: member?.gender,
|
|
memberType: member?.memberType,
|
|
handicap: member?.handicap || 0,
|
|
average: allMemberObjs.find(m => Number(m.memberId) === Number(p?.memberId))?.average,
|
|
status: p.status,
|
|
paymentStatus: p.paymentStatus,
|
|
comment: p.comment,
|
|
isGuest: member?.memberType === 'guest',
|
|
scores: scoresArr
|
|
};
|
|
});
|
|
// 디버깅: 최종 average 값 확인
|
|
return {
|
|
clubName: event.Club.name,
|
|
event: {
|
|
id: event.id,
|
|
title: event.title,
|
|
description: event.description,
|
|
eventType: event.eventType,
|
|
startDate: event.startDate,
|
|
endDate: event.endDate,
|
|
location: event.location,
|
|
gameCount: event.gameCount,
|
|
registrationDeadline: event.registrationDeadline,
|
|
maxParticipants: event.maxParticipants,
|
|
participantFee: event.participantFee,
|
|
status: event.status
|
|
},
|
|
teams: teamList,
|
|
participants: participantList,
|
|
unassignedMembers,
|
|
availableMembers,
|
|
needPassword: !!event.accessPassword,
|
|
...(token ? { token } : {})
|
|
};
|
|
} catch (e) {
|
|
console.error('공개 이벤트 조회 오류:', e);
|
|
throw new Error('이벤트 정보를 가져오는 중 오류가 발생했습니다.');
|
|
}
|
|
};
|
|
|
|
// 공개 참가자 등록/수정
|
|
exports.registerPublicParticipant = async (req, res) => {
|
|
const { publicHash } = req.params;
|
|
const { participantId, memberId, status, paymentStatus, comment } = req.body || {};
|
|
try {
|
|
const event = await Event.findOne({ where: { publicHash } });
|
|
if (!event) return res.status(404).json({ message: '이벤트를 찾을 수 없습니다.' });
|
|
if (event.status === '취소') return res.status(403).json({ message: '취소된 이벤트입니다.' });
|
|
let member = await Member.findOne({ where: { id: memberId } });
|
|
let participant = await EventParticipant.findOne({ where: { id: participantId, memberId: member.id } });
|
|
if (!participant) {
|
|
participant = await EventParticipant.create({ eventId: event.id, memberId: member.id, comment, status, paymentStatus });
|
|
} else {
|
|
await participant.update({ comment, status, paymentStatus });
|
|
}
|
|
res.json({ message: '참가 신청/수정이 완료되었습니다.' });
|
|
} catch (e) {
|
|
console.error('공개 참가자 등록 오류:', e);
|
|
res.status(500).json({ message: '참가 신청/수정 중 오류가 발생했습니다.' });
|
|
}
|
|
};
|
|
|
|
// 공개 게스트 추가
|
|
exports.addPublicGuest = async (req, res) => {
|
|
const { publicHash } = req.params;
|
|
const { name, phone, gender, average } = req.body || {};
|
|
try {
|
|
const event = await Event.findOne({ where: { publicHash } });
|
|
if (!event) return res.status(404).json({ message: '이벤트를 찾을 수 없습니다.' });
|
|
if (event.status === '취소') return res.status(403).json({ message: '취소된 이벤트입니다.' });
|
|
|
|
// 클럽의 회원 수와 구독 플랜의 최대 회원 수 확인
|
|
const memberCount = await Member.count({ where: { clubId: event.clubId } });
|
|
|
|
// 클럽 정보 가져오기 (여성 기본 핸디캡 확인을 위해)
|
|
const club = await Club.findByPk(event.clubId);
|
|
if (!club) return res.status(404).json({ message: '클럽 정보를 찾을 수 없습니다.' });
|
|
|
|
// 클럽의 구독 정보 가져오기 - 가장 최근 구독 정보
|
|
const clubSubscription = await sequelize.models.ClubSubscription.findOne({
|
|
where: { clubId: event.clubId },
|
|
include: [{ model: sequelize.models.SubscriptionPlan }],
|
|
order: [['endDate', 'DESC']] // 가장 최근 구독 정보를 가져오기 위해 만료일 기준 내림차순 정렬
|
|
});
|
|
|
|
// 구독이 없거나 만료된 경우 접근 제한
|
|
const now = new Date();
|
|
if (!clubSubscription || new Date(clubSubscription.endDate) < now) {
|
|
return res.status(403).json({ message: '클럽의 구독이 만료되어 이벤트에 접근할 수 없습니다. 클럽 관리자에게 문의하세요.' });
|
|
}
|
|
|
|
// 회원 수가 최대치를 초과하는 경우
|
|
if (clubSubscription.SubscriptionPlan) {
|
|
const maxMembers = clubSubscription.SubscriptionPlan.maxMembers;
|
|
if (memberCount >= maxMembers) {
|
|
return res.status(403).json({
|
|
message: `회원 수가 구독 플랜의 최대 허용 인원(${maxMembers}명)을 초과했습니다. 구독 업그레이드가 필요합니다.`
|
|
});
|
|
}
|
|
}
|
|
|
|
// 여성 핸디캡 적용
|
|
let handicap = 0;
|
|
if (gender === 'female' && club.femaleHandicap) {
|
|
handicap = club.femaleHandicap;
|
|
}
|
|
|
|
// publicAuth 미들웨어로 인증됨
|
|
const member = await Member.create({
|
|
name,
|
|
phone,
|
|
gender,
|
|
clubId: event.clubId,
|
|
memberType: 'guest',
|
|
average: 0, // 에버리지는 이제 사용하지 않지만 기본값은 설정
|
|
handicap: handicap // 여성 핸디캡 적용
|
|
});
|
|
const participant = await EventParticipant.create({ eventId: event.id, memberId: member.id });
|
|
|
|
// 클럽 설정에 따른 에버리지 계산
|
|
let calculatedAverage = 0;
|
|
try {
|
|
const averageData = await averageService.calculateMemberAverageByClubSetting(member.id, event.clubId);
|
|
calculatedAverage = averageData.average;
|
|
} catch (error) {
|
|
console.error(`게스트 ${member.id}의 에버리지 계산 중 오류:`, error);
|
|
}
|
|
|
|
res.json({
|
|
message: '게스트가 추가되었습니다.',
|
|
data: {
|
|
memberId: member.id,
|
|
participantId: participant.id,
|
|
name: member.name,
|
|
phone: member.phone,
|
|
gender: member.gender,
|
|
memberType: member.memberType,
|
|
handicap: member.handicap,
|
|
average: calculatedAverage,
|
|
group: '미신청'
|
|
}
|
|
});
|
|
} catch (e) {
|
|
console.error('공개 게스트 추가 오류:', e);
|
|
res.status(500).json({ message: '게스트 추가 중 오류가 발생했습니다.' });
|
|
}
|
|
};
|
|
|
|
// 공개 점수 수정
|
|
exports.updatePublicScore = async (req, res) => {
|
|
const { publicHash } = req.params;
|
|
let { participantId, gameNumber, score, handicap, teamNumber } = req.body || {};
|
|
score = Number(score);
|
|
handicap = Number(handicap) || 0; // undefined/null이면 0
|
|
teamNumber = teamNumber ?? null;
|
|
try {
|
|
const event = await Event.findOne({ where: { publicHash } });
|
|
if (!event) return res.status(404).json({ message: '이벤트를 찾을 수 없습니다.' });
|
|
if (event.status !== 'ready' && event.status !== 'active') return res.status(403).json({ message: '점수 수정이 불가능한 상태입니다.' });
|
|
// publicAuth 미들웨어로 인증됨
|
|
let eventScore = await EventScore.findOne({ where: { eventId: event.id, participantId, gameNumber } });
|
|
if (!eventScore) {
|
|
eventScore = await EventScore.create({ eventId: event.id, participantId, gameNumber, teamNumber, score, handicap, totalScore: score + handicap });
|
|
} else {
|
|
await eventScore.update({ teamNumber, score, handicap, totalScore: score + handicap });
|
|
}
|
|
|
|
// 점수 변경 시 해당 회원의 에버리지 캩0시 무효화
|
|
try {
|
|
const participant = await EventParticipant.findByPk(participantId);
|
|
if (participant) {
|
|
await averageService.invalidateMemberAverageCache(participant.memberId);
|
|
}
|
|
} catch (error) {
|
|
console.error('에버리지 캐시 무효화 중 오류:', error);
|
|
// 캩0시 무효화 오류는 점수 저장에 영향을 주지 않음
|
|
}
|
|
|
|
res.json({ message: '점수가 저장되었습니다.' });
|
|
} catch (e) {
|
|
console.error('공개 점수 수정 오류:', e);
|
|
res.status(500).json({ message: '점수 저장 중 오류가 발생했습니다.' });
|
|
}
|
|
};
|