@snapdragonsnursery/react-components 1.3.0 → 1.3.1

package/src/EmployeeSearchPage.jsx

@@ -0,0 +1,804 @@
+// Full page Employee Search component with TanStack table and shadcn styling
+// Provides a comprehensive search interface for employees with advanced filtering and pagination
+
+import React, { useState, useEffect, useCallback } from "react";
+import { useMsal } from "@azure/msal-react";
+import {
+  useReactTable,
+  getCoreRowModel,
+  getSortedRowModel,
+  flexRender,
+  createColumnHelper,
+} from "@tanstack/react-table";
+import { trackEvent } from "./telemetry";
+import { Button } from "./components/ui/button";
+import { Input } from "./components/ui/input";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "./components/ui/table";
+import {
+  Pagination,
+  PaginationContent,
+  PaginationEllipsis,
+  PaginationItem,
+  PaginationLink,
+  PaginationNext,
+  PaginationPrevious,
+} from "./components/ui/pagination";
+import {
+  CheckCircleIcon,
+  XCircleIcon,
+  ChevronUpIcon,
+  ChevronDownIcon,
+} from "@heroicons/react/24/outline";
+import { cn } from "./lib/utils";
+import EmployeeSearchFilters from "./components/EmployeeSearchFilters";
+
+const EmployeeSearchPage = ({
+  title = "Employee Search",
+  searchPlaceholder = "Search by name, employee ID, or email...",
+  siteId = null,
+  siteIds = null,
+  sites = null,
+  roles = null,
+  managers = null,
+  activeOnly = true,
+  status = null,
+  startDateFrom = null,
+  startDateTo = null,
+  endDateFrom = null,
+  endDateTo = null,
+  sortBy = "surname",
+  sortOrder = "asc",
+  applicationContext = "employee-search",
+  bypassPermissions = false,
+  onSelect = null, // Optional callback for when an employee is selected
+  multiSelect = false,
+  maxSelections = null,
+  selectedEmployees = [],
+  // Configurable filter visibility
+  showRoleFilter = true,
+  showManagerFilter = true,
+  showTermTimeFilter = true,
+  showMaternityFilter = true,
+  showStartDateFilter = true,
+  showEndDateFilter = true,
+  showDbsFilter = true,
+  showWorkingHoursFilter = true,
+}) => {
+  const [searchTerm, setSearchTerm] = useState("");
+  const [employees, setEmployees] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [pagination, setPagination] = useState({
+    page: 1,
+    pageSize: 20,
+    totalCount: 0,
+    totalPages: 0,
+    hasNextPage: false,
+    hasPreviousPage: false,
+  });
+  const [debouncedSearchTerm, setDebouncedSearchTerm] = useState("");
+  const [isAdvancedFiltersOpen, setIsAdvancedFiltersOpen] = useState(false);
+  const [advancedFilters, setAdvancedFilters] = useState({
+    status: status || (activeOnly ? "Active" : "all"),
+    selectedSiteId: siteId || "",
+    roleId: "",
+    managerId: "",
+    startDateFrom: startDateFrom || "",
+    startDateTo: startDateTo || "",
+    endDateFrom: endDateFrom || "",
+    endDateTo: endDateTo || "",
+    termTimeOnly: "",
+    onMaternityLeave: "",
+    dbsNumber: "",
+    minHoursPerWeek: "",
+    sortBy: sortBy,
+    sortOrder: sortOrder,
+  });
+
+  // Table sorting state
+  const [sorting, setSorting] = useState([]);
+  const [debouncedAdvancedFilters, setDebouncedAdvancedFilters] = useState(advancedFilters);
+
+  // State for multi-select mode
+  const [selectedEmployeesState, setSelectedEmployeesState] = useState(
+    selectedEmployees || []
+  );
+
+  const { instance, accounts } = useMsal();
+
+  // Column helper for TanStack table
+  const columnHelper = createColumnHelper();
+
+  // Helper function to create sortable header
+  const createSortableHeader = (column, label) => {
+    return ({ column: tableColumn }) => {
+      const isSorted = tableColumn.getIsSorted();
+      return (
+        <div
+          className="flex items-center space-x-1 cursor-pointer select-none"
+          onClick={tableColumn.getToggleSortingHandler()}
+        >
+          <span>{label}</span>
+          <div className="flex flex-col">
+            <ChevronUpIcon
+              className={cn(
+                "h-3 w-3 transition-colors",
+                isSorted === "asc" ? "text-blue-500" : "text-gray-400"
+              )}
+            />
+            <ChevronDownIcon
+              className={cn(
+                "h-3 w-3 transition-colors -mt-1",
+                isSorted === "desc" ? "text-blue-500" : "text-gray-400"
+              )}
+            />
+          </div>
+        </div>
+      );
+    };
+  };
+
+  // Define table columns
+  const columns = [
+    // Checkbox column for multi-select
+    ...(multiSelect
+      ? [
+          columnHelper.display({
+            id: "select",
+            header: ({ table }) => (
+              <input
+                type="checkbox"
+                checked={table.getIsAllPageRowsSelected()}
+                onChange={table.getToggleAllPageRowsSelectedHandler()}
+                className="rounded border-gray-300"
+              />
+            ),
+            cell: ({ row }) => (
+              <input
+                type="checkbox"
+                checked={row.getIsSelected()}
+                onChange={row.getToggleSelectedHandler()}
+                className="rounded border-gray-300"
+              />
+            ),
+            size: 50,
+          }),
+        ]
+      : []),
+    // Name column - sortable
+    columnHelper.accessor("full_name", {
+      header: createSortableHeader("full_name", "Name"),
+      cell: ({ row }) => (
+        <div>
+          <div className="font-medium">{row.original.full_name}</div>
+          <div className="text-sm text-gray-500">
+            ID: {row.original.employee_id}
+          </div>
+        </div>
+      ),
+    }),
+    // Site column - sortable
+    columnHelper.accessor("site_name", {
+      header: createSortableHeader("site_name", "Site"),
+      cell: ({ row }) => (
+        <span>{row.original.site_name}</span>
+      ),
+    }),
+    // Role column - sortable
+    columnHelper.accessor("role_name", {
+      header: createSortableHeader("role_name", "Role"),
+      cell: ({ row }) => (
+        <span>{row.original.role_name}</span>
+      ),
+    }),
+    // Email column
+    columnHelper.accessor("email", {
+      header: "Email",
+      cell: ({ row }) => (
+        <span className="text-sm">{row.original.email}</span>
+      ),
+    }),
+    // Start Date column - sortable
+    columnHelper.accessor("start_date", {
+      header: createSortableHeader("start_date", "Start Date"),
+      cell: ({ row }) => (
+        <span>
+          {row.original.start_date
+            ? new Date(row.original.start_date).toLocaleDateString("en-GB")
+            : "N/A"}
+        </span>
+      ),
+    }),
+    // Status column - sortable
+    columnHelper.accessor("employee_status", {
+      header: createSortableHeader("employee_status", "Status"),
+      cell: ({ row }) => {
+        const status = row.original.employee_status;
+        const statusColors = {
+          'Active': 'bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200',
+          'Inactive': 'bg-gray-100 text-gray-800 dark:bg-gray-900 dark:text-gray-200',
+          'On Leave': 'bg-yellow-100 text-yellow-800 dark:bg-yellow-900 dark:text-yellow-200',
+          'Terminated': 'bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-200',
+        };
+        
+        return (
+          <span
+            className={cn(
+              "px-2 py-1 text-xs rounded-full",
+              statusColors[status] || "bg-gray-100 text-gray-800 dark:bg-gray-900 dark:text-gray-200"
+            )}
+          >
+            {status || "Unknown"}
+          </span>
+        );
+      },
+    }),
+    // Working Hours column
+    columnHelper.accessor("total_hours_per_week", {
+      header: "Hours/Week",
+      cell: ({ row }) => (
+        <span>
+          {row.original.total_hours_per_week 
+            ? `${row.original.total_hours_per_week}h`
+            : "N/A"}
+        </span>
+      ),
+    }),
+    // Term Time Only column
+    columnHelper.accessor("term_time_only", {
+      header: "Term Time",
+      cell: ({ row }) => (
+        <span>
+          {row.original.term_time_only ? (
+            <CheckCircleIcon className="h-4 w-4 text-green-500" />
+          ) : (
+            <XCircleIcon className="h-4 w-4 text-gray-400" />
+          )}
+        </span>
+      ),
+    }),
+    // Maternity Leave column
+    columnHelper.accessor("on_maternity_leave", {
+      header: "Maternity",
+      cell: ({ row }) => (
+        <span>
+          {row.original.on_maternity_leave ? (
+            <CheckCircleIcon className="h-4 w-4 text-blue-500" />
+          ) : (
+            <XCircleIcon className="h-4 w-4 text-gray-400" />
+          )}
+        </span>
+      ),
+    }),
+  ];
+
+  // Create table instance
+  const table = useReactTable({
+    data: employees,
+    columns,
+    getCoreRowModel: getCoreRowModel(),
+    getSortedRowModel: getSortedRowModel(),
+    state: {
+      sorting,
+      rowSelection: selectedEmployeesState.reduce((acc, selectedEmployee) => {
+        const rowIndex = employees.findIndex(employee => employee.entra_id === selectedEmployee.entra_id);
+        if (rowIndex !== -1) {
+          acc[rowIndex] = true;
+        }
+        return acc;
+      }, {}),
+    },
+    onSortingChange: setSorting,
+    onRowSelectionChange: (updater) => {
+      const newSelection =
+        typeof updater === "function" ? updater({}) : updater;
+      const selectedRows = Object.keys(newSelection).map(
+        (index) => employees[parseInt(index)]
+      );
+      setSelectedEmployeesState(selectedRows);
+    },
+  });
+
+  // Debounce search term
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setDebouncedSearchTerm(searchTerm);
+      setPagination((prev) => ({ ...prev, page: 1 }));
+    }, 300);
+
+    return () => clearTimeout(timer);
+  }, [searchTerm]);
+
+  // Debounce advanced filters
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setDebouncedAdvancedFilters(advancedFilters);
+      setPagination((prev) => ({ ...prev, page: 1 }));
+    }, 500); // Slightly longer delay for filters
+
+    return () => clearTimeout(timer);
+  }, [advancedFilters]);
+
+  // Search employees
+  const searchEmployees = useCallback(async () => {
+    if (!instance || !accounts[0]) {
+      setError("Authentication required");
+      return;
+    }
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const functionKey = process.env.VITE_COMMON_API_FUNCTION_KEY || "";
+
+      const params = new URLSearchParams({
+        entra_id: accounts[0].localAccountId,
+        search_term: debouncedSearchTerm,
+        page: pagination.page,
+        page_size: pagination.pageSize,
+        application_context: applicationContext,
+        bypass_permissions: bypassPermissions.toString(),
+      });
+
+      // Handle site filtering
+      if (siteIds && siteIds.length > 0) {
+        params.append("site_ids", siteIds.join(","));
+      } else if (debouncedAdvancedFilters.selectedSiteId) {
+        params.append("site_id", debouncedAdvancedFilters.selectedSiteId.toString());
+      } else if (siteId) {
+        params.append("site_id", siteId.toString());
+      }
+
+      // Handle status filtering
+      if (debouncedAdvancedFilters.status && debouncedAdvancedFilters.status !== "all") {
+        params.append("status", debouncedAdvancedFilters.status);
+      } else if (activeOnly) {
+        params.append("active_only", "true");
+      }
+
+      // Add role filter
+      if (debouncedAdvancedFilters.roleId) {
+        params.append("role_id", debouncedAdvancedFilters.roleId);
+      }
+
+      // Add manager filter
+      if (debouncedAdvancedFilters.managerId) {
+        params.append("manager_id", debouncedAdvancedFilters.managerId);
+      }
+
+      // Add start date filters
+      if (debouncedAdvancedFilters.startDateFrom) {
+        params.append("start_date_from", debouncedAdvancedFilters.startDateFrom);
+      }
+      if (debouncedAdvancedFilters.startDateTo) {
+        params.append("start_date_to", debouncedAdvancedFilters.startDateTo);
+      }
+
+      // Add end date filters
+      if (debouncedAdvancedFilters.endDateFrom) {
+        params.append("end_date_from", debouncedAdvancedFilters.endDateFrom);
+      }
+      if (debouncedAdvancedFilters.endDateTo) {
+        params.append("end_date_to", debouncedAdvancedFilters.endDateTo);
+      }
+
+      // Add term time only filter
+      if (debouncedAdvancedFilters.termTimeOnly) {
+        params.append("term_time_only", debouncedAdvancedFilters.termTimeOnly);
+      }
+
+      // Add maternity leave filter
+      if (debouncedAdvancedFilters.onMaternityLeave) {
+        params.append("on_maternity_leave", debouncedAdvancedFilters.onMaternityLeave);
+      }
+
+      // Add DBS number filter
+      if (debouncedAdvancedFilters.dbsNumber) {
+        params.append("dbs_number", debouncedAdvancedFilters.dbsNumber);
+      }
+
+      // Add working hours filter
+      if (debouncedAdvancedFilters.minHoursPerWeek) {
+        params.append("min_hours_per_week", debouncedAdvancedFilters.minHoursPerWeek);
+      }
+
+      // Add sorting
+      params.append("sort_by", debouncedAdvancedFilters.sortBy);
+      params.append("sort_order", debouncedAdvancedFilters.sortOrder);
+
+      const apiResponse = await fetch(
+        `${
+          process.env.VITE_COMMON_API_BASE_URL ||
+          "https://snaps-common-api.azurewebsites.net"
+        }/api/search-employees?${params}`,
+        {
+          headers: {
+            "Content-Type": "application/json",
+            "x-functions-key": functionKey,
+          },
+        }
+      );
+
+      if (!apiResponse.ok) {
+        throw new Error(`API request failed: ${apiResponse.status}`);
+      }
+
+      const data = await apiResponse.json();
+
+      if (data.success) {
+        console.log("🔍 API Response:", {
+          employees: data.data.employees.length,
+          pagination: data.data.pagination,
+          totalCount: data.data.pagination.totalCount,
+          totalPages: data.data.pagination.totalPages
+        });
+        
+        setEmployees(data.data.employees);
+        setPagination(data.data.pagination);
+        trackEvent("employee_search_success", {
+          searchTerm: debouncedSearchTerm,
+          resultCount: data.data.employees.length,
+          totalCount: data.data.pagination.totalCount,
+        });
+      } else {
+        throw new Error(data.error || "Search failed");
+      }
+    } catch (err) {
+      console.error("Error searching employees:", err);
+      setError(err.message);
+      trackEvent("employee_search_error", {
+        error: err.message,
+        searchTerm: debouncedSearchTerm,
+      });
+    } finally {
+      setLoading(false);
+    }
+  }, [
+    instance,
+    accounts,
+    debouncedSearchTerm,
+    pagination.page,
+    pagination.pageSize,
+    siteId,
+    siteIds,
+    activeOnly,
+    debouncedAdvancedFilters,
+    applicationContext,
+    bypassPermissions,
+  ]);
+
+  // Track if component has mounted
+  const hasMounted = React.useRef(false);
+
+  // Search when debounced term changes or pagination changes
+  useEffect(() => {
+    if (instance && accounts[0] && hasMounted.current) {
+      searchEmployees();
+    }
+  }, [debouncedSearchTerm, pagination.page, instance, accounts]);
+
+  // Initial search on component mount
+  useEffect(() => {
+    if (instance && accounts[0]) {
+      hasMounted.current = true;
+      searchEmployees();
+    }
+  }, [instance, accounts]);
+
+  const handlePageChange = (newPage) => {
+    setPagination((prev) => ({ ...prev, page: newPage }));
+  };
+
+  const handleEmployeeSelect = (employee) => {
+    if (onSelect) {
+      if (multiSelect) {
+        const isAlreadySelected = selectedEmployeesState.some(
+          (selected) => selected.entra_id === employee.entra_id
+        );
+
+        if (isAlreadySelected) {
+          const updatedSelection = selectedEmployeesState.filter(
+            (selected) => selected.entra_id !== employee.entra_id
+          );
+          setSelectedEmployeesState(updatedSelection);
+          onSelect(updatedSelection);
+        } else {
+          if (maxSelections && selectedEmployeesState.length >= maxSelections) {
+            return;
+          }
+          const updatedSelection = [...selectedEmployeesState, employee];
+          setSelectedEmployeesState(updatedSelection);
+          onSelect(updatedSelection);
+        }
+      } else {
+        onSelect(employee);
+      }
+    }
+  };
+
+  const clearFilters = () => {
+    const clearedFilters = {
+      status: activeOnly ? "Active" : "all",
+      selectedSiteId: "",
+      roleId: "",
+      managerId: "",
+      startDateFrom: "",
+      startDateTo: "",
+      endDateFrom: "",
+      endDateTo: "",
+      termTimeOnly: "",
+      onMaternityLeave: "",
+      dbsNumber: "",
+      minHoursPerWeek: "",
+      sortBy: "surname",
+      sortOrder: "asc",
+    };
+    setAdvancedFilters(clearedFilters);
+    setDebouncedAdvancedFilters(clearedFilters); // Clear immediately
+  };
+
+  // Calculate pagination display values
+  const actualTotalCount = pagination.totalCount || employees.length;
+  const startItem = actualTotalCount > 0 ? (pagination.page - 1) * pagination.pageSize + 1 : 0;
+  const endItem = Math.min(pagination.page * pagination.pageSize, actualTotalCount);
+
+  return (
+    <div className="bg-gray-50 dark:bg-gray-900">
+      <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-8">
+        {/* Header */}
+        <div className="mb-8">
+          <h1 className="text-3xl font-bold text-gray-900 dark:text-white">
+            {title}
+          </h1>
+          {multiSelect && (
+            <div className="mt-4 flex items-center space-x-2" style={{ paddingBottom: '20px' }}>
+              <span className="px-3 py-1 text-sm bg-blue-100 text-blue-800 dark:bg-blue-900 dark:text-blue-200 rounded-full">
+                {selectedEmployeesState.length} selected
+                {maxSelections && ` / ${maxSelections}`}
+              </span>
+            </div>
+          )}
+        </div>
+
+        {/* Search Input */}
+        <div className="bg-white dark:bg-gray-800 rounded-lg shadow-sm border border-gray-200 dark:border-gray-700 mb-6">
+          <div className="p-6">
+            <div className="relative">
+              <Input
+                type="text"
+                placeholder={searchPlaceholder}
+                value={searchTerm}
+                onChange={(e) => setSearchTerm(e.target.value)}
+                className="pl-4"
+              />
+            </div>
+          </div>
+        </div>
+
+        {/* Advanced Filters */}
+        <EmployeeSearchFilters
+          filters={advancedFilters}
+          onFiltersChange={setAdvancedFilters}
+          onApplyFilters={setAdvancedFilters}
+          sites={sites}
+          roles={roles}
+          managers={managers}
+          activeOnly={activeOnly}
+          isAdvancedFiltersOpen={isAdvancedFiltersOpen}
+          onToggleAdvancedFilters={() => setIsAdvancedFiltersOpen(!isAdvancedFiltersOpen)}
+          onClearFilters={clearFilters}
+          showRoleFilter={showRoleFilter}
+          showManagerFilter={showManagerFilter}
+          showTermTimeFilter={showTermTimeFilter}
+          showMaternityFilter={showMaternityFilter}
+          showStartDateFilter={showStartDateFilter}
+          showEndDateFilter={showEndDateFilter}
+          showDbsFilter={showDbsFilter}
+          showWorkingHoursFilter={showWorkingHoursFilter}
+        />
+
+        {/* Results */}
+        <div className="bg-white dark:bg-gray-800 rounded-lg shadow-sm border border-gray-200 dark:border-gray-700">
+          {loading && (
+            <div className="flex items-center justify-center p-8" role="status" aria-label="Loading employees">
+              <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-500"></div>
+            </div>
+          )}
+
+          {error && (
+            <div className="p-6 text-center">
+              <div className="text-red-600 dark:text-red-400 bg-red-50 dark:bg-red-900/20 p-4 rounded-lg">
+                {error}
+              </div>
+            </div>
+          )}
+
+          {!loading && !error && (
+            <>
+              {/* Results Header */}
+              <div className="px-6 py-6 border-b border-gray-200 dark:border-gray-700" style={{ padding: '24px' }}>
+                <div className="flex items-center justify-between">
+                  <div className="text-sm text-gray-600 dark:text-gray-400">
+                    {(pagination.totalCount > 0 || employees.length > 0)
+                      ? `Showing ${startItem} to ${endItem} of ${actualTotalCount} employees`
+                      : "No employees found"}
+                  </div>
+                </div>
+              </div>
+
+              {/* Table */}
+              {employees.length > 0 ? (
+                <div className="overflow-x-auto mb-6">
+                  <Table>
+                    <TableHeader>
+                      {table.getHeaderGroups().map((headerGroup) => (
+                        <TableRow key={headerGroup.id}>
+                          {headerGroup.headers.map((header) => (
+                            <TableHead key={header.id}>
+                              {header.isPlaceholder
+                                ? null
+                                : flexRender(
+                                    header.column.columnDef.header,
+                                    header.getContext()
+                                  )}
+                            </TableHead>
+                          ))}
+                        </TableRow>
+                      ))}
+                    </TableHeader>
+                    <TableBody>
+                      {table.getRowModel().rows?.length ? (
+                        table.getRowModel().rows.map((row) => (
+                          <TableRow
+                            key={row.id}
+                            data-state={row.getIsSelected() && "selected"}
+                            onClick={() => handleEmployeeSelect(row.original)}
+                            className="cursor-pointer"
+                          >
+                            {row.getVisibleCells().map((cell) => (
+                              <TableCell key={cell.id}>
+                                {flexRender(
+                                  cell.column.columnDef.cell,
+                                  cell.getContext()
+                                )}
+                              </TableCell>
+                            ))}
+                          </TableRow>
+                        ))
+                      ) : (
+                        <TableRow>
+                          <TableCell
+                            colSpan={columns.length}
+                            className="h-24 text-center"
+                          >
+                            {debouncedSearchTerm
+                              ? "No employees found matching your search."
+                              : "Start typing to search for employees."}
+                          </TableCell>
+                        </TableRow>
+                      )}
+                    </TableBody>
+                  </Table>
+                </div>
+              ) : (
+                <div className="p-6 text-center text-gray-500 dark:text-gray-400 mb-6">
+                  {debouncedSearchTerm
+                    ? "No employees found matching your search."
+                    : "Start typing to search for employees."}
+                </div>
+              )}
+
+              {/* Pagination */}
+              {(pagination.totalCount > 0 || employees.length > 0) && (
+                <div className="px-6 py-8 border-t border-gray-200 dark:border-gray-700" style={{ padding: '32px 24px' }}>
+                  {/* Pagination Controls */}
+                  {(pagination.totalPages > 1 || employees.length > 0) && (
+                    <div className="flex justify-center">
+                      <Pagination>
+                        <PaginationContent>
+                          <PaginationItem>
+                            <PaginationPrevious 
+                              href="#"
+                              onClick={(e) => {
+                                e.preventDefault();
+                                if (pagination.hasPreviousPage) {
+                                  handlePageChange(pagination.page - 1);
+                                }
+                              }}
+                              className={cn(
+                                !pagination.hasPreviousPage &&
+                                  "pointer-events-none opacity-50"
+                              )}
+                            />
+                          </PaginationItem>
+
+                          {/* Page numbers */}
+                          {Array.from(
+                            { length: Math.max(pagination.totalPages, 1) },
+                            (_, i) => i + 1
+                          )
+                            .filter((page) => {
+                              const current = pagination.page;
+                              const total = Math.max(pagination.totalPages, 1);
+                              return (
+                                page === 1 ||
+                                page === total ||
+                                (page >= current - 1 && page <= current + 1)
+                              );
+                            })
+                            .map((page, index, array) => {
+                              if (index > 0 && array[index - 1] !== page - 1) {
+                                return (
+                                  <React.Fragment key={`ellipsis-${page}`}>
+                                    <PaginationItem>
+                                      <PaginationEllipsis />
+                                    </PaginationItem>
+                                    <PaginationItem>
+                                      <PaginationLink
+                                        href="#"
+                                        onClick={(e) => {
+                                          e.preventDefault();
+                                          handlePageChange(page);
+                                        }}
+                                        isActive={page === pagination.page}
+                                      >
+                                        {page}
+                                      </PaginationLink>
+                                    </PaginationItem>
+                                  </React.Fragment>
+                                );
+                              }
+                              return (
+                                <PaginationItem key={page}>
+                                  <PaginationLink
+                                    href="#"
+                                    onClick={(e) => {
+                                      e.preventDefault();
+                                      handlePageChange(page);
+                                    }}
+                                    isActive={page === pagination.page}
+                                  >
+                                    {page}
+                                  </PaginationLink>
+                                </PaginationItem>
+                              );
+                            })}
+
+                          <PaginationItem>
+                            <PaginationNext 
+                              href="#"
+                              onClick={(e) => {
+                                e.preventDefault();
+                                if (pagination.hasNextPage) {
+                                  handlePageChange(pagination.page + 1);
+                                }
+                              }}
+                              className={cn(
+                                !pagination.hasNextPage &&
+                                  "pointer-events-none opacity-50"
+                              )}
+                            />
+                          </PaginationItem>
+                        </PaginationContent>
+                      </Pagination>
+                    </div>
+                  )}
+                </div>
+              )}
+            </>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+};
+
+export default EmployeeSearchPage;