Merge pull request 'En-desarrollo' (#27) from En-desarrollo into main

Reviewed-on: #27
Reviewed-by: alex <alex@primefactorsolutions.com>

src/main/java/com/primefactorsolutions/model/BaseEntity.java

@@ -1,10 +1,6 @@
 package com.primefactorsolutions.model;
 
-import jakarta.persistence.GeneratedValue;
-import jakarta.persistence.GenerationType;
-import jakarta.persistence.Id;
-import jakarta.persistence.MappedSuperclass;
-import jakarta.persistence.Version;
+import jakarta.persistence.*;
 
 import java.util.UUID;
 

src/main/java/com/primefactorsolutions/model/Document.java

@@ -1,23 +1,23 @@
 package com.primefactorsolutions.model;
 
-import jakarta.annotation.Nullable;
-import jakarta.persistence.Entity;
-import jakarta.persistence.ManyToOne;
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import lombok.NoArgsConstructor;
+import jakarta.persistence.*;
+
+import lombok.*;
 
-@Entity
 @Data
+@Entity
 @AllArgsConstructor
 @NoArgsConstructor
 @EqualsAndHashCode(callSuper = true)
 public class Document extends BaseEntity {
-    @Nullable
-    private String description;
-    private String location;
+    private String fileName;
+    @Enumerated(EnumType.STRING)
     private DocumentType documentType;
     @ManyToOne
+    @JoinColumn(name = "employee_id", nullable = false)
     private Employee employee;
+    @Lob
+    @Column(columnDefinition = "BLOB")
+    private byte[] fileData;
+    private String creator;
 }

src/main/java/com/primefactorsolutions/model/DocumentType.java

@@ -1,7 +1,36 @@
 package com.primefactorsolutions.model;
 
 public enum DocumentType {
+    All,
     ID_CARD,
     PAY_STUB,
+    PAY_SLIPS,
+    EMPLOYMENT_CONTRACT,
+    WORK_CERTIFICATES,
+    NDA,
+    MEMORANDUMS,
+    CONTRACT_APPROVAL_MTEPS,
+    BACKGROUND_CHECK_CERTIFICATE,
+    PRE_EMPLOYMENT_EVALUATION,
+    INSURANCE_REGISTRATION_FORM,
+    INSURANCE_CANCELLATION_FORM,
+    PROFESSIONAL_DEGREE_1,
+    PROFESSIONAL_CERTIFICATE_1,
+    PROFESSIONAL_DEGREE_2,
+    PROFESSIONAL_CERTIFICATE_2,
+    PROFESSIONAL_DEGREE_3,
+    PROFESSIONAL_CERTIFICATE_3,
+    GENERAL_LABOR_REGULATIONS,
+    REMOTE_WORK_GUIDELINES,
+    SAFETY_REGULATIONS,
+    HUMAN_RESOURCES_GUIDELINES,
+    ADMINISTRATION_FUNCTIONS_MANUAL,
+    ENGINEERING_FUNCTIONS_MANUAL,
+    GENERAL_LABOR_LAW,
+    SUPREME_DECREE,
+    REGULATORY_RESOLUTION,
+    COMPLEMENTARY_REGULATION,
+    HEALTH_SAFETY_LAW,
+    INTERNSHIP_RULES,
     OTHER
 }

src/main/java/com/primefactorsolutions/repositories/DocumentRepository.java

@@ -0,0 +1,9 @@
+package com.primefactorsolutions.repositories;
+
+import com.primefactorsolutions.model.Document;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.UUID;
+
+public interface DocumentRepository  extends JpaRepository<Document, UUID> {
+}

src/main/java/com/primefactorsolutions/service/DocumentService.java

@@ -0,0 +1,78 @@
+package com.primefactorsolutions.service;
+
+import com.primefactorsolutions.model.Document;
+import com.primefactorsolutions.model.DocumentType;
+import com.primefactorsolutions.model.Employee;
+import com.primefactorsolutions.repositories.DocumentRepository;
+import lombok.AllArgsConstructor;
+import org.apache.commons.beanutils.BeanComparator;
+import org.springframework.stereotype.Service;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@Service
+@AllArgsConstructor
+public class DocumentService {
+    private final DocumentRepository documentRepository;
+
+    public void saveDocument(final Document newDocument) {
+        documentRepository.save(newDocument);
+    }
+
+    public void deleteDocument(final UUID id) {
+        documentRepository.deleteById(id);
+    }
+
+    public List<Document> getAllDocuments() {
+        return documentRepository.findAll();
+    }
+
+    public Document getDocument(final UUID id) {
+        Optional<Document> employee = documentRepository.findById(id);
+        return employee.orElse(null);
+    }
+
+    public List<Document> findDocuments(
+            final int start, final int pageSize, final String sortProperty, final boolean asc) {
+        List<Document> documents = documentRepository.findAll();
+
+        int end = Math.min(start + pageSize, documents.size());
+        documents.sort(new BeanComparator<>(sortProperty));
+
+        if (!asc) {
+            Collections.reverse(documents);
+        }
+
+        return documents.subList(start, end);
+    }
+
+    public List<Document> findDocuments(final int start, final int pageSize) {
+        List<Document> employees = documentRepository.findAll();
+
+        int end = Math.min(start + pageSize, employees.size());
+        return employees.subList(start, end);
+    }
+
+    public List<Document> findDocumentBy(final DocumentType documentType,
+                                         final Employee employee,
+                                         final int start,
+                                         final int pageSize) {
+        List<Document> documents = documentRepository.findAll();
+        if (documentType != null) {
+            documents = documents.stream()
+                    .filter(doc -> doc.getDocumentType().equals(documentType))
+                    .collect(Collectors.toList());
+        }
+        if (employee != null) {
+            documents = documents.stream()
+                    .filter(doc -> doc.getEmployee().equals(employee))
+                    .collect(Collectors.toList());
+        }
+        int end = Math.min(start + pageSize, documents.size());
+        return documents.subList(start, end);
+    }
+}

src/main/java/com/primefactorsolutions/service/EmployeeService.java

@@ -100,4 +100,8 @@ public class EmployeeService {
 
         ldapTemplate.modifyAttributes(buildDn(employee), new ModificationItem[] {item});
     }
+
+    public List<Employee> findAllEmployees() {
+        return employeeRepository.findAll();
+    }
 }

