Function bodies 285 total

public class AdaptiveFitApplication {

    public static void main(String[] args) {
        SpringApplication.run(AdaptiveFitApplication.class, args);
    }
}

    public static void main(String[] args) {
        SpringApplication.run(AdaptiveFitApplication.class, args);
    }

public class JwtConfig {

    @Value("${jwt.secret}")
    private String secret;

    @Value("${jwt.expiration}")
    private long expiration;
}

    public AuthenticationManager authenticationManager(AuthenticationConfiguration authenticationConfiguration) throws Exception {
        return authenticationConfiguration.getAuthenticationManager();
    }

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

public class AdminController {

    private final EventLogRepository eventLogRepository;
    private final DataExportService dataExportService;
    private final UserRepository userRepository;
    private final String adminEmail;

    public AdminController(EventLogRepository eventLogRepository,
                           DataExportService dataExportService,
                           UserRepository userRepository,
                           @Value("${app.admin.email}") String adminEmail) {
        this.eventLogRepository = eventLogRepository;
        this.dataExportService = dataExportService;
        this.userRepository = userRepository;
        this.adminEmail = adminEmail;
    }

    @GetMapping("/events")
    @Operation(summary = "Get event logs", description = "Returns event logs with optional filtering by event type and date range")
    public ResponseEntity<List<EventLog>> getEvents(
            @RequestParam(required = false) String eventType,
            @RequestParam(require

    public ResponseEntity<List<Map<String, Object>>> exportAll(Authentication authentication) {
        checkAdmin(authentication);
        List<Map<String, Object>> data = dataExportService.exportAllUsers();
        return ResponseEntity.ok(data);
    }

    private void checkAdmin(Authentication authentication) {
        String email = authentication.getName();
        if (!adminEmail.equals(email)) {
            User user = userRepository.findByEmail(email).orElse(null);
            if (user == null || !user.isAdmin()) {
                throw new ForbiddenException("Admin access required");
            }
        }
    }

public class AdminUserController {

    private final UserRepository userRepository;
    private final WorkoutLogRepository workoutLogRepository;
    private final WeeklyCheckInRepository weeklyCheckInRepository;
    private final NutritionLogRepository nutritionLogRepository;
    private final PasswordEncoder passwordEncoder;
    private final String adminEmail;

    public AdminUserController(UserRepository userRepository,
                               WorkoutLogRepository workoutLogRepository,
                               WeeklyCheckInRepository weeklyCheckInRepository,
                               NutritionLogRepository nutritionLogRepository,
                               PasswordEncoder passwordEncoder,
                               @Value("${app.admin.email}") String adminEmail) {
        this.userRepository = userRepository;
        this.workoutLogRepository = workoutLogRepository;
        this.weeklyCheckInRepository = weeklyCheckInRepository;
        this.nutritionLogR

    public ResponseEntity<Map<String, Object>> getStats(Authentication authentication) {
        checkAdmin(authentication);

        long totalUsers = userRepository.count();
        long verifiedUsers = userRepository.countByEmailVerifiedTrue();
        long totalWorkouts = workoutLogRepository.count();
        long totalNutritionLogs = nutritionLogRepository.count();

        Map<String, Object> stats = new LinkedHashMap<>();
        stats.put("totalUsers", totalUsers);
        stats.put("verifiedUsers", verifiedUsers);
        stats.put("totalWorkouts", totalWorkouts);
        stats.put("totalNutritionLogs", totalNutritionLogs);

        return ResponseEntity.ok(stats);
    }

    public ResponseEntity<List<Map<String, Object>>> listUsers(Authentication authentication) {
        checkAdmin(authentication);

        List<User> users = userRepository.findAll();
        List<Map<String, Object>> userList = users.stream()
                .map(user -> {
                    Map<String, Object> userMap = new LinkedHashMap<>();
                    userMap.put("id", user.getId());
                    userMap.put("email", user.getEmail());
                    userMap.put("emailVerified", user.isEmailVerified());
                    userMap.put("isAdmin", user.isAdmin());
                    userMap.put("createdAt", user.getCreatedAt());

                    Map<String, Object> counts = new LinkedHashMap<>();
                    counts.put("workoutLogs", workoutLogRepository.countByUserId(user.getId()));
                    counts.put("checkIns", weeklyCheckInRepository.countByUserId(user.getId()));
                    userMap.put("_count", counts);

                  

    public ResponseEntity<Map<String, Object>> createUser(
            @RequestBody Map<String, Object> body,
            Authentication authentication) {
        checkAdmin(authentication);

        String email = (String) body.get("email");
        String password = (String) body.get("password");

        if (email == null || password == null) {
            throw new BadRequestException("Email and password are required");
        }

        if (userRepository.findByEmail(email).isPresent()) {
            throw new BadRequestException("User with this email already exists");
        }

        User user = new User();
        user.setEmail(email);
        user.setPasswordHash(passwordEncoder.encode(password));
        user.setEmailVerified(true);

        if (body.containsKey("isAdmin")) {
            user.setAdmin(Boolean.TRUE.equals(body.get("isAdmin")));
        }

        User saved = userRepository.save(user);

        Map<String, Object> response = new LinkedHashMap<>();
        r

    public ResponseEntity<Map<String, Object>> updateUser(
            @PathVariable Long id,
            @RequestBody Map<String, Object> body,
            Authentication authentication) {
        checkAdmin(authentication);

        User user = userRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));

        if (body.containsKey("isAdmin")) {
            user.setAdmin(Boolean.TRUE.equals(body.get("isAdmin")));
        }
        if (body.containsKey("password")) {
            String newPassword = (String) body.get("password");
            user.setPasswordHash(passwordEncoder.encode(newPassword));
        }

        User updated = userRepository.save(user);

        Map<String, Object> response = new LinkedHashMap<>();
        response.put("id", updated.getId());
        response.put("email", updated.getEmail());
        response.put("admin", updated.isAdmin());
        response.put("message", "User updated successfully");

     

    public ResponseEntity<Map<String, String>> deleteUser(
            @PathVariable Long id,
            Authentication authentication) {
        checkAdmin(authentication);

        User user = userRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));

        userRepository.delete(user);
        return ResponseEntity.ok(Map.of("message", "User deleted successfully"));
    }

    private void checkAdmin(Authentication authentication) {
        String email = authentication.getName();
        if (!adminEmail.equals(email)) {
            User user = userRepository.findByEmail(email).orElse(null);
            if (user == null || !user.isAdmin()) {
                throw new ForbiddenException("Admin access required");
            }
        }
    }

public class AnnouncementController {

    private final AnnouncementRepository announcementRepository;
    private final UserRepository userRepository;
    private final String adminEmail;

    public AnnouncementController(AnnouncementRepository announcementRepository,
                                  UserRepository userRepository,
                                  @Value("${app.admin.email}") String adminEmail) {
        this.announcementRepository = announcementRepository;
        this.userRepository = userRepository;
        this.adminEmail = adminEmail;
    }

    @GetMapping("/api/announcements")
    @Operation(summary = "List announcements", description = "Returns all announcements ordered by pinned status and date")
    public ResponseEntity<List<Announcement>> listAnnouncements() {
        List<Announcement> announcements = announcementRepository.findAllByOrderByPinnedDescCreatedAtDesc();
        return ResponseEntity.ok(announcements);
    }

    @GetMapping("/api/admin/ann

    public ResponseEntity<List<Announcement>> listAnnouncements() {
        List<Announcement> announcements = announcementRepository.findAllByOrderByPinnedDescCreatedAtDesc();
        return ResponseEntity.ok(announcements);
    }

    public ResponseEntity<List<Announcement>> adminListAnnouncements(Authentication authentication) {
        checkAdmin(authentication);
        List<Announcement> announcements = announcementRepository.findAllByOrderByPinnedDescCreatedAtDesc();
        return ResponseEntity.ok(announcements);
    }

    public ResponseEntity<Announcement> createAnnouncement(
            @RequestBody Map<String, Object> body,
            Authentication authentication) {
        checkAdmin(authentication);

        Announcement announcement = new Announcement();
        announcement.setTitle((String) body.get("title"));
        announcement.setContent((String) body.get("content"));
        if (body.containsKey("pinned")) {
            announcement.setPinned(Boolean.TRUE.equals(body.get("pinned")));
        }

        Announcement saved = announcementRepository.save(announcement);
        return ResponseEntity.status(HttpStatus.CREATED).body(saved);
    }

    public ResponseEntity<Announcement> updateAnnouncement(
            @PathVariable Long id,
            @RequestBody Map<String, Object> body,
            Authentication authentication) {
        checkAdmin(authentication);

        Announcement announcement = announcementRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("Announcement not found"));

        if (body.containsKey("title")) {
            announcement.setTitle((String) body.get("title"));
        }
        if (body.containsKey("content")) {
            announcement.setContent((String) body.get("content"));
        }
        if (body.containsKey("pinned")) {
            announcement.setPinned(Boolean.TRUE.equals(body.get("pinned")));
        }

        Announcement updated = announcementRepository.save(announcement);
        return ResponseEntity.ok(updated);
    }

    public ResponseEntity<Map<String, String>> deleteAnnouncement(
            @PathVariable Long id,
            Authentication authentication) {
        checkAdmin(authentication);

        Announcement announcement = announcementRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("Announcement not found"));

        announcementRepository.delete(announcement);
        return ResponseEntity.ok(Map.of("message", "Announcement deleted successfully"));
    }

    private void checkAdmin(Authentication authentication) {
        String email = authentication.getName();
        if (!adminEmail.equals(email)) {
            User user = userRepository.findByEmail(email).orElse(null);
            if (user == null || !user.isAdmin()) {
                throw new ForbiddenException("Admin access required");
            }
        }
    }

public class AuthController {

    private final AuthService authService;
    private final UserRepository userRepository;

    public AuthController(AuthService authService, UserRepository userRepository) {
        this.authService = authService;
        this.userRepository = userRepository;
    }

    @PostMapping("/register")
    @Operation(summary = "Register a new user", description = "Creates a new user account and sends a verification email")
    public ResponseEntity<Map<String, String>> register(@Valid @RequestBody RegisterRequest request) {
        String message = authService.register(request.getEmail(), request.getPassword());
        return ResponseEntity.status(HttpStatus.CREATED).body(Map.of("message", message));
    }

    @GetMapping("/verify")
    @Operation(summary = "Verify email address", description = "Verifies a user's email address using the token sent via email")
    public ResponseEntity<Map<String, String>> verifyEmail(@RequestParam String token) {
        au

    public AuthController(AuthService authService, UserRepository userRepository) {
        this.authService = authService;
        this.userRepository = userRepository;
    }

    public ResponseEntity<Map<String, String>> register(@Valid @RequestBody RegisterRequest request) {
        String message = authService.register(request.getEmail(), request.getPassword());
        return ResponseEntity.status(HttpStatus.CREATED).body(Map.of("message", message));
    }

    public ResponseEntity<Map<String, String>> verifyEmail(@RequestParam String token) {
        authService.verifyEmail(token);
        return ResponseEntity.ok(Map.of("message", "Email verified successfully"));
    }

    public ResponseEntity<AuthResponse> login(@Valid @RequestBody LoginRequest request) {
        String token = authService.login(request.getEmail(), request.getPassword());
        User user = userRepository.findByEmail(request.getEmail()).orElse(null);
        boolean isAdmin = user != null && user.isAdmin();
        return ResponseEntity.ok(new AuthResponse(token, request.getEmail(), "Login successful", isAdmin));
    }

    public ResponseEntity<Map<String, String>> forgotPassword(@Valid @RequestBody ForgotPasswordRequest request) {
        authService.forgotPassword(request.getEmail());
        return ResponseEntity.ok(Map.of("message", "Password reset email sent"));
    }

    public ResponseEntity<Map<String, String>> resetPassword(@Valid @RequestBody ResetPasswordRequest request) {
        authService.resetPassword(request.getToken(), request.getNewPassword());
        return ResponseEntity.ok(Map.of("message", "Password reset successful"));
    }

    public ResponseEntity<Map<String, String>> changePassword(
            @Valid @RequestBody ChangePasswordRequest request,
            Authentication authentication) {
        authService.changePassword(authentication.getName(), request.getCurrentPassword(), request.getNewPassword());
        return ResponseEntity.ok(Map.of("message", "Password changed successfully"));
    }

public class CheckInController {

    private final AdaptiveEngineService adaptiveEngineService;
    private final EventLogService eventLogService;
    private final WeeklyCheckInRepository weeklyCheckInRepository;
    private final WorkoutPlanRepository workoutPlanRepository;
    private final UserRepository userRepository;

    public CheckInController(AdaptiveEngineService adaptiveEngineService,
                             EventLogService eventLogService,
                             WeeklyCheckInRepository weeklyCheckInRepository,
                             WorkoutPlanRepository workoutPlanRepository,
                             UserRepository userRepository) {
        this.adaptiveEngineService = adaptiveEngineService;
        this.eventLogService = eventLogService;
        this.weeklyCheckInRepository = weeklyCheckInRepository;
        this.workoutPlanRepository = workoutPlanRepository;
        this.userRepository = userRepository;
    }

    @PostMapping("/submit")
    @Oper

    public CheckInController(AdaptiveEngineService adaptiveEngineService,
                             EventLogService eventLogService,
                             WeeklyCheckInRepository weeklyCheckInRepository,
                             WorkoutPlanRepository workoutPlanRepository,
                             UserRepository userRepository) {
        this.adaptiveEngineService = adaptiveEngineService;
        this.eventLogService = eventLogService;
        this.weeklyCheckInRepository = weeklyCheckInRepository;
        this.workoutPlanRepository = workoutPlanRepository;
        this.userRepository = userRepository;
    }

    public ResponseEntity<AdaptationResponse> submitCheckIn(
            @Valid @RequestBody CheckInRequest request,
            Authentication authentication) {
        Long userId = getUserId(authentication);

        AdaptationResponse response = adaptiveEngineService.processCheckIn(userId, request);

        eventLogService.logEvent(userId, "CHECKIN_SUBMITTED",
                "{\"weekNumber\":" + request.getWeekNumber()
                        + ",\"sessionsCompleted\":" + request.getSessionsCompleted()
                        + ",\"difficultyRating\":" + request.getDifficultyRating() + "}");

        if (response.isChangesApplied()) {
            eventLogService.logEvent(userId, "PLAN_ADAPTED",
                    "{\"newPlanVersion\":" + response.getNewPlanVersion()
                            + ",\"changeSummary\":\"" + response.getChangeSummary().replace("\"", "\\\"") + "\"}");
        }

        return ResponseEntity.ok(response);
    }

    public ResponseEntity<List<WeeklyCheckIn>> getCheckInHistory(Authentication authentication) {
        Long userId = getUserId(authentication);
        List<WeeklyCheckIn> checkIns = weeklyCheckInRepository.findByUserIdOrderByWeekNumberDesc(userId);
        return ResponseEntity.ok(checkIns);
    }

    public ResponseEntity<Map<String, Boolean>> isCheckInDue(Authentication authentication) {
        Long userId = getUserId(authentication);

        boolean hasActivePlan = workoutPlanRepository
                .findByUserIdAndStatus(userId, PlanStatus.ACTIVE)
                .isPresent();

        if (!hasActivePlan) {
            return ResponseEntity.ok(Map.of("due", false));
        }

        Optional<WeeklyCheckIn> lastCheckIn = weeklyCheckInRepository
                .findFirstByUserIdOrderBySubmittedAtDesc(userId);

        if (lastCheckIn.isEmpty()) {
            return ResponseEntity.ok(Map.of("due", true));
        }

        long daysSinceLastCheckIn = ChronoUnit.DAYS.between(
                lastCheckIn.get().getSubmittedAt(), LocalDateTime.now());
        boolean due = daysSinceLastCheckIn >= 7;

        return ResponseEntity.ok(Map.of("due", due));
    }

    private Long getUserId(Authentication authentication) {
        String email = authentication.getName();
        User user = userRepository.findByEmail(email)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
        return user.getId();
    }

public class ClockController {

    private final ClockService clockService;

    public ClockController(ClockService clockService) {
        this.clockService = clockService;
    }

    @GetMapping
    public ResponseEntity<Map<String, String>> getAppDate() {
        return ResponseEntity.ok(Map.of("today", clockService.today().toString()));
    }
}

    public ClockController(ClockService clockService) {
        this.clockService = clockService;
    }

    public ResponseEntity<Map<String, String>> getAppDate() {
        return ResponseEntity.ok(Map.of("today", clockService.today().toString()));
    }

public class CustomExerciseController {

    private final CustomExerciseRepository customExerciseRepository;
    private final UserRepository userRepository;

    public CustomExerciseController(CustomExerciseRepository customExerciseRepository,
                                    UserRepository userRepository) {
        this.customExerciseRepository = customExerciseRepository;
        this.userRepository = userRepository;
    }

    @GetMapping
    @Operation(summary = "List custom exercises", description = "Returns all custom exercises for the authenticated user")
    public ResponseEntity<List<CustomExercise>> listCustomExercises(Authentication authentication) {
        User user = getUser(authentication);
        List<CustomExercise> exercises = customExerciseRepository.findByUserOrderByCreatedAtDesc(user);
        return ResponseEntity.ok(exercises);
    }

    @PostMapping
    @Operation(summary = "Create custom exercise", description = "Creates a new custom exercise for the aut

    public CustomExerciseController(CustomExerciseRepository customExerciseRepository,
                                    UserRepository userRepository) {
        this.customExerciseRepository = customExerciseRepository;
        this.userRepository = userRepository;
    }

    public ResponseEntity<List<CustomExercise>> listCustomExercises(Authentication authentication) {
        User user = getUser(authentication);
        List<CustomExercise> exercises = customExerciseRepository.findByUserOrderByCreatedAtDesc(user);
        return ResponseEntity.ok(exercises);
    }

    public ResponseEntity<CustomExercise> createCustomExercise(
            @RequestBody Map<String, String> body,
            Authentication authentication) {
        User user = getUser(authentication);

        CustomExercise exercise = new CustomExercise();
        exercise.setUser(user);
        exercise.setName(body.get("name"));
        exercise.setMuscleGroup(body.get("muscleGroup"));
        if (body.containsKey("equipment")) {
            exercise.setEquipment(body.get("equipment"));
        }

        CustomExercise saved = customExerciseRepository.save(exercise);
        return ResponseEntity.status(HttpStatus.CREATED).body(saved);
    }

    public ResponseEntity<Map<String, String>> deleteCustomExercise(
            @PathVariable Long id,
            Authentication authentication) {
        User user = getUser(authentication);
        CustomExercise exercise = customExerciseRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("Custom exercise not found"));

        if (!exercise.getUser().getId().equals(user.getId())) {
            throw new ResourceNotFoundException("Custom exercise not found");
        }

        customExerciseRepository.delete(exercise);
        return ResponseEntity.ok(Map.of("message", "Custom exercise deleted successfully"));
    }

    private User getUser(Authentication authentication) {
        String email = authentication.getName();
        return userRepository.findByEmail(email)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
    }

public class DayTemplateController {

    private final DayTemplateRepository dayTemplateRepository;
    private final UserRepository userRepository;
    private final ObjectMapper objectMapper;

    public DayTemplateController(DayTemplateRepository dayTemplateRepository,
                                 UserRepository userRepository,
                                 ObjectMapper objectMapper) {
        this.dayTemplateRepository = dayTemplateRepository;
        this.userRepository = userRepository;
        this.objectMapper = objectMapper;
    }

    @GetMapping
    @Operation(summary = "List day templates", description = "Returns all day templates for the authenticated user")
    public ResponseEntity<List<DayTemplate>> listDayTemplates(Authentication authentication) {
        User user = getUser(authentication);
        List<DayTemplate> templates = dayTemplateRepository.findByUserOrderByCreatedAtDesc(user);
        return ResponseEntity.ok(templates);
    }

    @PostMapping
    @

    public DayTemplateController(DayTemplateRepository dayTemplateRepository,
                                 UserRepository userRepository,
                                 ObjectMapper objectMapper) {
        this.dayTemplateRepository = dayTemplateRepository;
        this.userRepository = userRepository;
        this.objectMapper = objectMapper;
    }

    public ResponseEntity<List<DayTemplate>> listDayTemplates(Authentication authentication) {
        User user = getUser(authentication);
        List<DayTemplate> templates = dayTemplateRepository.findByUserOrderByCreatedAtDesc(user);
        return ResponseEntity.ok(templates);
    }

    public ResponseEntity<DayTemplate> createDayTemplate(
            @RequestBody Map<String, Object> body,
            Authentication authentication) {
        User user = getUser(authentication);

        DayTemplate template = new DayTemplate();
        template.setUser(user);
        template.setName((String) body.get("name"));

        Object exercises = body.get("exercises");
        if (exercises instanceof String) {
            template.setExercises((String) exercises);
        } else {
            try {
                template.setExercises(objectMapper.writeValueAsString(exercises));
            } catch (JsonProcessingException e) {
                throw new com.adaptivefit.exception.BadRequestException("Invalid exercises JSON");
            }
        }

        DayTemplate saved = dayTemplateRepository.save(template);
        return ResponseEntity.status(HttpStatus.CREATED).body(saved);
    }

    public ResponseEntity<Map<String, String>> deleteDayTemplate(
            @PathVariable Long id,
            Authentication authentication) {
        User user = getUser(authentication);
        DayTemplate template = dayTemplateRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("Day template not found"));

        if (!template.getUser().getId().equals(user.getId())) {
            throw new ResourceNotFoundException("Day template not found");
        }

        dayTemplateRepository.delete(template);
        return ResponseEntity.ok(Map.of("message", "Day template deleted successfully"));
    }