Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Make the following change: 1. When user uploads an image to an existing request, it…

  1. User

    Make the following change:

    1. When user uploads an image to an existing request, it updates the same document, do not create a new document
    2. When approve and reject request, it also updates the status of same document, do not create a new document Give me the entire code. Also, Help me create 2 simple front end interface to test out the leave request functionality of creating a request, and updating the request with a photo. The other is to accept or reject request. Give me the entire code (just do it in vanila html css js) and what data to fill up to test all the routes of leaverequest controller to ensure everything works.

    Code context: File: src\main\java\com\g4t4\home_cleaning_scheduler\model\LeaveRequest.java

    package com.g4t4.home_cleaning_scheduler.model;

    import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import com.google.cloud.Timestamp; import com.google.cloud.firestore.annotation.DocumentId; import com.google.cloud.firestore.annotation.IgnoreExtraProperties;

    import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor;

    @Data @NoArgsConstructor @AllArgsConstructor @IgnoreExtraProperties @JsonIgnoreProperties(ignoreUnknown = true) public class LeaveRequest { @DocumentId private String leaveRequestId; private String workerId;

    @JsonDeserialize(using = FlexibleTimestampDeserializer.class)
    private Timestamp dateOfApplication;
    
    private String status; // e.g., Pending, Approved, Rejected
    private String leaveType; // e.g., Medical, Annual, etc.
    private String supervisorId;
    
    @JsonDeserialize(using = FlexibleTimestampDeserializer.class)
    private Timestamp leaveStartDate;
    
    @JsonDeserialize(using = FlexibleTimestampDeserializer.class)
    private Timestamp leaveEndDate;
    
    private String medicalCertificateUrl; // URL to the stored medical certificate image
    
    // Additional fields and methods if necessary
    

    }

    File: src\main\java\com\g4t4\home_cleaning_scheduler\repository\AbstractFirestoreRepository.java

    package com.g4t4.home_cleaning_scheduler.repository;

    import java.lang.reflect.ParameterizedType; import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.Optional; import java.util.UUID; import java.util.concurrent.ExecutionException; import java.util.stream.Collectors;

    import org.springframework.lang.Nullable;

    import com.g4t4.home_cleaning_scheduler.utils.DocumentId; import com.google.api.core.ApiFuture; import com.google.cloud.firestore.CollectionReference; import com.google.cloud.firestore.DocumentReference; import com.google.cloud.firestore.DocumentSnapshot; import com.google.cloud.firestore.Firestore; import com.google.cloud.firestore.QueryDocumentSnapshot; import com.google.cloud.firestore.QuerySnapshot; import com.google.cloud.firestore.WriteResult;

    import lombok.extern.slf4j.Slf4j;

    @Slf4j public abstract class AbstractFirestoreRepository {

    private final CollectionReference collectionReference;
    private final String collectionName;
    private final Class<T> parameterizedType;
    
    protected final Firestore firestore;
    
    // Constructor
    protected AbstractFirestoreRepository(Firestore firestore, String collectionName) {
        if (firestore == null) {
            throw new IllegalArgumentException("Firestore cannot be null");
        }
        this.firestore = firestore;
        this.collectionName = collectionName;
        this.collectionReference = firestore.collection(collectionName);
    
        // Initialize parameterizedType by calling getParameterizedType()
        this.parameterizedType = getParameterizedType();
    }
    
    // Method to get the generic type parameter (T)
    private Class<T> getParameterizedType() {
        ParameterizedType type = (ParameterizedType) this.getClass().getGenericSuperclass();
        return (Class<T>) type.getActualTypeArguments()[0];
    }
    
    public boolean save(T model) {
        String documentId = getDocumentId(model);
        ApiFuture<WriteResult> resultApiFuture = collectionReference.document(documentId).set(model);
    
        try {
            log.info("{}-{} saved at {}", collectionName, documentId, resultApiFuture.get().getUpdateTime());
            return true;
        } catch (InterruptedException | ExecutionException e) {
            log.error("Error saving {}={} {}", collectionName, documentId, e.getMessage());
        }
    
        return false;
    }
    
    public void delete(T model) {
        String documentId = getDocumentId(model);
        ApiFuture<WriteResult> resultApiFuture = collectionReference.document(documentId).delete();
    }
    
    public List<T> retrieveAll() {
        ApiFuture<QuerySnapshot> querySnapshotApiFuture = collectionReference.get();
    
        try {
            List<QueryDocumentSnapshot> queryDocumentSnapshots = querySnapshotApiFuture.get().getDocuments();
    
            return queryDocumentSnapshots.stream()
                    .map(queryDocumentSnapshot -> queryDocumentSnapshot.toObject(parameterizedType))
                    .collect(Collectors.toList());
    
        } catch (InterruptedException | ExecutionException e) {
            log.error("Exception occurred while retrieving all documents for {}", collectionName);
        }
        return Collections.<T>emptyList();
    }
    
    public Optional<T> get(String documentId) {
        DocumentReference documentReference = collectionReference.document(documentId);
        ApiFuture<DocumentSnapshot> documentSnapshotApiFuture = documentReference.get();
    
        try {
            DocumentSnapshot documentSnapshot = documentSnapshotApiFuture.get();
    
            if (documentSnapshot.exists()) {
                return Optional.ofNullable(documentSnapshot.toObject(parameterizedType));
            }
    
        } catch (InterruptedException | ExecutionException e) {
            log.error("Exception occurred retrieving: {} {}, {}", collectionName, documentId, e.getMessage());
        }
    
        return Optional.empty();
    }
    
    protected String getDocumentId(T t) {
        Object key;
        Class<?> clzz = t.getClass();
        do {
            key = getKeyFromFields(clzz, t);
            clzz = clzz.getSuperclass();
        } while (key == null && clzz != null);
    
        if (key == null) {
            return UUID.randomUUID().toString();
        }
        return String.valueOf(key);
    }
    
    private Object getKeyFromFields(Class<?> clazz, Object t) {
        return Arrays.stream(clazz.getDeclaredFields())
                .filter(field -> field.isAnnotationPresent(DocumentId.class))
                .findFirst()
                .map(field -> getValue(t, field))
                .orElse(null);
    }
    
    @Nullable
    private Object getValue(Object t, java.lang.reflect.Field field) {
        field.setAccessible(true);
        try {
            return field.get(t);
        } catch (IllegalAccessException e) {
            log.error("Error in getting documentId key", e);
        }
        return null;
    }
    
    protected CollectionReference getCollectionReference() {
        return this.collectionReference;
    }
    
    protected Class<T> getType() {
        return this.parameterizedType;
    }
    

    }

    File: src\main\java\com\g4t4\home_cleaning_scheduler\repository\LeaveRequestRepository.java

    package com.g4t4.home_cleaning_scheduler.repository;

    import com.g4t4.home_cleaning_scheduler.model.LeaveRequest; import com.google.cloud.firestore.CollectionReference; import com.google.cloud.firestore.Firestore;

    import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Repository;

    @Repository public class LeaveRequestRepository extends AbstractFirestoreRepository {

    @Autowired
    public LeaveRequestRepository(Firestore firestore) {
        super(firestore, "leave_requests");
    }
    
    public boolean saveLeaveRequest(LeaveRequest leaveRequest) {
        return save(leaveRequest);
    }
    
    public void deleteLeaveRequest(LeaveRequest leaveRequest) {
        delete(leaveRequest);
    }
    
    public CollectionReference getCollectionReference() {
        return super.getCollectionReference();
    }
    
    // Additional methods to get leave requests by workerId, supervisorId, etc., can be added if needed.
    

    }

    File: src\main\java\com\g4t4\home_cleaning_scheduler\service\LeaveRequestService.java

    package com.g4t4.home_cleaning_scheduler.service;

    import com.g4t4.home_cleaning_scheduler.model.LeaveRequest; import com.g4t4.home_cleaning_scheduler.model.User; import com.g4t4.home_cleaning_scheduler.repository.LeaveRequestRepository; import com.g4t4.home_cleaning_scheduler.repository.UserRepository; import com.google.api.core.ApiFuture; import com.google.cloud.Timestamp; import com.google.cloud.firestore.CollectionReference; import com.google.cloud.firestore.Query; import com.google.cloud.firestore.QuerySnapshot; import com.google.cloud.storage.BlobInfo; import com.google.cloud.storage.Acl; import com.google.firebase.cloud.StorageClient;

    import org.springframework.beans.factory.annotation.Autowired; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Service; import org.springframework.web.multipart.MultipartFile;

    import java.io.IOException; import java.util.List; import java.util.Optional; import java.util.UUID; import java.util.concurrent.ExecutionException; import java.util.stream.Collectors;

    @Service public class LeaveRequestService {

    private final LeaveRequestRepository leaveRequestRepository;
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    public LeaveRequestService(LeaveRequestRepository leaveRequestRepository) {
        this.leaveRequestRepository = leaveRequestRepository;
    }
    
    /**
     * Submits a new leave request. Image upload is optional.
     *
     * @param leaveRequest            The leave request details provided by the user.
     * @param medicalCertificateFile  The medical certificate image file (optional).
     * @return true if the leave request is saved successfully.
     * @throws IOException if there's an error processing the image.
     */
    public boolean submitLeaveRequest(LeaveRequest leaveRequest, MultipartFile medicalCertificateFile) throws IOException {
        // Validate leave dates
        if (leaveRequest.getLeaveStartDate() == null || leaveRequest.getLeaveEndDate() == null) {
            throw new IllegalArgumentException("Leave start date and end date are required.");
        }
    
        if (leaveRequest.getLeaveStartDate().compareTo(leaveRequest.getLeaveEndDate()) > 0) {
            throw new IllegalArgumentException("Leave start date must be before or equal to leave end date.");
        }
    
        // Set dateOfApplication to current time
        leaveRequest.setDateOfApplication(Timestamp.now());
    
        // Set status to Pending
        leaveRequest.setStatus("Pending");
    
        // If leave type is Medical and medicalCertificateFile is provided, upload it
        if ("Medical".equalsIgnoreCase(leaveRequest.getLeaveType())) {
            if (medicalCertificateFile != null && !medicalCertificateFile.isEmpty()) {
                String imageUrl = uploadMedicalCertificate(medicalCertificateFile);
                leaveRequest.setMedicalCertificateUrl(imageUrl);
            }
            // Image upload is optional; proceed even if not provided
        } else {
            // For non-Medical leave types, ensure medicalCertificateUrl is null
            leaveRequest.setMedicalCertificateUrl(null);
        }
    
        // Generate a unique ID for the leave request
        String leaveRequestId = UUID.randomUUID().toString();
        leaveRequest.setLeaveRequestId(leaveRequestId);
    
        return leaveRequestRepository.saveLeaveRequest(leaveRequest);
    }
    
    /**
     * Uploads a medical certificate image and updates the corresponding leave request.
     *
     * @param leaveRequestId         The ID of the leave request to update.
     * @param medicalCertificateFile The medical certificate image file.
     * @return true if the update is successful.
     * @throws IOException              if there's an error processing the image.
     * @throws ExecutionException
     * @throws InterruptedException
     */
    public boolean uploadMedicalCertificate(String leaveRequestId, MultipartFile medicalCertificateFile) throws IOException, ExecutionException, InterruptedException {
        if (medicalCertificateFile == null || medicalCertificateFile.isEmpty()) {
            throw new IllegalArgumentException("Medical certificate image is required.");
        }
    
        // Retrieve existing leave request
        Optional<LeaveRequest> optionalLeaveRequest = leaveRequestRepository.get(leaveRequestId);
        if (!optionalLeaveRequest.isPresent()) {
            throw new IllegalArgumentException("Leave request not found.");
        }
    
        LeaveRequest leaveRequest = optionalLeaveRequest.get();
    
        // Check if leave type is Medical
        if (!"Medical".equalsIgnoreCase(leaveRequest.getLeaveType())) {
            throw new IllegalArgumentException("Cannot upload medical certificate to a non-medical leave request.");
        }
    
        // Upload the image
        String imageUrl = uploadMedicalCertificate(medicalCertificateFile);
        leaveRequest.setMedicalCertificateUrl(imageUrl);
    
        // Update the leave request
        return leaveRequestRepository.saveLeaveRequest(leaveRequest);
    }
    
    /**
     * Updates the status of a leave request.
     *
     * @param leaveRequestId The ID of the leave request.
     * @param adminId        The ID of the admin updating the request.
     * @param status         The new status ("Approved" or "Rejected").
     * @return true if the update is successful.
     * @throws ExecutionException
     * @throws InterruptedException
     */
    public boolean updateLeaveRequestStatus(String leaveRequestId, String adminId, String status) throws ExecutionException, InterruptedException {
        // Retrieve the leave request
        Optional<LeaveRequest> optionalLeaveRequest = leaveRequestRepository.get(leaveRequestId);
        if (!optionalLeaveRequest.isPresent()) {
            throw new IllegalArgumentException("Leave request not found.");
        }
        LeaveRequest leaveRequest = optionalLeaveRequest.get();
    
        // Check if the admin is the supervisor of the worker
        if (!leaveRequest.getSupervisorId().equals(adminId)) {
            throw new IllegalArgumentException("Admin is not authorized to update this leave request.");
        }
    
        leaveRequest.setStatus(status);
        return leaveRequestRepository.saveLeaveRequest(leaveRequest);
    }
    
    /**
     * Approves a leave request.
     *
     * @param leaveRequestId The ID of the leave request.
     * @param adminId        The ID of the admin approving the request.
     * @return true if the approval is successful.
     * @throws ExecutionException
     * @throws InterruptedException
     */
    public boolean approveLeaveRequest(String leaveRequestId, String adminId) throws ExecutionException, InterruptedException {
        return updateLeaveRequestStatus(leaveRequestId, adminId, "Approved");
    }
    
    /**
     * Rejects a leave request.
     *
     * @param leaveRequestId The ID of the leave request.
     * @param adminId        The ID of the admin rejecting the request.
     * @return true if the rejection is successful.
     * @throws ExecutionException
     * @throws InterruptedException
     */
    public boolean rejectLeaveRequest(String leaveRequestId, String adminId) throws ExecutionException, InterruptedException {
        return updateLeaveRequestStatus(leaveRequestId, adminId, "Rejected");
    }
    
    /**
     * Uploads the medical certificate image to Firebase Storage with public access.
     *
     * @param file The image file to upload.
     * @return The public URL of the uploaded image.
     * @throws IOException if an error occurs during upload.
     */
    private String uploadMedicalCertificate(MultipartFile file) throws IOException {
        String bucketName = "clean-affcc.appspot.com"; // Replace with your Firebase bucket name
        String folderName = "medical_certificates";
    
        String fileName = folderName + "/" + UUID.randomUUID().toString() + "_" + file.getOriginalFilename();
    
        // Build the blob info with public read ACL
        BlobInfo blobInfo = BlobInfo.newBuilder(bucketName, fileName)
                .setContentType(file.getContentType())
                .setAcl(
                        List.of(Acl.of(Acl.User.ofAllUsers(), Acl.Role.READER))
                )
                .build();
    
        // Upload to Cloud Storage
        StorageClient.getInstance().bucket(bucketName).create(blobInfo.getName(), file.getBytes(), blobInfo.getContentType());
    
        // Return the public URL to the uploaded file
        return String.format("https://storage.googleapis.com/%s/%s", bucketName, fileName);
    }
    
    /**
     * Retrieves all leave requests supervised by a specific supervisor.
     *
     * @param supervisorId The ID of the supervisor.
     * @return A list of matching leave requests.
     * @throws ExecutionException
     * @throws InterruptedException
     */
    public List<LeaveRequest> getLeaveRequestsBySupervisor(String supervisorId) throws ExecutionException, InterruptedException {
        CollectionReference collection = leaveRequestRepository.getCollectionReference();
        Query query = collection.whereEqualTo("supervisorId", supervisorId);
    
        ApiFuture<QuerySnapshot> querySnapshot = query.get();
    
        return querySnapshot.get().getDocuments().stream()
                .map(document -> document.toObject(LeaveRequest.class))
                .collect(Collectors.toList());
    }
    
    /**
     * Retrieves all leave requests submitted by a specific worker.
     *
     * @param workerId The ID of the worker.
     * @return A list of matching leave requests.
     * @throws ExecutionException
     * @throws InterruptedException
     */
    public List<LeaveRequest> getLeaveRequestsByWorker(String workerId) throws ExecutionException, InterruptedException {
        CollectionReference collection = leaveRequestRepository.getCollectionReference();
        Query query = collection.whereEqualTo("workerId", workerId);
    
        ApiFuture<QuerySnapshot> querySnapshot = query.get();
    
        return querySnapshot.get().getDocuments().stream()
                .map(document -> document.toObject(LeaveRequest.class))
                .collect(Collectors.toList());
    }
    
    /**
     * Retrieves all approved leave requests.
     *
     * @return A list of approved leave requests.
     * @throws ExecutionException
     * @throws InterruptedException
     */
    public List<LeaveRequest> getApprovedLeaveRequests() throws ExecutionException, InterruptedException {
        CollectionReference collection = leaveRequestRepository.getCollectionReference();
        Query query = collection.whereEqualTo("status", "Approved");
    
        ApiFuture<QuerySnapshot> querySnapshot = query.get();
    
        return querySnapshot.get().getDocuments().stream()
                .map(document -> document.toObject(LeaveRequest.class))
                .collect(Collectors.toList());
    }
    
    /**
     * Scheduled task that runs daily at midnight to notify admins about pending medical certificates.
     *
     * @throws ExecutionException
     * @throws InterruptedException
     */
    @Scheduled(cron = "0 0 0 * * *") // Runs daily at midnight
    public void notifyAdminsForPendingMedicalCertificates() throws ExecutionException, InterruptedException {
        CollectionReference collection = leaveRequestRepository.getCollectionReference();
        Query query = collection
                .whereEqualTo("leaveType", "Medical")
                .whereEqualTo("status", "Pending")
                .whereEqualTo("medicalCertificateUrl", null);
    
        ApiFuture<QuerySnapshot> querySnapshot = query.get();
    
        List<LeaveRequest> leaveRequests = querySnapshot.get().getDocuments().stream()
                .map(document -> document.toObject(LeaveRequest.class))
                .collect(Collectors.toList());
    
        for (LeaveRequest leaveRequest : leaveRequests) {
            // Get supervisor/admin information
            String supervisorId = leaveRequest.getSupervisorId();
            User supervisor = userRepository.findUserById(supervisorId);
    
            if (supervisor != null) {
                // Send notification to supervisor
                // Implement your notification logic here (e.g., send email)
                System.out.println("Sending notification to admin: " + supervisor.getEmail());
                // Placeholder for notification logic
            }
        }
    }
    

    }

  2. Assistant

    To address your requirements, we'll make the necessary changes to ensure that existing documents are updated rather than creating new ones when uploading images or updating the status of leave requests. Additionally, we'll provide two simple front-end interfaces using vanilla HTML, CSS, and JavaScript to test the leave request functionalities.

    Here's an overview of what we'll cover:

    1. Backend Modifications:

      • Ensure existing LeaveRequest documents are updated instead of creating new ones when uploading images or updating statuses.
      • Provide the complete backend code, including the LeaveRequestController.
    2. Front-End Interfaces:

      • Interface 1: Create and update leave requests with an optional photo upload.
      • Interface 2: Approve or reject leave requests.
    3. Testing Instructions:

      • How to populate data and test all routes of the LeaveRequestController.

    1. Backend Modifications

    1.1. Ensuring Updates Instead of Creating New Documents

    The key changes revolve around ensuring that when a leave request is updated (either by uploading an image or changing its status), the same document in Firestore is updated instead of creating a new one. This is achieved by correctly setting the leaveRequestId and using the set method with the document ID.

    1.2. Complete Backend Code

    Below is the complete backend code with necessary modifications:

    1.2.1. LeaveRequest.java

    package com.g4t4.home_cleaning_scheduler.model;
    
    import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
    import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
    import com.google.cloud.Timestamp;
    import com.google.cloud.firestore.annotation.DocumentId;
    import com.google.cloud.firestore.annotation.IgnoreExtraProperties;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @IgnoreExtraProperties
    @JsonIgnoreProperties(ignoreUnknown = true)
    public class LeaveRequest {
        @DocumentId
        private String leaveRequestId;
        private String workerId;
    
        @JsonDeserialize(using = FlexibleTimestampDeserializer.class)
        private Timestamp dateOfApplication;
    
        private String status; // e.g., Pending, Approved, Rejected
        private String leaveType; // e.g., Medical, Annual, etc.
        private String supervisorId;
    
        @JsonDeserialize(using = FlexibleTimestampDeserializer.class)
        private Timestamp leaveStartDate;
    
        @JsonDeserialize(using = FlexibleTimestampDeserializer.class)
        private Timestamp leaveEndDate;
    
        private String medicalCertificateUrl; // URL to the stored medical certificate image
    
        // Additional fields and methods if necessary
    }
    

    1.2.2. AbstractFirestoreRepository.java

    package com.g4t4.home_cleaning_scheduler.repository;
    
    import java.lang.reflect.ParameterizedType;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.List;
    import java.util.Optional;
    import java.util.UUID;
    import java.util.concurrent.ExecutionException;
    import java.util.stream.Collectors;
    
    import org.springframework.lang.Nullable;
    
    import com.g4t4.home_cleaning_scheduler.utils.DocumentId;
    import com.google.api.core.ApiFuture;
    import com.google.cloud.firestore.CollectionReference;
    import com.google.cloud.firestore.DocumentReference;
    import com.google.cloud.firestore.DocumentSnapshot;
    import com.google.cloud.firestore.Firestore;
    import com.google.cloud.firestore.QueryDocumentSnapshot;
    import com.google.cloud.firestore.QuerySnapshot;
    import com.google.cloud.firestore.WriteResult;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    public abstract class AbstractFirestoreRepository<T> {
    
        private final CollectionReference collectionReference;
        private final String collectionName;
        private final Class<T> parameterizedType;
    
        protected final Firestore firestore;
    
        // Constructor
        protected AbstractFirestoreRepository(Firestore firestore, String collectionName) {
            if (firestore == null) {
                throw new IllegalArgumentException("Firestore cannot be null");
            }
            this.firestore = firestore;
            this.collectionName = collectionName;
            this.collectionReference = firestore.collection(collectionName);
    
            // Initialize parameterizedType by calling getParameterizedType()
            this.parameterizedType = getParameterizedType();
        }
    
        // Method to get the generic type parameter (T)
        @SuppressWarnings("unchecked")
        private Class<T> getParameterizedType() {
            ParameterizedType type = (ParameterizedType) this.getClass().getGenericSuperclass();
            return (Class<T>) type.getActualTypeArguments()[0];
        }
    
        public boolean save(T model) {
            String documentId = getDocumentId(model);
            ApiFuture<WriteResult> resultApiFuture = collectionReference.document(documentId).set(model);
    
            try {
                log.info("{}-{} saved at {}", collectionName, documentId, resultApiFuture.get().getUpdateTime());
                return true;
            } catch (InterruptedException | ExecutionException e) {
                log.error("Error saving {}={} {}", collectionName, documentId, e.getMessage());
                Thread.currentThread().interrupt(); // Restore interrupted status
            }
    
            return false;
        }
    
        public void delete(T model) {
            String documentId = getDocumentId(model);
            ApiFuture<WriteResult> resultApiFuture = collectionReference.document(documentId).delete();
        }
    
        public List<T> retrieveAll() {
            ApiFuture<QuerySnapshot> querySnapshotApiFuture = collectionReference.get();
    
            try {
                List<QueryDocumentSnapshot> queryDocumentSnapshots = querySnapshotApiFuture.get().getDocuments();
    
                return queryDocumentSnapshots.stream()
                        .map(queryDocumentSnapshot -> queryDocumentSnapshot.toObject(parameterizedType))
                        .collect(Collectors.toList());
    
            } catch (InterruptedException | ExecutionException e) {
                log.error("Exception occurred while retrieving all documents for {}", collectionName);
                Thread.currentThread().interrupt(); // Restore interrupted status
            }
            return Collections.<T>emptyList();
        }
    
        public Optional<T> get(String documentId) {
            DocumentReference documentReference = collectionReference.document(documentId);
            ApiFuture<DocumentSnapshot> documentSnapshotApiFuture = documentReference.get();
    
            try {
                DocumentSnapshot documentSnapshot = documentSnapshotApiFuture.get();
    
                if (documentSnapshot.exists()) {
                    return Optional.ofNullable(documentSnapshot.toObject(parameterizedType));
                }
    
            } catch (InterruptedException | ExecutionException e) {
                log.error("Exception occurred retrieving: {} {}, {}", collectionName, documentId, e.getMessage());
                Thread.currentThread().interrupt(); // Restore interrupted status
            }
    
            return Optional.empty();
        }
    
        protected String getDocumentId(T t) {
            Object key;
            Class<?> clzz = t.getClass();
            do {
                key = getKeyFromFields(clzz, t);
                clzz = clzz.getSuperclass();
            } while (key == null && clzz != null);
    
            if (key == null) {
                // Attempt to generate a new document ID; but for updates, the ID should be present
                throw new IllegalArgumentException("Document ID is missing for update operation.");
            }
            return String.valueOf(key);
        }
    
        private Object getKeyFromFields(Class<?> clazz, Object t) {
            return Arrays.stream(clazz.getDeclaredFields())
                    .filter(field -> field.isAnnotationPresent(DocumentId.class))
                    .findFirst()
                    .map(field -> getValue(t, field))
                    .orElse(null);
        }
    
        @Nullable
        private Object getValue(Object t, java.lang.reflect.Field field) {
            field.setAccessible(true);
            try {
                return field.get(t);
            } catch (IllegalAccessException e) {
                log.error("Error in getting documentId key", e);
            }
            return null;
        }
    
        protected CollectionReference getCollectionReference() {
            return this.collectionReference;
        }
    
        protected Class<T> getType() {
            return this.parameterizedType;
        }
    }
    

    Note: Added an exception in getDocumentId to prevent generating a new ID when updating, ensuring that only existing documents are updated.

    1.2.3. LeaveRequestRepository.java

    package com.g4t4.home_cleaning_scheduler.repository;
    
    import com.g4t4.home_cleaning_scheduler.model.LeaveRequest;
    import com.google.cloud.firestore.CollectionReference;
    import com.google.cloud.firestore.Firestore;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Repository;
    
    @Repository
    public class LeaveRequestRepository extends AbstractFirestoreRepository<LeaveRequest> {
    
        @Autowired
        public LeaveRequestRepository(Firestore firestore) {
            super(firestore, "leave_requests");
        }
    
        public boolean saveLeaveRequest(LeaveRequest leaveRequest) {
            return save(leaveRequest);
        }
    
        public void deleteLeaveRequest(LeaveRequest leaveRequest) {
            delete(leaveRequest);
        }
    
        public CollectionReference getCollectionReference() {
            return super.getCollectionReference();
        }
    
        // Additional methods to get leave requests by workerId, supervisorId, etc., can be added if needed.
    }
    

    1.2.4. LeaveRequestService.java

    package com.g4t4.home_cleaning_scheduler.service;
    
    import com.g4t4.home_cleaning_scheduler.model.LeaveRequest;
    import com.g4t4.home_cleaning_scheduler.model.User;
    import com.g4t4.home_cleaning_scheduler.repository.LeaveRequestRepository;
    import com.g4t4.home_cleaning_scheduler.repository.UserRepository;
    import com.google.api.core.ApiFuture;
    import com.google.cloud.Timestamp;
    import com.google.cloud.firestore.CollectionReference;
    import com.google.cloud.firestore.Query;
    import com.google.cloud.firestore.QuerySnapshot;
    import com.google.cloud.storage.BlobInfo;
    import com.google.cloud.storage.Acl;
    import com.google.firebase.cloud.StorageClient;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.stereotype.Service;
    import org.springframework.web.multipart.MultipartFile;
    
    import java.io.IOException;
    import java.util.List;
    import java.util.Optional;
    import java.util.UUID;
    import java.util.concurrent.ExecutionException;
    import java.util.stream.Collectors;
    
    @Service
    public class LeaveRequestService {
    
        private final LeaveRequestRepository leaveRequestRepository;
    
        @Autowired
        private UserRepository userRepository;
    
        @Autowired
        public LeaveRequestService(LeaveRequestRepository leaveRequestRepository) {
            this.leaveRequestRepository = leaveRequestRepository;
        }
    
        /**
         * Submits a new leave request. Image upload is optional.
         *
         * @param leaveRequest            The leave request details provided by the user.
         * @param medicalCertificateFile  The medical certificate image file (optional).
         * @return true if the leave request is saved successfully.
         * @throws IOException if there's an error processing the image.
         */
        public boolean submitLeaveRequest(LeaveRequest leaveRequest, MultipartFile medicalCertificateFile) throws IOException {
            // Validate leave dates
            if (leaveRequest.getLeaveStartDate() == null || leaveRequest.getLeaveEndDate() == null) {
                throw new IllegalArgumentException("Leave start date and end date are required.");
            }
    
            if (leaveRequest.getLeaveStartDate().compareTo(leaveRequest.getLeaveEndDate()) > 0) {
                throw new IllegalArgumentException("Leave start date must be before or equal to leave end date.");
            }
    
            // Set dateOfApplication to current time
            leaveRequest.setDateOfApplication(Timestamp.now());
    
            // Set status to Pending
            leaveRequest.setStatus("Pending");
    
            // If leave type is Medical and medicalCertificateFile is provided, upload it
            if ("Medical".equalsIgnoreCase(leaveRequest.getLeaveType())) {
                if (medicalCertificateFile != null && !medicalCertificateFile.isEmpty()) {
                    String imageUrl = uploadMedicalCertificate(medicalCertificateFile);
                    leaveRequest.setMedicalCertificateUrl(imageUrl);
                }
                // Image upload is optional; proceed even if not provided
            } else {
                // For non-Medical leave types, ensure medicalCertificateUrl is null
                leaveRequest.setMedicalCertificateUrl(null);
            }
    
            // Generate a unique ID for the leave request
            String leaveRequestId = UUID.randomUUID().toString();
            leaveRequest.setLeaveRequestId(leaveRequestId);
    
            return leaveRequestRepository.saveLeaveRequest(leaveRequest);
        }
    
        /**
         * Uploads a medical certificate image and updates the corresponding leave request.
         *
         * @param leaveRequestId         The ID of the leave request to update.
         * @param medicalCertificateFile The medical certificate image file.
         * @return true if the update is successful.
         * @throws IOException              if there's an error processing the image.
         * @throws ExecutionException
         * @throws InterruptedException
         */
        public boolean uploadMedicalCertificate(String leaveRequestId, MultipartFile medicalCertificateFile) throws IOException, ExecutionException, InterruptedException {
            if (medicalCertificateFile == null || medicalCertificateFile.isEmpty()) {
                throw new IllegalArgumentException("Medical certificate image is required.");
            }
    
            // Retrieve existing leave request
            Optional<LeaveRequest> optionalLeaveRequest = leaveRequestRepository.get(leaveRequestId);
            if (!optionalLeaveRequest.isPresent()) {
                throw new IllegalArgumentException("Leave request not found.");
            }
    
            LeaveRequest leaveRequest = optionalLeaveRequest.get();
    
            // Check if leave type is Medical
            if (!"Medical".equalsIgnoreCase(leaveRequest.getLeaveType())) {
                throw new IllegalArgumentException("Cannot upload medical certificate to a non-medical leave request.");
            }
    
            // Upload the image
            String imageUrl = uploadMedicalCertificate(medicalCertificateFile);
            leaveRequest.setMedicalCertificateUrl(imageUrl);
    
            // Update the leave request
            return leaveRequestRepository.saveLeaveRequest(leaveRequest);
        }
    
        /**
         * Updates the status of a leave request.
         *
         * @param leaveRequestId The ID of the leave request.
         * @param adminId        The ID of the admin updating the request.
         * @param status         The new status ("Approved" or "Rejected").
         * @return true if the update is successful.
         * @throws ExecutionException
         * @throws InterruptedException
         */
        public boolean updateLeaveRequestStatus(String leaveRequestId, String adminId, String status) throws ExecutionException, InterruptedException {
            // Retrieve the leave request
            Optional<LeaveRequest> optionalLeaveRequest = leaveRequestRepository.get(leaveRequestId);
            if (!optionalLeaveRequest.isPresent()) {
                throw new IllegalArgumentException("Leave request not found.");
            }
            LeaveRequest leaveRequest = optionalLeaveRequest.get();
    
            // Check if the admin is the supervisor of the worker
            if (!leaveRequest.getSupervisorId().equals(adminId)) {
                throw new IllegalArgumentException("Admin is not authorized to update this leave request.");
            }
    
            leaveRequest.setStatus(status);
            return leaveRequestRepository.saveLeaveRequest(leaveRequest);
        }
    
        /**
         * Approves a leave request.
         *
         * @param leaveRequestId The ID of the leave request.
         * @param adminId        The ID of the admin approving the request.
         * @return true if the approval is successful.
         * @throws ExecutionException
         * @throws InterruptedException
         */
        public boolean approveLeaveRequest(String leaveRequestId, String adminId) throws ExecutionException, InterruptedException {
            return updateLeaveRequestStatus(leaveRequestId, adminId, "Approved");
        }
    
        /**
         * Rejects a leave request.
         *
         * @param leaveRequestId The ID of the leave request.
         * @param adminId        The ID of the admin rejecting the request.
         * @return true if the rejection is successful.
         * @throws ExecutionException
         * @throws InterruptedException
         */
        public boolean rejectLeaveRequest(String leaveRequestId, String adminId) throws ExecutionException, InterruptedException {
            return updateLeaveRequestStatus(leaveRequestId, adminId, "Rejected");
        }
    
        /**
         * Uploads the medical certificate image to Firebase Storage with public access.
         *
         * @param file The image file to upload.
         * @return The public URL of the uploaded image.
         * @throws IOException if an error occurs during upload.
         */
        private String uploadMedicalCertificate(MultipartFile file) throws IOException {
            String bucketName = "clean-affcc.appspot.com"; // Replace with your Firebase bucket name
            String folderName = "medical_certificates";
    
            String fileName = folderName + "/" + UUID.randomUUID().toString() + "_" + file.getOriginalFilename();
    
            // Build the blob info with public read ACL
            BlobInfo blobInfo = BlobInfo.newBuilder(bucketName, fileName)
                    .setContentType(file.getContentType())
                    .setAcl(
                            List.of(Acl.of(Acl.User.ofAllUsers(), Acl.Role.READER))
                    )
                    .build();
    
            // Upload to Cloud Storage
            StorageClient.getInstance().bucket(bucketName).create(blobInfo.getName(), file.getBytes(), blobInfo.getContentType());
    
            // Return the public URL to the uploaded file
            return String.format("https://storage.googleapis.com/%s/%s", bucketName, fileName);
        }
    
        /**
         * Retrieves all leave requests supervised by a specific supervisor.
         *
         * @param supervisorId The ID of the supervisor.
         * @return A list of matching leave requests.
         * @throws ExecutionException
         * @throws InterruptedException
         */
        public List<LeaveRequest> getLeaveRequestsBySupervisor(String supervisorId) throws ExecutionException, InterruptedException {
            CollectionReference collection = leaveRequestRepository.getCollectionReference();
            Query query = collection.whereEqualTo("supervisorId", supervisorId);
    
            ApiFuture<QuerySnapshot> querySnapshot = query.get();
    
            return querySnapshot.get().getDocuments().stream()
                    .map(document -> document.toObject(LeaveRequest.class))
                    .collect(Collectors.toList());
        }
    
        /**
         * Retrieves all leave requests submitted by a specific worker.
         *
         * @param workerId The ID of the worker.
         * @return A list of matching leave requests.
         * @throws ExecutionException
         * @throws InterruptedException
         */
        public List<LeaveRequest> getLeaveRequestsByWorker(String workerId) throws ExecutionException, InterruptedException {
            CollectionReference collection = leaveRequestRepository.getCollectionReference();
            Query query = collection.whereEqualTo("workerId", workerId);
    
            ApiFuture<QuerySnapshot> querySnapshot = query.get();
    
            return querySnapshot.get().getDocuments().stream()
                    .map(document -> document.toObject(LeaveRequest.class))
                    .collect(Collectors.toList());
        }
    
        /**
         * Retrieves all approved leave requests.
         *
         * @return A list of approved leave requests.
         * @throws ExecutionException
         * @throws InterruptedException
         */
        public List<LeaveRequest> getApprovedLeaveRequests() throws ExecutionException, InterruptedException {
            CollectionReference collection = leaveRequestRepository.getCollectionReference();
            Query query = collection.whereEqualTo("status", "Approved");
    
            ApiFuture<QuerySnapshot> querySnapshot = query.get();
    
            return querySnapshot.get().getDocuments().stream()
                    .map(document -> document.toObject(LeaveRequest.class))
                    .collect(Collectors.toList());
        }
    
        /**
         * Scheduled task that runs daily at midnight to notify admins about pending medical certificates.
         *
         * @throws ExecutionException
         * @throws InterruptedException
         */
        @Scheduled(cron = "0 0 0 * * *") // Runs daily at midnight
        public void notifyAdminsForPendingMedicalCertificates() throws ExecutionException, InterruptedException {
            CollectionReference collection = leaveRequestRepository.getCollectionReference();
            Query query = collection
                    .whereEqualTo("leaveType", "Medical")
                    .whereEqualTo("status", "Pending")
                    .whereEqualTo("medicalCertificateUrl", null);
    
            ApiFuture<QuerySnapshot> querySnapshot = query.get();
    
            List<LeaveRequest> leaveRequests = querySnapshot.get().getDocuments().stream()
                    .map(document -> document.toObject(LeaveRequest.class))
                    .collect(Collectors.toList());
    
            for (LeaveRequest leaveRequest : leaveRequests) {
                // Get supervisor/admin information
                String supervisorId = leaveRequest.getSupervisorId();
                User supervisor = userRepository.findUserById(supervisorId);
    
                if (supervisor != null) {
                    // Send notification to supervisor
                    // Implement your notification logic here (e.g., send email)
                    System.out.println("Sending notification to admin: " + supervisor.getEmail());
                    // Placeholder for notification logic
                }
            }
        }
    }
    

    Key Changes:

    • Prevent Generating New Document IDs on Update: In the AbstractFirestoreRepository, the save method now throws an exception if leaveRequestId is missing when attempting to update an existing document. This ensures that updates are only performed on existing documents.

    1.2.5. LeaveRequestController.java

    We'll create a LeaveRequestController to handle REST API requests for creating, updating, and managing leave requests.

    package com.g4t4.home_cleaning_scheduler.controller;
    
    import com.g4t4.home_cleaning_scheduler.model.LeaveRequest;
    import com.g4t4.home_cleaning_scheduler.service.LeaveRequestService;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.http.HttpStatus;
    import org.springframework.http.ResponseEntity;
    import org.springframework.web.bind.annotation.*;
    import org.springframework.web.multipart.MultipartFile;
    import org.springframework.web.server.ResponseStatusException;
    
    import java.io.IOException;
    import java.util.List;
    import java.util.concurrent.ExecutionException;
    
    @RestController
    @RequestMapping("/api/leaverequests")
    public class LeaveRequestController {
    
        private final LeaveRequestService leaveRequestService;
    
        @Autowired
        public LeaveRequestController(LeaveRequestService leaveRequestService) {
            this.leaveRequestService = leaveRequestService;
        }
    
        /**
         * Endpoint to create a new leave request.
         *
         * @param leaveRequest           The leave request details in JSON format.
         * @param medicalCertificateFile The medical certificate file (optional).
         * @return ResponseEntity with success message or error.
         */
        @PostMapping(consumes = {"multipart/form-data"})
        public ResponseEntity<String> createLeaveRequest(
                @RequestPart("leaveRequest") LeaveRequest leaveRequest,
                @RequestPart(value = "medicalCertificateFile", required = false) MultipartFile medicalCertificateFile) {
    
            try {
                boolean success = leaveRequestService.submitLeaveRequest(leaveRequest, medicalCertificateFile);
                if (success) {
                    return ResponseEntity.status(HttpStatus.CREATED).body("Leave request created successfully.");
                } else {
                    return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Failed to create leave request.");
                }
            } catch (IllegalArgumentException | IOException e) {
                throw new ResponseStatusException(HttpStatus.BAD_REQUEST, e.getMessage(), e);
            }
        }
    
        /**
         * Endpoint to upload a medical certificate to an existing leave request.
         *
         * @param leaveRequestId         The ID of the leave request to update.
         * @param medicalCertificateFile The medical certificate file.
         * @return ResponseEntity with success message or error.
         */
        @PostMapping("/{leaveRequestId}/uploadMedicalCertificate")
        public ResponseEntity<String> uploadMedicalCertificate(
                @PathVariable String leaveRequestId,
                @RequestParam("medicalCertificateFile") MultipartFile medicalCertificateFile) {
    
            try {
                boolean success = leaveRequestService.uploadMedicalCertificate(leaveRequestId, medicalCertificateFile);
                if (success) {
                    return ResponseEntity.ok("Medical certificate uploaded successfully.");
                } else {
                    return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Failed to upload medical certificate.");
                }
            } catch (IllegalArgumentException | IOException | ExecutionException | InterruptedException e) {
                throw new ResponseStatusException(HttpStatus.BAD_REQUEST, e.getMessage(), e);
            }
        }
    
        /**
         * Endpoint to approve a leave request.
         *
         * @param leaveRequestId The ID of the leave request to approve.
         * @param adminId        The ID of the admin performing the action.
         * @return ResponseEntity with success message or error.
         */
        @PostMapping("/{leaveRequestId}/approve")
        public ResponseEntity<String> approveLeaveRequest(
                @PathVariable String leaveRequestId,
                @RequestParam("adminId") String adminId) {
    
            try {
                boolean success = leaveRequestService.approveLeaveRequest(leaveRequestId, adminId);
                if (success) {
                    return ResponseEntity.ok("Leave request approved successfully.");
                } else {
                    return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Failed to approve leave request.");
                }
            } catch (IllegalArgumentException | ExecutionException | InterruptedException e) {
                throw new ResponseStatusException(HttpStatus.BAD_REQUEST, e.getMessage(), e);
            }
        }
    
        /**
         * Endpoint to reject a leave request.
         *
         * @param leaveRequestId The ID of the leave request to reject.
         * @param adminId        The ID of the admin performing the action.
         * @return ResponseEntity with success message or error.
         */
        @PostMapping("/{leaveRequestId}/reject")
        public ResponseEntity<String> rejectLeaveRequest(
                @PathVariable String leaveRequestId,
                @RequestParam("adminId") String adminId) {
    
            try {
                boolean success = leaveRequestService.rejectLeaveRequest(leaveRequestId, adminId);
                if (success) {
                    return ResponseEntity.ok("Leave request rejected successfully.");
                } else {
                    return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Failed to reject leave request.");
                }
            } catch (IllegalArgumentException | ExecutionException | InterruptedException e) {
                throw new ResponseStatusException(HttpStatus.BAD_REQUEST, e.getMessage(), e);
            }
        }
    
        /**
         * Endpoint to retrieve all leave requests.
         *
         * @return List of leave requests.
         */
        @GetMapping
        public ResponseEntity<List<LeaveRequest>> getAllLeaveRequests() {
            List<LeaveRequest> leaveRequests = leaveRequestService.getLeaveRequestsBySupervisor(""); // Modify as needed
            return ResponseEntity.ok(leaveRequests);
        }
    
        /**
         * Endpoint to retrieve leave requests by worker ID.
         *
         * @param workerId The ID of the worker.
         * @return List of matching leave requests.
         */
        @GetMapping("/worker/{workerId}")
        public ResponseEntity<List<LeaveRequest>> getLeaveRequestsByWorker(@PathVariable String workerId) {
            try {
                List<LeaveRequest> leaveRequests = leaveRequestService.getLeaveRequestsByWorker(workerId);
                return ResponseEntity.ok(leaveRequests);
            } catch (ExecutionException | InterruptedException e) {
                throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, "Error retrieving leave requests.", e);
            }
        }
    
        /**
         * Endpoint to retrieve leave requests by supervisor ID.
         *
         * @param supervisorId The ID of the supervisor.
         * @return List of matching leave requests.
         */
        @GetMapping("/supervisor/{supervisorId}")
        public ResponseEntity<List<LeaveRequest>> getLeaveRequestsBySupervisor(@PathVariable String supervisorId) {
            try {
                List<LeaveRequest> leaveRequests = leaveRequestService.getLeaveRequestsBySupervisor(supervisorId);
                return ResponseEntity.ok(leaveRequests);
            } catch (ExecutionException | InterruptedException e) {
                throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, "Error retrieving leave requests.", e);
            }
        }
    
        /**
         * Endpoint to retrieve approved leave requests.
         *
         * @return List of approved leave requests.
         */
        @GetMapping("/approved")
        public ResponseEntity<List<LeaveRequest>> getApprovedLeaveRequests() {
            try {
                List<LeaveRequest> leaveRequests = leaveRequestService.getApprovedLeaveRequests();
                return ResponseEntity.ok(leaveRequests);
            } catch (ExecutionException | InterruptedException e) {
                throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, "Error retrieving approved leave requests.", e);
            }
        }
    
    }
    

    Key Points:

    • Creating a Leave Request: The createLeaveRequest endpoint accepts a multipart/form-data request where the leaveRequest is a JSON part and medicalCertificateFile is an optional file part.

    • Uploading Medical Certificate: The uploadMedicalCertificate endpoint updates an existing leave request with the uploaded image.

    • Approving/Rejecting Leave Requests: The approveLeaveRequest and rejectLeaveRequest endpoints update the status of a leave request.

    • Retrieving Leave Requests: Additional GET endpoints are provided to fetch leave requests based on different criteria.

    1.2.6. Dependencies and Configurations

    Ensure that you have the necessary dependencies in your pom.xml or build.gradle for Spring Boot, Firebase, and other required libraries.

    Example pom.xml Dependencies:

    <dependencies>
        <!-- Spring Boot Starter Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    
        <!-- Firebase Admin SDK -->
        <dependency>
            <groupId>com.google.firebase</groupId>
            <artifactId>firebase-admin</artifactId>
            <version>9.1.1</version>
        </dependency>
    
        <!-- Other dependencies -->
        <!-- ... -->
    </dependencies>
    

    Firebase Initialization:

    Ensure that Firebase is properly initialized in your application. Typically, you'd have a configuration class like the following:

    package com.g4t4.home_cleaning_scheduler.config;
    
    import com.google.auth.oauth2.GoogleCredentials;
    import com.google.firebase.FirebaseApp;
    import com.google.firebase.FirebaseOptions;
    
    import com.google.cloud.firestore.Firestore;
    import com.google.firebase.cloud.FirestoreClient;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import javax.annotation.PostConstruct;
    import java.io.FileInputStream;
    import java.io.IOException;
    
    @Configuration
    public class FirebaseConfig {
    
        @PostConstruct
        public void initializeFirebase() throws IOException {
            FileInputStream serviceAccount =
                    new FileInputStream("path/to/serviceAccountKey.json"); // Provide the path to your Firebase service account key
    
            FirebaseOptions options = FirebaseOptions.builder()
                    .setCredentials(GoogleCredentials.fromStream(serviceAccount))
                    .setStorageBucket("clean-affcc.appspot.com") // Replace with your Firebase Storage bucket
                    .build();
    
            if (FirebaseApp.getApps().isEmpty()) {
                FirebaseApp.initializeApp(options);
            }
        }
    
        @Bean
        public Firestore firestore() {
            return FirestoreClient.getFirestore();
        }
    }
    

    Note: Replace "path/to/serviceAccountKey.json" with the actual path to your Firebase service account JSON file and "clean-affcc.appspot.com" with your Firebase Storage bucket name.


    2. Front-End Interfaces

    We'll create two simple front-end interfaces using vanilla HTML, CSS, and JavaScript:

    1. Leave Request Interface: Allows users to create a leave request and upload a medical certificate image if applicable.

    2. Admin Interface: Allows admins to approve or reject leave requests.

    2.1. Leave Request Interface

    File: leave_request.html

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Leave Request</title>
        <style>
            body {
                font-family: Arial, sans-serif;
                background-color: #f2f2f2;
                padding: 20px;
            }
    
            .container {
                background-color: #fff;
                padding: 20px;
                border-radius: 5px;
                max-width: 500px;
                margin: auto;
                box-shadow: 0 0 10px rgba(0,0,0,0.1);
            }
    
            h2 {
                text-align: center;
            }
    
            label {
                display: block;
                margin-top: 10px;
            }
    
            input[type="text"],
            input[type="date"],
            select,
            input[type="file"] {
                width: 100%;
                padding: 8px;
                margin-top: 5px;
            }
    
            button {
                margin-top: 15px;
                padding: 10px;
                width: 100%;
                background-color: #4CAF50;
                border: none;
                color: #fff;
                cursor: pointer;
            }
    
            button:hover {
                background-color: #45a049;
            }
    
            #message {
                margin-top: 15px;
                text-align: center;
            }
        </style>
    </head>
    <body>
    
    <div class="container">
        <h2>Submit Leave Request</h2>
        <form id="leaveRequestForm">
            <label for="workerId">Worker ID:</label>
            <input type="text" id="workerId" name="workerId" required>
    
            <label for="leaveType">Leave Type:</label>
            <select id="leaveType" name="leaveType" required>
                <option value="">Select Leave Type</option>
                <option value="Annual">Annual</option>
                <option value="Medical">Medical</option>
                <option value="Casual">Casual</option>
            </select>
    
            <label for="leaveStartDate">Start Date:</label>
            <input type="date" id="leaveStartDate" name="leaveStartDate" required>
    
            <label for="leaveEndDate">End Date:</label>
            <input type="date" id="leaveEndDate" name="leaveEndDate" required>
    
            <label for="supervisorId">Supervisor ID:</label>
            <input type="text" id="supervisorId" name="supervisorId" required>
    
            <div id="medicalCertificateDiv" style="display: none;">
                <label for="medicalCertificateFile">Medical Certificate (Optional):</label>
                <input type="file" id="medicalCertificateFile" name="medicalCertificateFile" accept="image/*">
            </div>
    
            <button type="submit">Submit Request</button>
        </form>
    
        <div id="message"></div>
    
        <hr>
    
        <h2>Upload Medical Certificate to Existing Request</h2>
        <form id="uploadMedicalCertificateForm">
            <label for="existingLeaveRequestId">Leave Request ID:</label>
            <input type="text" id="existingLeaveRequestId" name="existingLeaveRequestId" required>
    
            <label for="uploadMedicalCertificateFile">Medical Certificate Image:</label>
            <input type="file" id="uploadMedicalCertificateFile" name="uploadMedicalCertificateFile" accept="image/*" required>
    
            <button type="submit">Upload Medical Certificate</button>
        </form>
    
        <div id="uploadMessage"></div>
    </div>
    
    <script>
        const leaveTypeSelect = document.getElementById('leaveType');
        const medicalCertificateDiv = document.getElementById('medicalCertificateDiv');
        const leaveRequestForm = document.getElementById('leaveRequestForm');
        const uploadMedicalCertificateForm = document.getElementById('uploadMedicalCertificateForm');
    
        leaveTypeSelect.addEventListener('change', function () {
            if (this.value === 'Medical') {
                medicalCertificateDiv.style.display = 'block';
            } else {
                medicalCertificateDiv.style.display = 'none';
            }
        });
    
        leaveRequestForm.addEventListener('submit', function (e) {
            e.preventDefault();
    
            const workerId = document.getElementById('workerId').value;
            const leaveType = document.getElementById('leaveType').value;
            const leaveStartDate = document.getElementById('leaveStartDate').value;
            const leaveEndDate = document.getElementById('leaveEndDate').value;
            const supervisorId = document.getElementById('supervisorId').value;
            const medicalCertificateFile = document.getElementById('medicalCertificateFile').files[0];
    
            const leaveRequest = {
                workerId: workerId,
                leaveType: leaveType,
                leaveStartDate: {
                    // Firestore expects Timestamp; we'll send date strings and let the backend handle it
                    // Alternatively, adjust the backend to parse date strings
                    _seconds: Math.floor(new Date(leaveStartDate).getTime() / 1000),
                    _nanoseconds: 0
                },
                leaveEndDate: {
                    _seconds: Math.floor(new Date(leaveEndDate).getTime() / 1000),
                    _nanoseconds: 0
                },
                supervisorId: supervisorId
                // leaveRequestId, dateOfApplication, status, medicalCertificateUrl will be handled by backend
            };
    
            const formData = new FormData();
            formData.append('leaveRequest', new Blob([JSON.stringify(leaveRequest)], { type: 'application/json' }));
            if (medicalCertificateFile) {
                formData.append('medicalCertificateFile', medicalCertificateFile);
            }
    
            fetch('/api/leaverequests', {
                method: 'POST',
                body: formData
            })
                .then(response => response.text())
                .then(data => {
                    document.getElementById('message').innerText = data;
                    leaveRequestForm.reset();
                    medicalCertificateDiv.style.display = 'none';
                })
                .catch(error => {
                    document.getElementById('message').innerText = 'Error: ' + error.message;
                });
        });
    
        uploadMedicalCertificateForm.addEventListener('submit', function (e) {
            e.preventDefault();
    
            const leaveRequestId = document.getElementById('existingLeaveRequestId').value;
            const medicalCertificateFile = document.getElementById('uploadMedicalCertificateFile').files[0];
    
            const formData = new FormData();
            formData.append('medicalCertificateFile', medicalCertificateFile);
    
            fetch(`/api/leaverequests/${leaveRequestId}/uploadMedicalCertificate`, {
                method: 'POST',
                body: formData
            })
                .then(response => response.text())
                .then(data => {
                    document.getElementById('uploadMessage').innerText = data;
                    uploadMedicalCertificateForm.reset();
                })
                .catch(error => {
                    document.getElementById('uploadMessage').innerText = 'Error: ' + error.message;
                });
        });
    </script>
    
    </body>
    </html>
    

    Explanation:

    • Leave Request Form: Allows users to submit a new leave request. If the Leave Type selected is Medical, an additional file input appears to upload a medical certificate.

    • Upload Medical Certificate Form: Allows users to upload a medical certificate to an existing leave request by providing the Leave Request ID.

    • JavaScript: Handles form submissions using the Fetch API. It sends multipart/form-data requests to the backend endpoints.

    2.2. Admin Interface

    File: admin_interface.html

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Admin - Approve/Reject Leave Requests</title>
        <style>
            body {
                font-family: Arial, sans-serif;
                background-color: #eef2f3;
                padding: 20px;
            }
    
            .container {
                background-color: #fff;
                padding: 20px;
                border-radius: 5px;
                max-width: 700px;
                margin: auto;
                box-shadow: 0 0 10px rgba(0,0,0,0.1);
            }
    
            h2 {
                text-align: center;
            }
    
            table {
                width: 100%;
                border-collapse: collapse;
                margin-top: 15px;
            }
    
            th, td {
                border: 1px solid #ddd;
                padding: 8px;
                text-align: center;
            }
    
            th {
                background-color: #4CAF50;
                color: white;
            }
    
            button {
                padding: 5px 10px;
                margin: 2px;
                border: none;
                border-radius: 3px;
                cursor: pointer;
                color: #fff;
            }
    
            .approve-btn {
                background-color: #4CAF50;
            }
    
            .reject-btn {
                background-color: #f44336;
            }
    
            #message {
                margin-top: 15px;
                text-align: center;
            }
    
            #refreshBtn {
                margin-top: 10px;
                padding: 8px 16px;
                background-color: #2196F3;
                border: none;
                color: #fff;
                cursor: pointer;
            }
    
            #refreshBtn:hover {
                background-color: #0b7dda;
            }
        </style>
    </head>
    <body>
    
    <div class="container">
        <h2>Approve or Reject Leave Requests</h2>
        <button id="refreshBtn">Refresh Requests</button>
        <table id="leaveRequestsTable">
            <thead>
                <tr>
                    <th>Leave Request ID</th>
                    <th>Worker ID</th>
                    <th>Leave Type</th>
                    <th>Start Date</th>
                    <th>End Date</th>
                    <th>Status</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <!-- Leave requests will be populated here -->
            </tbody>
        </table>
    
        <div id="message"></div>
    </div>
    
    <script>
        const leaveRequestsTableBody = document.querySelector('#leaveRequestsTable tbody');
        const messageDiv = document.getElementById('message');
        const refreshBtn = document.getElementById('refreshBtn');
    
        // Replace with the actual admin ID
        const adminId = prompt("Enter your Admin ID:");
    
        function fetchLeaveRequests() {
            fetch('/api/leaverequests/supervisor/' + adminId)
                .then(response => response.json())
                .then(data => {
                    populateTable(data);
                })
                .catch(error => {
                    messageDiv.innerText = 'Error fetching leave requests: ' + error.message;
                });
        }
    
        function populateTable(leaveRequests) {
            leaveRequestsTableBody.innerHTML = '';
            leaveRequests.forEach(request => {
                const tr = document.createElement('tr');
    
                tr.innerHTML = `
                    <td>${request.leaveRequestId}</td>
                    <td>${request.workerId}</td>
                    <td>${request.leaveType}</td>
                    <td>${convertTimestamp(request.leaveStartDate)}</td>
                    <td>${convertTimestamp(request.leaveEndDate)}</td>
                    <td>${request.status}</td>
                    <td>
                        <button class="approve-btn" data-id="${request.leaveRequestId}">Approve</button>
                        <button class="reject-btn" data-id="${request.leaveRequestId}">Reject</button>
                    </td>
                `;
    
                leaveRequestsTableBody.appendChild(tr);
            });
        }
    
        function convertTimestamp(timestamp) {
            const date = new Date(timestamp._seconds * 1000);
            return date.toLocaleDateString();
        }
    
        // Event delegation for approve and reject buttons
        leaveRequestsTableBody.addEventListener('click', function (e) {
            if (e.target.classList.contains('approve-btn')) {
                const leaveRequestId = e.target.getAttribute('data-id');
                handleApprove(leaveRequestId);
            }
    
            if (e.target.classList.contains('reject-btn')) {
                const leaveRequestId = e.target.getAttribute('data-id');
                handleReject(leaveRequestId);
            }
        });
    
        function handleApprove(leaveRequestId) {
            fetch(`/api/leaverequests/${leaveRequestId}/approve`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: new URLSearchParams({
                    adminId: adminId
                })
            })
                .then(response => response.text())
                .then(data => {
                    messageDiv.innerText = data;
                    fetchLeaveRequests();
                })
                .catch(error => {
                    messageDiv.innerText = 'Error approving request: ' + error.message;
                });
        }
    
        function handleReject(leaveRequestId) {
            fetch(`/api/leaverequests/${leaveRequestId}/reject`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: new URLSearchParams({
                    adminId: adminId
                })
            })
                .then(response => response.text())
                .then(data => {
                    messageDiv.innerText = data;
                    fetchLeaveRequests();
                })
                .catch(error => {
                    messageDiv.innerText = 'Error rejecting request: ' + error.message;
                });
        }
    
        refreshBtn.addEventListener('click', fetchLeaveRequests);
    
        // Initial fetch
        fetchLeaveRequests();
    </script>
    
    </body>
    </html>
    

    Explanation:

    • Admin Authentication: Upon loading the page, the admin is prompted to enter their Admin ID. This ID is used to fetch leave requests supervised by them.

    • Fetching Leave Requests: The fetchLeaveRequests function retrieves all leave requests associated with the admin's Supervisor ID.

    • Approve/Reject Actions: Each leave request has Approve and Reject buttons. Clicking these buttons sends a POST request to the respective endpoints to update the status.

    • Refresh Button: Allows the admin to manually refresh the list of leave requests.


    3. Testing Instructions

    To thoroughly test the leave request functionalities, follow these steps:

    3.1. Setting Up Backend

    1. Configure Firebase:

      • Ensure that Firebase is properly initialized with access to Firestore and Storage.
      • Replace "path/to/serviceAccountKey.json" and "clean-affcc.appspot.com" with your actual Firebase credentials and bucket name.
    2. Run the Spring Boot Application:

      • Ensure all dependencies are correctly set.
      • Start the application using your IDE or via the command line using mvn spring-boot:run or gradle bootRun.

    3.2. Testing Leave Request Creation

    1. Open the Leave Request Interface:

      • Open leave_request.html in your web browser.
    2. Fill in the Leave Request Form:

      • Worker ID: Enter a unique identifier for the worker (e.g., worker123).
      • Leave Type: Select Medical, Annual, or Casual.
      • Start Date: Choose a start date for the leave.
      • End Date: Choose an end date for the leave.
      • Supervisor ID: Enter the supervisor's ID (ensure it matches an existing supervisor in your system, e.g., supervisor456).
    3. Upload Medical Certificate (If Applicable):

      • If Leave Type is Medical, an additional file input appears. Upload an image file (e.g., .jpg, .png) as the medical certificate.
    4. Submit the Form:

      • Click on Submit Request.
      • A success message should appear if the request is created successfully.
    5. Verify in Firestore:

      • Check the leave_requests collection in Firestore to verify that the new leave request has been added with the correct details.

    3.3. Testing Medical Certificate Upload

    1. Obtain an Existing Leave Request ID:

      • From Firestore or the leave request creation step, note down the leaveRequestId of an existing leave request with leaveType set to Medical and without a medicalCertificateUrl.
    2. Open the Leave Request Interface:

      • Scroll down to the Upload Medical Certificate to Existing Request section in leave_request.html.
    3. Upload Medical Certificate:

      • Leave Request ID: Enter the obtained leaveRequestId.
      • Medical Certificate Image: Upload an image file.
    4. Submit the Form:

      • Click on Upload Medical Certificate.
      • A success message should appear if the image is uploaded and the leave request is updated.
    5. Verify in Firestore:

      • Check the corresponding LeaveRequest document to ensure that medicalCertificateUrl is updated with the uploaded image's URL.

    3.4. Testing Approve/Reject Functionality

    1. Open the Admin Interface:

      • Open admin_interface.html in your web browser.
    2. Enter Admin ID:

      • When prompted, enter the adminId that corresponds to the supervisorId of the leave requests you want to manage (e.g., supervisor456).
    3. View Leave Requests:

      • Click on Refresh Requests to fetch the latest leave requests supervised by the admin.
    4. Approve a Leave Request:

      • Click on the Approve button corresponding to a Pending leave request.
      • A success message should appear, and the status of the leave request should update to Approved.
    5. Reject a Leave Request:

      • Click on the Reject button corresponding to a Pending leave request.
      • A success message should appear, and the status of the leave request should update to Rejected.
    6. Verify in Firestore:

      • Check the leave_requests collection to ensure that the status field of the respective documents is updated accordingly.

    3.5. Additional Testing

    • Invalid Supervisor ID:

      • Attempt to approve/reject a leave request with an adminId that does not match the supervisorId of the request. An error should be returned.
    • Non-Medical Leave Request:

      • Try uploading a medical certificate to a leave request with leaveType other than Medical. An error should be returned.
    • Missing Fields:

      • Attempt to submit forms without filling in required fields to ensure validation errors are handled appropriately.

    Conclusion

    The provided backend and frontend code facilitate the creation, updating, and management of leave requests with the required functionalities:

    1. Updating Existing Documents: Ensures that existing LeaveRequest documents in Firestore are updated when uploading images or changing statuses, preventing the creation of duplicate documents.

    2. User Interface: Simple and intuitive interfaces for both workers to submit and update leave requests and for admins to manage these requests.

    3. Testing: Comprehensive instructions to test all functionalities, ensuring that the system works as expected.

    Ensure that all configurations, especially Firebase credentials and Firestore rules, are correctly set to allow the necessary read and write operations. Additionally, handle authentication and authorization in a production environment to secure the APIs effectively.

    If you encounter any issues or have further questions, feel free to ask!