Function bodies 105 total

public class AdminController {

    private final CallSessionRepository callSessionRepository;
    private final AuditLogRepository auditLogRepository;
    private final PatientDeviceRepository patientDeviceRepository;

    @GetMapping("/calls")
    public ResponseEntity<List<CallSession>> getCalls(
            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime from,
            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime to) {
        
        if (from == null) from = LocalDateTime.now().minusDays(7);
        if (to == null) to = LocalDateTime.now();
        
        return ResponseEntity.ok(callSessionRepository.findByRequestedAtBetweenOrderByRequestedAtDesc(from, to));
    }

    @GetMapping("/devices")
    public ResponseEntity<List<PatientDevice>> getDevices() {
        return ResponseEntity.ok(patientDeviceRepository.findAll());
    }

    @GetMapping("/logs")
    public ResponseE

    public ResponseEntity<List<PatientDevice>> getDevices() {
        return ResponseEntity.ok(patientDeviceRepository.findAll());
    }

public class AuthController {

    private final AuthService authService;

    @PostMapping("/signup")
    public ResponseEntity<AuthResponse> signup(@Valid @RequestBody SignupRequest request) {
        return ResponseEntity.ok(authService.signup(request));
    }

    @PostMapping("/login")
    public ResponseEntity<AuthResponse> login(@Valid @RequestBody AuthRequest request) {
        return ResponseEntity.ok(authService.login(request));
    }
}

    public ResponseEntity<AuthResponse> signup(@Valid @RequestBody SignupRequest request) {
        return ResponseEntity.ok(authService.signup(request));
    }

    public ResponseEntity<AuthResponse> login(@Valid @RequestBody AuthRequest request) {
        return ResponseEntity.ok(authService.login(request));
    }

public class CallController {

    private final CallService callService;

    @PostMapping("/request")
    public ResponseEntity<CallSessionDto> requestCall(
            Authentication authentication,
            @Valid @RequestBody CallRequestDto request) {
        Long userId = (Long) authentication.getPrincipal();
        return ResponseEntity.ok(callService.requestCall(userId, request));
    }

    @PostMapping("/accept")
    public ResponseEntity<CallSessionDto> acceptCall(
            Authentication authentication,
            @Valid @RequestBody CallAcceptRequest request) {
        Long userId = (Long) authentication.getPrincipal();
        return ResponseEntity.ok(callService.acceptCall(userId, request));
    }

