AdminController.java

package fr.but.infoetu.meetingplannr.controller;

import java.time.LocalTime;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AnonymousAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import fr.but.infoetu.meetingplannr.pojo.Meeting;
import fr.but.infoetu.meetingplannr.pojo.Request;
import fr.but.infoetu.meetingplannr.pojo.User;
import fr.but.infoetu.meetingplannr.repository.MeetingRepository;
import fr.but.infoetu.meetingplannr.repository.RequestRepository;
import fr.but.infoetu.meetingplannr.repository.UserRepository;
import fr.but.infoetu.meetingplannr.service.RequestService;
import fr.but.infoetu.meetingplannr.service.UserService;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpSession;

@Controller
public class AdminController {
    @Autowired
    MeetingRepository mr;

    @Autowired UserRepository ur;

    @Autowired
    RequestRepository rr;

    @Autowired
    UserService us;

    @Autowired 
    RequestService rs;

    @RequestMapping
    private String redirectHome(HttpSession session) {
        if (session.getAttribute("currentUser") == null) {
            return "public/login";
        }
        return "user/listeAction";
    }



    @RequestMapping(value = "admin/dashboard", method = RequestMethod.GET)
    private String adminDashboard(@AuthenticationPrincipal UserDetails details, Model model) {
        User user = ur.findByUsername(details.getUsername()).get();
        
        model.addAttribute("currentUser", user);
        return "admin/dashboard";
    }

    @RequestMapping(value = "admin/users", method = RequestMethod.GET)
    private String usersList(@AuthenticationPrincipal UserDetails details, 
                            @RequestParam(defaultValue = "1") int page,
                            @RequestParam(required = false) String search,
                            Model model) {

        
        int pageSize = 5;
        List<User> allUsers = search != null && !search.trim().isEmpty() 
            ? ur.findByNameContainingOrSurnameContainingOrUsernameContaining(search, search, search)
            : ur.findAll();
        
        int start = (page - 1) * pageSize;
        int end = Math.min(start + pageSize, allUsers.size());
        List<User> users = allUsers.subList(start, end);
        
        model.addAttribute("users", users);
        model.addAttribute("currentPage", page);
        model.addAttribute("totalPages", (int) Math.ceil(allUsers.size() / (double) pageSize));
        model.addAttribute("currentUser", ur.findByUsername(details.getUsername()).get());
        
        return "admin/users";
    }

    @RequestMapping(value = "admin/users/ban/{uno}", method = RequestMethod.POST)
    private String banUser(@PathVariable Integer uno) {
        us.banUser(uno);
        return "redirect:/admin/users";
    }

    @RequestMapping(value = "admin/requests", method = RequestMethod.GET)
    private String requestsList(@AuthenticationPrincipal UserDetails details, 
                          @RequestParam(defaultValue = "1") int page,
                          @RequestParam(required = false) String search,
                          @RequestParam(required = false) Boolean filter,
                          Model model) {
    
    int pageSize = 5;
    List<Request> allRequests = search != null && !search.trim().isEmpty() 
        ? rr.findByReasonContainingOrDescriptionContaining(search, search)
        : rr.findAll();
    
    if (filter != null && filter) {
        allRequests = allRequests.stream()
            .filter(req -> !rs.hasMeeting(req))
            .collect(Collectors.toList());
    }
    
    int start = (page - 1) * pageSize;
    int end = Math.min(start + pageSize, allRequests.size());
    List<Request> requests = allRequests.subList(start, end);
    
    for (Request req : requests) {
        model.addAttribute("hasMeeting_" + req.getRno(), rs.hasMeeting(req));
    }
    
    model.addAttribute("requests", requests);
    model.addAttribute("currentPage", page);
    model.addAttribute("totalPages", (int) Math.ceil(allRequests.size() / (double) pageSize));
    model.addAttribute("currentUser", ur.findByUsername(details.getUsername()).get());
    model.addAttribute("filter", filter);
    
    return "admin/requests";
}