src/main/java/com/primefactorsolutions/views/DocumentView.java

@@ -0,0 +1,273 @@
+package com.primefactorsolutions.views;
+
+import com.primefactorsolutions.model.Document;
+import com.primefactorsolutions.model.DocumentType;
+import com.primefactorsolutions.model.Employee;
+import com.primefactorsolutions.service.DocumentService;
+import com.primefactorsolutions.service.EmployeeService;
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.button.Button;
+import com.vaadin.flow.component.combobox.ComboBox;
+import com.vaadin.flow.component.notification.Notification;
+import com.vaadin.flow.component.orderedlayout.HorizontalLayout;
+import com.vaadin.flow.component.textfield.TextField;
+import com.vaadin.flow.component.upload.Upload;
+import com.vaadin.flow.component.upload.receivers.MemoryBuffer;
+import com.vaadin.flow.router.*;
+import com.vaadin.flow.server.StreamRegistration;
+import com.vaadin.flow.server.StreamResource;
+import com.vaadin.flow.spring.annotation.SpringComponent;
+import elemental.json.Json;
+import elemental.json.JsonArray;
+import elemental.json.JsonObject;
+import jakarta.annotation.security.PermitAll;
+import org.springframework.context.annotation.Scope;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.vaadin.firitin.form.BeanValidationForm;
+import com.vaadin.flow.spring.security.AuthenticationContext;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.Base64;
+import java.util.List;
+import java.util.UUID;
+import java.io.InputStream;
+
+@SpringComponent
+@PermitAll
+@Scope("prototype")
+@PageTitle("Document")
+@Route(value = "/documents/:documentId?/:action?", layout = MainLayout.class)
+public class DocumentView extends BeanValidationForm<Document> implements HasUrlParameter<String> {
+    private final TextField fileName = new TextField("Document Name");
+    private final ComboBox<DocumentType> documentType = new ComboBox<>("Document Type");
+    private final ComboBox<Employee> employeeComboBox = new ComboBox<>("Employee");
+    private final MemoryBuffer buffer = new MemoryBuffer();
+    private final Upload uploadButton = new Upload(buffer);
+    private final DocumentService documentService;
+    private final EmployeeService employeeService;
+    private final AuthenticationContext authContext;
+    private boolean fileUploaded = false;
+    private Button saveButton;
+    private Button viewDocumentButton;
+
+
+    public DocumentView(final DocumentService documentService,
+                        final EmployeeService employeeService,
+                        final AuthenticationContext authContext) {
+        super(Document.class);
+        this.documentService = documentService;
+        this.employeeService = employeeService;
+        this.authContext = authContext;
+        initializeView();
+    }
+
+    private void initializeView() {
+        configureComponents();
+        configureUploadButton();
+    }
+
+    protected Button createSaveButton() {
+        saveButton = new Button("Save");
+        saveButton.addClickListener(event -> saveDocument());
+        return saveButton;
+    }
+
+    protected Button createCloseButton() {
+        Button closeButton = new Button("Close");
+        closeButton.addClickListener(event -> closeForm());
+        return closeButton;
+    }
+
+    protected Button createViewDocumentButton() {
+        viewDocumentButton = new Button("View Document");
+        viewDocumentButton.setEnabled(false);
+        viewDocumentButton.addClickListener(event -> viewDocument());
+        return viewDocumentButton;
+    }
+
+    private void setFileNameProperties() {
+        fileName.setWidthFull();
+    }
+
+    private void setDocumentTypeProperties() {
+        documentType.setItems(DocumentType.values());
+        documentType.setWidthFull();
+    }
+
+    private void setEmployeeComboBoxProperties() {
+        List<Employee> employees = employeeService.findAllEmployees();
+        employeeComboBox.setItems(employees);
+        employeeComboBox.setItemLabelGenerator(employee -> employee.getFirstName() + " " + employee.getLastName());
+        employeeComboBox.setWidthFull();
+    }
+
+    private void setDocumentCreator(final Document document) {
+        authContext.getAuthenticatedUser(UserDetails.class).ifPresent(user -> {
+            document.setCreator(user.getUsername());
+        });
+    }
+
+    private void setFieldsReadOnly(final boolean option) {
+        fileName.setReadOnly(option);
+        documentType.setReadOnly(option);
+        employeeComboBox.setReadOnly(option);
+    }
+
+    private void viewDocument() {
+        StreamResource resource;
+        try {
+            InputStream inputStream = buffer.getInputStream();
+            if (inputStream != null && inputStream.available() > 0) {
+                resource = new StreamResource(fileName.getValue(), () -> new ByteArrayInputStream(readFileData()));
+            } else {
+                byte[] fileData = getEntity().getFileData();
+                resource = new StreamResource(fileName.getValue(), () -> new ByteArrayInputStream(fileData));
+            }
+            resource.setContentType("application/pdf");
+            getUI().ifPresent(ui -> {
+                StreamRegistration registration = ui.getSession().getResourceRegistry().registerResource(resource);
+                ui.getPage().open(registration.getResourceUri().toString());
+            });
+        } catch (IOException e) {
+            Notification.show("Error reading file.");
+        }
+    }
+
+    private void navigateToDocumentsListView() {
+        getUI().ifPresent(ui -> ui.navigate(DocumentsListView.class));
+    }
+
+    private void saveDocument() {
+        if (isFormValid()) {
+            Document document = getEntity();
+            document.setFileName(fileName.getValue());
+            document.setDocumentType(documentType.getValue());
+            document.setEmployee(employeeComboBox.getValue());
+            document.setFileData(readFileData());
+            setDocumentCreator(document);
+
+            documentService.saveDocument(document);
+            Notification.show("File saved successfully.");
+            clearForm();
+        } else {
+            Notification.show("Save failed: Please complete all fields and upload a file.");
+        }
+    }
+
+    private void closeForm() {
+        navigateToDocumentsListView();
+    }
+
+    private boolean isFormValid() {
+        return !fileName.isEmpty()
+                && documentType.getValue() != null
+                && employeeComboBox.getValue() != null
+                && fileUploaded;
+    }
+
+    private void clearForm() {
+        fileName.clear();
+        documentType.clear();
+        employeeComboBox.clear();
+        fileUploaded = false;
+        uploadButton.getElement().setPropertyJson("files", Json.createArray());
+        viewDocumentButton.setEnabled(false);
+    }
+
+    private byte[] readFileData() {
+        try {
+            return buffer.getInputStream().readAllBytes();
+        } catch (IOException e) {
+            Notification.show("Error reading file data.");
+            return new byte[0];
+        }
+    }
+
+    private void preLoadFile(final Document document) {
+        JsonArray jsonArray = Json.createArray();
+        JsonObject jsonObject = Json.createObject();
+        jsonObject.put("name", document.getFileName());
+        jsonObject.put("progress", 100);
+        jsonObject.put("complete", true);
+        jsonObject.put("fileData", Base64.getEncoder().encodeToString(document.getFileData()));
+        jsonArray.set(0, jsonObject);
+        uploadButton.getElement().setPropertyJson("files", jsonArray);
+        fileUploaded = true;
+    }
+
+    private void updateSaveButtonState() {
+        boolean isModified = !fileName.getValue().equals(getEntity().getFileName())
+                || documentType.getValue() != getEntity().getDocumentType()
+                || employeeComboBox.getValue() != getEntity().getEmployee()
+                || fileUploaded;
+        saveButton.setEnabled(isModified);
+    }
+
+    private void configureComponents() {
+        setFileNameProperties();
+        setDocumentTypeProperties();
+        setEmployeeComboBoxProperties();
+        fileName.addValueChangeListener(e -> updateSaveButtonState());
+        documentType.addValueChangeListener(e -> updateSaveButtonState());
+        employeeComboBox.addValueChangeListener(e -> updateSaveButtonState());
+        uploadButton.addSucceededListener(e -> updateSaveButtonState());
+        uploadButton.getElement().addEventListener("file-remove", event -> updateSaveButtonState());
+    }
+
+    private void configureUploadButton() {
+        uploadButton.setMaxFiles(1);
+        uploadButton.setAcceptedFileTypes(".pdf");
+        uploadButton.addSucceededListener(event -> {
+            fileUploaded = true;
+            Notification.show("File uploaded successfully.");
+            viewDocumentButton.setEnabled(true);
+            updateSaveButtonState();
+        });
+        uploadButton.getElement().addEventListener("file-remove", event -> {
+            fileUploaded = false;
+            Notification.show("File removed.");
+            viewDocumentButton.setEnabled(false);
+            updateSaveButtonState();
+        });
+    }
+
+    private void configureViewOrEditAction(final String action, final String documentIdString) {
+        if ("edit".equals(action) && !documentIdString.isEmpty()) {
+            setFieldsReadOnly(false);
+            preLoadFile(getEntity());
+            viewDocumentButton.setEnabled(true);
+        } else if ("view".equals(action) && !documentIdString.isEmpty()) {
+            setFieldsReadOnly(true);
+            preLoadFile(getEntity());
+            saveButton.setEnabled(false);
+            viewDocumentButton.setEnabled(true);
+        }
+    }
+
+    @Override
+    public void setParameter(final BeforeEvent beforeEvent, final String action) {
+        final RouteParameters params = beforeEvent.getRouteParameters();
+        final String documentIdString = params.get("documentId").orElse(null);
+
+        if ("new".equals(action)) {
+            setEntityWithEnabledSave(new Document());
+        } else {
+            assert documentIdString != null;
+            UUID documentId = UUID.fromString(documentIdString);
+            Document document = documentService.getDocument(documentId);
+            setEntity(document);
+            employeeComboBox.setValue(document.getEmployee());
+            preLoadFile(document);
+            configureViewOrEditAction(action, documentIdString);
+        }
+    }
+
+    @Override
+    protected List<Component> getFormComponents() {
+        HorizontalLayout buttonLayout = new HorizontalLayout();
+        buttonLayout.add(uploadButton, createViewDocumentButton());
+        buttonLayout.setSpacing(true);
+        return List.of(fileName, documentType, employeeComboBox, buttonLayout, createCloseButton());
+    }
+}

