1702 lines
58 KiB
Dart
1702 lines
58 KiB
Dart
import 'package:flutter/material.dart';
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:flutter/services.dart';
|
|
import 'package:provider/provider.dart';
|
|
import 'package:intl/intl.dart';
|
|
import 'package:share_plus/share_plus.dart';
|
|
import '../../widgets/dialog_actions.dart';
|
|
|
|
import '../../models/club_model.dart';
|
|
import '../../models/event_model.dart';
|
|
import '../../models/member_model.dart';
|
|
import '../../models/participant_model.dart';
|
|
import '../../models/score_model.dart';
|
|
import '../../models/team_model.dart';
|
|
import '../../services/club_service.dart';
|
|
import '../../services/event_service.dart';
|
|
import '../../services/member_service.dart';
|
|
import '../../services/notification_service.dart';
|
|
import '../../utils/url_utils.dart';
|
|
import '../../widgets/loading_indicator.dart';
|
|
import '../../utils/enum_mappings.dart';
|
|
// participant_form_screen 제거: 모든 추가는 기존 회원 빠른추가 경로로 통일
|
|
import 'score_form_screen.dart';
|
|
import 'event_form_screen.dart';
|
|
import '../score/score_batch_edit_screen.dart';
|
|
import 'tabs/scores_tab.dart';
|
|
import 'tabs/basic_info_tab.dart';
|
|
import 'tabs/participants_tab.dart';
|
|
import 'tabs/teams_tab.dart';
|
|
|
|
class EventDetailsScreen extends StatefulWidget {
|
|
final Event event;
|
|
// 테스트 시 초기 비동기 로드를 건너뛰기 위한 플래그
|
|
@visibleForTesting
|
|
static bool testMode = false;
|
|
|
|
const EventDetailsScreen({Key? key, required this.event}) : super(key: key);
|
|
|
|
@override
|
|
State<EventDetailsScreen> createState() => _EventDetailsScreenState();
|
|
}
|
|
|
|
class _EventDetailsScreenState extends State<EventDetailsScreen>
|
|
with SingleTickerProviderStateMixin {
|
|
late TabController _tabController;
|
|
Event? _event; // 최신 이벤트 정보 보관
|
|
List<Participant> _participants = [];
|
|
List<Score> _scores = [];
|
|
List<Team> _teams = [];
|
|
List<Member> _members = [];
|
|
// 클럽 전체 회원 목록 (빠른추가 드롭다운에 사용)
|
|
List<Member> _clubMembers = [];
|
|
Club? _club;
|
|
bool _isLoading = true;
|
|
int _teamGenerationMethod = 1; // 1: 팀 인원수로 나누기, 2: 팀 개수로 나누기
|
|
final TextEditingController _teamSizeController = TextEditingController(
|
|
text: '4',
|
|
);
|
|
final TextEditingController _teamCountController = TextEditingController(
|
|
text: '2',
|
|
);
|
|
bool _showTeamTab = false;
|
|
bool _includeHandicap = true; // 핸디캡 포함 여부
|
|
bool _groupByParticipant = false; // 점수 표시 방식: false=점수별(기존), true=참가자별 그룹
|
|
bool _clubMembersLoading = false;
|
|
VoidCallback? _memberServiceListener;
|
|
MemberService? _memberServiceRef;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
// 테스트를 위해 팀 탭 항상 표시
|
|
_showTeamTab = true;
|
|
// 탭 컨트롤러 길이 동적 설정
|
|
_tabController = TabController(length: _showTeamTab ? 4 : 3, vsync: this);
|
|
// 탭 전환 시 FAB 등 상단 Scaffold 요소가 즉시 갱신되도록 리스너 추가
|
|
_tabController.addListener(() {
|
|
if (!mounted) return;
|
|
// index 변화 시 재빌드하여 floatingActionButton을 갱신
|
|
setState(() {});
|
|
});
|
|
// 프레임 이후 Provider 접근 및 MemberService 구독 설정
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
if (!mounted) return;
|
|
final memberService = Provider.of<MemberService>(context, listen: false);
|
|
_memberServiceRef = memberService;
|
|
// 초기 동기화
|
|
setState(() {
|
|
_clubMembers = memberService.members;
|
|
_clubMembersLoading = memberService.isLoading;
|
|
});
|
|
// 리스너 등록: 회원 목록/로딩 상태 변화 시 동기화
|
|
_memberServiceListener = () {
|
|
if (!mounted) return;
|
|
setState(() {
|
|
_clubMembers = memberService.members;
|
|
_clubMembersLoading = memberService.isLoading;
|
|
});
|
|
};
|
|
memberService.addListener(_memberServiceListener!);
|
|
// 이벤트 상세 로드 (테스트 모드에서는 스킵)
|
|
if (!EventDetailsScreen.testMode) {
|
|
_loadEventDetails();
|
|
} else {
|
|
setState(() {
|
|
_isLoading = false;
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
// 드래그앤드롭으로 팀 간 참가자 이동 처리
|
|
void _moveParticipantBetweenTeams(
|
|
Participant participant,
|
|
Team fromTeam,
|
|
Team toTeam,
|
|
int toIndex,
|
|
) {
|
|
setState(() {
|
|
final fromIdx = _teams.indexWhere((t) => t.id == fromTeam.id);
|
|
final toIdx = _teams.indexWhere((t) => t.id == toTeam.id);
|
|
if (toIdx < 0) return;
|
|
|
|
final memberId = participant.memberId;
|
|
// remove from source (미배정에서 오는 경우 fromIdx는 -1이 될 수 있음)
|
|
List<String>? fromMemberIds;
|
|
if (fromIdx >= 0) {
|
|
fromMemberIds = List<String>.from(_teams[fromIdx].memberIds);
|
|
fromMemberIds.remove(memberId);
|
|
}
|
|
|
|
// insert into target at index
|
|
final toMemberIds = List<String>.from(_teams[toIdx].memberIds);
|
|
// 중복 방지: 기존에 있으면 먼저 제거 (같은 팀 이동 시 길이가 줄어듦)
|
|
toMemberIds.remove(memberId);
|
|
// 제거 이후 길이에 맞춰 인덱스 보정
|
|
int insertIndex = toIndex.clamp(0, toMemberIds.length);
|
|
toMemberIds.insert(insertIndex, memberId);
|
|
|
|
if (fromIdx >= 0 && fromMemberIds != null) {
|
|
_teams[fromIdx] = Team(
|
|
id: _teams[fromIdx].id,
|
|
eventId: _teams[fromIdx].eventId,
|
|
name: _teams[fromIdx].name,
|
|
memberIds: fromMemberIds,
|
|
description: _teams[fromIdx].description,
|
|
createdAt: _teams[fromIdx].createdAt,
|
|
updatedAt: _teams[fromIdx].updatedAt,
|
|
);
|
|
}
|
|
|
|
_teams[toIdx] = Team(
|
|
id: _teams[toIdx].id,
|
|
eventId: _teams[toIdx].eventId,
|
|
name: _teams[toIdx].name,
|
|
memberIds: toMemberIds,
|
|
description: _teams[toIdx].description,
|
|
createdAt: _teams[toIdx].createdAt,
|
|
updatedAt: _teams[toIdx].updatedAt,
|
|
);
|
|
});
|
|
}
|
|
|
|
|
|
|
|
// 참가자 추가 선택 시트: 기존 회원 추가 vs 게스트 추가
|
|
Future<void> _openAddChooser() async {
|
|
if (!mounted) return;
|
|
await showModalBottomSheet<void>(
|
|
context: context,
|
|
shape: const RoundedRectangleBorder(
|
|
borderRadius: BorderRadius.vertical(top: Radius.circular(16)),
|
|
),
|
|
builder: (ctx) {
|
|
return SafeArea(
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
ListTile(
|
|
key: const Key('add_existing_member'),
|
|
leading: const Icon(Icons.person_add_alt_1),
|
|
title: const Text('기존 회원 추가'),
|
|
onTap: () async {
|
|
Navigator.of(ctx).pop();
|
|
await _openMemberQuickAddModal();
|
|
},
|
|
),
|
|
ListTile(
|
|
key: const Key('add_guest'),
|
|
leading: const Icon(Icons.group_add),
|
|
title: const Text('게스트 추가'),
|
|
onTap: () async {
|
|
Navigator.of(ctx).pop();
|
|
await _openGuestModal();
|
|
},
|
|
),
|
|
const SizedBox(height: 8),
|
|
],
|
|
),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
// 테스트 전용: 탭 전환 없이 모달을 직접 오픈
|
|
@visibleForTesting
|
|
Future<void> openQuickAddForTest() => _openMemberQuickAddModal();
|
|
|
|
// 테스트 전용: 탭 전환/ FAB 없이 추가 선택 시트를 직접 오픈
|
|
@visibleForTesting
|
|
Future<void> openAddChooserForTest() => _openAddChooser();
|
|
|
|
Future<void> _duplicateEvent() async {
|
|
final messenger = ScaffoldMessenger.of(context);
|
|
try {
|
|
final eventService = Provider.of<EventService>(context, listen: false);
|
|
// cloneEvent에 필요한 clubId 보장
|
|
eventService.setClubId(widget.event.clubId);
|
|
await eventService.cloneEvent(widget.event.id);
|
|
if (!mounted) return;
|
|
messenger.showSnackBar(const SnackBar(content: Text('이벤트가 복제되었습니다')));
|
|
// 목록 화면에서 새로고침할 수 있도록 결과 전달
|
|
Navigator.of(context).pop(true);
|
|
} catch (e) {
|
|
messenger.showSnackBar(SnackBar(content: Text('이벤트 복제에 실패했습니다: $e')));
|
|
}
|
|
}
|
|
|
|
@visibleForTesting
|
|
List<Map<String, dynamic>> buildServerTeamsForSave(
|
|
List<Team> teams,
|
|
List<Participant> participants,
|
|
) {
|
|
final List<Map<String, dynamic>> serverTeams = [];
|
|
for (int i = 0; i < teams.length; i++) {
|
|
final team = teams[i];
|
|
final members = <Map<String, dynamic>>[];
|
|
for (int j = 0; j < team.memberIds.length; j++) {
|
|
final memberId = team.memberIds[j];
|
|
final participant = participants.firstWhere(
|
|
(p) => p.memberId == memberId,
|
|
orElse: () => Participant(id: '', eventId: widget.event.id, memberId: memberId),
|
|
);
|
|
if (participant.id.isNotEmpty) {
|
|
members.add({'id': participant.id, 'order': j + 1});
|
|
}
|
|
}
|
|
serverTeams.add({'teamNumber': i + 1, 'handicap': 0, 'members': members});
|
|
}
|
|
return serverTeams;
|
|
}
|
|
|
|
// ===== 테스트 훅들 (TDD 지원) =====
|
|
@visibleForTesting
|
|
void debugSetTeamsAndParticipants(List<Team> teams, List<Participant> participants) {
|
|
setState(() {
|
|
_teams = teams;
|
|
_participants = participants;
|
|
});
|
|
}
|
|
|
|
@visibleForTesting
|
|
List<Team> debugGetTeams() => _teams.map((t) => Team(
|
|
id: t.id,
|
|
eventId: t.eventId,
|
|
name: t.name,
|
|
memberIds: List<String>.from(t.memberIds),
|
|
description: t.description,
|
|
createdAt: t.createdAt,
|
|
updatedAt: t.updatedAt,
|
|
)).toList();
|
|
|
|
@visibleForTesting
|
|
void testMoveParticipantBetweenTeams(
|
|
Participant participant,
|
|
Team fromTeam,
|
|
Team toTeam,
|
|
int toIndex,
|
|
) {
|
|
_moveParticipantBetweenTeams(participant, fromTeam, toTeam, toIndex);
|
|
}
|
|
|
|
@visibleForTesting
|
|
double debugCalculateTeamAverage(Team team) => _calculateTeamAverage(team);
|
|
|
|
@visibleForTesting
|
|
void debugSetScores(List<Score> scores) {
|
|
setState(() {
|
|
_scores = scores;
|
|
});
|
|
}
|
|
|
|
// 참가자별 점수 일괄 수정 화면으로 이동
|
|
Future<void> _openBatchEdit(
|
|
Participant participant,
|
|
List<Score> scores,
|
|
) async {
|
|
if (!mounted) return;
|
|
final messenger = ScaffoldMessenger.of(context);
|
|
final result = await Navigator.of(context).push<bool>(
|
|
MaterialPageRoute(
|
|
builder: (_) => ScoreBatchEditScreen(
|
|
eventId: widget.event.id,
|
|
participant: participant,
|
|
scores: scores,
|
|
gameCount: widget.event.gameCount ?? scores.length,
|
|
),
|
|
),
|
|
);
|
|
if (result == true && mounted) {
|
|
await _loadEventDetails();
|
|
messenger.showSnackBar(const SnackBar(content: Text('점수를 일괄 수정했습니다')));
|
|
}
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
// MemberService 리스너 해제: dispose 시점의 BuildContext 사용을 피하기 위해 보관한 ref 사용
|
|
if (_memberServiceListener != null && _memberServiceRef != null) {
|
|
try {
|
|
_memberServiceRef!.removeListener(_memberServiceListener!);
|
|
} catch (_) {}
|
|
_memberServiceListener = null;
|
|
}
|
|
|
|
_tabController.dispose();
|
|
_teamSizeController.dispose();
|
|
_teamCountController.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
// 게스트 사전입력 모달 열기
|
|
Future<void> _openGuestModal() async {
|
|
// await 이전에 필요한 의존성/서비스를 캡처
|
|
final messenger = ScaffoldMessenger.of(context);
|
|
final eventService = Provider.of<EventService>(context, listen: false);
|
|
final memberService = Provider.of<MemberService>(context, listen: false);
|
|
|
|
final nameController = TextEditingController();
|
|
String gender = 'male';
|
|
final phoneController = TextEditingController();
|
|
final emailController = TextEditingController();
|
|
final handicapController = TextEditingController();
|
|
String participantStatus = 'pending';
|
|
String paymentStatus = 'unpaid';
|
|
final commentController = TextEditingController();
|
|
|
|
final result = await showModalBottomSheet<bool>(
|
|
context: context,
|
|
isScrollControlled: true,
|
|
shape: const RoundedRectangleBorder(
|
|
borderRadius: BorderRadius.vertical(top: Radius.circular(16)),
|
|
),
|
|
builder: (ctx) {
|
|
return Padding(
|
|
padding: EdgeInsets.only(
|
|
bottom: MediaQuery.of(ctx).viewInsets.bottom,
|
|
left: 16,
|
|
right: 16,
|
|
top: 16,
|
|
),
|
|
child: SingleChildScrollView(
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
const Text(
|
|
'게스트 정보 입력',
|
|
style: TextStyle(fontWeight: FontWeight.bold, fontSize: 16),
|
|
),
|
|
const SizedBox(height: 12),
|
|
TextField(
|
|
controller: nameController,
|
|
decoration: const InputDecoration(
|
|
labelText: '이름(선택)',
|
|
border: OutlineInputBorder(),
|
|
prefixIcon: Icon(Icons.person),
|
|
),
|
|
),
|
|
const SizedBox(height: 8),
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: DropdownButtonFormField<String>(
|
|
key: const Key('event_details_guest_gender_dropdown'),
|
|
initialValue: gender,
|
|
decoration: const InputDecoration(
|
|
labelText: '성별',
|
|
border: OutlineInputBorder(),
|
|
prefixIcon: Icon(Icons.wc),
|
|
),
|
|
isExpanded: true,
|
|
items: [
|
|
DropdownMenuItem<String>(
|
|
value: 'male',
|
|
child: Text(
|
|
'남',
|
|
maxLines: 1,
|
|
overflow: TextOverflow.ellipsis,
|
|
),
|
|
),
|
|
DropdownMenuItem<String>(
|
|
value: 'female',
|
|
child: Text(
|
|
'여',
|
|
maxLines: 1,
|
|
overflow: TextOverflow.ellipsis,
|
|
),
|
|
),
|
|
],
|
|
onChanged: (v) => gender = v ?? 'male',
|
|
),
|
|
),
|
|
const SizedBox(width: 8),
|
|
Expanded(
|
|
child: TextField(
|
|
controller: handicapController,
|
|
decoration: const InputDecoration(
|
|
labelText: '핸디캡(선택)',
|
|
border: OutlineInputBorder(),
|
|
prefixIcon: Icon(Icons.calculate),
|
|
),
|
|
keyboardType: TextInputType.number,
|
|
inputFormatters: [
|
|
FilteringTextInputFormatter.digitsOnly,
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 8),
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: TextField(
|
|
controller: phoneController,
|
|
decoration: const InputDecoration(
|
|
labelText: '전화(선택)',
|
|
border: OutlineInputBorder(),
|
|
prefixIcon: Icon(Icons.phone),
|
|
),
|
|
keyboardType: TextInputType.phone,
|
|
),
|
|
),
|
|
const SizedBox(width: 8),
|
|
Expanded(
|
|
child: TextField(
|
|
controller: emailController,
|
|
decoration: const InputDecoration(
|
|
labelText: '이메일(선택)',
|
|
border: OutlineInputBorder(),
|
|
prefixIcon: Icon(Icons.email),
|
|
),
|
|
keyboardType: TextInputType.emailAddress,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 12),
|
|
const Text(
|
|
'참가 정보',
|
|
style: TextStyle(fontWeight: FontWeight.bold),
|
|
),
|
|
const SizedBox(height: 8),
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: DropdownButtonFormField<String>(
|
|
key: const Key(
|
|
'event_details_participant_status_dropdown',
|
|
),
|
|
initialValue:
|
|
(participantStatusOptions.keys.contains(
|
|
participantStatus,
|
|
))
|
|
? participantStatus
|
|
: null,
|
|
decoration: const InputDecoration(
|
|
labelText: '상태',
|
|
border: OutlineInputBorder(),
|
|
prefixIcon: Icon(Icons.verified_user),
|
|
),
|
|
isExpanded: true,
|
|
items: participantStatusOptions.entries
|
|
.map(
|
|
(e) => DropdownMenuItem<String>(
|
|
value: e.key,
|
|
child: Text(
|
|
e.value,
|
|
maxLines: 1,
|
|
overflow: TextOverflow.ellipsis,
|
|
),
|
|
),
|
|
)
|
|
.toList(),
|
|
onChanged: (v) => participantStatus = v ?? 'pending',
|
|
),
|
|
),
|
|
const SizedBox(width: 8),
|
|
Expanded(
|
|
child: DropdownButtonFormField<String>(
|
|
key: const Key('event_details_payment_status_dropdown'),
|
|
initialValue:
|
|
(paymentStatusOptions.keys.contains(paymentStatus))
|
|
? paymentStatus
|
|
: null,
|
|
decoration: const InputDecoration(
|
|
labelText: '결제',
|
|
border: OutlineInputBorder(),
|
|
prefixIcon: Icon(Icons.payment),
|
|
),
|
|
isExpanded: true,
|
|
items: paymentStatusOptions.entries
|
|
.map(
|
|
(e) => DropdownMenuItem<String>(
|
|
value: e.key,
|
|
child: Text(
|
|
e.value,
|
|
maxLines: 1,
|
|
overflow: TextOverflow.ellipsis,
|
|
),
|
|
),
|
|
)
|
|
.toList(),
|
|
onChanged: (v) => paymentStatus = v ?? 'unpaid',
|
|
),
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 8),
|
|
TextField(
|
|
controller: commentController,
|
|
decoration: const InputDecoration(
|
|
labelText: '비고(선택)',
|
|
border: OutlineInputBorder(),
|
|
prefixIcon: Icon(Icons.notes),
|
|
),
|
|
maxLines: 2,
|
|
),
|
|
const SizedBox(height: 12),
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: OutlinedButton(
|
|
onPressed: () => Navigator.of(ctx).pop(false),
|
|
child: const Text('취소'),
|
|
),
|
|
),
|
|
const SizedBox(width: 8),
|
|
Expanded(
|
|
child: ElevatedButton.icon(
|
|
icon: const Icon(Icons.save),
|
|
onPressed: () => Navigator.of(ctx).pop(true),
|
|
label: const Text('저장 후 추가'),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 8),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
},
|
|
);
|
|
|
|
if (result != true) {
|
|
return;
|
|
}
|
|
|
|
// 저장 처리: 입력값 기반으로 회원 생성 후 참가자 추가
|
|
setState(() => _isLoading = true);
|
|
try {
|
|
final Map<String, dynamic> memberPayload = {
|
|
'name': (nameController.text.trim().isEmpty)
|
|
? '게스트'
|
|
: nameController.text.trim(),
|
|
'gender': gender, // 백엔드 필수
|
|
'memberType': 'guest',
|
|
'status': 'active',
|
|
};
|
|
if (phoneController.text.trim().isNotEmpty) {
|
|
memberPayload['phone'] = phoneController.text.trim();
|
|
}
|
|
if (emailController.text.trim().isNotEmpty) {
|
|
memberPayload['email'] = emailController.text.trim();
|
|
}
|
|
if (handicapController.text.trim().isNotEmpty) {
|
|
final parsed = int.tryParse(handicapController.text.trim());
|
|
if (parsed != null) memberPayload['handicap'] = parsed;
|
|
}
|
|
|
|
final guestMember = await memberService.addMember(memberPayload);
|
|
|
|
final Map<String, dynamic> participantPayload = {
|
|
'memberId': guestMember.id,
|
|
// 드롭다운과 백엔드 허용값 정합성: enum 키 사용 (pending/confirmed/canceled)
|
|
'status': participantStatus,
|
|
'paymentStatus': paymentStatus,
|
|
};
|
|
if (commentController.text.trim().isNotEmpty) {
|
|
participantPayload['comment'] = commentController.text.trim();
|
|
}
|
|
|
|
await eventService.addParticipant(widget.event.id, participantPayload);
|
|
if (!mounted) {
|
|
return;
|
|
}
|
|
// 서버 재조회로 상세 정보 반영
|
|
await _loadEventDetails();
|
|
messenger.showSnackBar(const SnackBar(content: Text('게스트를 추가했습니다.')));
|
|
} catch (e) {
|
|
messenger.showSnackBar(SnackBar(content: Text('게스트 추가 실패: $e')));
|
|
} finally {
|
|
if (mounted) {
|
|
setState(() => _isLoading = false);
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<void> _loadEventDetails() async {
|
|
setState(() {
|
|
_isLoading = true;
|
|
});
|
|
|
|
try {
|
|
final eventService = Provider.of<EventService>(context, listen: false);
|
|
final clubService = Provider.of<ClubService>(context, listen: false);
|
|
final memberService = Provider.of<MemberService>(context, listen: false);
|
|
// EventService가 clubId 없을 경우 참가자/점수/참가자 추가 등에서 인증/클럽 정보 오류가 발생하므로
|
|
// 화면 진입 시점의 이벤트 clubId를 주입하여 안정화한다.
|
|
eventService.setClubId(widget.event.clubId);
|
|
// MemberService도 clubId가 필요하므로 함께 주입한다.
|
|
await memberService.setClubId(widget.event.clubId);
|
|
|
|
// 최신 이벤트 상세 로드
|
|
final fetchedEvent = await eventService.fetchEventById(widget.event.id);
|
|
|
|
// 참가자 목록 로드
|
|
final participants = await eventService.fetchEventParticipants(
|
|
widget.event.id,
|
|
);
|
|
|
|
// 점수 목록 로드
|
|
final scores = await eventService.fetchEventScores(widget.event.id);
|
|
|
|
// participantId 누락 데이터 보정: memberId로 매칭하여 participantId 채움
|
|
final Map<String, String> memberIdToParticipantId = {
|
|
for (final p in participants) p.memberId: p.id,
|
|
};
|
|
final adjustedScores = scores.map((s) {
|
|
if (s.participantId == null || s.participantId!.isEmpty) {
|
|
final pid = memberIdToParticipantId[s.memberId];
|
|
if (pid != null) {
|
|
return Score(
|
|
id: s.id,
|
|
memberId: s.memberId,
|
|
eventId: s.eventId,
|
|
clubId: s.clubId,
|
|
participantId: pid,
|
|
frames: s.frames,
|
|
totalScore: s.totalScore,
|
|
handicap: s.handicap,
|
|
gameNumber: s.gameNumber,
|
|
date: s.date,
|
|
notes: s.notes,
|
|
participantName: s.participantName,
|
|
);
|
|
}
|
|
}
|
|
return s;
|
|
}).toList();
|
|
|
|
// 클럽 정보 로드
|
|
final club = await clubService.fetchClub(widget.event.clubId);
|
|
|
|
// 회원 정보 로드 (동점자 처리 시 생년월일 사용)
|
|
final memberIds = participants.map((p) => p.memberId).toList();
|
|
final members = await memberService.fetchMembersByIds(
|
|
widget.event.clubId,
|
|
memberIds,
|
|
);
|
|
// 참가자 정보 보강: Member에서 handicap/gender/name 보완
|
|
final Map<String, Member> memberById = {for (final m in members) m.id: m};
|
|
final List<Participant> enrichedParticipants = participants.map((p) {
|
|
final m = memberById[p.memberId];
|
|
if (m == null) return p;
|
|
final int? pHcp = p.handicap;
|
|
final bool needHcp = pHcp == null || pHcp <= 0;
|
|
final String? pGender = p.gender;
|
|
final bool needGender = pGender == null || pGender.isEmpty;
|
|
final String? pName = p.name;
|
|
final bool needName = pName == null || pName.isEmpty;
|
|
if (!needHcp && !needGender && !needName) return p;
|
|
return p.copyWith(
|
|
handicap: needHcp ? m.handicap : p.handicap,
|
|
gender: needGender ? m.gender : p.gender,
|
|
name: needName ? m.name : p.name,
|
|
);
|
|
}).toList();
|
|
// 빠른추가용 클럽 전체 회원 목록 로드 (MemberService 리스너로 동기화되므로 별도 setState 없이 호출만)
|
|
await memberService.fetchClubMembers();
|
|
|
|
// 팀 목록 로드 (선택적)
|
|
List<Team> teams = [];
|
|
try {
|
|
teams = await eventService.fetchEventTeams(widget.event.id);
|
|
} catch (e) {
|
|
// 팀 기능이 없거나 오류 발생 시 무시
|
|
if (kDebugMode) {
|
|
debugPrint('팀 로드 실패: $e');
|
|
}
|
|
}
|
|
|
|
if (mounted) {
|
|
setState(() {
|
|
_event = fetchedEvent;
|
|
_participants = enrichedParticipants;
|
|
_scores = adjustedScores;
|
|
_teams = teams;
|
|
_club = club;
|
|
_members = members;
|
|
_showTeamTab = true; // 테스트를 위해 팀 탭 항상 표시
|
|
_isLoading = false;
|
|
});
|
|
}
|
|
} catch (e) {
|
|
if (mounted) {
|
|
setState(() {
|
|
_isLoading = false;
|
|
});
|
|
ScaffoldMessenger.of(
|
|
context,
|
|
).showSnackBar(SnackBar(content: Text('이벤트 정보를 불러오는데 실패했습니다: $e')));
|
|
}
|
|
}
|
|
}
|
|
|
|
// 상단 빠른추가 제거로 재조회 핸들러는 더 이상 사용하지 않습니다.
|
|
|
|
// 이벤트 공유 기능
|
|
void _shareEvent() {
|
|
// 공유할 내용 구성
|
|
final String eventTitle = widget.event.title;
|
|
final String eventType = getEventTypeLabel(widget.event.type);
|
|
final String eventDate = DateFormat(
|
|
'yyyy-MM-dd HH:mm',
|
|
).format(widget.event.startDate);
|
|
final String eventLocation = widget.event.location ?? '장소 미정';
|
|
|
|
// 공개 URL 생성
|
|
String shareUrl = '';
|
|
if (widget.event.publicHash != null &&
|
|
widget.event.publicHash!.isNotEmpty) {
|
|
shareUrl = UrlUtils.getEventPublicUrl(widget.event.publicHash!);
|
|
}
|
|
|
|
// 공유 메시지 구성
|
|
final String shareText =
|
|
'''
|
|
[볼링 이벤트 초대]
|
|
$eventTitle
|
|
|
|
유형: $eventType
|
|
일시: $eventDate
|
|
장소: $eventLocation
|
|
|
|
참가자: ${_participants.length}명
|
|
|
|
${shareUrl.isNotEmpty ? '참가 링크: $shareUrl' : ''}
|
|
${widget.event.accessPassword != null && widget.event.accessPassword!.isNotEmpty ? '비밀번호: ${widget.event.accessPassword}' : ''}
|
|
''';
|
|
|
|
// 공유 다이얼로그 표시 (Share는 deprecated)
|
|
SharePlus.instance.share(
|
|
ShareParams(text: shareText, subject: '볼링 이벤트: $eventTitle'),
|
|
);
|
|
}
|
|
|
|
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Scaffold(
|
|
appBar: AppBar(
|
|
title: Text(
|
|
(_event ?? widget.event).title,
|
|
maxLines: 1,
|
|
overflow: TextOverflow.ellipsis,
|
|
),
|
|
actions: _buildAppBarActions(),
|
|
bottom: TabBar(
|
|
controller: _tabController,
|
|
tabs: [
|
|
const Tab(text: '기본 정보'),
|
|
const Tab(text: '참가자'),
|
|
const Tab(text: '점수'),
|
|
if (_showTeamTab) const Tab(text: '팀'),
|
|
],
|
|
),
|
|
),
|
|
body: _isLoading
|
|
? const LoadingIndicator()
|
|
: TabBarView(
|
|
controller: _tabController,
|
|
children: [
|
|
_buildBasicInfoTab(),
|
|
_buildParticipantsTab(),
|
|
_buildScoresTab(),
|
|
if (_showTeamTab) _buildTeamsTab(),
|
|
],
|
|
),
|
|
// FAB 제거: 상단 AppBar actions로 통합
|
|
);
|
|
}
|
|
|
|
List<Widget> _buildAppBarActions() {
|
|
final currentTab = _tabController.index;
|
|
final actions = <Widget>[];
|
|
switch (currentTab) {
|
|
case 0: // 기본 정보
|
|
actions.add(
|
|
IconButton(
|
|
tooltip: '이벤트 수정',
|
|
icon: const Icon(Icons.edit),
|
|
onPressed: _editEvent,
|
|
),
|
|
);
|
|
break;
|
|
case 1: // 참가자
|
|
actions.add(
|
|
IconButton(
|
|
tooltip: '참가자 추가',
|
|
icon: const Icon(Icons.person_add),
|
|
onPressed: _openAddChooser,
|
|
),
|
|
);
|
|
break;
|
|
case 2: // 점수
|
|
actions.add(
|
|
IconButton(
|
|
tooltip: '점수 추가',
|
|
icon: const Icon(Icons.add_chart),
|
|
onPressed: _addScore,
|
|
),
|
|
);
|
|
break;
|
|
case 3: // 팀
|
|
if (_showTeamTab) {
|
|
actions.addAll([
|
|
IconButton(
|
|
tooltip: '팀 재생성',
|
|
icon: const Icon(Icons.refresh),
|
|
onPressed: _isLoading ? null : _generateTeams,
|
|
),
|
|
IconButton(
|
|
tooltip: '팀 저장',
|
|
icon: const Icon(Icons.save),
|
|
onPressed: _isLoading ? null : _saveTeams,
|
|
),
|
|
]);
|
|
}
|
|
break;
|
|
}
|
|
return actions;
|
|
}
|
|
|
|
// 기본 정보 탭
|
|
Widget _buildBasicInfoTab() {
|
|
return BasicInfoTab(
|
|
event: _event ?? widget.event,
|
|
participantsCount: _participants.length,
|
|
onShareEvent: _shareEvent,
|
|
onSetEventReminders: _setEventReminders,
|
|
);
|
|
}
|
|
|
|
|
|
|
|
// 참가자 탭
|
|
Widget _buildParticipantsTab() {
|
|
return ParticipantsTab(
|
|
participants: _participants,
|
|
scores: _scores,
|
|
onEditParticipant: _editParticipant,
|
|
);
|
|
}
|
|
|
|
// 상단 빠른추가 제거로 개별 추가 핸들러는 더 이상 사용하지 않습니다.
|
|
|
|
// 점수 탭
|
|
Widget _buildScoresTab() {
|
|
return ScoresTab(
|
|
eventId: widget.event.id,
|
|
participants: _participants,
|
|
scores: _scores,
|
|
members: _members,
|
|
clubMembers: _clubMembers,
|
|
club: _club,
|
|
includeHandicap: _includeHandicap,
|
|
onIncludeHandicapChanged: (v) => setState(() => _includeHandicap = v),
|
|
groupByParticipant: _groupByParticipant,
|
|
onGroupByParticipantChanged: (v) => setState(() => _groupByParticipant = v),
|
|
onOpenBatchEdit: _openBatchEdit,
|
|
onEditScore: _editScore,
|
|
onDeleteScore: _deleteScore,
|
|
);
|
|
}
|
|
|
|
// 점수 추가
|
|
Future<void> _addScore() async {
|
|
final result = await Navigator.of(context).push<bool>(
|
|
MaterialPageRoute(
|
|
builder: (_) => ScoreFormScreen(
|
|
eventId: widget.event.id,
|
|
participants: _participants,
|
|
gameCount: widget.event.gameCount ?? 1,
|
|
),
|
|
),
|
|
);
|
|
if (result == true) {
|
|
_loadEventDetails();
|
|
if (_tabController.index != 2) {
|
|
_tabController.animateTo(2);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 점수 수정
|
|
Future<void> _editScore(Score score) async {
|
|
final result = await Navigator.of(context).push<bool>(
|
|
MaterialPageRoute(
|
|
builder: (_) => ScoreFormScreen(
|
|
eventId: widget.event.id,
|
|
score: score,
|
|
participants: _participants,
|
|
),
|
|
),
|
|
);
|
|
if (result == true) {
|
|
_loadEventDetails();
|
|
if (_tabController.index != 2) {
|
|
_tabController.animateTo(2);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 팀 탭
|
|
Widget _buildTeamsTab() {
|
|
return TeamsTab(
|
|
event: widget.event,
|
|
isLoading: _isLoading,
|
|
teams: _teams,
|
|
participants: _participants,
|
|
scores: _scores,
|
|
teamGenerationMethod: _teamGenerationMethod,
|
|
teamSizeController: _teamSizeController,
|
|
teamCountController: _teamCountController,
|
|
unassignedParticipants: _getUnassignedParticipants(),
|
|
onChangeTeamGenerationMethod: (value) => setState(() => _teamGenerationMethod = value),
|
|
onGenerateTeams: _generateTeams,
|
|
onSaveTeams: _saveTeams,
|
|
onRemoveFromTeam: _removeFromTeam,
|
|
onShowParticipantSelectionDialog: _showParticipantSelectionDialog,
|
|
onShowTeamSelectionDialog: _showTeamSelectionDialog,
|
|
calculateTeamAverage: _calculateTeamAverage,
|
|
onShareEvent: _shareEvent,
|
|
onMoveParticipant: _moveParticipantBetweenTeams,
|
|
);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// 이벤트 알림 설정 기능
|
|
Future<void> _setEventReminders() async {
|
|
final notificationService = NotificationService();
|
|
|
|
final hasPermission = await notificationService.requestPermission();
|
|
if (!hasPermission) {
|
|
if (mounted) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(content: Text('알림 권한이 없습니다. 설정에서 권한을 허용해주세요.')),
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (!mounted) return;
|
|
final messenger = ScaffoldMessenger.of(context);
|
|
|
|
showDialog(
|
|
context: context,
|
|
builder: (dialogContext) => AlertDialog(
|
|
title: const Text('이벤트 알림 설정'),
|
|
content: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
ListTile(
|
|
leading: const Icon(Icons.notifications_active),
|
|
title: const Text('이벤트 시작 알림'),
|
|
subtitle: Text(
|
|
'${DateFormat('yyyy-MM-dd HH:mm').format(widget.event.startDate)} 1시간 전',
|
|
),
|
|
onTap: () async {
|
|
final navigator = Navigator.of(dialogContext);
|
|
navigator.pop();
|
|
await notificationService.scheduleEventStartReminder(
|
|
widget.event,
|
|
);
|
|
messenger.showSnackBar(
|
|
const SnackBar(content: Text('이벤트 시작 알림이 설정되었습니다')),
|
|
);
|
|
},
|
|
),
|
|
if (widget.event.registrationDeadline != null)
|
|
ListTile(
|
|
leading: const Icon(Icons.timer),
|
|
title: const Text('등록 마감 알림'),
|
|
subtitle: Text(
|
|
'${DateFormat('yyyy-MM-dd HH:mm').format(widget.event.registrationDeadline!)} 1일 전',
|
|
),
|
|
onTap: () async {
|
|
final navigator = Navigator.of(dialogContext);
|
|
navigator.pop();
|
|
await notificationService
|
|
.scheduleRegistrationDeadlineReminder(widget.event);
|
|
messenger.showSnackBar(
|
|
const SnackBar(content: Text('등록 마감 알림이 설정되었습니다')),
|
|
);
|
|
},
|
|
),
|
|
ListTile(
|
|
leading: const Icon(Icons.notifications_off),
|
|
title: const Text('알림 취소'),
|
|
subtitle: const Text('이 이벤트에 대한 모든 알림 취소'),
|
|
onTap: () async {
|
|
final navigator = Navigator.of(dialogContext);
|
|
navigator.pop();
|
|
await notificationService.cancelEventNotifications(
|
|
widget.event.id,
|
|
);
|
|
messenger.showSnackBar(
|
|
const SnackBar(content: Text('이벤트 알림이 취소되었습니다')),
|
|
);
|
|
},
|
|
),
|
|
],
|
|
),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: () => Navigator.of(dialogContext).pop(),
|
|
child: const Text('닫기'),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
// 미배정 참가자 목록 가져오기
|
|
List<Participant> _getUnassignedParticipants() {
|
|
// 현재 팀에 배정된 모든 참가자 ID 목록
|
|
final List<String> assignedMemberIds = [];
|
|
for (final team in _teams) {
|
|
assignedMemberIds.addAll(team.memberIds);
|
|
}
|
|
|
|
// 배정되지 않은 참가자 목록 반환
|
|
return _participants
|
|
.where((p) => !assignedMemberIds.contains(p.memberId))
|
|
.toList();
|
|
}
|
|
|
|
// 팀 평균 점수 계산
|
|
double _calculateTeamAverage(Team team) {
|
|
if (team.memberIds.isEmpty) return 0.0;
|
|
|
|
double totalAverage = 0.0;
|
|
int memberCount = 0;
|
|
|
|
for (final memberId in team.memberIds) {
|
|
final memberScores = _scores.where((s) => s.memberId == memberId).toList();
|
|
if (memberScores.isNotEmpty) {
|
|
final memberTotal = memberScores.fold<int>(0, (sum, score) => sum + score.totalScore);
|
|
totalAverage += memberTotal / memberScores.length;
|
|
memberCount++;
|
|
} else {
|
|
// 점수가 없으면 참가자 프로필의 평균을 사용 (있다면, 0은 무시)
|
|
final participant = _participants.firstWhere(
|
|
(p) => p.memberId == memberId,
|
|
orElse: () => Participant(id: 'unknown_$memberId', eventId: widget.event.id, memberId: memberId),
|
|
);
|
|
final avg = participant.average;
|
|
if (avg != null && avg > 0) {
|
|
totalAverage += avg;
|
|
memberCount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
return memberCount > 0 ? totalAverage / memberCount : 0.0;
|
|
}
|
|
|
|
// 팀 생성: 현재 탭에서 로컬 생성 후 저장
|
|
Future<void> _generateTeams() async {
|
|
// 입력값 검증 및 파라미터 구성
|
|
int? teamSize;
|
|
int? teamCount;
|
|
if (_teamGenerationMethod == 1) {
|
|
teamSize = int.tryParse(_teamSizeController.text.trim());
|
|
if (teamSize == null || teamSize <= 0) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(content: Text('유효한 인원수를 입력해주세요')),
|
|
);
|
|
return;
|
|
}
|
|
} else if (_teamGenerationMethod == 2) {
|
|
teamCount = int.tryParse(_teamCountController.text.trim());
|
|
if (teamCount == null || teamCount <= 0) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(content: Text('유효한 팀 수를 입력해주세요')),
|
|
);
|
|
return;
|
|
}
|
|
} else {
|
|
// 기본: 참가자 수 기반 2팀
|
|
teamCount = 2;
|
|
}
|
|
|
|
setState(() => _isLoading = true);
|
|
try {
|
|
// 1) 대상 참가자 선택: 취소된 참가자 제외
|
|
final selected = _participants.where((p) {
|
|
final st = (p.status ?? '').toLowerCase();
|
|
return st != 'canceled';
|
|
}).toList();
|
|
if (selected.isEmpty) {
|
|
setState(() => _isLoading = false);
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(content: Text('팀에 배정할 참가자가 없습니다')),
|
|
);
|
|
return;
|
|
}
|
|
|
|
// 2) 팀 수 계산
|
|
int finalTeamCount;
|
|
if (teamSize != null) {
|
|
finalTeamCount = (selected.length / teamSize).ceil();
|
|
} else {
|
|
finalTeamCount = teamCount ?? 2;
|
|
}
|
|
if (finalTeamCount <= 0) finalTeamCount = 1;
|
|
if (finalTeamCount > selected.length) finalTeamCount = selected.length;
|
|
|
|
// 3) 셔플 후 라운드로빈 배정(균등 배분)
|
|
selected.shuffle();
|
|
final buckets = List.generate(finalTeamCount, (_) => <Participant>[]);
|
|
for (int i = 0; i < selected.length; i++) {
|
|
buckets[i % finalTeamCount].add(selected[i]);
|
|
}
|
|
|
|
// 4) UI용 Team 모델 구성 (memberIds는 memberId 문자열)
|
|
final newTeams = List.generate(
|
|
finalTeamCount,
|
|
(i) => Team(
|
|
id: '',
|
|
eventId: widget.event.id,
|
|
name: '${i + 1}',
|
|
memberIds: buckets[i].map((p) => p.memberId).toList(),
|
|
description: '자동 생성된 팀',
|
|
),
|
|
);
|
|
|
|
if (!mounted) return;
|
|
setState(() {
|
|
_teams = newTeams;
|
|
_isLoading = false;
|
|
});
|
|
if (_showTeamTab && _tabController.index != 3) {
|
|
_tabController.animateTo(3);
|
|
}
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(content: Text('팀이 생성되었습니다. "팀 저장"을 눌러 저장하세요.')),
|
|
);
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
setState(() => _isLoading = false);
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(content: Text('팀 생성 실패: $e')),
|
|
);
|
|
}
|
|
}
|
|
|
|
// 팀 저장: 현재 _teams 상태를 서버 포맷으로 변환하여 저장
|
|
void _saveTeams() async {
|
|
if (_teams.isEmpty) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(content: Text('저장할 팀이 없습니다.')),
|
|
);
|
|
return;
|
|
}
|
|
|
|
// 서버 저장 포맷으로 변환: teamNumber, members: [{id: participantId, order}]
|
|
final serverTeams = buildServerTeamsForSave(_teams, _participants);
|
|
|
|
final eventService = Provider.of<EventService>(context, listen: false);
|
|
setState(() => _isLoading = true);
|
|
try {
|
|
await eventService.createOrUpdateEventTeams(widget.event.id, serverTeams);
|
|
if (!mounted) return;
|
|
// 서버 반영 직후 최신 상태 재조회
|
|
await _loadEventDetails();
|
|
if (!mounted) return;
|
|
setState(() => _isLoading = false);
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(content: Text('팀이 저장되었습니다.')),
|
|
);
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
setState(() => _isLoading = false);
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(content: Text('팀 저장 실패: $e')),
|
|
);
|
|
}
|
|
}
|
|
|
|
// 팀에서 참가자 제거
|
|
void _removeFromTeam(Team team, Participant participant) {
|
|
setState(() {
|
|
team.memberIds.remove(participant.memberId);
|
|
});
|
|
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(content: Text('${participant.name}님이 팀에서 제외되었습니다.')),
|
|
);
|
|
}
|
|
|
|
// 참가자 선택 다이얼로그 표시
|
|
void _showParticipantSelectionDialog(Team team) {
|
|
final unassignedParticipants = _getUnassignedParticipants();
|
|
if (unassignedParticipants.isEmpty) {
|
|
ScaffoldMessenger.of(
|
|
context,
|
|
).showSnackBar(const SnackBar(content: Text('추가할 참가자가 없습니다.')));
|
|
return;
|
|
}
|
|
|
|
showDialog(
|
|
context: context,
|
|
builder: (context) => AlertDialog(
|
|
title: Text('팀 ${team.name}에 참가자 추가'),
|
|
content: SizedBox(
|
|
width: double.maxFinite,
|
|
child: ListView.builder(
|
|
shrinkWrap: true,
|
|
itemCount: unassignedParticipants.length,
|
|
itemBuilder: (context, index) {
|
|
final participant = unassignedParticipants[index];
|
|
return ListTile(
|
|
leading: const CircleAvatar(
|
|
child: Icon(Icons.person, size: 16),
|
|
),
|
|
title: Text(participant.name ?? '알 수 없음'),
|
|
onTap: () {
|
|
Navigator.of(context).pop();
|
|
setState(() {
|
|
team.memberIds.add(participant.memberId);
|
|
});
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(
|
|
content: Text(
|
|
'${participant.name}님이 팀 ${team.name}에 추가되었습니다.',
|
|
),
|
|
),
|
|
);
|
|
},
|
|
);
|
|
},
|
|
),
|
|
),
|
|
actions: DialogActions.confirm(
|
|
onCancel: () => Navigator.of(context).pop(),
|
|
onConfirm: () => Navigator.of(context).pop(),
|
|
confirmText: '닫기',
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
// 참가자를 추가할 팀 선택 다이얼로그 표시
|
|
void _showTeamSelectionDialog(Participant participant) {
|
|
if (_teams.isEmpty) {
|
|
ScaffoldMessenger.of(
|
|
context,
|
|
).showSnackBar(const SnackBar(content: Text('추가할 팀이 없습니다.')));
|
|
return;
|
|
}
|
|
|
|
showDialog(
|
|
context: context,
|
|
builder: (context) => AlertDialog(
|
|
title: Text('${participant.name}님을 추가할 팀 선택'),
|
|
content: SizedBox(
|
|
width: double.maxFinite,
|
|
child: ListView.builder(
|
|
shrinkWrap: true,
|
|
itemCount: _teams.length,
|
|
itemBuilder: (context, index) {
|
|
final team = _teams[index];
|
|
return ListTile(
|
|
leading: CircleAvatar(
|
|
backgroundColor: Colors.blue.shade700,
|
|
child: Text(
|
|
'${index + 1}',
|
|
style: const TextStyle(color: Colors.white),
|
|
),
|
|
),
|
|
title: Text('팀 ${team.name} (${team.memberIds.length}명)'),
|
|
onTap: () {
|
|
Navigator.of(context).pop();
|
|
setState(() {
|
|
team.memberIds.add(participant.memberId);
|
|
});
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(
|
|
content: Text(
|
|
'${participant.name}님이 팀 ${team.name}에 추가되었습니다.',
|
|
),
|
|
),
|
|
);
|
|
},
|
|
);
|
|
},
|
|
),
|
|
),
|
|
actions: DialogActions.confirm(
|
|
onCancel: () => Navigator.of(context).pop(),
|
|
onConfirm: () => Navigator.of(context).pop(),
|
|
confirmText: '닫기',
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
// 이벤트 수정: 생성 폼을 그대로 활용하여 수정에도 사용
|
|
Future<void> _editEvent() async {
|
|
final result = await Navigator.of(context).push<bool>(
|
|
MaterialPageRoute(builder: (_) => EventFormScreen(event: _event ?? widget.event)),
|
|
);
|
|
if (result == true && mounted) {
|
|
await _loadEventDetails();
|
|
}
|
|
}
|
|
|
|
// 기존 회원 빠른추가 모달 (상태/결제 선택 포함)
|
|
Future<void> _openMemberQuickAddModal() async {
|
|
if (!mounted) return;
|
|
final messenger = ScaffoldMessenger.of(context);
|
|
final eventService = Provider.of<EventService>(context, listen: false);
|
|
final memberService = Provider.of<MemberService>(context, listen: false);
|
|
|
|
String? selectedMemberId;
|
|
String status = 'pending';
|
|
String paymentStatus = 'unpaid';
|
|
final commentCtrl = TextEditingController();
|
|
|
|
// 최신 회원 목록 없으면 로드 시도
|
|
if (_clubMembers.isEmpty && !_clubMembersLoading) {
|
|
try {
|
|
await memberService.fetchClubMembers();
|
|
setState(() {
|
|
_clubMembers = memberService.members;
|
|
});
|
|
} catch (_) {}
|
|
}
|
|
|
|
// 비동기 작업 이후, context 사용 전 마운트 상태 확인 (lint: use_build_context_synchronously)
|
|
if (!mounted) return;
|
|
|
|
// 이미 참가 중인 회원 제외한 드롭다운 목록 구성
|
|
final existingMemberIds = _participants.map((p) => p.memberId).toSet();
|
|
final selectableMembers = _clubMembers
|
|
.where((m) => !existingMemberIds.contains(m.id))
|
|
.toList();
|
|
|
|
// ignore: use_build_context_synchronously
|
|
final ok = await showModalBottomSheet<bool>(
|
|
context: context,
|
|
isScrollControlled: true,
|
|
shape: const RoundedRectangleBorder(
|
|
borderRadius: BorderRadius.vertical(top: Radius.circular(16)),
|
|
),
|
|
builder: (ctx) {
|
|
return Padding(
|
|
padding: EdgeInsets.only(
|
|
left: 16,
|
|
right: 16,
|
|
bottom: MediaQuery.of(ctx).viewInsets.bottom + 16,
|
|
top: 16,
|
|
),
|
|
child: SingleChildScrollView(
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
const Text(
|
|
'기존 회원 빠른추가',
|
|
style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
|
|
),
|
|
const SizedBox(height: 12),
|
|
if (selectableMembers.isEmpty)
|
|
const Text('추가 가능한 회원이 없습니다 (이미 모두 참가 중).')
|
|
else
|
|
DropdownButtonFormField<String>(
|
|
key: const Key('quick_add_member_dropdown'),
|
|
initialValue: selectedMemberId,
|
|
isExpanded: true,
|
|
decoration: const InputDecoration(
|
|
labelText: '회원 선택',
|
|
border: OutlineInputBorder(),
|
|
),
|
|
items: selectableMembers
|
|
.map(
|
|
(m) => DropdownMenuItem<String>(
|
|
value: m.id,
|
|
child: Text(
|
|
m.name,
|
|
maxLines: 1,
|
|
overflow: TextOverflow.ellipsis,
|
|
),
|
|
),
|
|
)
|
|
.toList(),
|
|
onChanged: (v) => selectedMemberId = v,
|
|
),
|
|
const SizedBox(height: 12),
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: DropdownButtonFormField<String>(
|
|
key: const Key('quick_add_status_dropdown'),
|
|
initialValue: status,
|
|
isExpanded: true,
|
|
decoration: const InputDecoration(
|
|
labelText: '상태',
|
|
border: OutlineInputBorder(),
|
|
),
|
|
items: participantStatusOptions.entries
|
|
.map(
|
|
(e) => DropdownMenuItem<String>(
|
|
value: e.key,
|
|
child: Text(e.value),
|
|
),
|
|
)
|
|
.toList(),
|
|
onChanged: (v) => status = v ?? 'pending',
|
|
),
|
|
),
|
|
const SizedBox(width: 8),
|
|
Expanded(
|
|
child: DropdownButtonFormField<String>(
|
|
key: const Key('quick_add_payment_dropdown'),
|
|
initialValue: paymentStatus,
|
|
isExpanded: true,
|
|
decoration: const InputDecoration(
|
|
labelText: '결제',
|
|
border: OutlineInputBorder(),
|
|
),
|
|
items: paymentStatusOptions.entries
|
|
.map(
|
|
(e) => DropdownMenuItem<String>(
|
|
value: e.key,
|
|
child: Text(e.value),
|
|
),
|
|
)
|
|
.toList(),
|
|
onChanged: (v) => paymentStatus = v ?? 'unpaid',
|
|
),
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 12),
|
|
TextField(
|
|
controller: commentCtrl,
|
|
decoration: const InputDecoration(
|
|
labelText: '비고(선택)',
|
|
border: OutlineInputBorder(),
|
|
prefixIcon: Icon(Icons.notes),
|
|
),
|
|
maxLines: 2,
|
|
),
|
|
const SizedBox(height: 12),
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: OutlinedButton(
|
|
onPressed: () => Navigator.of(ctx).pop(false),
|
|
child: const Text('취소'),
|
|
),
|
|
),
|
|
const SizedBox(width: 8),
|
|
Expanded(
|
|
child: ElevatedButton.icon(
|
|
icon: const Icon(Icons.person_add_alt),
|
|
onPressed: () {
|
|
if (selectableMembers.isEmpty) {
|
|
Navigator.of(ctx).pop(false);
|
|
return;
|
|
}
|
|
if (selectedMemberId == null ||
|
|
selectedMemberId!.isEmpty) {
|
|
ScaffoldMessenger.of(ctx).showSnackBar(
|
|
const SnackBar(content: Text('추가할 회원을 선택하세요')),
|
|
);
|
|
return;
|
|
}
|
|
Navigator.of(ctx).pop(true);
|
|
},
|
|
label: const Text('추가'),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
},
|
|
);
|
|
|
|
if (ok != true) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
setState(() => _isLoading = true);
|
|
final payload = <String, dynamic>{
|
|
'memberId': selectedMemberId,
|
|
'status': status,
|
|
'paymentStatus': paymentStatus,
|
|
};
|
|
if (commentCtrl.text.trim().isNotEmpty) {
|
|
payload['comment'] = commentCtrl.text.trim();
|
|
}
|
|
await eventService.addParticipant(widget.event.id, payload);
|
|
if (!mounted) return;
|
|
// 서버 데이터 재조회로 중복 없이 정확한 목록을 반영
|
|
await _loadEventDetails();
|
|
messenger.showSnackBar(const SnackBar(content: Text('참가자를 추가했습니다.')));
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
setState(() => _isLoading = false);
|
|
messenger.showSnackBar(SnackBar(content: Text('참가자 추가 실패: $e')));
|
|
}
|
|
}
|
|
|
|
// 참가자 수정(상태/결제만 변경)
|
|
Future<void> _editParticipant(Participant participant) async {
|
|
final messenger = ScaffoldMessenger.of(context);
|
|
final eventService = Provider.of<EventService>(context, listen: false);
|
|
String status = participant.status ?? 'pending';
|
|
String paymentStatus = participant.isPaid ? 'paid' : 'unpaid';
|
|
final commentCtrl = TextEditingController(text: participant.notes ?? '');
|
|
|
|
final ok = await showDialog<bool>(
|
|
context: context,
|
|
builder: (ctx) => AlertDialog(
|
|
title: const Text('참가자 수정'),
|
|
content: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
DropdownButtonFormField<String>(
|
|
initialValue: status,
|
|
isExpanded: true,
|
|
decoration: const InputDecoration(labelText: '상태'),
|
|
items: participantStatusOptions.entries
|
|
.map(
|
|
(e) => DropdownMenuItem<String>(
|
|
value: e.key,
|
|
child: Text(e.value),
|
|
),
|
|
)
|
|
.toList(),
|
|
onChanged: (v) => status = v ?? 'pending',
|
|
),
|
|
const SizedBox(height: 8),
|
|
DropdownButtonFormField<String>(
|
|
initialValue: paymentStatus,
|
|
isExpanded: true,
|
|
decoration: const InputDecoration(labelText: '결제'),
|
|
items: paymentStatusOptions.entries
|
|
.map(
|
|
(e) => DropdownMenuItem<String>(
|
|
value: e.key,
|
|
child: Text(e.value),
|
|
),
|
|
)
|
|
.toList(),
|
|
onChanged: (v) => paymentStatus = v ?? 'unpaid',
|
|
),
|
|
const SizedBox(height: 8),
|
|
TextField(
|
|
controller: commentCtrl,
|
|
decoration: const InputDecoration(labelText: '비고(선택)'),
|
|
maxLines: 2,
|
|
),
|
|
],
|
|
),
|
|
actions: DialogActions.confirm(
|
|
onCancel: () => Navigator.of(ctx).pop(false),
|
|
onConfirm: () => Navigator.of(ctx).pop(true),
|
|
confirmText: '저장',
|
|
),
|
|
),
|
|
);
|
|
|
|
if (ok != true) return;
|
|
|
|
try {
|
|
setState(() => _isLoading = true);
|
|
final payload = <String, dynamic>{
|
|
'status': status,
|
|
'paymentStatus': paymentStatus,
|
|
};
|
|
if (commentCtrl.text.trim().isNotEmpty) {
|
|
payload['comment'] = commentCtrl.text.trim();
|
|
}
|
|
await eventService.updateParticipant(
|
|
widget.event.id,
|
|
participant.id,
|
|
payload,
|
|
);
|
|
await _loadEventDetails();
|
|
messenger.showSnackBar(const SnackBar(content: Text('참가자 정보가 수정되었습니다')));
|
|
} catch (e) {
|
|
setState(() => _isLoading = false);
|
|
messenger.showSnackBar(SnackBar(content: Text('참가자 수정 실패: $e')));
|
|
}
|
|
}
|
|
|
|
// 참가자 삭제: 스와이프(Dismissible)로 대체됨
|
|
|
|
// 점수 삭제
|
|
void _deleteScore(Score score) {
|
|
showDialog(
|
|
context: context,
|
|
builder: (dialogContext) => AlertDialog(
|
|
title: const Text('점수 삭제'),
|
|
content: const Text('이 점수를 정말 삭제하시겠습니까?'),
|
|
actions: DialogActions.confirm(
|
|
onCancel: () => Navigator.of(dialogContext).pop(),
|
|
onConfirm: () async {
|
|
final navigator = Navigator.of(dialogContext);
|
|
final messenger = ScaffoldMessenger.of(dialogContext);
|
|
final eventService = Provider.of<EventService>(
|
|
dialogContext,
|
|
listen: false,
|
|
);
|
|
navigator.pop();
|
|
|
|
setState(() {
|
|
_isLoading = true;
|
|
});
|
|
|
|
try {
|
|
await eventService.deleteScore(widget.event.id, score.id);
|
|
if (mounted) {
|
|
setState(() {
|
|
_scores.removeWhere((s) => s.id == score.id);
|
|
_isLoading = false;
|
|
});
|
|
messenger.showSnackBar(
|
|
const SnackBar(content: Text('점수가 삭제되었습니다')),
|
|
);
|
|
}
|
|
} catch (e) {
|
|
if (mounted) {
|
|
setState(() {
|
|
_isLoading = false;
|
|
});
|
|
messenger.showSnackBar(
|
|
SnackBar(content: Text('점수 삭제에 실패했습니다: $e')),
|
|
);
|
|
}
|
|
}
|
|
},
|
|
destructive: true,
|
|
confirmText: '삭제',
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|