    @RequestMapping(value = "admin/requests/validate/{rno}", method = RequestMethod.POST)
    private String validateRequest(@PathVariable int rno, @AuthenticationPrincipal UserDetails details,
                                   @RequestParam(defaultValue = "1") int page,
                                   @RequestParam(required = false) String search,
                                   @RequestParam(required = false) Boolean filter) {
        

        Optional<Request> requestOpt = rr.findById(rno);
        if (requestOpt.isPresent()) {
            Request request = requestOpt.get();
            User user = request.getUser();
            Meeting meeting = new Meeting();
            meeting.setRequest(request);
            meeting.setUser(user);
            if(user.getUsername().endsWith("@univ-lille.fr")) {
                us.sendValidationMeeting(user, meeting);
            } 
            mr.save(meeting);
        }

        String redirectUrl = String.format("redirect:/admin/requests?page=%d", page);
        if (search != null) {
            redirectUrl += "&search=" + search;
        }
        if (filter != null) {
            redirectUrl += "&filter=" + filter;
        }

        return redirectUrl;
    }

    @RequestMapping(value = "admin/meetings", method = RequestMethod.GET)
    private String meetingsList(@AuthenticationPrincipal UserDetails details, 
                              @RequestParam(defaultValue = "1") int page,
                              @RequestParam(required = false) String search,
                              Model model) {
        if (details == null || !details.getAuthorities().stream()
                .anyMatch(a -> a.getAuthority().equals("ROLE_ADMIN"))) {
            return "redirect:/public/login";
        }
        
        int pageSize = 5;
        List<Meeting> allMeetings = search != null && !search.trim().isEmpty() 
            ? mr.findByRequestReasonContainingOrRequestDescriptionContaining(search, search)
            : mr.findAll();
        
        int start = (page - 1) * pageSize;
        int end = Math.min(start + pageSize, allMeetings.size());
        List<Meeting> meetings = allMeetings.subList(start, end);
        
        model.addAttribute("meetings", meetings);
        model.addAttribute("currentPage", page);
        model.addAttribute("totalPages", (int) Math.ceil(allMeetings.size() / (double) pageSize));
        model.addAttribute("currentUser", ur.findByUsername(details.getUsername()).get());
        
        return "admin/meetings";
    }

    @RequestMapping(value = "admin/meetings/delete/{mno}", method = RequestMethod.POST)
    private String adminDeleteMeeting(@PathVariable int mno, @AuthenticationPrincipal UserDetails details) {
        if (details == null || !details.getAuthorities().stream()
                .anyMatch(a -> a.getAuthority().equals("ROLE_ADMIN"))) {
            return "redirect:/public/login";
        }

        Optional<Meeting> meetingOpt = mr.findById(mno);
        if (meetingOpt.isPresent()) {
            mr.delete(meetingOpt.get());
        }

        return "redirect:/admin/meetings";
    }

    @RequestMapping(value = "admin/meetings/edit/{mno}", method = RequestMethod.GET)
    private String editMeeting(@PathVariable int mno, @AuthenticationPrincipal UserDetails details, Model model) {
        if (details == null || !details.getAuthorities().stream()
                .anyMatch(a -> a.getAuthority().equals("ROLE_ADMIN"))) {
            return "redirect:/public/login";
        }

        Optional<Meeting> meetingOpt = mr.findById(mno);
        if (!meetingOpt.isPresent()) {
            return "redirect:/admin/meetings";
        }

        Meeting meeting = meetingOpt.get();
        

        model.addAttribute("meeting", meeting);
        return "admin/editMeeting";
    }

    @RequestMapping(value = "admin/meetings/update/{mno}", method = RequestMethod.POST)
    private String updateMeeting(@PathVariable int mno, Meeting updatedMeeting, 
                               BindingResult result, @AuthenticationPrincipal UserDetails details, 
                               Model model) {
        if (details == null || !details.getAuthorities().stream()
                .anyMatch(a -> a.getAuthority().equals("ROLE_ADMIN"))) {
            return "redirect:/public/login";
        }

        if (result.hasErrors()) {
            model.addAttribute("errorMessage", "Veuillez corriger les erreurs du formulaire.");
            return "admin/editMeeting";
        }

        Optional<Meeting> meetingOpt = mr.findById(mno);
        if (!meetingOpt.isPresent()) {
            return "redirect:/admin/meetings";
        }

        Meeting existingMeeting = meetingOpt.get();
        Request existingRequest = existingMeeting.getRequest();
        
        existingRequest.setReason(updatedMeeting.getRequest().getReason());
        existingRequest.setDescription(updatedMeeting.getRequest().getDescription());
        existingRequest.setTime(updatedMeeting.getRequest().getTime());
        
        rr.save(existingRequest);  
        mr.save(existingMeeting);  

        return "redirect:/admin/meetings";
    }

    private boolean isAuthenticated() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        return authentication != null && 
               authentication.isAuthenticated() && 
               !(authentication instanceof AnonymousAuthenticationToken);
    }
}