Function bodies 261 total

public class AuthSuccessHandler extends SimpleUrlAuthenticationSuccessHandler {

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request,
                                        HttpServletResponse response,
                                        Authentication authentication)
            throws IOException, ServletException {
        // 권한 목록에서 역할 추출
        String redirectUrl = "/"; // 기본값
        for (GrantedAuthority auth : authentication.getAuthorities()) {
            String role = auth.getAuthority();
            if ("ROLE_TEACHER".equals(role)) {
                redirectUrl = "/teacher/dashboard";
                break;
            } else if ("ROLE_STUDENT".equals(role)) {
                redirectUrl = "/student/home";
                break;
            }
        }
        response.sendRedirect(request.getContextPath() + redirectUrl);
    }
}

    public void onAuthenticationSuccess(HttpServletRequest request,
                                        HttpServletResponse response,
                                        Authentication authentication)
            throws IOException, ServletException {
        // 권한 목록에서 역할 추출
        String redirectUrl = "/"; // 기본값
        for (GrantedAuthority auth : authentication.getAuthorities()) {
            String role = auth.getAuthority();
            if ("ROLE_TEACHER".equals(role)) {
                redirectUrl = "/teacher/dashboard";
                break;
            } else if ("ROLE_STUDENT".equals(role)) {
                redirectUrl = "/student/home";
                break;
            }
        }
        response.sendRedirect(request.getContextPath() + redirectUrl);
    }

public class DataInitializer implements CommandLineRunner {

    private final TeacherRepository teacherRepository;
    private final SportItemRepository sportItemRepository;
    private final PasswordEncoder passwordEncoder;
    private final TestDataSeeder testDataSeeder;

    public DataInitializer(TeacherRepository teacherRepository,
                           SportItemRepository sportItemRepository,
                           PasswordEncoder passwordEncoder,
                           TestDataSeeder testDataSeeder) {
        this.teacherRepository = teacherRepository;
        this.sportItemRepository = sportItemRepository;
        this.passwordEncoder = passwordEncoder;
        this.testDataSeeder = testDataSeeder;
    }