src/main/java/com/primefactorsolutions/views/DocumentsListView.java

@@ -0,0 +1,205 @@
+package com.primefactorsolutions.views;
+
+import com.primefactorsolutions.model.Document;
+import com.primefactorsolutions.model.DocumentType;
+import com.primefactorsolutions.model.Employee;
+import com.primefactorsolutions.service.DocumentService;
+import com.primefactorsolutions.service.EmployeeService;
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.component.button.Button;
+import com.vaadin.flow.component.combobox.ComboBox;
+import com.vaadin.flow.component.grid.GridSortOrder;
+import com.vaadin.flow.component.html.Main;
+import com.vaadin.flow.component.html.Span;
+import com.vaadin.flow.data.provider.SortDirection;
+import com.vaadin.flow.router.PageTitle;
+import com.vaadin.flow.router.Route;
+import com.vaadin.flow.server.StreamRegistration;
+import com.vaadin.flow.server.StreamResource;
+import com.vaadin.flow.spring.annotation.SpringComponent;
+import jakarta.annotation.security.PermitAll;
+import org.springframework.context.annotation.Scope;
+import org.vaadin.firitin.components.grid.PagingGrid;
+
+import java.io.ByteArrayInputStream;
+import java.util.List;
+
+
+@SpringComponent
+@Scope("prototype")
+@PageTitle("Documents")
+@Route(value = "/documents", layout = MainLayout.class)
+@PermitAll
+public class DocumentsListView extends Main {
+
+    private final DocumentService documentService;
+    private final EmployeeService employeeService;
+    private final PagingGrid<Document> documentGrid = new PagingGrid<>(Document.class);
+    private ComboBox<Employee> employeeFilter;
+    private ComboBox<DocumentType> documentTypeFilter;
+
+    public DocumentsListView(final DocumentService documentService, final EmployeeService employeeService) {
+        this.documentService = documentService;
+        this.employeeService = employeeService;
+        initializeView();
+        updateDocumentGrid(null, null);
+    }
+
+    private void initializeView() {
+        configureDocumentGrid();
+        add(createActionButton("Add Document", this::navigateToAddDocumentView));
+        add(createDocumentTypeFilter());
+        add(createEmployeeFilter());
+        add(documentGrid);
+    }
+
+    private void configureDocumentGrid() {
+        documentGrid.setColumns("fileName", "documentType", "creator");
+        documentGrid.addComponentColumn(this::createEmployeeSpan).setHeader("Employee");
+        addActionColumns();
+        configurePagination();
+    }
+
+    private Span createEmployeeSpan(final Document document) {
+        Employee employee = document.getEmployee();
+        String employeeName = employee.getFirstName() + " " + employee.getLastName();
+        return new Span(employeeName);
+    }
+
+    private void addActionColumns() {
+        addDocumentActionColumn("View", this::navigateToDocumentView);
+        addDocumentActionColumn("Edit", this::navigateToEditDocumentView);
+        addDocumentActionColumn("Download", this::downloadDocument);
+    }
+
+    private void addDocumentActionColumn(final String label, final DocumentActionHandler handler) {
+        documentGrid.addComponentColumn(document -> createActionButton(label, () -> handler.handle(document)));
+    }
+
+    private Button createActionButton(final String label, final Runnable onClickAction) {
+        Button actionButton = new Button(label);
+        actionButton.addClickListener(event -> onClickAction.run());
+        return actionButton;
+    }
+
+    private ComboBox<DocumentType> createDocumentTypeFilter() {
+        documentTypeFilter = new ComboBox<>("Document Type");
+        documentTypeFilter.setItems(DocumentType.values());
+        documentTypeFilter.setValue(DocumentType.values()[0]);
+        documentTypeFilter.addValueChangeListener(event -> {
+            updateDocumentGrid(event.getValue(), employeeFilter.getValue());
+        });
+        return documentTypeFilter;
+    }
+
+    private ComboBox<Employee> createEmployeeFilter() {
+        employeeFilter = new ComboBox<>("Employee");
+        List<Employee> employees = employeeService.findAllEmployees();
+        employees.addFirst(createAllEmployeesOption());
+        employeeFilter.setItems(employees);
+        employeeFilter.setItemLabelGenerator(this::getEmployeeLabel);
+        employeeFilter.setValue(employees.getFirst());
+        employeeFilter.addValueChangeListener(event -> {
+            updateDocumentGrid(documentTypeFilter.getValue(), event.getValue());
+        });
+        return employeeFilter;
+    }
+
+    private Employee createAllEmployeesOption() {
+        Employee allEmployeesOption = new Employee();
+        allEmployeesOption.setFirstName("All");
+        return allEmployeesOption;
+    }
+
+    private String getEmployeeLabel(final Employee employee) {
+        return employee.getFirstName().equals("All") ? "All" : employee.getFirstName() + " " + employee.getLastName();
+    }
+
+    private void navigateToEditDocumentView(final Document document) {
+        navigateToDocumentView(document, "edit");
+    }
+
+    private void navigateToDocumentView(final Document document) {
+        navigateToDocumentView(document, "view");
+    }
+
+    private void navigateToDocumentView(final Document document, final String action) {
+        getUI().ifPresent(ui -> ui.navigate(DocumentView.class, document.getId().toString() + "/" + action));
+    }
+
+    private void navigateToAddDocumentView() {
+        getUI().ifPresent(ui -> ui.navigate(DocumentView.class, "new"));
+    }
+
+    private void configurePagination() {
+        documentGrid.setPaginationBarMode(PagingGrid.PaginationBarMode.BOTTOM);
+        documentGrid.setPageSize(5);
+    }
+
+    private void updateDocumentGrid(final DocumentType documentType, final Employee employee) {
+        DocumentType finalDocumentType = isValidDocumentType(documentType) ? documentType : null;
+        Employee finalEmployee = isValidEmployee(employee) ? employee : null;
+        documentGrid.setPagingDataProvider((page, pageSize) ->
+                (finalDocumentType == null && finalEmployee == null)
+                        ? fetchDocuments((int) page, pageSize)
+                        : fetchFilteredDocuments((int) page, pageSize, finalDocumentType, finalEmployee)
+        );
+        documentGrid.getDataProvider().refreshAll();
+    }
+
+    private boolean isValidDocumentType(final DocumentType documentType) {
+        return documentType != null && !"All".equals(documentType.name());
+    }
+
+    private boolean isValidEmployee(final Employee employee) {
+        return employee != null && !"All".equals(employee.getFirstName());
+    }
+
+    private List<Document> fetchFilteredDocuments(final int page,
+                                                  final int pageSize,
+                                                  final DocumentType documentType,
+                                                  final Employee employee) {
+        return documentService.findDocumentBy(documentType, employee, page, pageSize);
+    }
+
+    private List<Document> fetchDocuments(final int page, final int size) {
+        int startIndex = page * size;
+        return isSortOrderPresent()
+                ? fetchSortedDocuments(startIndex, size)
+                : documentService.findDocuments(startIndex, size);
+    }
+
+    private boolean isSortOrderPresent() {
+        return !documentGrid.getSortOrder().isEmpty();
+    }
+
+    private List<Document> fetchSortedDocuments(final int start, final int pageSize) {
+        GridSortOrder<Document> sortOrder = documentGrid.getSortOrder().getFirst();
+        return documentService.findDocuments(start, pageSize,
+                sortOrder.getSorted().getKey(),
+                sortOrder.getDirection() == SortDirection.ASCENDING);
+    }
+
+    private void downloadDocument(final Document document) {
+        StreamResource resource = createDocumentStreamResource(document);
+        getUI().ifPresent(ui -> openDocumentStream(resource, ui));
+    }
+
+    private StreamResource createDocumentStreamResource(final Document document) {
+        StreamResource resource = new StreamResource(document.getFileName(),
+                () -> new ByteArrayInputStream(document.getFileData()));
+        resource.setContentType("application/pdf");
+        resource.setHeader("Content-Disposition", "attachment; filename=\"" + document.getFileName() + ".pdf\"");
+        return resource;
+    }
+
+    private void openDocumentStream(final StreamResource resource, final UI ui) {
+        StreamRegistration registration = ui.getSession().getResourceRegistry().registerResource(resource);
+        ui.getPage().open(registration.getResourceUri().toString());
+    }
+
+    @FunctionalInterface
+    private interface DocumentActionHandler {
+        void handle(Document document);
+    }
+}