    @PostMapping("/end")
    public ResponseEntity<Void> endCall(
            Authentication authentication,
            @Valid @RequestBody CallEndRequest request) {
        Long userId = (Long) authentication.getPrincipal();
        callService.endCall(userId, reques

    public ResponseEntity<CallSessionDto> requestCall(
            Authentication authentication,
            @Valid @RequestBody CallRequestDto request) {
        Long userId = (Long) authentication.getPrincipal();
        return ResponseEntity.ok(callService.requestCall(userId, request));
    }

    public ResponseEntity<CallSessionDto> acceptCall(
            Authentication authentication,
            @Valid @RequestBody CallAcceptRequest request) {
        Long userId = (Long) authentication.getPrincipal();
        return ResponseEntity.ok(callService.acceptCall(userId, request));
    }

    public ResponseEntity<Void> endCall(
            Authentication authentication,
            @Valid @RequestBody CallEndRequest request) {
        Long userId = (Long) authentication.getPrincipal();
        callService.endCall(userId, request);
        return ResponseEntity.ok().build();
    }

    public ResponseEntity<CallSessionDto> getCallSession(@PathVariable Long id) {
        return ResponseEntity.ok(callService.getCallSession(id));
    }

    public ResponseEntity<List<CallSessionDto>> getCallHistory(Authentication authentication) {
        Long userId = (Long) authentication.getPrincipal();
        return ResponseEntity.ok(callService.getCallHistory(userId));
    }

public class DeviceController {

    private final DeviceService deviceService;

    @PostMapping("/register")
    public ResponseEntity<PatientDevice> registerDevice(
            Authentication authentication,
            @Valid @RequestBody DeviceRegisterRequest request) {
        Long userId = (Long) authentication.getPrincipal();
        return ResponseEntity.ok(deviceService.registerDevice(userId, request));
    }

    @PostMapping("/heartbeat")
    public ResponseEntity<Void> heartbeat(
            Authentication authentication,
            @Valid @RequestBody DeviceHeartbeatRequest request) {
        Long userId = (Long) authentication.getPrincipal();
        deviceService.heartbeat(userId, request);
        return ResponseEntity.ok().build();
    }

    @PatchMapping("/settings")
    public ResponseEntity<PatientDevice> updateSettings(
            Authentication authentication,
            @Valid @RequestBody DeviceSettingsRequest request) {
        Long userId = (Long) authent

    public ResponseEntity<PatientDevice> registerDevice(
            Authentication authentication,
            @Valid @RequestBody DeviceRegisterRequest request) {
        Long userId = (Long) authentication.getPrincipal();
        return ResponseEntity.ok(deviceService.registerDevice(userId, request));
    }

    public ResponseEntity<Void> heartbeat(
            Authentication authentication,
            @Valid @RequestBody DeviceHeartbeatRequest request) {
        Long userId = (Long) authentication.getPrincipal();
        deviceService.heartbeat(userId, request);
        return ResponseEntity.ok().build();
    }

    public ResponseEntity<PatientDevice> updateSettings(
            Authentication authentication,
            @Valid @RequestBody DeviceSettingsRequest request) {
        Long userId = (Long) authentication.getPrincipal();
        return ResponseEntity.ok(deviceService.updateSettings(userId, request));
    }

    public ResponseEntity<PatientDevice> getMyDevice(Authentication authentication) {
        Long userId = (Long) authentication.getPrincipal();
        return ResponseEntity.ok(deviceService.getDeviceByPatientId(userId));
    }

public class PairingController {

    private final PairingService pairingService;

    @PostMapping("/code")
    public ResponseEntity<PairingCodeResponse> generateCode(Authentication authentication) {
        Long userId = (Long) authentication.getPrincipal();
        return ResponseEntity.ok(pairingService.generateCode(userId));
    }

    @PostMapping("/claim")
    public ResponseEntity<PairingDto> claimPairing(
            Authentication authentication,
            @Valid @RequestBody ClaimPairingRequest request) {
        Long userId = (Long) authentication.getPrincipal();
        return ResponseEntity.ok(pairingService.claimPairing(userId, request));
    }

    @GetMapping("/me")
    public ResponseEntity<List<PairingDto>> getMyPairings(Authentication authentication) {
        Long userId = (Long) authentication.getPrincipal();
        return ResponseEntity.ok(pairingService.getMyPairings(userId));
    }
}

    public ResponseEntity<PairingCodeResponse> generateCode(Authentication authentication) {
        Long userId = (Long) authentication.getPrincipal();
        return ResponseEntity.ok(pairingService.generateCode(userId));
    }

    public ResponseEntity<PairingDto> claimPairing(
            Authentication authentication,
            @Valid @RequestBody ClaimPairingRequest request) {
        Long userId = (Long) authentication.getPrincipal();
        return ResponseEntity.ok(pairingService.claimPairing(userId, request));
    }

    public ResponseEntity<List<PairingDto>> getMyPairings(Authentication authentication) {
        Long userId = (Long) authentication.getPrincipal();
        return ResponseEntity.ok(pairingService.getMyPairings(userId));
    }

public class AuditLog {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private Type type;

    private Long actorUserId;

    private Long targetUserId;

    @Column(columnDefinition = "TEXT")
    private String payloadJson;

    @CreationTimestamp
    @Column(nullable = false, updatable = false)
    private LocalDateTime createdAt;

    public enum Type {
        USER_SIGNUP,
        USER_LOGIN,
        PAIRING_CODE_GENERATED,
        PAIRING_CLAIMED,
        DEVICE_REGISTERED,
        DEVICE_HEARTBEAT,
        DEVICE_SETTINGS_UPDATED,
        CALL_REQUESTED,
        CALL_ACCEPTED,
        CALL_REJECTED,
        CALL_CONNECTED,
        CALL_ENDED,
        CALL_FAILED,
        CALL_TIMEOUT
    }
}

public class CallSession {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private Long patientUserId;

    @Column(nullable = false)
    private Long guardianUserId;

    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private Status status;

    @CreationTimestamp
    @Column(nullable = false, updatable = false)
    private LocalDateTime requestedAt;

    private LocalDateTime connectedAt;

    private LocalDateTime endedAt;

    private String failReason;

    private String providerSessionId;

    public enum Status {
        REQUESTED, ACCEPTED, CONNECTED, ENDED, REJECTED, FAILED, TIMEOUT
    }
}

public class PairingCode {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true, nullable = false, length = 6)
    private String code;

    @Column(nullable = false)
    private Long patientUserId;

    @Column(nullable = false)
    private LocalDateTime expiresAt;

    @Builder.Default
    @Column(nullable = false)
    private Boolean used = false;

    @CreationTimestamp
    @Column(nullable = false, updatable = false)
    private LocalDateTime createdAt;

    public boolean isExpired() {
        return LocalDateTime.now().isAfter(expiresAt);
    }

    public boolean isValid() {
        return !used && !isExpired();
    }
}

    public boolean isExpired() {
        return LocalDateTime.now().isAfter(expiresAt);
    }

    public boolean isValid() {
        return !used && !isExpired();
    }

public class Pairing {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private Long patientUserId;

    @Column(nullable = false)
    private Long guardianUserId;

    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private Status status;

    @CreationTimestamp
    @Column(nullable = false, updatable = false)
    private LocalDateTime createdAt;

    public enum Status {
        ACTIVE, INACTIVE
    }
}

public class PatientDevice {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private Long patientUserId;

    @Column(nullable = false, unique = true)
    private String deviceId;

    private LocalDateTime lastSeenAt;

    @Builder.Default
    @Column(nullable = false)
    private Boolean online = false;

    @Builder.Default
    @Column(nullable = false)
    private Boolean autoAnswerEnabled = true;

    @Builder.Default
    private LocalTime allowedTimeStart = LocalTime.of(0, 0);

    @Builder.Default
    private LocalTime allowedTimeEnd = LocalTime.of(23, 59);

    @CreationTimestamp
    @Column(nullable = false, updatable = false)
    private LocalDateTime createdAt;

    public boolean isOnline(long heartbeatTimeoutMs) {
        if (lastSeenAt == null) return false;
        return LocalDateTime.now().isBefore(lastSeenAt.plusNanos(heartbeatTimeoutMs * 1_000_000));
    }

    public boolean isCal

    public boolean isOnline(long heartbeatTimeoutMs) {
        if (lastSeenAt == null) return false;
        return LocalDateTime.now().isBefore(lastSeenAt.plusNanos(heartbeatTimeoutMs * 1_000_000));
    }

    public boolean isCallAllowed() {
        if (!autoAnswerEnabled) return false;
        LocalTime now = LocalTime.now();
        return !now.isBefore(allowedTimeStart) && !now.isAfter(allowedTimeEnd);
    }

public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true, nullable = false)
    private String email;

    @Column(nullable = false)
    private String passwordHash;

    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private Role role;

    @Column(nullable = false)
    private String name;

    @CreationTimestamp
    @Column(nullable = false, updatable = false)
    private LocalDateTime createdAt;

    public enum Role {
        PATIENT, GUARDIAN, ADMIN
    }
}

public class AuthRequest {
    @Email
    @NotBlank
    private String email;

    @NotBlank
    private String password;
}

public class AuthResponse {
    private String accessToken;
    private UserDto user;

    @Data
    @Builder
    public static class UserDto {
        private Long id;
        private String email;
        private User.Role role;
        private String name;
    }
}

    public static class UserDto {
        private Long id;
        private String email;
        private User.Role role;
        private String name;
    }

public class CallAcceptRequest {
    @NotNull
    private Long callSessionId;
    
    @NotBlank
    private String deviceId;
}

public class CallEndRequest {
    @NotNull
    private Long callSessionId;
}

public class CallRequestDto {
    @NotNull
    private Long patientUserId;
}

public class CallSessionDto {
    private Long id;
    private Long patientUserId;
    private String patientName;
    private Long guardianUserId;
    private String guardianName;
    private CallSession.Status status;
    private LocalDateTime requestedAt;
    private LocalDateTime connectedAt;
    private LocalDateTime endedAt;
    private String failReason;
    private String providerSessionId;
}

public class ClaimPairingRequest {
    @NotBlank
    @Size(min = 6, max = 6)
    private String code;
}

public class DeviceHeartbeatRequest {
    @NotBlank
    private String deviceId;
}

public class DeviceRegisterRequest {
    @NotBlank
    private String deviceId;
}

public class DeviceSettingsRequest {
    private Boolean autoAnswerEnabled;
    private LocalTime allowedTimeStart;
    private LocalTime allowedTimeEnd;
}

public class PairingCodeResponse {
    private String code;
    private LocalDateTime expiresAt;
}

public class PairingDto {
    private Long id;
    private Long patientUserId;
    private String patientName;
    private Long guardianUserId;
    private String guardianName;
    private Pairing.Status status;
    private LocalDateTime createdAt;
    private DeviceStatusDto deviceStatus;

    @Data
    @Builder
    public static class DeviceStatusDto {
        private Boolean online;
        private LocalDateTime lastSeenAt;
    }
}

    public static class DeviceStatusDto {
        private Boolean online;
        private LocalDateTime lastSeenAt;
    }

public class SignupRequest {
    @Email
    @NotBlank
    private String email;

    @NotBlank
    private String password;

    @NotNull
    private User.Role role;

    @NotBlank
    private String name;
}

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

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

public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private final JwtUtil jwtUtil;

    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                    HttpServletResponse response, 
                                    FilterChain filterChain) throws ServletException, IOException {
        
        String requestURI = request.getRequestURI();
        System.out.println(">>> JWT Filter processing: " + request.getMethod() + " " + requestURI);
        
        final String authorizationHeader = request.getHeader("Authorization");
        System.out.println(">>> Authorization header: " + (authorizationHeader != null ? "Present" : "Missing"));

        String username = null;
        String jwt = null;

        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            jwt = authorizationHeader.substring(7);
            System.out.println(">>> JWT token extracted, length: " + jwt.length());

    protected void doFilterInternal(HttpServletRequest request, 
                                    HttpServletResponse response, 
                                    FilterChain filterChain) throws ServletException, IOException {
        
        String requestURI = request.getRequestURI();
        System.out.println(">>> JWT Filter processing: " + request.getMethod() + " " + requestURI);
        
        final String authorizationHeader = request.getHeader("Authorization");
        System.out.println(">>> Authorization header: " + (authorizationHeader != null ? "Present" : "Missing"));

        String username = null;
        String jwt = null;

        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            jwt = authorizationHeader.substring(7);
            System.out.println(">>> JWT token extracted, length: " + jwt.length());
            try {
                username = jwtUtil.extractUsername(jwt);
                System.out.println(">>> User

public class JwtUtil {

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

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

    private SecretKey getSigningKey() {
        return Keys.hmacShaKeyFor(secret.getBytes(StandardCharsets.UTF_8));
    }

    public String extractUsername(String token) {
        return extractClaim(token, Claims::getSubject);
    }

    public Date extractExpiration(String token) {
        return extractClaim(token, Claims::getExpiration);
    }

    public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = extractAllClaims(token);
        return claimsResolver.apply(claims);
    }

    private Claims extractAllClaims(String token) {
        return Jwts.parser()
                .verifyWith(getSigningKey())
                .build()
                .parseSignedClaims(token)
                .getPayload();
    }

    private Boolean isTokenExpired(String token) {
        return extractExpiration(to