    @Override
    @Transactional
    public void run(String... args) {
        // 1. 기본 선생님 계정 생성
        if (teacherRepository.count() == 0) {
            Teacher teacher = new Teacher();
            teacher.setUsername("teacher");
            teacher.setPasswor

    public DataInitializer(TeacherRepository teacherRepository,
                           SportItemRepository sportItemRepository,
                           PasswordEncoder passwordEncoder,
                           TestDataSeeder testDataSeeder) {
        this.teacherRepository = teacherRepository;
        this.sportItemRepository = sportItemRepository;
        this.passwordEncoder = passwordEncoder;
        this.testDataSeeder = testDataSeeder;
    }

    public void run(String... args) {
        // 1. 기본 선생님 계정 생성
        if (teacherRepository.count() == 0) {
            Teacher teacher = new Teacher();
            teacher.setUsername("teacher");
            teacher.setPassword(passwordEncoder.encode("1234"));
            teacher.setName("기본 선생님");
            teacher.setEmail("[email protected]");
            teacherRepository.save(teacher);
            System.out.println("[DataInitializer] 기본 선생님 계정 생성 완료 (teacher / 1234)");
        }

        // 2. 기본 종목 데이터 생성
        if (sportItemRepository.count() == 0) {
            List<String[]> defaultItems = List.of(
                new String[]{"축구", "구기종목"},
                new String[]{"농구", "구기종목"},
                new String[]{"배구", "구기종목"},
                new String[]{"피구", "구기종목"},
                new String[]{"수영", "수영"},
                new String[]{"달리기", "육상"},
                new String[]{"멀리뛰기", "육상"},
                new String[]{"줄넘기", "기타"},
                new Strin

public class GlobalControllerAdvice {

    /**
     * 사이트 이름 - 모든 템플릿에서 ${siteName}으로 사용 가능
     */
    @ModelAttribute("siteName")
    public String siteName() {
        return "Yumi Class";
    }

    /**
     * 사이트 부제 - 모든 템플릿에서 ${siteSubtitle}로 사용 가능
     */
    @ModelAttribute("siteSubtitle")
    public String siteSubtitle() {
        return "체육수업 도우미";
    }
}

    public String siteName() {
        return "Yumi Class";
    }

    public String siteSubtitle() {
        return "체육수업 도우미";
    }

public class LeagueMatchSchemaMigration implements ApplicationRunner {

    private final JdbcTemplate jdbc;

    public LeagueMatchSchemaMigration(JdbcTemplate jdbc) {
        this.jdbc = jdbc;
    }

    @Override
    public void run(ApplicationArguments args) {
        tryAlter("ALTER TABLE league_match MODIFY COLUMN home_team_id BIGINT NULL");
        tryAlter("ALTER TABLE league_match MODIFY COLUMN away_team_id BIGINT NULL");
        // 불규칙 토너먼트 브라켓 지원용 컬럼 추가 (이미 있으면 실패 무시)
        tryAlter("ALTER TABLE league_match ADD COLUMN leaf_start INT NULL");
        tryAlter("ALTER TABLE league_match ADD COLUMN leaf_end INT NULL");
        tryAlter("ALTER TABLE league_match ADD COLUMN next_match_id BIGINT NULL");
        tryAlter("ALTER TABLE league_match ADD COLUMN next_match_slot VARCHAR(10) NULL");
    }

    /** ALTER 실패해도 서버 기동에 영향 주지 않도록 로그만 찍고 무시 */
    private void tryAlter(String sql) {
        try {
            jdbc.execute(sql);
        } catch (Exception e) {
            // 이미 

    public LeagueMatchSchemaMigration(JdbcTemplate jdbc) {
        this.jdbc = jdbc;
    }

    public void run(ApplicationArguments args) {
        tryAlter("ALTER TABLE league_match MODIFY COLUMN home_team_id BIGINT NULL");
        tryAlter("ALTER TABLE league_match MODIFY COLUMN away_team_id BIGINT NULL");
        // 불규칙 토너먼트 브라켓 지원용 컬럼 추가 (이미 있으면 실패 무시)
        tryAlter("ALTER TABLE league_match ADD COLUMN leaf_start INT NULL");
        tryAlter("ALTER TABLE league_match ADD COLUMN leaf_end INT NULL");
        tryAlter("ALTER TABLE league_match ADD COLUMN next_match_id BIGINT NULL");
        tryAlter("ALTER TABLE league_match ADD COLUMN next_match_slot VARCHAR(10) NULL");
    }

    private void tryAlter(String sql) {
        try {
            jdbc.execute(sql);
        } catch (Exception e) {
            // 이미 NULL 허용이거나 테이블 없음 - 무시
        }
    }

public class PapsSchemaMigration implements ApplicationRunner {

    private final JdbcTemplate jdbc;

    public PapsSchemaMigration(JdbcTemplate jdbc) {
        this.jdbc = jdbc;
    }

    @Override
    public void run(ApplicationArguments args) {
        // paps_grade 를 VARCHAR(30) NOT NULL 로 강제 변환
        // - 이전 DB 에서 MySQL ENUM 타입이었을 경우 새 값(FAIL, BMI_*) 저장 실패 방지
        // - 이전 VARCHAR(20) 이었을 경우 길이 확장
        try {
            jdbc.execute("ALTER TABLE paps MODIFY COLUMN paps_grade VARCHAR(30) NOT NULL");
        } catch (Exception e) {
            System.err.println("[PapsSchemaMigration] paps_grade 컬럼 변환 실패 (무시됨): " + e.getMessage());
        }
    }
}

    public PapsSchemaMigration(JdbcTemplate jdbc) {
        this.jdbc = jdbc;
    }

    public void run(ApplicationArguments args) {
        // paps_grade 를 VARCHAR(30) NOT NULL 로 강제 변환
        // - 이전 DB 에서 MySQL ENUM 타입이었을 경우 새 값(FAIL, BMI_*) 저장 실패 방지
        // - 이전 VARCHAR(20) 이었을 경우 길이 확장
        try {
            jdbc.execute("ALTER TABLE paps MODIFY COLUMN paps_grade VARCHAR(30) NOT NULL");
        } catch (Exception e) {
            System.err.println("[PapsSchemaMigration] paps_grade 컬럼 변환 실패 (무시됨): " + e.getMessage());
        }
    }

public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate() {
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        factory.setConnectTimeout(5000);   // 연결 타임아웃 5초
        factory.setReadTimeout(30000);     // 응답 타임아웃 30초 (AI 응답 대기)
        return new RestTemplate(factory);
    }
}

    public RestTemplate restTemplate() {
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        factory.setConnectTimeout(5000);   // 연결 타임아웃 5초
        factory.setReadTimeout(30000);     // 응답 타임아웃 30초 (AI 응답 대기)
        return new RestTemplate(factory);
    }

    public SecurityConfig(AuthSuccessHandler authSuccessHandler) {
        this.authSuccessHandler = authSuccessHandler;
    }

    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

public class TestDataSeeder {

    private final StudentRepository studentRepository;
    private final AttendanceRepository attendanceRepository;
    private final ScoreRepository scoreRepository;
    private final PapsRepository papsRepository;
    private final AssignmentRepository assignmentRepository;
    private final SportItemRepository sportItemRepository;
    private final TeacherRepository teacherRepository;
    private final PasswordEncoder passwordEncoder;

    // 한국어 이름 풀 (성씨 10 × 이름 20 = 200가지 조합)
    private static final String[] SURNAMES = {"김","이","박","최","정","강","조","윤","장","임"};
    private static final String[] FIRST_NAMES = {
        "민준","서연","하준","지우","도윤","서준","예준","주원","지호","수아",
        "지민","하은","서윤","지유","아윤","채원","유나","수빈","윤서","다은"
    };

    private final Random random = new Random(42); // 고정 시드 (재현 가능)

    public TestDataSeeder(StudentRepository studentRepository, AttendanceRepository attendanceRepository,
                          ScoreRepository scor

    public TestDataSeeder(StudentRepository studentRepository, AttendanceRepository attendanceRepository,
                          ScoreRepository scoreRepository, PapsRepository papsRepository,
                          AssignmentRepository assignmentRepository, SportItemRepository sportItemRepository,
                          TeacherRepository teacherRepository, PasswordEncoder passwordEncoder) {
        this.studentRepository = studentRepository;
        this.attendanceRepository = attendanceRepository;
        this.scoreRepository = scoreRepository;
        this.papsRepository = papsRepository;
        this.assignmentRepository = assignmentRepository;
        this.sportItemRepository = sportItemRepository;
        this.teacherRepository = teacherRepository;
        this.passwordEncoder = passwordEncoder;
    }

    public void seedAll() {
        if (studentRepository.count() > 0) {
            System.out.println("[TestDataSeeder] 학생 데이터가 이미 존재하여 스킵합니다.");
            return;
        }
        System.out.println("[TestDataSeeder] 테스트 데이터 생성 시작...");

        List<Student> students = seedStudents();
        seedAttendance(students);
        seedScores(students);
        seedPaps(students);
        seedAssignments();

        System.out.println("[TestDataSeeder] 테스트 데이터 생성 완료! 학생 " + students.size() + "명");
    }

    private List<Student> seedStudents() {
        List<Student> saved = new ArrayList<>();
        for (int grade = 1; grade <= 3; grade++) {
            for (int classNum = 1; classNum <= 2; classNum++) {
                for (int number = 1; number <= 10; number++) {
                    Student s = new Student();
                    // 학번: 2026 + 학년(1) + 반(2자리) + 번호(2자리) = 2026101 형식
                    String studentNumber = String.format("2026%d%02d%02d", grade, classNum, number);
                    s.setStudentNumber(studentNumber);
                    s.setUsername("s" + studentNumber); // 예: s2026010101
                    s.setPassword(passwordEncoder.encode("1234"));
                    s.setName(randomName());
                    s.setGrade(grade);
                    s.setClassNum(classNum);
                    s.setNumber(number);
                    // 번호 기준으로 남/여 번갈아
                    s.setGender(number % 2 == 1 ? Gender.MALE : Gender.FEMALE);
                    saved

    private void seedAttendance(List<Student> students) {
        LocalDate start = LocalDate.of(2026, 3, 1);
        LocalDate end = LocalDate.of(2026, 4, 5);
        List<LocalDate> schoolDays = new ArrayList<>();
        for (LocalDate d = start; !d.isAfter(end); d = d.plusDays(1)) {
            // 주말 제외
            if (d.getDayOfWeek() != DayOfWeek.SATURDAY && d.getDayOfWeek() != DayOfWeek.SUNDAY) {
                schoolDays.add(d);
            }
        }
        int count = 0;
        for (Student s : students) {
            for (LocalDate date : schoolDays) {
                Attendance a = new Attendance();
                a.setStudent(s);
                a.setAttendanceDate(date);
                // 90% 출석 / 5% 지각 / 3% 결석 / 2% 조퇴
                int r = random.nextInt(100);
                if (r < 90) a.setStatus(AttendanceStatus.PRESENT);
                else if (r < 95) { a.setStatus(AttendanceStatus.LATE); a.setMemo("교통 지연"); }
                else if (r < 98) { a.setStatus

    private void seedScores(List<Student> students) {
        List<SportItem> items = sportItemRepository.findByEnabledTrueOrderByNameAsc();
        if (items.size() < 3) return;
        // 축구/농구/수영만 고르기
        List<SportItem> targets = items.stream()
            .filter(i -> List.of("축구","농구","수영").contains(i.getName()))
            .toList();

        int count = 0;
        for (Student s : students) {
            for (SportItem item : targets) {
                Score sc = new Score();
                sc.setStudent(s);
                sc.setSportItem(item);
                sc.setYear(2026);
                sc.setSemester(Semester.FIRST);
                int score = 70 + random.nextInt(31); // 70~100
                sc.setScore(score);
                sc.setGrade(score >= 90 ? "A" : score >= 80 ? "B" : "C");
                scoreRepository.save(sc);
                count++;
            }
        }
        System.out.println("[TestDataSeeder] 점수 " + count + "건");
    }

    private void seedPaps(List<Student> students) {
        // 일반 종목용 급수 1~5 만 사용 (BMI 전용 enum 값 제외)
        PapsGrade[] grades = new PapsGrade[] {
            PapsGrade.GRADE_1, PapsGrade.GRADE_2, PapsGrade.GRADE_3,
            PapsGrade.GRADE_4, PapsGrade.GRADE_5
        };
        int count = 0;
        for (Student s : students) {
            // 심폐지구력 - 왕복오래달리기
            Paps p1 = new Paps();
            p1.setStudent(s);
            p1.setYear(2026);
            p1.setCategory("심폐지구력");
            p1.setSubItem("왕복오래달리기");
            p1.setMeasureValue((40 + random.nextInt(50)) + "회");
            p1.setPapsGrade(grades[random.nextInt(grades.length)]);
            papsRepository.save(p1);
            count++;

            // 유연성 - 앉아윗몸앞으로굽히기
            Paps p2 = new Paps();
            p2.setStudent(s);
            p2.setYear(2026);
            p2.setCategory("유연성");
            p2.setSubItem("앉아윗몸앞으로굽히기");
            p2.setMeasureValue((random.nextInt(25) + 5) + "cm");
    

    private void seedAssignments() {
        Teacher teacher = teacherRepository.findByUsername("teacher")
            .orElseThrow(() -> new IllegalStateException("기본 선생님 없음"));

        String[][] data = {
            {"체육복 준비", "매 체육 수업에 체육복을 지참하세요.", "2026-04-30"},
            {"단원평가 - 축구 규칙", "교과서 1단원을 읽고 축구 규칙 5가지를 정리해 제출하세요.", "2026-04-15"},
            {"자유 주제 보고서", "좋아하는 스포츠 종목에 대한 A4 1장 보고서 작성.", "2026-05-10"}
        };
        for (String[] d : data) {
            Assignment a = new Assignment();
            a.setTeacher(teacher);
            a.setTitle(d[0]);
            a.setContent(d[1]);
            a.setDueDate(LocalDate.parse(d[2]));
            a.setTargetGrade(1); // 1학년 대상
            a.setTargetClass(null); // 전체 반
            assignmentRepository.save(a);
        }
        System.out.println("[TestDataSeeder] 과제 3건");
    }

    private String randomName() {
        return SURNAMES[random.nextInt(SURNAMES.length)]
             + FIRST_NAMES[random.nextInt(FIRST_NAMES.length)];
    }

public class AuthController {

    /**
     * 로그인 폼 페이지
     * error: 로그인 실패 시, logout: 로그아웃 완료 시
     */
    @GetMapping("/login")
    public String loginForm(@RequestParam(required = false) String error,
                            @RequestParam(required = false) String logout,
                            Model model) {
        if (error != null) {
            model.addAttribute("error", "아이디 또는 비밀번호가 올바르지 않습니다.");
        }
        if (logout != null) {
            model.addAttribute("message", "로그아웃되었습니다.");
        }
        return "auth/login";
    }
}

public class ChatbotController {

    private final ChatbotService chatbotService;
    private final TeacherRepository teacherRepository;
    private final StudentRepository studentRepository;

    public ChatbotController(ChatbotService chatbotService,
                             TeacherRepository teacherRepository,
                             StudentRepository studentRepository) {
        this.chatbotService = chatbotService;
        this.teacherRepository = teacherRepository;
        this.studentRepository = studentRepository;
    }

    /**
     * 챗봇 메인 페이지
     * - session 파라미터가 있으면 해당 세션 메시지 표시
     * - 없으면 빈 새 채팅 화면
     */
    @GetMapping
    public String chat(@RequestParam(name = "session", required = false) Long sessionId,
                       @AuthenticationPrincipal UserDetails userDetails,
                       Authentication auth, Model model) {
        UserRole role = extractRole(auth);
        Long userId = findUserId(userDetails.getUsername(), role);

        // 

    public ChatbotController(ChatbotService chatbotService,
                             TeacherRepository teacherRepository,
                             StudentRepository studentRepository) {
        this.chatbotService = chatbotService;
        this.teacherRepository = teacherRepository;
        this.studentRepository = studentRepository;
    }

    public String newChat() {
        return "redirect:/chatbot";
    }

    public String deleteSession(@PathVariable Long sessionId,
                                @AuthenticationPrincipal UserDetails userDetails,
                                Authentication auth, RedirectAttributes ra) {
        UserRole role = extractRole(auth);
        Long userId = findUserId(userDetails.getUsername(), role);
        int deleted = chatbotService.deleteSession(role, userId, sessionId);
        if (deleted > 0) {
            ra.addFlashAttribute("message", "대화가 삭제되었습니다.");
        }
        return "redirect:/chatbot";
    }

    private UserRole extractRole(Authentication auth) {
        for (GrantedAuthority a : auth.getAuthorities()) {
            if ("ROLE_TEACHER".equals(a.getAuthority())) return UserRole.TEACHER;
            if ("ROLE_STUDENT".equals(a.getAuthority())) return UserRole.STUDENT;
        }
        throw new IllegalStateException("알 수 없는 권한");
    }

    private Long findUserId(String username, UserRole role) {
        if (role == UserRole.TEACHER) {
            Teacher t = teacherRepository.findByUsername(username)
                .orElseThrow(() -> new IllegalArgumentException("선생님 없음"));
            return t.getId();
        } else {
            Student s = studentRepository.findByUsername(username)
                .orElseThrow(() -> new IllegalArgumentException("학생 없음"));
            return s.getId();
        }
    }

public class HomeController {

    /**
     * 루트 URL (/) 접근 시 index.html 반환
     */
    @GetMapping("/")
    public String index() {
        return "index";
    }
}

    public String index() {
        return "index";
    }

public class StudentController {

    private final StudentDashboardService dashboardService;
    private final StudentPageService pageService;
    private final LeagueService leagueService;

    public StudentController(StudentDashboardService dashboardService,
                             StudentPageService pageService,
                             LeagueService leagueService) {
        this.dashboardService = dashboardService;
        this.pageService = pageService;
        this.leagueService = leagueService;
    }

    /** 학생 홈 → 대시보드로 리다이렉트 */
    @GetMapping("/home")
    public String home() {
        return "redirect:/student/dashboard";
    }

    /** 대시보드 */
    @GetMapping("/dashboard")
    public String dashboard(@AuthenticationPrincipal UserDetails userDetails, Model model) {
        Student student = dashboardService.findStudent(userDetails.getUsername());
        model.addAttribute("summary", dashboardService.getSummary(student));
        return "student/dashboard";
    }

    public StudentController(StudentDashboardService dashboardService,
                             StudentPageService pageService,
                             LeagueService leagueService) {
        this.dashboardService = dashboardService;
        this.pageService = pageService;
        this.leagueService = leagueService;
    }

    public String home() {
        return "redirect:/student/dashboard";
    }

    public String dashboard(@AuthenticationPrincipal UserDetails userDetails, Model model) {
        Student student = dashboardService.findStudent(userDetails.getUsername());
        model.addAttribute("summary", dashboardService.getSummary(student));
        return "student/dashboard";
    }

    public String scores(@AuthenticationPrincipal UserDetails userDetails, Model model) {
        Student student = dashboardService.findStudent(userDetails.getUsername());
        model.addAttribute("student", student);
        model.addAttribute("scores", pageService.getScores(student));
        return "student/scores";
    }

    public String paps(@AuthenticationPrincipal UserDetails userDetails, Model model) {
        Student student = dashboardService.findStudent(userDetails.getUsername());
        model.addAttribute("student", student);
        model.addAttribute("papsList", pageService.getPaps(student));
        return "student/paps";
    }

    public String assignments(@AuthenticationPrincipal UserDetails userDetails, Model model) {
        Student student = dashboardService.findStudent(userDetails.getUsername());
        model.addAttribute("student", student);
        model.addAttribute("assignments", pageService.getAssignments(student));
        return "student/assignments";
    }

    public String leagues(@AuthenticationPrincipal UserDetails userDetails, Model model) {
        Student student = dashboardService.findStudent(userDetails.getUsername());
        model.addAttribute("student", student);
        model.addAttribute("leagues", pageService.getLeagues(student));
        return "student/leagues";
    }

    public String leagueDetail(@PathVariable Long id,
                                @AuthenticationPrincipal UserDetails userDetails,
                                Model model, RedirectAttributes ra) {
        Student student = dashboardService.findStudent(userDetails.getUsername());
        League league = leagueService.findById(id);
        // 권한 체크: 학생 학년-반이 대회에 참가 중인지
        String key = student.getGrade() + "-" + student.getClassNum();
        boolean allowed = false;
        if (league.getClassNums() != null && !league.getClassNums().isEmpty()) {
            for (String c : league.getClassNums().split(",")) {
                if (key.equals(c.trim())) { allowed = true; break; }
            }
        } else if (league.getGrade().equals(student.getGrade())
                && league.getClassNum().equals(student.getClassNum())) {
            allowed = true;
        }
        if (!allowed) {
            ra.addFlashAttribute("error", "해당 대회에 접근 권한이 없습니다.");
            return "redi

public class TeacherAssignmentController {

    private final AssignmentService assignmentService;

    public TeacherAssignmentController(AssignmentService assignmentService) {
        this.assignmentService = assignmentService;
    }

    @GetMapping
    public String list(@AuthenticationPrincipal UserDetails user, Model model) {
        model.addAttribute("assignments", assignmentService.findByTeacher(user.getUsername()));
        return "teacher/assignments/list";
    }

    @GetMapping("/new")
    public String createForm(Model model) {
        model.addAttribute("assignment", new Assignment());
        return "teacher/assignments/form";
    }

    @PostMapping
    public String create(@ModelAttribute Assignment assignment,
                         @AuthenticationPrincipal UserDetails user, RedirectAttributes ra) {
        assignmentService.create(assignment, user.getUsername());
        ra.addFlashAttribute("message", "과제가 등록되었습니다.");
        return "redirect:/teacher/assignments

    public TeacherAssignmentController(AssignmentService assignmentService) {
        this.assignmentService = assignmentService;
    }

    public String list(@AuthenticationPrincipal UserDetails user, Model model) {
        model.addAttribute("assignments", assignmentService.findByTeacher(user.getUsername()));
        return "teacher/assignments/list";
    }

    public String createForm(Model model) {
        model.addAttribute("assignment", new Assignment());
        return "teacher/assignments/form";
    }