src/main/java/com/primefactorsolutions/views/DocumentsView.java

@@ -1,17 +0,0 @@
-package com.primefactorsolutions.views;
-
-import com.vaadin.flow.component.html.Main;
-import com.vaadin.flow.router.PageTitle;
-import com.vaadin.flow.router.Route;
-import com.vaadin.flow.spring.annotation.SpringComponent;
-import jakarta.annotation.security.PermitAll;
-import org.springframework.context.annotation.Scope;
-
-@SpringComponent
-@PermitAll
-@Scope("prototype")
-@PageTitle("Documents")
-@Route(value = "/documents/me", layout = MainLayout.class)
-public class DocumentsView extends Main {
-}
-

src/main/java/com/primefactorsolutions/views/EmployeesListView.java

@@ -47,12 +47,6 @@ public class EmployeesListView extends Main {
         setupPagingGrid();
     }
 
-    private void updateEmployeeStatus(final Employee employee, final boolean isActive) {
-        employee.setStatus(isActive ? Employee.Status.ACTIVE : Employee.Status.INACTIVE);
-        employeeService.createOrUpdate(employee);
-        refreshGrid();
-    }
-
     private void addEditButtonColumn(final String label, final ButtonClickHandler handler) {
         table.addComponentColumn(employee -> createButton(label, () -> handler.handle(employee)));
     }

src/main/java/com/primefactorsolutions/views/MainLayout.java

@@ -100,12 +100,10 @@ public class MainLayout extends AppLayout {
 
             SideNavItem admin = new SideNavItem("Admin", MainView.class,
                     LineAwesomeIcon.SUPERSCRIPT_SOLID.create());
-            admin.addItem(new SideNavItem("Requests", RequestsListView.class,
-                    LineAwesomeIcon.TASKS_SOLID.create()));
-            admin.addItem(new SideNavItem("Timesheets", TimesheestReportView.class,
-                    LineAwesomeIcon.HOURGLASS_END_SOLID.create()));
             admin.addItem(new SideNavItem("Employees", EmployeesListView.class,
                     LineAwesomeIcon.USER_EDIT_SOLID.create()));
+            admin.addItem(new SideNavItem("Documents", DocumentsListView.class,
+                    LineAwesomeIcon.FILE_ALT_SOLID.create()));
 
             SideNavItem timeOff = new SideNavItem("My Time-off", TimeoffView.class,
                     LineAwesomeIcon.PLANE_DEPARTURE_SOLID.create());
@@ -113,8 +111,6 @@ public class MainLayout extends AppLayout {
                     LineAwesomeIcon.HOURGLASS_START_SOLID.create());
             SideNavItem profile = new SideNavItem("My Profile", ProfileView.class,
                     LineAwesomeIcon.USER_EDIT_SOLID.create());
-            SideNavItem documents = new SideNavItem("My Documents", DocumentsView.class,
-                    LineAwesomeIcon.SUITCASE_SOLID.create());
 
             nav.addItem(new SideNavItem("Home", MainView.class, LineAwesomeIcon.HOME_SOLID.create()));
             nav.addItem(admin);