Construyendo y Desplegando una App de Recursos Humanos Usando Refine

Tutoriales
React

Introducción

En este tutorial, construiremos una aplicación de Gestión de Recursos Humanos con el Marco de Refine y la desplegaremos en la Plataforma de Aplicaciones de DigitalOcean.

Al final de este tutorial, tendremos una aplicación de gestión de recursos humanos que incluirá:

  • Página de inicio de sesión: Permite a los usuarios iniciar sesión como gerente o empleado. Los gerentes tienen acceso a las páginas de Días Libres y Solicitudes, mientras que los empleados solo tienen acceso a la página de Días Libres.
  • Páginas de Días Libres: Permite a los empleados solicitar, ver y cancelar sus días libres. Además, los gerentes pueden asignar nuevos días libres.
  • Página de Solicitudes: Accesible solo para los gerentes de Recursos Humanos para aprobar o rechazar las solicitudes de días libres.

Nota: Puedes obtener el código fuente completo de la aplicación que construiremos en este tutorial desde este repositorio de GitHub

Mientras hacemos esto, utilizaremos:

  • API REST: Para obtener y actualizar los datos. Refine tiene paquetes de proveedores de datos y API REST integrados, pero también puedes construir los tuyos para adaptarlos a tus requisitos específicos. En esta guía, vamos a utilizar NestJs CRUD como nuestro servicio backend y el paquete @refinedev/nestjsx-crud como nuestro proveedor de datos.
  • Material UI: Lo utilizaremos para los componentes de la interfaz de usuario y lo personalizaremos completamente según nuestro propio diseño. Refine tiene soporte integrado para Material UI, pero puedes utilizar cualquier biblioteca de interfaz de usuario que desees.

Una vez que hayamos construido la aplicación, la pondremos en línea utilizando la Plataforma de Aplicaciones de DigitalOcean, que facilita la configuración, el lanzamiento y el crecimiento de aplicaciones y sitios web estáticos. Puedes implementar código simplemente apuntando a un repositorio de GitHub y dejar que la Plataforma de Aplicaciones se encargue de la infraestructura, los tiempos de ejecución de la aplicación y las dependencias.

Requisitos previos

¿Qué es Refine?

Refine es un metaframework de React de código abierto para construir aplicaciones web B2B complejas, principalmente enfocado en casos de uso de gestión de datos como herramientas internas, paneles de administración y tableros. Está diseñado para proporcionar un conjunto de ganchos y componentes que mejoren el proceso de desarrollo con un mejor flujo de trabajo para el desarrollador.

Ofrece características completas y listas para producción para aplicaciones de nivel empresarial con el fin de simplificar tareas pagas como la gestión de estado y datos, la autenticación y el control de acceso. Esto permite a los desarrolladores mantenerse enfocados en el núcleo de su aplicación de una manera que está abstracta de muchos detalles de implementación abrumadores.

Paso 1: Configurar el Proyecto

Usaremos el comando npm create refine-app para inicializar el proyecto de forma interactiva.

npm create refine-app@latest

Selecciona las siguientes opciones cuando se te solicite:

✔ Choose a project template · Vite
✔ What would you like to name your project?: · hr-app
✔ Choose your backend service to connect: · nestjsx-crud
✔ Do you want to use a UI Framework?: · Material UI
✔ Do you want to add example pages?: · No
✔ Do you need any Authentication logic?: · None
✔ Choose a package manager: · npm

Una vez que la configuración esté completa, navega hasta la carpeta del proyecto y inicia tu aplicación con:

npm run dev

Abre http://localhost:5173 en tu navegador para ver la aplicación.

Preparando el Proyecto

Ahora que tenemos nuestro proyecto configurado, hagamos algunos cambios en la estructura del proyecto y eliminemos los archivos innecesarios.

Primero, instala las dependencias de terceros:

  • @mui/x-date-pickers, @mui/x-date-pickers-pro: Estos son componentes de selector de fecha para Material UI. Los usaremos para seleccionar el rango de fechas para las solicitudes de tiempo libre.
  • react-hot-toast: Una biblioteca de toasts minimalista para React. La usaremos para mostrar mensajes de éxito y error.
  • react-infinite-scroll-component: Un componente de React para facilitar el scroll infinito. Lo usaremos para cargar más solicitudes de tiempo libre a medida que el usuario hace scroll hacia abajo en la página para ver más solicitudes.
  • dayjs: Una biblioteca de fechas liviana para analizar, validar, manipular y formatear fechas.
  • vite-tsconfig-paths: Un plugin de Vite que te permite usar alias de rutas TypeScript en tu proyecto Vite.
npm install @mui/x-date-pickers @mui/x-date-pickers-pro dayjs react-hot-toast react-infinite-scroll-component

npm install --save-dev vite-tsconfig-paths

Después de instalar las dependencias, actualiza vite.config.ts y tsconfig.json para usar el plugin vite-tsconfig-paths. Esto habilita los alias de ruta de TypeScript en los proyectos de Vite, permitiendo importaciones con el alias @.

import react from "@vitejs/plugin-react";
import { defineConfig } from "vite";
import tsconfigPaths from "vite-tsconfig-paths";

// https://vitejs.dev/config/
export default defineConfig({
  plugins: [tsconfigPaths({ root: __dirname }), react()],
});

{
  "compilerOptions": {
    "target": "ESNext",
    "useDefineForClassFields": true,
    "lib": ["DOM", "DOM.Iterable", "ESNext"],
    "allowJs": false,
    "skipLibCheck": true,
    "esModuleInterop": false,
    "allowSyntheticDefaultImports": true,
    "strict": true,
    "forceConsistentCasingInFileNames": true,
    "module": "ESNext",
    "moduleResolution": "bundler",
    "resolveJsonModule": true,
    "isolatedModules": true,
    "noEmit": true,
    "jsx": "react-jsx",
    "baseUrl": "./src",
    "paths": {
      "@/*": ["./*"]
    }
  },
  "include": ["src"],
  "references": [{ "path": "./tsconfig.node.json" }]
}

A continuación, eliminemos los archivos y carpetas innecesarios:

  • src/contexts: Esta carpeta contiene un solo archivo que es ColorModeContext. Maneja el modo oscuro/claro para la aplicación. No lo usaremos en este tutorial.
  • src/components: Esta carpeta contiene el componente <Header />. Usaremos un componente de encabezado personalizado en este tutorial.
rm -rf src/contexts src/components

Después de eliminar los archivos y carpetas, App.tsx arroja un error que resolveremos en los próximos pasos.
A lo largo del tutorial, cubriremos la codificación de las páginas y componentes principales. Así que, obtén los archivos y carpetas necesarios del repositorio de GitHub. Con estos archivos, tendremos una estructura básica para nuestra aplicación de Gestión de Recursos Humanos.

  • íconos: Carpeta de íconos que contiene todos los íconos de la aplicación.
  • tipos:
  • utilidades:
    • constants.ts: Constantes de la aplicación.
    • axios.ts: Instancia de Axios para solicitudes API, gestionando tokens de acceso, tokens de refresco y errores.
    • init-dayjs.ts: Inicializa Day.js con los plugins requeridos.
  • proveedores:
    • access-control: Gestiona los permisos de usuario utilizando accessControlProvider; controla la visibilidad de la página de Requests según el rol del usuario.
    • auth-provider: Gestiona la autenticación con authProvider; asegura que todas las páginas estén protegidas y requieran inicio de sesión.
    • notification-provider: Muestra mensajes de éxito y error a través de react-hot-toast.
    • query-client: Cliente de consulta personalizado para un control y personalización completos.
    • theme-provider: Gestiona el tema de Material UI.
  • componentes:
    • layout: Componentes de diseño.
    • loading-overlay: Muestra una superposición de carga durante la obtención de datos.
    • input: Renderiza campos de entrada de formulario.
    • frame: Componente personalizado que añade bordes, títulos e íconos a secciones de la página.
    • modal: Componente de diálogo modal personalizado.

Después de copiar los archivos y carpetas, la estructura de archivos debería verse así:

└── 📁src
    └── 📁components
        └── 📁frame
        └── 📁input
        └── 📁layout
            └── 📁header
            └── 📁page-header
            └── 📁sider
        └── 📁loading-overlay
        └── 📁modal
    └── 📁icons
    └── 📁providers
        └── 📁access-control
        └── 📁auth-provider
        └── 📁notification-provider
        └── 📁query-client
        └── 📁theme-provider
    └── 📁types
    └── 📁utilities
    └── App.tsx
    └── index.tsx
    └── vite-env.d.ts

A continuación, actualiza el archivo App.tsx para incluir los proveedores y componentes necesarios.

src/App.tsx
import { Refine } from '@refinedev/core'
import { DevtoolsProvider, DevtoolsPanel } from '@refinedev/devtools'
import dataProvider from '@refinedev/nestjsx-crud'
import routerProvider, { UnsavedChangesNotifier, DocumentTitleHandler } from '@refinedev/react-router-v6'
import { BrowserRouter, Routes, Route, Outlet } from 'react-router-dom'
import { Toaster } from 'react-hot-toast'

import { Layout } from '@/components/layout'

import { ThemeProvider } from '@/providers/theme-provider'
import { authProvider } from '@/providers/auth-provider'
import { accessControlProvider } from '@/providers/access-control'
import { useNotificationProvider } from '@/providers/notification-provider'
import { queryClient } from '@/providers/query-client'

import { BASE_URL } from '@/utilities/constants'
import { axiosInstance } from '@/utilities/axios'

import { Role } from './types'

import '@/utilities/init-dayjs'

function App() {
  return (
    <BrowserRouter>
      <ThemeProvider>
        <DevtoolsProvider>
          <Refine
            authProvider={authProvider}
            routerProvider={routerProvider}
            dataProvider={dataProvider(BASE_URL, axiosInstance)}
            notificationProvider={useNotificationProvider}
            resources={[
              {
                name: 'employee',
                meta: {
                  scope: Role.EMPLOYEE,
                },
              },
              {
                name: 'manager',
                meta: {
                  scope: Role.MANAGER,
                },
              },
            ]}
            accessControlProvider={accessControlProvider}
            options={{
              reactQuery: {
                clientConfig: queryClient,
              },
              syncWithLocation: true,
              warnWhenUnsavedChanges: true,
              useNewQueryKeys: true,
            }}>
            <Routes>
              <Route
                element={
                  <Layout>
                    <Outlet />
                  </Layout>
                }>
                <Route index element={<h1>Hello World</h1>} />
              </Route>
            </Routes>
            <UnsavedChangesNotifier />
            <DocumentTitleHandler />
            <Toaster position='bottom-right' reverseOrder={false} />
            <DevtoolsPanel />
          </Refine>
        </DevtoolsProvider>
      </ThemeProvider>
    </BrowserRouter>
  )
}

export default App

Desglosemos los cambios importantes que hicimos en el archivo App.tsx:

  • <Refine />: El componente principal de @refinedev/core que envuelve toda la aplicación para proporcionar recuperación de datos, gestión de estado y otras características.
  • <DevtoolsProvider /> y <DevtoolsPanel />: Utilizados para depuración y propósitos de desarrollo.
  • <ThemeProvider />: Aplica una personalización del tema a través de la aplicación.
  • Inicializando Day.js: Para la manipulación de fechas y horas.
  • recursos: Un array que especifica las entidades de datos (empleado y gerente) que Refine obtendrá. Usamos recursos padre e hijo para organizar los datos y gestionar permisos. Cada recurso tiene un scope que define el rol del usuario, lo que controla el acceso a diferentes partes de la aplicación.
  • queryClient: Un cliente de consulta personalizado para un control y personalización completos de la obtención de datos.
  • syncWithLocation: Permite sincronizar el estado de la aplicación (filtros, ordenamientos, paginación, etc.) con la URL.
  • warnWhenUnsavedChanges: Muestra una advertencia cuando el usuario intenta navegar fuera de una página con cambios no guardados.
  • <Layout />: Un componente de diseño personalizado que envuelve el contenido de la aplicación. Contiene el encabezado, la barra lateral y el área de contenido principal. Explicaremos este componente en los siguientes pasos.

Ahora estamos listos para comenzar a construir la aplicación de gestión de recursos humanos.

Paso 2— Personalización y estilo

Examina más de cerca el theme-provider. Hemos personalizado en gran medida el tema de Material UI para que coincida con el diseño de la aplicación de gestión de recursos humanos, creando dos temas, uno para gerentes y otro para empleados, para diferenciarlos con diferentes colores.

Además, hemos añadido Inter como fuente personalizada para la aplicación. Para instalar, necesitas añadir la siguiente línea al archivo index.html:

<head>
  <meta charset="utf-8" />
  <link rel="icon" href="/favicon.ico" />

  <^>
  <link <^ />
  <^>
  href="https://fonts.googleapis.com/css2?family=Inter:ital,opsz,wght@0,14..32,100..900;1,14..32,100..900&display=swap"
    rel="stylesheet"   /> <^>

  <meta name="viewport" content="width=device-width, initial-scale=1" />
  <meta name="theme-color" content="#000000" />
  <meta
    name="description"
    content="refine | Build your React-based CRUD applications, without constraints."
  />
  <meta
    data-rh="true"
    property="og:image"
    content="https://refine.dev/img/refine_social.png"
  />
  <meta
    data-rh="true"
    name="twitter:image"
    content="https://refine.dev/img/refine_social.png"
  />
  <title>
    Refine - Build your React-based CRUD applications, without constraints.
  </title>
</head>

Inspección personalizada <Layout /> Componente

En el paso anterior, agregamos un componente de diseño personalizado a la aplicación. Normalmente, podríamos usar el diseño predeterminado del marco de trabajo de la interfaz de usuario, pero queremos mostrar cómo puedes personalizarlo.

El componente de diseño contiene el encabezado, la barra lateral y el área de contenido principal. Utiliza <ThemedLayoutV2 /> como base y lo personalizó para que coincida con el diseño de la aplicación de Gestión de RRHH.

<Sider />

La barra lateral contiene el logotipo de la aplicación y enlaces de navegación. En los dispositivos móviles, es una barra lateral colapsable que se abre cuando el usuario hace clic en el ícono de menú. Los enlaces de navegación se preparan con el useMenu hook de Refine y se renderizan según el rol del usuario con la ayuda del componente <CanAccess />.

<UserSelect />

Montado en la barra lateral, muestra el avatar y el nombre del usuario conectado. Al hacer clic, se abre un popover con los detalles del usuario y un botón de cierre de sesión. Los usuarios pueden cambiar entre diferentes roles seleccionando del menú desplegable. Este componente permite probar cambiando entre usuarios con diferentes roles.

<Header />

No renderiza nada en dispositivos de escritorio. En dispositivos móviles, muestra el logotipo de la aplicación y un ícono de menú para abrir la barra lateral. El encabezado es fijo y siempre visible en la parte superior de la página.

<PageHeader />

Esto muestra el título de la página y los botones de navegación. El título de la página se genera automáticamente con el useResource hook, que obtiene el nombre del recurso del contexto de Refine. Esto nos permite compartir el mismo estilo y diseño en toda la aplicación.

Paso 3 — Implementación de la Autenticación y Autorización

En este paso, implementaremos la lógica de autenticación y autorización para nuestra aplicación de Gestión de Recursos Humanos. Esto servirá como un gran ejemplo de control de acceso en aplicaciones empresariales.

Cuando los usuarios inicien sesión como gerentes, podrán ver las páginas de Tiempo Libre y Solicitudes. Si inician sesión como empleados, solo verán la página de Tiempo Libre. Los gerentes pueden aprobar o rechazar las solicitudes de tiempo libre en la página de Solicitudes.

Los empleados pueden solicitar tiempo libre y ver su historial en la página de Time Off. Para implementar esto, utilizaremos las funciones authProvider y accessControlProvider de Refine.

Autenticación

En Refine, la autenticación es manejada por el authProvider. Te permite definir la lógica de autenticación para tu aplicación. En el paso anterior, ya copiamos el authProvider del repositorio de GitHub y lo pasamos como una propiedad al componente <Refine />. Utilizaremos los siguientes hooks y componentes para controlar el comportamiento de nuestra aplicación según si el usuario ha iniciado sesión o no.

  • useLogin: Un hook que proporciona una función mutate para iniciar sesión en el usuario.
  • useLogout: Un hook que proporciona una función mutate para cerrar sesión en el usuario.
  • useIsAuthenticated: Un gancho que devuelve un booleano que indica si el usuario está autenticado.
  • <Authenticated />: Un componente que renderiza sus hijos solo si el usuario está autenticado.

Autorización

En Refine, la autorización se maneja mediante el accessControlProvider. Te permite definir roles y permisos de usuario, y controlar el acceso a diferentes partes de la aplicación según el rol del usuario. En el paso anterior, ya copiamos el accessControlProvider del repositorio de GitHub y se lo pasamos al componente <Refine /> como una propiedad. Veamos más de cerca el accessControlProvider para ver cómo funciona.

src/providers/access-control/index.ts

import type { AccessControlBindings } from "@refinedev/core";
import { Role } from "@/types";

export const accessControlProvider: AccessControlBindings = {
  options: {
    queryOptions: {
      keepPreviousData: true,
    },
    buttons: {
      hideIfUnauthorized: true,
    },
  },
  can: async ({ params, action }) => {
    const user = JSON.parse(localStorage.getItem("user") || "{}");
    if (!user) return { can: false };

    const scope = params?.resource?.meta?.scope;
    // si el recurso no tiene un alcance, no es accesible
    if (!scope) return { can: false };

    if (user.role === Role.MANAGER) {
      return {
        can: true,
      };
    }

    if (action === "manager") {
      return {
        can: user.role === Role.MANAGER,
      };
    }

    if (action === "employee") {
      return {
        can: user.role === Role.EMPLOYEE,
      };
    }

    // los usuarios solo pueden acceder a recursos si su rol coincide con el alcance del recurso
    return {
      can: user.role === scope,
    };
  },
};

En nuestra aplicación, tenemos dos roles: GERENTE y EMPLEADO.

Los gerentes tienen acceso a la página de Solicitudes, mientras que los empleados solo tienen acceso a la página de Días libres. El accessControlProvider verifica el rol del usuario y el alcance del recurso para determinar si el usuario puede acceder al recurso. Si el rol del usuario coincide con el alcance del recurso, puede acceder al recurso. De lo contrario, se le niega el acceso. Usaremos el useCan hook y el <CanAccess /> componente para controlar el comportamiento de nuestra aplicación en función del rol del usuario.

Configurando la Página de Inicio de Sesión

En el paso anterior, agregamos el authProvider al componente <Refine />. El authProvider es responsable de manejar la autenticación.

Primero, necesitamos obtener imágenes. Usaremos estas imágenes como imágenes de fondo para la página de inicio de sesión. Crea una nueva carpeta llamada images en la carpeta public y obtén las imágenes del repositorio de GitHub.

Después de obtener las imágenes, vamos a crear un nuevo archivo llamado index.tsx en la carpeta src/pages/login y agregar el siguiente código:

src/pages/login/index.tsx
import { useState } from "react";
import { useLogin } from "@refinedev/core";
import {
  Avatar,
  Box,
  Button,
  Divider,
  MenuItem,
  Select,
  Typography,
} from "@mui/material";
import { HrLogo } from "@/icons";

export const PageLogin = () => {
  const [selectedEmail, setSelectedEmail] = useState<string>(
    mockUsers.managers[0].email,
  );

  const { mutate: login } = useLogin();

  return (
    <Box
      sx={{
        position: "relative",
        background:
          "linear-gradient(180deg, #7DE8CD 0%, #C6ECD9 24.5%, #5CD6D6 100%)",
        display: "flex",
        flexDirection: "column",
        justifyContent: "center",
        alignItems: "center",
        height: "100dvh",
      }}
    >
      <Box
        sx={{
          zIndex: 2,
          background: "white",
          width: "328px",
          padding: "24px",
          borderRadius: "36px",
          display: "flex",
          flexDirection: "column",
          gap: "24px",
        }}
      >
        <Box
          sx={{
            display: "flex",
            flexDirection: "column",
            alignItems: "center",
            gap: "16px",
          }}
        >
          <HrLogo />
          <Typography variant="body1" fontWeight={600}>
            Welcome to RefineHR
          </Typography>
        </Box>

        <Divider />

        <Box sx={{ display: "flex", flexDirection: "column", gap: "8px" }}>
          <Typography variant="caption" color="text.secondary">
            Select user
          </Typography>
          <Select
            size="small"
            value={selectedEmail}
            sx={{
              height: "40px",
              borderRadius: "12px",

              "& .MuiOutlinedInput-notchedOutline": {
                borderWidth: "1px !important",
                borderColor: (theme) => `${theme.palette.divider} !important`,
              },
            }}
            MenuProps={{
              sx: {
                "& .MuiList-root": {
                  paddingBottom: "0px",
                },

                "& .MuiPaper-root": {
                  border: (theme) => `1px solid ${theme.palette.divider}`,
                  borderRadius: "12px",
                  boxShadow: "none",
                },
              },
            }}
          >
            <Typography
              variant="caption"
              textTransform="uppercase"
              color="text.secondary"
              sx={{
                paddingLeft: "12px",
                paddingBottom: "8px",
                display: "block",
              }}
            >
              Managers
            </Typography>
            {mockUsers.managers.map((user) => (
              <MenuItem
                key={user.email}
                value={user.email}
                onClick={() => setSelectedEmail(user.email)}
              >
                <Box sx={{ display: "flex", alignItems: "center", gap: "8px" }}>
                  <Avatar
                    src={user.avatarUrl}
                    alt={`${user.firstName} ${user.lastName}`}
                    sx={{ width: "24px", height: "24px" }}
                  />
                  <Typography
                    noWrap
                    variant="caption"
                    sx={{ display: "flex", alignItems: "center" }}
                  >
                    {`${user.firstName} ${user.lastName}`}
                  </Typography>
                </Box>
              </MenuItem>
            ))}

            <Divider />

            <Typography
              variant="caption"
              textTransform="uppercase"
              color="text.secondary"
              sx={{
                paddingLeft: "12px",
                paddingBottom: "8px",
                display: "block",
              }}
            >
              Employees
            </Typography>
            {mockUsers.employees.map((user) => (
              <MenuItem
                key={user.email}
                value={user.email}
                onClick={() => setSelectedEmail(user.email)}
              >
                <Box sx={{ display: "flex", alignItems: "center", gap: "8px" }}>
                  <Avatar
                    src={user.avatarUrl}
                    alt={`${user.firstName} ${user.lastName}`}
                    sx={{ width: "24px", height: "24px" }}
                  />
                  <Typography
                    noWrap
                    variant="caption"
                    sx={{ display: "flex", alignItems: "center" }}
                  >
                    {`${user.firstName} ${user.lastName}`}
                  </Typography>
                </Box>
              </MenuItem>
            ))}
          </Select>
        </Box>

        <Button
          variant="contained"
          sx={{
            borderRadius: "12px",
            height: "40px",
            width: "100%",
            color: "white",
            backgroundColor: (theme) => theme.palette.grey[900],
          }}
          onClick={() => {
            login({ email: selectedEmail });
          }}
        >
          Sign in
        </Button>
      </Box>

      <Box
        sx={{
          zIndex: 1,
          width: {
            xs: "240px",
            sm: "370px",
            md: "556px",
          },
          height: {
            xs: "352px",
            sm: "554px",
            md: "816px",
          },
          position: "absolute",
          left: "0px",
          bottom: "0px",
        }}
      >
        <img
          src="/images/login-left.png"
          alt="flowers"
          width="100%"
          height="100%"
        />
      </Box>
      <Box
        sx={{
          zIndex: 1,
          width: {
            xs: "320px",
            sm: "480px",
            md: "596px",
          },
          height: {
            xs: "312px",
            sm: "472px",
            md: "584px",
          },
          position: "absolute",
          right: "0px",
          top: "0px",
        }}
      >
        <img
          src="/images/login-right.png"
          alt="flowers"
          width="100%"
          height="100%"
        />
      </Box>
    </Box>
  );
};

const mockUsers = {
  managers: [
    {
      email: "[email protected]",
      firstName: "Michael",
      lastName: "Scott",
      avatarUrl:
        "https://refine-hr-example.s3.eu-west-1.amazonaws.com/avatars/Michael-Scott.png",
    },
    {
      avatarUrl:
        "https://refine-hr-example.s3.eu-west-1.amazonaws.com/avatars/Jim-Halpert.png",
      firstName: "Jim",
      lastName: "Halpert",
      email: "[email protected]",
    },
    {
      avatarUrl:
        "https://refine-hr-example.s3.eu-west-1.amazonaws.com/avatars/Toby-Flenderson.png",
      firstName: "Toby",
      lastName: "Flenderson",
      email: "[email protected]",
    },
  ],
  employees: [
    {
      avatarUrl:
        "https://refine-hr-example.s3.eu-west-1.amazonaws.com/avatars/Pam-Beesly.png",
      firstName: "Pam",
      lastName: "Beesly",
      email: "[email protected]",
    },
    {
      avatarUrl:
        "https://refine-hr-example.s3.eu-west-1.amazonaws.com/avatars/Andy-Bernard.png",
      firstName: "Andy",
      lastName: "Bernard",
      email: "[email protected]",
    },
    {
      avatarUrl:
        "https://refine-hr-example.s3.eu-west-1.amazonaws.com/avatars/Ryan-Howard.png",
      firstName: "Ryan",
      lastName: "Howard",
      email: "[email protected]",
    },
  ],
};

Para simplificar el proceso de autenticación, hemos creado un objeto mockUsers con dos arreglos: managers y employees. Cada arreglo contiene objetos de usuario predefinidos. Cuando un usuario selecciona un correo electrónico del menú desplegable y hace clic en el botón Iniciar sesión, se llama a la función login con el correo electrónico seleccionado. La función login es una función de mutación proporcionada por el hook useLogin de Refine. Llama a authProvider.login con el correo electrónico seleccionado.

A continuación, importemos el componente <PageLogin /> y actualicemos el archivo App.tsx con los cambios destacados.

src/App.tsx
import { Authenticated, Refine } from "@refinedev/core";
import { DevtoolsProvider, DevtoolsPanel } from "@refinedev/devtools";
import { ErrorComponent } from "@refinedev/mui";
import dataProvider from "@refinedev/nestjsx-crud";
import routerProvider, {
  UnsavedChangesNotifier,
  DocumentTitleHandler,
} from "@refinedev/react-router-v6";
import {
  BrowserRouter,
  Routes,
  Route,
  Outlet,
  Navigate,
} from "react-router-dom";
import { Toaster } from "react-hot-toast";

import { PageLogin } from "@/pages/login";

import { Layout } from "@/components/layout";

import { ThemeProvider } from "@/providers/theme-provider";
import { authProvider } from "@/providers/auth-provider";
import { accessControlProvider } from "@/providers/access-control";
import { useNotificationProvider } from "@/providers/notification-provider";
import { queryClient } from "@/providers/query-client";

import { BASE_URL } from "@/utilities/constants";
import { axiosInstance } from "@/utilities/axios";

import { Role } from './types'

import "@/utilities/init-dayjs";

function App() {
  return (
    <BrowserRouter>
      <ThemeProvider>
        <DevtoolsProvider>
          <Refine
            authProvider={authProvider}
            routerProvider={routerProvider}
            dataProvider={dataProvider(BASE_URL, axiosInstance)}
            notificationProvider={useNotificationProvider}
            resources={[
              {
                name: 'employee',
                meta: {
                  scope: Role.EMPLOYEE,
                },
              },
              {
                name: 'manager',
                meta: {
                  scope: Role.MANAGER,
                },
              },
            ]}
            accessControlProvider={accessControlProvider}
            options={{
              reactQuery: {
                clientConfig: queryClient,
              },
              syncWithLocation: true,
              warnWhenUnsavedChanges: true,
              useNewQueryKeys: true,
            }}
          >
            <Routes>
              <Route
                element={
                  <Authenticated
                    key="authenticated-routes"
                    redirectOnFail="/login"
                  >
                    <Layout>
                      <Outlet />
                    </Layout>
                  </Authenticated>
                }
              >
                <Route index element={<h1>Hello World</h1>} />
              </Route>

              <Route
                element={
                  <Authenticated key="auth-pages" fallback={<Outlet />}>
                    <Navigate to="/" />
                  </Authenticated>
                }
              >
                <Route path="/login" element={<PageLogin />} />
              </Route>

              <Route
                element={
                  <Authenticated key="catch-all">
                    <Layout>
                      <Outlet />
                    </Layout>
                  </Authenticated>
                }
              >
                <Route path="*" element={<ErrorComponent />} />
              </Route>
            </Routes>

            <UnsavedChangesNotifier />
            <DocumentTitleHandler />
            <Toaster position="bottom-right" reverseOrder={false} />
            <DevtoolsPanel />
          </Refine>
        </DevtoolsProvider>
      </ThemeProvider>
    </BrowserRouter>
  );
}

export default App;

En el archivo App.tsx actualizado, hemos añadido el componente <Authenticated /> de Refine. Este componente se utiliza para proteger rutas que requieren autenticación. Toma una prop key para identificar de manera única el componente, una prop fallback para renderizar cuando el usuario no está autenticado, y una prop redirectOnFail para redirigir al usuario a la ruta especificada cuando la autenticación falla. En el fondo, llama al método authProvider.check para verificar si el usuario está autenticado.

Veamos más de cerca lo que tenemos en key="auth-pages"

<Route
  element={
    <Authenticated key="auth-pages" fallback={<Outlet />}>
      <Navigate to="/" />
    </Authenticated>
  }
>
  <Route path="/login" element={<PageLogin />} />
</Route>

<Authenticated /> componente envuelve la ruta “/login” para verificar el estado de autenticación del usuario.

  • fallback={<Outlet />}: Si el usuario no está autenticado, renderiza la ruta anidada (es decir, muestra el componente <PageLogin />).
  • Children (<Navigate to="/" />): Si el usuario está autenticado, redirígelo a la página de inicio (/).

Veamos más de cerca lo que tenemos en key="catch-all"

<Route
  element={
    <Authenticated key="catch-all">
      <Layout>
        <Outlet />
      </Layout>
    </Authenticated>
  }
>
  <Route path="*" element={<ErrorComponent />} />
</Route>

<Authenticated /> componente envuelve la ruta path="*" para verificar el estado de autenticación del usuario. Esta ruta es una ruta de captura que renderiza el <ErrorComponent /> cuando el usuario está autenticado. Nos permite mostrar una página 404 cuando el usuario intenta acceder a una ruta inexistente.

Ahora, cuando ejecutes la aplicación y navegues a http://localhost:5173/login, deberías ver la página de inicio de sesión con el menú desplegable para seleccionar al usuario.

En este momento, la página “/” no está haciendo nada. En los próximos pasos implementaremos las páginas Time Off y Requests.

Paso 4 — Construyendo una Página de Tiempo Libre

Página de Lista de Tiempo Libre

En este paso, construiremos la página de Tiempo Libre. Los empleados pueden solicitar tiempo libre y ver su historial de tiempo libre. Los gerentes también pueden ver su historial, pero en lugar de solicitar tiempo libre, pueden asignárselo directamente a sí mismos. Haremos que esto funcione utilizando el accessControlProvider de Refine, el componente <CanAccess /> y el hook useCan.

<PageEmployeeTimeOffsList />

Antes de comenzar a construir la página de tiempo libre, necesitamos crear un par de componentes para mostrar el historial de tiempo libre, las solicitudes de tiempo libre pendientes y las estadísticas de los tiempos libres utilizados. Al final de este paso, utilizaremos estos componentes para construir la página de tiempo libre.

Construyendo el componente <TimeOffList /> para mostrar el historial de tiempo libre

Crea una nueva carpeta llamada time-offs en la carpeta src/components. Dentro de la carpeta time-offs, crea un nuevo archivo llamado list.tsx y agrega el siguiente código:

src/components/time-offs/list.tsx
import { useState } from "react";
import {
  type CrudFilters,
  type CrudSort,
  useDelete,
  useGetIdentity,
  useInfiniteList,
} from "@refinedev/core";
import {
  Box,
  Button,
  CircularProgress,
  IconButton,
  Popover,
  Typography,
} from "@mui/material";
import InfiniteScroll from "react-infinite-scroll-component";
import dayjs from "dayjs";
import { DateField } from "@refinedev/mui";
import { Frame } from "@/components/frame";
import { LoadingOverlay } from "@/components/loading-overlay";
import { red } from "@/providers/theme-provider/colors";
import {
  AnnualLeaveIcon,
  CasualLeaveIcon,
  DeleteIcon,
  NoTimeOffIcon,
  SickLeaveIcon,
  ThreeDotsIcon,
  PopoverTipIcon,
} from "@/icons";
import { type Employee, TimeOffStatus, type TimeOff } from "@/types";

const variantMap = {
  Annual: {
    label: "Annual Leave",
    iconColor: "primary.700",
    iconBgColor: "primary.50",
    icon: <AnnualLeaveIcon width={16} height={16} />,
  },
  Sick: {
    label: "Sick Leave",
    iconColor: "#C2410C",
    iconBgColor: "#FFF7ED",
    icon: <SickLeaveIcon width={16} height={16} />,
  },
  Casual: {
    label: "Casual Leave",
    iconColor: "grey.700",
    iconBgColor: "grey.50",
    icon: <CasualLeaveIcon width={16} height={16} />,
  },
} as const;

type Props = {
  type: "upcoming" | "history" | "inReview";
};

export const TimeOffList = (props: Props) => {
  const { data: employee } = useGetIdentity<Employee>();

  const { data, isLoading, hasNextPage, fetchNextPage } =
    useInfiniteList<TimeOff>({
      resource: "time-offs",
      sorters: sorters[props.type],
      filters: [
        ...filters[props.type],
        {
          field: "employeeId",
          operator: "eq",
          value: employee?.id,
        },
      ],
      queryOptions: {
        enabled: !!employee?.id,
      },
    });

  const timeOffHistory = data?.pages.flatMap((page) => page.data) || [];
  const hasData = isLoading || timeOffHistory.length !== 0;

  if (props.type === "inReview" && !hasData) {
    return null;
  }

  return (
    <Frame
      sx={(theme) => ({
        maxHeight: "362px",
        paddingBottom: 0,
        position: "relative",
        "&::after": {
          pointerEvents: "none",
          content: '""',
          position: "absolute",
          bottom: 0,
          left: "24px",
          right: "24px",
          width: "80%",
          height: "32px",
          background:
            "linear-gradient(180deg, rgba(255, 255, 255, 0), #FFFFFF)",
        },
        display: "flex",
        flexDirection: "column",
      })}
      sxChildren={{
        paddingRight: 0,
        paddingLeft: 0,
        flex: 1,
        overflow: "hidden",
      }}
      title={title[props.type]}
    >
      <LoadingOverlay loading={isLoading} sx={{ height: "100%" }}>
        {!hasData ? (
          <Box
            sx={{
              display: "flex",
              flexDirection: "column",
              alignItems: "center",
              justifyContent: "center",
              gap: "24px",
              height: "180px",
            }}
          >
            <NoTimeOffIcon />
            <Typography variant="body2" color="text.secondary">
              {props.type === "history"
                ? "No time off used yet."
                : "No upcoming time offs scheduled."}
            </Typography>
          </Box>
        ) : (
          <Box
            id="scrollableDiv-timeOffHistory"
            sx={(theme) => ({
              maxHeight: "312px",
              height: "auto",
              [theme.breakpoints.up("lg")]: {
                height: "312px",
              },
              overflow: "auto",
              paddingLeft: "12px",
              paddingRight: "12px",
            })}
          >
            <InfiniteScroll
              dataLength={timeOffHistory.length}
              next={() => fetchNextPage()}
              hasMore={hasNextPage || false}
              endMessage={
                !isLoading &&
                hasData && (
                  <Box
                    sx={{
                      pt: timeOffHistory.length > 3 ? "40px" : "16px",
                    }}
                  />
                )
              }
              scrollableTarget="scrollableDiv-timeOffHistory"
              loader={
                <Box
                  sx={{
                    display: "flex",
                    alignItems: "center",
                    justifyContent: "center",
                    width: "100%",
                    height: "100px",
                  }}
                >
                  <CircularProgress size={24} />
                </Box>
              }
            >
              <Box
                sx={{
                  display: "flex",
                  flexDirection: "column",
                  gap: "12px",
                }}
              >
                {timeOffHistory.map((timeOff) => {
                  return (
                    <ListItem
                      timeOff={timeOff}
                      key={timeOff.id}
                      type={props.type}
                    />
                  );
                })}
              </Box>
            </InfiniteScroll>
          </Box>
        )}
      </LoadingOverlay>
    </Frame>
  );
};

const ListItem = ({
  timeOff,
  type,
}: { timeOff: TimeOff; type: Props["type"] }) => {
  const { mutateAsync: timeOffCancel } = useDelete<TimeOff>();

  const [anchorEl, setAnchorEl] = useState<HTMLButtonElement | null>(null);
  const [hovered, setHovered] = useState(false);

  const diffrenceOfDays =
    dayjs(timeOff.endsAt).diff(dayjs(timeOff.startsAt), "day") + 1;

  const isSameDay = dayjs(timeOff.startsAt).isSame(
    dayjs(timeOff.endsAt),
    "day",
  );

  return (
    <Box
      key={timeOff.id}
      onMouseEnter={() => setHovered(true)}
      onMouseLeave={() => setHovered(false)}
      sx={{
        display: "flex",
        alignItems: "center",
        gap: "16px",
        height: "64px",
        paddingLeft: "12px",
        paddingRight: "12px",
        borderRadius: "64px",
        backgroundColor: hovered ? "grey.50" : "transparent",
        transition: "background-color 0.2s",
      }}
    >
      <Box
        sx={{
          display: "flex",
          alignItems: "center",
          justifyContent: "center",
          color: variantMap[timeOff.timeOffType].iconColor,
          backgroundColor: variantMap[timeOff.timeOffType].iconBgColor,
          width: "40px",
          height: "40px",
          borderRadius: "100%",
        }}
      >
        {variantMap[timeOff.timeOffType].icon}
      </Box>
      <Box
        sx={{
          display: "flex",
          flexDirection: "column",
          gap: "4px",
        }}
      >
        <Box
          sx={{
            display: "flex",
            alignItems: "center",
            gap: "4px",
          }}
        >
          {isSameDay ? (
            <DateField
              value={timeOff.startsAt}
              color="text.secondary"
              variant="caption"
              format="MMMM DD"
            />
          ) : (
            <>
              <DateField
                value={timeOff.startsAt}
                color="text.secondary"
                variant="caption"
                format="MMMM DD"
              />
              <Typography variant="caption" color="text.secondary">
                -
              </Typography>
              <DateField
                value={timeOff.endsAt}
                color="text.secondary"
                variant="caption"
                format="MMMM DD"
              />
            </>
          )}
        </Box>
        <Typography variant="body2">
          <span
            style={{
              fontWeight: 500,
            }}
          >
            {diffrenceOfDays} {diffrenceOfDays > 1 ? "days" : "day"} of{" "}
          </span>
          {variantMap[timeOff.timeOffType].label}
        </Typography>
      </Box>

      {hovered && (type === "inReview" || type === "upcoming") && (
        <IconButton
          onClick={(e) => setAnchorEl(e.currentTarget)}
          sx={{
            display: "flex",
            alignItems: "center",
            justifyContent: "center",
            width: "40px",
            height: "40px",
            marginLeft: "auto",
            backgroundColor: "white",
            borderRadius: "100%",
            color: "grey.400",
            border: (theme) => `1px solid ${theme.palette.grey[400]}`,
            flexShrink: 0,
          }}
        >
          <ThreeDotsIcon />
        </IconButton>
      )}

      <Popover
        id={timeOff.id.toString()}
        open={Boolean(anchorEl)}
        anchorEl={anchorEl}
        onClose={() => {
          setAnchorEl(null);
          setHovered(false);
        }}
        anchorOrigin={{
          vertical: "bottom",
          horizontal: "center",
        }}
        transformOrigin={{
          vertical: "top",
          horizontal: "center",
        }}
        sx={{
          "& .MuiPaper-root": {
            overflow: "visible",
            borderRadius: "12px",
            border: (theme) => `1px solid ${theme.palette.grey[400]}`,
            boxShadow: "0px 0px 0px 4px rgba(222, 229, 237, 0.25)",
          },
        }}
      >
        <Button
          variant="text"
          onClick={async () => {
            await timeOffCancel({
              resource: "time-offs",
              id: timeOff.id,
              invalidates: ["all"],
              successNotification: () => {
                return {
                  type: "success",
                  message: "Time off request cancelled successfully.",
                };
              },
            });
          }}
          sx={{
            position: "relative",
            width: "200px",
            height: "56px",
            paddingLeft: "16px",
            color: red[900],
            display: "flex",
            gap: "12px",
            justifyContent: "flex-start",
            "&:hover": {
              backgroundColor: "transparent",
            },
          }}
        >
          <DeleteIcon />
          <Typography variant="body2">Cancel Request</Typography>

          <Box
            sx={{
              width: "40px",
              height: "16px",
              position: "absolute",
              top: "-2px",
              left: "calc(50% - 1px)",
              transform: "translate(-50%, -50%)",
            }}
          >
            <PopoverTipIcon />
          </Box>
        </Button>
      </Popover>
    </Box>
  );
};

const today = dayjs().toISOString();

const title: Record<Props["type"], string> = {
  history: "Time Off History",
  upcoming: "Upcoming Time Off",
  inReview: "In Review",
};

const filters: Record<Props["type"], CrudFilters> = {
  history: [
    {
      field: "status",
      operator: "eq",
      value: TimeOffStatus.APPROVED,
    },
    {
      field: "endsAt",
      operator: "lt",
      value: today,
    },
  ],
  upcoming: [
    {
      field: "status",
      operator: "eq",
      value: TimeOffStatus.APPROVED,
    },
    {
      field: "endsAt",
      operator: "gte",
      value: today,
    },
  ],
  inReview: [
    {
      field: "status",
      operator: "eq",
      value: TimeOffStatus.PENDING,
    },
  ],
};

const sorters: Record<Props["type"], CrudSort[]> = {
  history: [{ field: "startsAt", order: "desc" }],
  upcoming: [{ field: "endsAt", order: "asc" }],
  inReview: [{ field: "startsAt", order: "asc" }],
};

El archivo list.tsx es extenso, pero la mayor parte trata sobre estilos y presentación de la interfaz de usuario.

<TimeOffList />

Utilizaremos este componente <TimeOffList /> en tres contextos diferentes:

  <TimeOffList type="inReview" />
  <TimeOffList type="upcoming" />
  <TimeOffList type="history" />

La propiedad type determina qué tipo de lista de tiempo libre mostrar:

  • inReview: Muestra las solicitudes de tiempo libre que están pendientes de aprobación.
  • upcoming: Muestra los próximos tiempos libres que han sido aprobados pero aún no han ocurrido.
  • history: Enumera los tiempos libres que han sido aprobados y que ya han tenido lugar.

Dentro del componente, crearemos filtros y ordenadores basados en la propiedad type. Utilizaremos estos filtros y ordenadores para obtener los datos de tiempo libre de la API.

Vamos a analizar las partes clave del componente:

1. Obteniendo el Usuario Actual
const { data: employee } = useGetIdentity<Employee>();
  • useGetIdentity<Employee>(): Obtiene la información del usuario actual.
    • Utilizamos el ID del empleado para filtrar los tiempos libres, de manera que cada usuario vea solo sus solicitudes.
2. Obteniendo los Datos de Tiempo Libre con Desplazamiento Infinito
const { data, isLoading, hasNextPage, fetchNextPage } =
  useInfiniteList <
  TimeOff >
  {
    resource: "time-offs",
    sorters: sorters[props.type],
    filters: [
      ...filters[props.type],
      { field: "employeeId", operator: "eq", value: employee?.id },
    ],
    queryOptions: { enabled: !!employee?.id },
  };

// ...

<InfiniteScroll
  dataLength={timeOffHistory.length}
  next={() => fetchNextPage()}
  hasMore={hasNextPage || false}
  // ... otras props
>
  {/* Renderizar los elementos de la lista aquí */}
</InfiniteScroll>;

  • useInfiniteList<TimeOff>(): Obtiene datos de tiempo libre con desplazamiento infinito.

    • resource: Especifica el punto final de la API.
    • sorters y filters: Ajustados según type para obtener los datos correctos.
    • employeeId filtro: Asegura que solo se obtengan los tiempos libres del usuario actual.
    • queryOptions.enabled: Ejecuta la consulta solo cuando los datos del empleado están disponibles.

  • <InfiniteScroll />: Permite cargar más datos a medida que el usuario desplaza hacia abajo.

    • next: Función para obtener la siguiente página de datos.
    • hasMore: Indica si hay más datos disponibles.
3. Cancelar una solicitud de tiempo libre
const { mutateAsync: timeOffCancel } = useDelete<TimeOff>();

// Dentro del componente ListItem
await timeOffCancel({
  resource: "time-offs",
  id: timeOff.id,
  invalidates: ["all"],
  successNotification: () => ({
    type: "success",
    message: "Time off request cancelled successfully.",
  }),
});
  • useDelete: Proporciona la función timeOffCancel para eliminar una solicitud de tiempo libre.
    • Se utiliza cuando un usuario cancela su tiempo libre.
    • Muestra un mensaje de éxito al completarse.
4. Mostrando fechas con <DateField />
<DateField
  value={timeOff.startsAt}
  color="text.secondary"
  variant="caption"
  format="MMMM DD"
/>
  • <DateField />: Formatea y muestra fechas de manera amigable para el usuario.
    • value: La fecha a mostrar.
    • format: Especifica el formato de la fecha (por ejemplo, “5 de enero”).
5. Creando Filtros y Ordenadores basados en type

Filtros:

const filters: Record<Props["type"], CrudFilters> = {
  history: [
    {
      field: "status",
      operator: "eq",
      value: TimeOffStatus.APPROVED,
    },
    {
      field: "endsAt",
      operator: "lt",
      value: today,
    },
  ],
  // ... otros tipos
};
  • Define criterios para obtener ausencias basadas en estado y fechas.
    • history: Obtiene ausencias aprobadas que ya han finalizado.
    • upcoming: Obtiene ausencias aprobadas que están por venir.

Ordenadores:

const sorters: Record<Props["type"], CrudSort[]> = {
  history: [{ field: "startsAt", order: "desc" }],
  // ... otros tipos
};
  • Determina el orden de los datos obtenidos.
    • history: Ordena por fecha de inicio en orden descendente.

Construyendo el componente <TimeOffLeaveCards /> para mostrar estadísticas de las ausencias utilizadas.

Crea un nuevo archivo llamado leave-cards.tsx en la carpeta src/components/time-offs y añade el siguiente código:

src/components/time-offs/leave-cards.tsx

import { useGetIdentity, useList } from "@refinedev/core";
import { Box, Grid, Skeleton, Typography } from "@mui/material";
import { AnnualLeaveIcon, CasualLeaveIcon, SickLeaveIcon } from "@/icons";
import {
  type Employee,
  TimeOffStatus,
  TimeOffType,
  type TimeOff,
} from "@/types";

type Props = {
  employeeId?: number;
};

export const TimeOffLeaveCards = (props: Props) => {
  const { data: employee, isLoading: isLoadingEmployee } =
    useGetIdentity<Employee>({
      queryOptions: {
        enabled: !props.employeeId,
      },
    });

  const { data: timeOffsSick, isLoading: isLoadingTimeOffsSick } =
    useList<TimeOff>({
      resource: "time-offs",
      // solo necesitamos el número total de días de enfermedad, así que podemos establecer pageSize en 1 para reducir la carga
      pagination: { pageSize: 1 },
      filters: [
        {
          field: "status",
          operator: "eq",
          value: TimeOffStatus.APPROVED,
        },
        {
          field: "timeOffType",
          operator: "eq",
          value: TimeOffType.SICK,
        },
        {
          field: "employeeId",
          operator: "eq",
          value: employee?.id,
        },
      ],
      queryOptions: {
        enabled: !!employee?.id,
      },
    });

  const { data: timeOffsCasual, isLoading: isLoadingTimeOffsCasual } =
    useList<TimeOff>({
      resource: "time-offs",
      // solo necesitamos el número total de días de enfermedad, así que podemos establecer pageSize en 1 para reducir la carga
      pagination: { pageSize: 1 },
      filters: [
        {
          field: "status",
          operator: "eq",
          value: TimeOffStatus.APPROVED,
        },
        {
          field: "timeOffType",
          operator: "eq",
          value: TimeOffType.CASUAL,
        },
        {
          field: "employeeId",
          operator: "eq",
          value: employee?.id,
        },
      ],
      queryOptions: {
        enabled: !!employee?.id,
      },
    });

  const loading =
    isLoadingEmployee || isLoadingTimeOffsSick || isLoadingTimeOffsCasual;

  return (
    <Grid container spacing="24px">
      <Grid item xs={12} sm={4}>
        <Card
          loading={loading}
          type="annual"
          value={employee?.availableAnnualLeaveDays || 0}
        />
      </Grid>
      <Grid item xs={12} sm={4}>
        <Card loading={loading} type="sick" value={timeOffsSick?.total || 0} />
      </Grid>
      <Grid item xs={12} sm={4}>
        <Card
          loading={loading}
          type="casual"
          value={timeOffsCasual?.total || 0}
        />
      </Grid>
    </Grid>
  );
};

const variantMap = {
  annual: {
    label: "Annual Leave",
    description: "Days available",
    bgColor: "primary.50",
    titleColor: "primary.900",
    descriptionColor: "primary.700",
    iconColor: "primary.700",
    icon: <AnnualLeaveIcon />,
  },
  sick: {
    label: "Sick Leave",
    description: "Days used",
    bgColor: "#FFF7ED",
    titleColor: "#7C2D12",
    descriptionColor: "#C2410C",
    iconColor: "#C2410C",
    icon: <SickLeaveIcon />,
  },
  casual: {
    label: "Casual Leave",
    description: "Days used",
    bgColor: "grey.50",
    titleColor: "grey.900",
    descriptionColor: "grey.700",
    iconColor: "grey.700",
    icon: <CasualLeaveIcon />,
  },
};

const Card = (props: {
  type: "annual" | "sick" | "casual";
  value: number;
  loading?: boolean;
}) => {
  return (
    <Box
      sx={{
        backgroundColor: variantMap[props.type].bgColor,
        padding: "24px",
        borderRadius: "12px",
      }}
    >
      <Box
        sx={{
          display: "flex",
          alignItems: "center",
          justifyContent: "space-between",
        }}
      >
        <Typography
          variant="h6"
          sx={{
            color: variantMap[props.type].titleColor,
            fontSize: "16px",
            fontWeight: 500,
            lineHeight: "24px",
          }}
        >
          {variantMap[props.type].label}
        </Typography>
        <Box
          sx={{
            color: variantMap[props.type].iconColor,
          }}
        >
          {variantMap[props.type].icon}
        </Box>
      </Box>

      <Box sx={{ marginTop: "8px", display: "flex", flexDirection: "column" }}>
        {props.loading ? (
          <Box
            sx={{
              width: "40%",
              height: "32px",
              display: "flex",
              alignItems: "center",
              justifyContent: "center",
            }}
          >
            <Skeleton
              variant="rounded"
              sx={{
                width: "100%",
                height: "20px",
              }}
            />
          </Box>
        ) : (
          <Typography
            variant="caption"
            sx={{
              color: variantMap[props.type].descriptionColor,
              fontSize: "24px",
              lineHeight: "32px",
              fontWeight: 600,
            }}
          >
            {props.value}
          </Typography>
        )}
        <Typography
          variant="body1"
          sx={{
            color: variantMap[props.type].descriptionColor,
            fontSize: "12px",
            lineHeight: "16px",
          }}
        >
          {variantMap[props.type].description}
        </Typography>
      </Box>
    </Box>
  );
};
<TimeOffLeaveCards />

El componente <TimeOffLeaveCards /> muestra estadísticas sobre el tiempo libre de un empleado. Muestra tres tarjetas para Licencia Anual, Licencia por Enfermedad y Licencia Casual, indicando cuántos días están disponibles o se han utilizado.

Desglosemos las partes clave del componente:

1. Obtención de Datos
  • Datos del Empleado: Utiliza useGetIdentity para obtener la información del empleado actual, como los días de licencia anual disponibles.
  • Conteo de Tiempo Libre: Utiliza useList para obtener el número total de días de licencia por enfermedad y licencia casual utilizados por el empleado. Establece pageSize en 1 porque solo necesitamos el conteo total, no todos los detalles.
2. Mostrando las Tarjetas
  • El componente renderiza tres componentes de tarjeta, uno para cada tipo de licencia.
  • Cada tarjeta muestra:
    • El tipo de licencia (por ejemplo, Licencia Anual).
    • El número de días disponibles o utilizados.
    • Un ícono que representa el tipo de licencia.
3. Manejo de Estados de Carga
  • Si los datos todavía se están cargando, muestra un marcador de esqueleto en lugar de los números reales.
  • La propiedad cargando se pasa a las tarjetas para gestionar este estado.
4. El Componente de Tarjeta
  • Recibe tipo, valor y cargando como propiedades.
  • Utiliza un variantMap para obtener las etiquetas correctas, colores e iconos basados en el tipo de permiso.
  • Muestra la información del permiso con el estilo apropiado.

Construyendo <PageEmployeeTimeOffsList />

Ahora que tenemos los componentes para listar los permisos y mostrar las tarjetas de permiso, creemos el nuevo archivo en la carpeta src/pages/employee/time-offs/ llamado list.tsx y agreguemos el siguiente código:

src/pages/time-off.tsx
import { CanAccess, useCan } from "@refinedev/core";
import { CreateButton } from "@refinedev/mui";
import { Box, Grid } from "@mui/material";
import { PageHeader } from "@/components/layout/page-header";
import { TimeOffList } from "@/components/time-offs/list";
import { TimeOffLeaveCards } from "@/components/time-offs/leave-cards";
import { TimeOffIcon } from "@/icons";
import { ThemeProvider } from "@/providers/theme-provider";
import { Role } from "@/types";

export const PageEmployeeTimeOffsList = () => {
  const { data: useCanData } = useCan({
    action: "manager",
    params: {
      resource: {
        name: "time-offs",
        meta: {
          scope: "manager",
        },
      },
    },
  });
  const isManager = useCanData?.can;

  return (
    <ThemeProvider role={isManager ? Role.MANAGER : Role.EMPLOYEE}>
      <Box>
        <PageHeader
          title="Time Off"
          rightSlot={
            <CreateButton
              size="large"
              variant="contained"
              startIcon={<TimeOffIcon />}
            >
              <CanAccess action="manager" fallback="Request Time Off">
                Assign Time Off
              </CanAccess>
            </CreateButton>
          }
        />

        <TimeOffLeaveCards />

        <Grid
          container
          spacing="24px"
          sx={{
            marginTop: "24px",
          }}
        >
          <Grid item xs={12} md={6}>
            <Box
              sx={{
                display: "flex",
                flexDirection: "column",
                gap: "24px",
              }}
            >
              <TimeOffList type="inReview" />
              <TimeOffList type="upcoming" />
            </Box>
          </Grid>
          <Grid item xs={12} md={6}>
            <TimeOffList type="history" />
          </Grid>
        </Grid>
      </Box>
    </ThemeProvider>
  );
};

<PageEmployeeTimeOffsList /> es el componente principal para la página de permisos, usaremos este componente para mostrar las listas de permisos y las tarjetas de permiso cuando los usuarios naveguen a la ruta /employee/time-offs.

<PageEmployeeTimeOffsList />

Desglosemos las partes clave del componente:

1. Verificación de Roles de Usuario
  • Utiliza el gancho useCan para determinar si el usuario actual es un gerente.
  • Establece isManager en true si el usuario tiene permisos de gerente.
2. Aplicación de Tema Basado en el Rol
  • Envuelve el contenido dentro de un <ThemeProvider />.
  • El tema cambia según si el usuario es un gerente o un empleado.
3. Encabezado de Página con Botón Condicional
  • Renderiza un <PageHeader /> con el título “Tiempo Libre”.
  • Incluye un <CreateButton /> que cambia según el rol del usuario:
    • Si el usuario es un gerente, el botón dice “Asignar Tiempo Libre”.
    • Si el usuario no es un gerente, dice “Solicitar Tiempo Libre”.
  • Esto se maneja utilizando el componente <CanAccess />, que verifica los permisos.
4. Mostrando Estadísticas de Licencias
  • Incluye el componente <TimeOffLeaveCards /> para mostrar saldos y uso de licencias.
  • Esto proporciona un resumen de licencias anuales, por enfermedad y casuales.
5. Listando Solicitudes de Tiempo Libre
  • Utiliza un diseño de <Grid /> para organizar el contenido.
  • En el lado izquierdo (md={6}), muestra:
    • TimeOffList con type="inReview": Muestra solicitudes de tiempo libre pendientes.
    • TimeOffList con type="upcoming": Muestra los próximos tiempos libres aprobados.
  • En el lado derecho (md={6}), se muestra:
    • TimeOffList con type="history": Muestra los tiempos libres pasados que ya han ocurrido.

Agregando la ruta “/employee/time-offs”

Estamos listos para renderizar el componente <PageEmployeeTimeOffsList /> en la ruta /employee/time-offs. Actualicemos el archivo App.tsx para incluir esta ruta:

src/App.tsx
import { Authenticated, ErrorComponent, Refine } from '@refinedev/core'
import { DevtoolsProvider, DevtoolsPanel } from '@refinedev/devtools'
import dataProvider from '@refinedev/nestjsx-crud'
import routerProvider, {
  UnsavedChangesNotifier,
  DocumentTitleHandler,
  NavigateToResource,
} from '@refinedev/react-router-v6'
import { BrowserRouter, Routes, Route, Outlet } from 'react-router-dom'
import { Toaster } from 'react-hot-toast'

import { PageEmployeeTimeOffsList } from '@/pages/employee/time-offs/list'
import { PageLogin } from '@/pages/login'

import { Layout } from '@/components/layout'

import { ThemeProvider } from '@/providers/theme-provider'
import { authProvider } from '@/providers/auth-provider'
import { accessControlProvider } from '@/providers/access-control'
import { useNotificationProvider } from '@/providers/notification-provider'
import { queryClient } from '@/providers/query-client'

import { BASE_URL } from '@/utilities/constants'
import { axiosInstance } from '@/utilities/axios'

import { TimeOffIcon } from '@/icons'

import { Role } from '@/types'

import '@/utilities/init-dayjs'

function App() {
  return (
    <BrowserRouter>
      <ThemeProvider>
        <DevtoolsProvider>
          <Refine
            authProvider={authProvider}
            routerProvider={routerProvider}
            dataProvider={dataProvider(BASE_URL, axiosInstance)}
            notificationProvider={useNotificationProvider}
            resources={[
              {
                name: 'employee',
                meta: {
                  scope: Role.EMPLOYEE,
                },
              },
              {
                name: 'manager',
                meta: {
                  scope: Role.MANAGER,
                },
              },
              {
                name: 'time-offs',
                list: '/employee/time-offs',
                meta: {
                  parent: 'employee',
                  scope: Role.EMPLOYEE,
                  label: 'Time Off',
                  icon: <TimeOffIcon />,
                },
              },
            ]}
            accessControlProvider={accessControlProvider}
            options={{
              reactQuery: {
                clientConfig: queryClient,
              },
              syncWithLocation: true,
              warnWhenUnsavedChanges: true,
              useNewQueryKeys: true,
            }}>
            <Routes>
              <Route
                element={
                  <Authenticated key='authenticated-routes' redirectOnFail='/login'>
                    <Outlet />
                  </Authenticated>
                }>
                <Route index element={<NavigateToResource resource='time-offs' />} />

                <Route
                  path='employee'
                  element={
                    <ThemeProvider role={Role.EMPLOYEE}>
                      <Layout>
                        <Outlet />
                      </Layout>
                    </ThemeProvider>
                  }>
                  <Route path='time-offs' element={<Outlet />}>
                    <Route index element={<PageEmployeeTimeOffsList />} />
                  </Route>
                </Route>
              </Route>

              <Route
                element={
                  <Authenticated key='auth-pages' fallback={<Outlet />}>
                    <NavigateToResource resource='time-offs' />
                  </Authenticated>
                }>
                <Route path='/login' element={<PageLogin />} />
              </Route>

              <Route
                element={
                  <Authenticated key="catch-all">
                    <Layout>
                      <Outlet />
                    </Layout>
                  </Authenticated>
                }
              >
                <Route path="*" element={<ErrorComponent />} />
              </Route>
            </Routes>

            <UnsavedChangesNotifier />
            <DocumentTitleHandler />
            <Toaster position='bottom-right' reverseOrder={false} />
            <DevtoolsPanel />
          </Refine>
        </DevtoolsProvider>
      </ThemeProvider>
    </BrowserRouter>
  )
}

export default App

Desglosemos las partes clave del archivo App.tsx actualizado:

1. Definición del recurso de tiempo libre
{
  name: 'time-offs',
  list: '/employee/time-offs',
  meta: {
    parent: 'employee',
    scope: Role.EMPLOYEE,
    label: 'Time Off',
    icon: <TimeOffIcon />,
  },
}

Agregamos un nuevo recurso para los tiempos libres como hijo del recurso de employee. Esto indica que los tiempos libres están relacionados con los empleados y son accesibles por los empleados.

  • name: 'time-offs': Este es el identificador del recurso, utilizado internamente por Refine.
  • list: '/employee/time-offs': Especifica la ruta que muestra la vista de lista del recurso.
  • meta: Un objeto que contiene metadatos adicionales sobre el recurso.
    • parent: 'employee': Agrupa este recurso bajo el alcance de employee, que se puede utilizar para organizar recursos en la interfaz de usuario (como en un menú lateral) o para el control de acceso.
    • scope: Role.EMPLOYEE: Indica que este recurso es accesible para usuarios con el rol EMPLOYEE. Usamos esto en el accessControlProvider para gestionar permisos.
    • label: 'Time Off': El nombre de visualización del recurso en la interfaz de usuario.
    • icon: <TimeOffIcon />: Asocia el TimeOffIcon con este recurso para su identificación visual.
2. Redirigir al recurso “time-offs” cuando los usuarios navegan a la ruta /
<Route index element={<NavigateToResource resource="time-offs" />} />

Usamos el <NavigateToResource /> componente para redirigir a los usuarios al recurso time-offs cuando navegan a la ruta /. Esto asegura que los usuarios vean la lista de ausencias por defecto.

3. Redirigiendo al recurso “time-offs” cuando los usuarios están autenticados
<Route
  element={
    <Authenticated key="auth-pages" fallback={<Outlet />}>
      <NavigateToResource resource="time-offs" />
    </Authenticated>
  }
>
  <Route path="/login" element={<PageLogin />} />
</Route>

Cuando los usuarios están autenticados, los redirigimos al recurso time-offs. Si no están autenticados, ven la página de inicio de sesión.

4. Agregando la Ruta /employee/time-offs
<Route
  path="employee"
  element={
    <ThemeProvider role={Role.EMPLOYEE}>
      <Layout>
        <Outlet />
      </Layout>
    </ThemeProvider>
  }
>
  <Route path="time-offs" element={<Outlet />}>
    <Route index element={<PageEmployeeTimeOffsList />} />
  </Route>
</Route>

Organizamos las páginas de empleados utilizando rutas anidadas. Primero, creamos una ruta principal con path='employee' que envuelve el contenido en un tema y diseño específico para empleados. Dentro de esta ruta, añadimos path='time-offs', que muestra el componente PageEmployeeTimeOffsList. Esta estructura agrupa todas las características de empleados bajo una ruta y mantiene el estilo consistente.

Después de añadir estos cambios, puedes navegar a la ruta /employee/time-offs para ver la página de lista de ausencias en acción.

/employee/time-offs

En este momento, la página de lista de ausencias es funcional, pero carece de la capacidad de crear nuevas solicitudes de ausencias. Vamos a añadir la capacidad de crear nuevas solicitudes de ausencias.

Construyendo la Página de Creación de Ausencias

Crearemos una nueva página para solicitar o asignar tiempo libre. Esta página incluirá un formulario donde los usuarios podrán especificar el tipo de tiempo libre, las fechas de inicio y fin, y cualquier nota adicional.

Antes de empezar, necesitamos crear nuevos componentes para usar en el formulario:

Creación del Componente <TimeOffFormSummary />

Crea un nuevo archivo llamado form-summary.tsx en la carpeta src/components/time-offs/ y agrega el siguiente código:

src/components/time-offs/form-summary.tsx

import { Box, Divider, Typography } from "@mui/material";

type Props = {
  availableAnnualDays: number;
  requestedDays: number;
};

export const TimeOffFormSummary = (props: Props) => {
  const remainingDays = props.availableAnnualDays - props.requestedDays;

  return (
    <Box
      sx={{
        display: "flex",
        flexDirection: "column",
        alignItems: "flex-end",
        gap: "16px",
        whiteSpace: "nowrap",
      }}
    >
      <Box
        sx={{
          display: "flex",
          gap: "16px",
        }}
      >
        <Typography variant="body2" color="text.secondary">
          Available Annual Leave Days:
        </Typography>
        <Typography variant="body2">{props.availableAnnualDays}</Typography>
      </Box>

      <Box
        sx={{
          display: "flex",
          gap: "16px",
        }}
      >
        <Typography variant="body2" color="text.secondary">
          Requested Days:
        </Typography>
        <Typography variant="body2">{props.requestedDays}</Typography>
      </Box>

      <Divider
        sx={{
          width: "100%",
        }}
      />
      <Box
        sx={{
          display: "flex",
          gap: "16px",
          height: "40px",
        }}
      >
        <Typography variant="body2" color="text.secondary">
          Remaining Days:
        </Typography>
        <Typography variant="body2" fontWeight={500}>
          {remainingDays}
        </Typography>
      </Box>
    </Box>
  );
};
<TimeOffFormSummary />

El componente <TimeOffFormSummary /> muestra un resumen de la solicitud de tiempo libre. Muestra los días disponibles de licencia anual, el número de días solicitados y los días restantes. Utilizaremos este componente en el formulario de tiempo libre para proporcionar a los usuarios una visión clara de su solicitud.

Creación del Componente <PageEmployeeTimeOffsCreate />

Crea un nuevo archivo llamado create.tsx en la carpeta src/pages/employee/time-offs/ y agrega el siguiente código:

src/pages/time-offs/create.tsx
import { useCan, useGetIdentity, type HttpError } from "@refinedev/core";
import { useForm } from "@refinedev/react-hook-form";
import { Controller } from "react-hook-form";
import type { DateRange } from "@mui/x-date-pickers-pro/models";
import { Box, Button, MenuItem, Select, Typography } from "@mui/material";
import dayjs from "dayjs";
import { PageHeader } from "@/components/layout/page-header";
import { InputText } from "@/components/input/text";
import { LoadingOverlay } from "@/components/loading-overlay";
import { InputDateStartsEnds } from "@/components/input/date-starts-ends";
import { TimeOffFormSummary } from "@/components/time-offs/form-summary";
import { ThemeProvider } from "@/providers/theme-provider";
import {
  type Employee,
  type TimeOff,
  TimeOffType,
  TimeOffStatus,
  Role,
} from "@/types";
import { CheckRectangleIcon } from "@/icons";

type FormValues = Omit<TimeOff, "id" | "notes"> & {
  notes: string;
  dates: DateRange<dayjs.Dayjs>;
};

export const PageEmployeeTimeOffsCreate = () => {
  const { data: useCanData } = useCan({
    action: "manager",
    params: {
      resource: {
        name: "time-offs",
        meta: {
          scope: "manager",
        },
      },
    },
  });
  const isManager = useCanData?.can;

  const { data: employee } =
    useGetIdentity<Employee>();

  const {
    refineCore: { formLoading, onFinish },
    ...formMethods
  } = useForm<TimeOff, HttpError, FormValues>({
    defaultValues: {
      timeOffType: TimeOffType.ANNUAL,
      notes: "",
      dates: [null, null],
    },
    refineCoreProps: {
      successNotification: () => {
        return {
          message: isManager
            ? "Time off assigned"
            : "Your time off request is submitted for review.",
          type: "success",
        };
      },
    },
  });
  const { control, handleSubmit, formState, watch } = formMethods;

  const onFinishHandler = async (values: FormValues) => {
    const payload: FormValues = {
      ...values,
      startsAt: dayjs(values.dates[0]).format("YYYY-MM-DD"),
      endsAt: dayjs(values.dates[1]).format("YYYY-MM-DD"),
      ...(isManager && {
        status: TimeOffStatus.APPROVED,
      }),
    };
    await onFinish(payload);
  };

  const timeOffType = watch("timeOffType");
  const selectedDays = watch("dates");
  const startsAt = selectedDays[0];
  const endsAt = selectedDays[1];
  const availableAnnualDays = employee?.availableAnnualLeaveDays ?? 0;
  const requestedDays =
    startsAt && endsAt ? endsAt.diff(startsAt, "day") + 1 : 0;

  return (
    <ThemeProvider role={isManager ? Role.MANAGER : Role.EMPLOYEE}>
      <LoadingOverlay loading={formLoading}>
        <Box>
          <PageHeader
            title={isManager ? "Assign Time Off" : "Request Time Off"}
            showListButton
            showDivider
          />

          <Box
            component="form"
            onSubmit={handleSubmit(onFinishHandler)}
            sx={{
              display: "flex",
              flexDirection: "column",
              gap: "24px",
              marginTop: "24px",
            }}
          >
            <Box>
              <Typography
                variant="body2"
                sx={{
                  mb: "8px",
                }}
              >
                Time Off Type
              </Typography>
              <Controller
                name="timeOffType"
                control={control}
                render={({ field }) => (
                  <Select
                    {...field}
                    size="small"
                    sx={{
                      minWidth: "240px",
                      height: "40px",
                      "& .MuiSelect-select": {
                        paddingBlock: "10px",
                      },
                    }}
                  >
                    <MenuItem value={TimeOffType.ANNUAL}>Annual Leave</MenuItem>
                    <MenuItem value={TimeOffType.CASUAL}>Casual Leave</MenuItem>
                    <MenuItem value={TimeOffType.SICK}>Sick Leave</MenuItem>
                  </Select>
                )}
              />
            </Box>

            <Box>
              <Typography
                variant="body2"
                sx={{
                  mb: "16px",
                }}
              >
                Requested Dates
              </Typography>
              <Controller
                name="dates"
                control={control}
                rules={{
                  validate: (value) => {
                    if (!value[0] || !value[1]) {
                      return "Please select both start and end dates";
                    }

                    return true;
                  },
                }}
                render={({ field }) => {
                  return (
                    <Box
                      sx={{
                        display: "grid",
                        gridTemplateColumns: () => {
                          return {
                            sm: "1fr",
                            lg: "628px 1fr",
                          };
                        },
                        gap: "40px",
                      }}
                    >
                      <InputDateStartsEnds
                        {...field}
                        error={formState.errors.dates?.message}
                        availableAnnualDays={availableAnnualDays}
                        requestedDays={requestedDays}
                      />
                      {timeOffType === TimeOffType.ANNUAL && (
                        <Box
                          sx={{
                            display: "flex",
                            maxWidth: "628px",
                            alignItems: () => {
                              return {
                                lg: "flex-end",
                              };
                            },
                            justifyContent: () => {
                              return {
                                xs: "flex-end",
                                lg: "flex-start",
                              };
                            },
                          }}
                        >
                          <TimeOffFormSummary
                            availableAnnualDays={availableAnnualDays}
                            requestedDays={requestedDays}
                          />
                        </Box>
                      )}
                    </Box>
                  );
                }}
              />
            </Box>

            <Box
              sx={{
                maxWidth: "628px",
              }}
            >
              <Controller
                name="notes"
                control={control}
                render={({ field, fieldState }) => {
                  return (
                    <InputText
                      {...field}
                      label="Notes"
                      error={fieldState.error?.message}
                      placeholder="Place enter your notes"
                      multiline
                      rows={3}
                    />
                  );
                }}
              />
            </Box>

            <Button
              variant="contained"
              size="large"
              type="submit"
              startIcon={isManager ? <CheckRectangleIcon /> : undefined}
            >
              {isManager ? "Assign" : "Send Request"}
            </Button>
          </Box>
        </Box>
      </LoadingOverlay>
    </ThemeProvider>
  );
};
<PageEmployeeTimeOffsCreate />

El componente <PageEmployeeTimeOffsCreate /> muestra un formulario para crear nuevas solicitudes de tiempo libre en una aplicación de gestión de recursos humanos. Tanto los empleados como los gerentes pueden usarlo para solicitar o asignar tiempo libre. El formulario incluye opciones para seleccionar el tipo de tiempo libre, elegir fechas de inicio y fin, agregar notas, y muestra un resumen del tiempo libre solicitado.

Desglosemos las partes clave del componente:

1. Verificación del Rol del Usuario

const { data: useCanData } = useCan({
  action: "manager",
  params: {
    resource: {
      name: "time-offs",
      meta: {
        scope: "manager",
      },
    },
  },
});
const isManager = useCanData?.can;

Con el gancho useCan, verificamos si el usuario actual tiene permisos de gerente. Esto determina si el usuario puede asignar tiempo libre o solo solicitarlo. Manejaremos el envío del formulario de manera diferente en onFinishHandler según el rol del usuario.

2. Estado y Envío del Formulario


 const {
  refineCore: { formLoading, onFinish },
  ...formMethods
} = useForm<TimeOff, HttpError, FormValues>({
  defaultValues: {
    timeOffType: TimeOffType.ANNUAL,
    notes: "",
    dates: [null, null],
  },
  refineCoreProps: {
    successNotification: () => {
      return {
        message: isManager
          ? "Time off assigned"
          : "Your time off request is submitted for review.",
        type: "success",
      };
    },
  },
});
const { control, handleSubmit, formState, watch } = formMethods;

  const onFinishHandler = async (values: FormValues) => {
    const payload: FormValues = {
      ...values,
      startsAt: dayjs(values.dates[0]).format("YYYY-MM-DD"),
      endsAt: dayjs(values.dates[1]).format("YYYY-MM-DD"),
      ...(isManager && {
        status: TimeOffStatus.APPROVED,
      }),
    };
    await onFinish(payload);
  };

useForm inicializa el formulario con valores predeterminados y establece notificaciones de éxito según el rol del usuario. La función onFinishHandler procesa los datos del formulario antes de enviarlos. Para los gerentes, el estado se establece en APPROVED de inmediato, mientras que las solicitudes de los empleados se envían para su revisión.

3. Estilos

<ThemeProvider role={isManager ? Role.MANAGER : Role.EMPLOYEE}>
  {/* ... */}
</ThemeProvider>

<Button
  variant="contained"
  size="large"
  type="submit"
  startIcon={isManager ? <CheckRectangleIcon /> : undefined}
>
  {isManager ? "Assign" : "Send Request"}
</Button>

En nuestro diseño, el color principal cambia según el rol del usuario. Utilizamos el <ThemeProvider /> para aplicar el tema correcto en consecuencia. El texto e icono del botón de enviar también cambian dependiendo de si el usuario es un gerente o un empleado.

4. Agregar la Ruta “/employee/time-offs/create”

Necesitamos agregar la nueva ruta para la página de creación de tiempo libre. Actualicemos el archivo App.tsx para incluir esta ruta:

src/App.tsx
import { Authenticated, ErrorComponent, Refine } from '@refinedev/core'
import { DevtoolsProvider, DevtoolsPanel } from '@refinedev/devtools'
import dataProvider from '@refinedev/nestjsx-crud'
import routerProvider, {
  UnsavedChangesNotifier,
  DocumentTitleHandler,
  NavigateToResource,
} from '@refinedev/react-router-v6'
import { BrowserRouter, Routes, Route, Outlet } from 'react-router-dom'
import { Toaster } from 'react-hot-toast'

import { PageEmployeeTimeOffsList } from '@/pages/employee/time-offs/list'
import { PageEmployeeTimeOffsCreate } from '@/pages/employee/time-offs/create'
import { PageLogin } from '@/pages/login'

import { Layout } from '@/components/layout'

import { ThemeProvider } from '@/providers/theme-provider'
import { authProvider } from '@/providers/auth-provider'
import { accessControlProvider } from '@/providers/access-control'
import { useNotificationProvider } from '@/providers/notification-provider'
import { queryClient } from '@/providers/query-client'

import { BASE_URL } from '@/utilities/constants'
import { axiosInstance } from '@/utilities/axios'

import { TimeOffIcon } from '@/icons'

import { Role } from '@/types'

import '@/utilities/init-dayjs'

function App() {
  return (
    <BrowserRouter>
      <ThemeProvider>
        <DevtoolsProvider>
          <Refine
            authProvider={authProvider}
            routerProvider={routerProvider}
            dataProvider={dataProvider(BASE_URL, axiosInstance)}
            notificationProvider={useNotificationProvider}
            resources={[
              {
                name: 'employee',
                meta: {
                  scope: Role.EMPLOYEE,
                  order: 2,
                },
              },
              {
                name: 'manager',
                meta: {
                  scope: Role.MANAGER,
                  order: 1,
                },
              },
              {
                name: 'time-offs',
                list: '/employee/time-offs',
                create: '/employee/time-offs/new',
                meta: {
                  parent: 'employee',
                  scope: Role.EMPLOYEE,
                  label: 'Time Off',
                  icon: <TimeOffIcon />,
                },
              },
            ]}
            accessControlProvider={accessControlProvider}
            options={{
              reactQuery: {
                clientConfig: queryClient,
              },
              syncWithLocation: true,
              warnWhenUnsavedChanges: true,
              useNewQueryKeys: true,
            }}>
            <Routes>
              <Route
                element={
                  <Authenticated key='authenticated-routes' redirectOnFail='/login'>
                    <Outlet />
                  </Authenticated>
                }>
                <Route index element={<NavigateToResource resource='time-offs' />} />

                <Route
                  path='employee'
                  element={
                    <ThemeProvider role={Role.EMPLOYEE}>
                      <Layout>
                        <Outlet />
                      </Layout>
                    </ThemeProvider>
                  }>
                  <Route path='time-offs' element={<Outlet />}>
                    <Route index element={<PageEmployeeTimeOffsList />} />
                    <Route path='new' element={<PageEmployeeTimeOffsCreate />} />
                  </Route>
                </Route>
              </Route>

              <Route
                element={
                  <Authenticated key='auth-pages' fallback={<Outlet />}>
                    <NavigateToResource resource='time-offs' />
                  </Authenticated>
                }>
                <Route path='/login' element={<PageLogin />} />
              </Route>

              <Route
                element={
                  <Authenticated key='catch-all'>
                    <Layout>
                      <Outlet />
                    </Layout>
                  </Authenticated>
                }>
                <Route path='*' element={<ErrorComponent />} />
              </Route>
            </Routes>

            <UnsavedChangesNotifier />
            <DocumentTitleHandler />
            <Toaster position='bottom-right' reverseOrder={false} />
            <DevtoolsPanel />
          </Refine>
        </DevtoolsProvider>
      </ThemeProvider>
    </BrowserRouter>
  )
}

export default App

Después de realizar estos cambios, puedes navegar a la ruta /employee/time-offs/create o hacer clic en el botón “Asignar Tiempo Libre” en la página de lista de tiempos libres para acceder al formulario de creación de tiempo libre.

/employee/time-offs/create

Paso 5 — Construcción de la Página de Gestión de Solicitudes de Tiempo Libre

En este paso, crearemos una nueva página para gestionar las solicitudes de tiempo libre. Esta página permitirá a los gerentes revisar y aprobar o rechazar las solicitudes de tiempo libre enviadas por los empleados.

/manager/requests

Construcción de la Página de Listado de Solicitudes de Tiempo Libre

Crearemos una nueva página para gestionar las solicitudes de tiempo libre. Esta página incluirá un listado de solicitudes de tiempo libre, mostrando detalles como el nombre del empleado, el tipo de tiempo libre, las fechas solicitadas y el estado actual.

Antes de comenzar, necesitamos crear nuevos componentes para usar en el listado:

Construcción del Componente <RequestsList />

Crea un nuevo archivo llamado list.tsx en la carpeta src/components/requests/ y agrega el siguiente código:

src/components/requests/list.tsx
import type { ReactNode } from "react";
import InfiniteScroll from "react-infinite-scroll-component";
import {
  Box,
  Button,
  CircularProgress,
  Skeleton,
  Typography,
} from "@mui/material";

type Props = {
  dataLength: number;
  hasMore: boolean;
  scrollableTarget: string;
  loading: boolean;
  noDataText: string;
  noDataIcon: ReactNode;
  children: ReactNode;
  next: () => void;
};

export const RequestsList = (props: Props) => {
  const hasData = props.dataLength > 0 || props.loading;
  if (!hasData) {
    return (
      <Box
        sx={{
          display: "flex",
          alignItems: "center",
          justifyContent: "center",
          flexDirection: "column",
          gap: "24px",
        }}
      >
        {props.noDataIcon}
        <Typography variant="body2" color="text.secondary">
          {props.noDataText || "No data."}
        </Typography>
      </Box>
    );
  }

  return (
    <Box
      sx={{
        position: "relative",
      }}
    >
      <Box
        id={props.scrollableTarget}
        sx={(theme) => ({
          maxHeight: "600px",
          [theme.breakpoints.up("lg")]: {
            height: "600px",
          },
          overflow: "auto",
          ...((props.dataLength > 6 || props.loading) && {
            "&::after": {
              pointerEvents: "none",
              content: '""',
              zIndex: 1,
              position: "absolute",
              bottom: "0",
              left: "12px",
              right: "12px",
              width: "calc(100% - 24px)",
              height: "60px",
              background:
                "linear-gradient(180deg, rgba(255, 255, 255, 0), #FFFFFF)",
            },
          }),
        })}
      >
        <InfiniteScroll
          dataLength={props.dataLength}
          hasMore={props.hasMore}
          next={props.next}
          scrollableTarget={props.scrollableTarget}
          endMessage={
            !props.loading &&
            props.dataLength > 6 && (
              <Box
                sx={{
                  pt: "40px",
                }}
              />
            )
          }
          loader={
            <Box
              sx={{
                display: "flex",
                alignItems: "center",
                justifyContent: "center",
                width: "100%",
                height: "100px",
              }}
            >
              <CircularProgress size={24} />
            </Box>
          }
        >
          <Box
            sx={{
              display: "flex",
              flexDirection: "column",
            }}
          >
            {props.loading ? <SkeletonList /> : props.children}
          </Box>
        </InfiniteScroll>
      </Box>
    </Box>
  );
};

const SkeletonList = () => {
  return (
    <>
      {[...Array(6)].map((_, index) => (
        <Box
          key={index}
          sx={(theme) => ({
            paddingRight: "24px",
            paddingLeft: "24px",
            display: "flex",
            flexDirection: "column",
            justifyContent: "flex-end",
            gap: "12px",
            paddingTop: "12px",
            paddingBottom: "4px",

            [theme.breakpoints.up("sm")]: {
              paddingTop: "20px",
              paddingBottom: "12px",
            },

            "& .MuiSkeleton-rectangular": {
              borderRadius: "2px",
            },
          })}
        >
          <Skeleton variant="rectangular" width="64px" height="12px" />
          <Box
            sx={{
              display: "flex",
              alignItems: "center",
              gap: "24px",
            }}
          >
            <Skeleton
              variant="circular"
              width={48}
              height={48}
              sx={{
                flexShrink: 0,
              }}
            />
            <Box
              sx={(theme) => ({
                height: "auto",
                width: "100%",
                [theme.breakpoints.up("md")]: {
                  height: "48px",
                },
                display: "flex",
                flex: 1,
                flexDirection: "column",
                justifyContent: "center",
                gap: "8px",
              })}
            >
              <Skeleton
                variant="rectangular"
                sx={(theme) => ({
                  width: "100%",
                  [theme.breakpoints.up("sm")]: {
                    width: "120px",
                  },
                })}
                height="16px"
              />
              <Skeleton
                variant="rectangular"
                sx={(theme) => ({
                  width: "100%",
                  [theme.breakpoints.up("sm")]: {
                    width: "230px",
                  },
                })}
                height="12px"
              />
            </Box>
            <Button
              size="small"
              color="inherit"
              sx={(theme) => ({
                display: "none",
                [theme.breakpoints.up("sm")]: {
                  display: "block",
                },

                alignSelf: "flex-start",
                flexShrink: 0,
                marginLeft: "auto",
              })}
            >
              View Request
            </Button>
          </Box>
        </Box>
      ))}
    </>
  );
};

El componente <RequestsList /> muestra un listado de solicitudes de tiempo libre con desplazamiento infinito. Incluye un indicador de carga, marcadores de esqueleto y un mensaje cuando no hay datos. Este componente está diseñado para manejar grandes conjuntos de datos de manera eficiente y proporcionar una experiencia de usuario fluida.

Construyendo el componente <RequestsListItem />

Crea un nuevo archivo llamado list-item.tsx en la carpeta src/components/requests/ y añade el siguiente código:

src/components/requests/list-item.tsx
import { Box, Typography, Avatar, Button } from "@mui/material";
import type { ReactNode } from "react";

type Props = {
  date: string;
  avatarURL: string;
  title: string;
  descriptionIcon?: ReactNode;
  description: string;
  onClick?: () => void;
  showTimeSince?: boolean;
};

export const RequestsListItem = ({
  date,
  avatarURL,
  title,
  descriptionIcon,
  description,
  onClick,
  showTimeSince,
}: Props) => {
  return (
    <Box
      role="button"
      onClick={onClick}
      sx={(theme) => ({
        cursor: "pointer",
        paddingRight: "24px",
        paddingLeft: "24px",

        paddingTop: "4px",
        paddingBottom: "4px",
        [theme.breakpoints.up("sm")]: {
          paddingTop: "12px",
          paddingBottom: "12px",
        },

        "&:hover": {
          backgroundColor: theme.palette.action.hover,
        },
      })}
    >
      {showTimeSince && (
        <Box
          sx={{
            marginBottom: "8px",
          }}
        >
          <Typography variant="caption" color="textSecondary">
            {date}
          </Typography>
        </Box>
      )}
      <Box
        sx={{
          display: "flex",
        }}
      >
        <Avatar
          src={avatarURL}
          alt={title}
          sx={{ width: "48px", height: "48px" }}
        />
        <Box
          sx={(theme) => ({
            height: "auto",
            [theme.breakpoints.up("md")]: {
              height: "48px",
            },
            width: "100%",
            display: "flex",
            flexWrap: "wrap",
            justifyContent: "space-between",
            gap: "4px",
            marginLeft: "16px",
          })}
        >
          <Box>
            <Typography variant="body2" fontWeight={500} lineHeight="24px">
              {title}
            </Typography>
            <Box
              sx={{
                display: "flex",
                alignItems: "center",
                gap: "8px",
                minWidth: "260px",
              }}
            >
              {descriptionIcon}
              <Typography variant="caption" color="textSecondary">
                {description}
              </Typography>
            </Box>
          </Box>

          {onClick && (
            <Button
              size="small"
              color="inherit"
              onClick={onClick}
              sx={{
                alignSelf: "flex-start",
                flexShrink: 0,
                marginLeft: "auto",
              }}
            >
              View Request
            </Button>
          )}
        </Box>
      </Box>
    </Box>
  );
};

El componente <RequestsListItem /> muestra una única solicitud de tiempo libre en la lista. Incluye el avatar del empleado, nombre, descripción y un botón para ver los detalles de la solicitud. Este componente es reutilizable y puede ser utilizado para renderizar cada elemento en la lista de solicitudes de tiempo libre.

Construyendo el componente <PageManagerRequestsList />

Crea un nuevo archivo llamado list.tsx en la carpeta src/pages/manager/requests/ y añade el siguiente código:

import type { PropsWithChildren } from "react";
import { useGo, useInfiniteList } from "@refinedev/core";
import { Box, Typography } from "@mui/material";
import dayjs from "dayjs";
import { Frame } from "@/components/frame";
import { PageHeader } from "@/components/layout/page-header";
import { RequestsListItem } from "@/components/requests/list-item";
import { RequestsList } from "@/components/requests/list";
import { indigo } from "@/providers/theme-provider/colors";
import { TimeOffIcon, RequestTypeIcon, NoTimeOffIcon } from "@/icons";
import { TimeOffStatus, type Employee, type TimeOff } from "@/types";

export const PageManagerRequestsList = ({ children }: PropsWithChildren) => {
  return (
    <>
      <Box>
        <PageHeader title="Awaiting Requests" />
        <TimeOffsList />
      </Box>
      {children}
    </>
  );
};

const TimeOffsList = () => {
  const go = useGo();

  const {
    data: timeOffsData,
    isLoading: timeOffsLoading,
    fetchNextPage: timeOffsFetchNextPage,
    hasNextPage: timeOffsHasNextPage,
  } = useInfiniteList<
    TimeOff & {
      employee: Employee;
    }
  >({
    resource: "time-offs",
    filters: [
      { field: "status", operator: "eq", value: TimeOffStatus.PENDING },
    ],
    sorters: [{ field: "createdAt", order: "desc" }],
    meta: {
      join: ["employee"],
    },
  });

  const timeOffs = timeOffsData?.pages.flatMap((page) => page.data) || [];
  const totalCount = timeOffsData?.pages[0].total;

  return (
    <Frame
      title="Time off Requests"
      titleSuffix={
        !!totalCount &&
        totalCount > 0 && (
          <Box
            sx={{
              padding: "4px",
              display: "flex",
              alignItems: "center",
              justifyContent: "center",
              minWidth: "24px",
              height: "24px",
              borderRadius: "4px",
              backgroundColor: indigo[100],
            }}
          >
            <Typography
              variant="caption"
              sx={{
                color: indigo[500],
                fontSize: "12px",
                lineHeight: "16px",
              }}
            >
              {totalCount}
            </Typography>
          </Box>
        )
      }
      icon={<TimeOffIcon width={24} height={24} />}
      sx={{
        flex: 1,
        paddingBottom: "0px",
      }}
      sxChildren={{
        padding: 0,
      }}
    >
      <RequestsList
        loading={timeOffsLoading}
        dataLength={timeOffs.length}
        hasMore={timeOffsHasNextPage || false}
        next={timeOffsFetchNextPage}
        scrollableTarget="scrollableDiv-timeOffs"
        noDataText="No time off requests right now."
        noDataIcon={<NoTimeOffIcon />}
      >
        {timeOffs.map((timeOff) => {
          const date = dayjs(timeOff.createdAt).fromNow();
          const fullName = `${timeOff.employee.firstName} ${timeOff.employee.lastName}`;
          const avatarURL = timeOff.employee.avatarUrl;
          const requestedDay =
            dayjs(timeOff.endsAt).diff(dayjs(timeOff.startsAt), "day") + 1;
          const description = `Requested ${requestedDay} ${
            requestedDay > 1 ? "days" : "day"
          } of time  ${timeOff.timeOffType.toLowerCase()} leave.`;

          return (
            <RequestsListItem
              key={timeOff.id}
              date={date}
              avatarURL={avatarURL}
              title={fullName}
              showTimeSince
              descriptionIcon={<RequestTypeIcon type={timeOff.timeOffType} />}
              description={description}
              onClick={() => {
                go({
                  type: "replace",
                  to: {
                    resource: "requests",
                    id: timeOff.id,
                    action: "edit",
                  },
                });
              }}
            />
          );
        })}
      </RequestsList>
    </Frame>
  );
};

El componente <PageManagerRequestsList /> muestra las solicitudes de tiempo libre pendientes que los gerentes necesitan aprobar. Muestra detalles como el nombre del empleado, tipo de licencia, fechas solicitadas y cuánto tiempo ha pasado desde que se hizo la solicitud. Los gerentes pueden hacer clic en una solicitud para ver más detalles. Utiliza <RequestsList /> y <RequestsListItem /> para renderizar la lista.

Este componente también acepta children como una propiedad. A continuación, implementaremos una ruta modal usando <Outlet /> para mostrar los detalles de la solicitud, renderizando la ruta /manager/requests/:id dentro del componente.

Agregando la ruta “/manager/requests”

Necesitamos agregar la nueva ruta para la página de gestión de solicitudes de tiempo libre. Actualicemos el archivo App.tsx para incluir esta ruta:

src/App.tsx
import { Authenticated, ErrorComponent, Refine } from '@refinedev/core'
import { DevtoolsProvider, DevtoolsPanel } from '@refinedev/devtools'
import dataProvider from '@refinedev/nestjsx-crud'
import routerProvider, {
  UnsavedChangesNotifier,
  DocumentTitleHandler,
  NavigateToResource,
} from '@refinedev/react-router-v6'
import { BrowserRouter, Routes, Route, Outlet } from 'react-router-dom'
import { Toaster } from 'react-hot-toast'

import { PageEmployeeTimeOffsList } from '@/pages/employee/time-offs/list'
import { PageEmployeeTimeOffsCreate } from '@/pages/employee/time-offs/create'
import { PageLogin } from '@/pages/login'

import { Layout } from '@/components/layout'

import { ThemeProvider } from '@/providers/theme-provider'
import { authProvider } from '@/providers/auth-provider'
import { accessControlProvider } from '@/providers/access-control'
import { useNotificationProvider } from '@/providers/notification-provider'
import { queryClient } from '@/providers/query-client'

import { BASE_URL } from '@/utilities/constants'
import { axiosInstance } from '@/utilities/axios'

import { RequestsIcon, TimeOffIcon } from '@/icons'

import { Role } from '@/types'

import '@/utilities/init-dayjs'
import { PageManagerRequestsList } from './pages/manager/requests/list'

function App() {
  return (
    <BrowserRouter>
      <ThemeProvider>
        <DevtoolsProvider>
          <Refine
            authProvider={authProvider}
            routerProvider={routerProvider}
            dataProvider={dataProvider(BASE_URL, axiosInstance)}
            notificationProvider={useNotificationProvider}
            resources={[
              {
                name: 'employee',
                meta: {
                  scope: Role.EMPLOYEE,
                  order: 2,
                },
              },
              {
                name: 'manager',
                meta: {
                  scope: Role.MANAGER,
                  order: 1,
                },
              },
              {
                name: 'time-offs',
                list: '/employee/time-offs',
                create: '/employee/time-offs/new',
                meta: {
                  parent: 'employee',
                  scope: Role.EMPLOYEE,
                  label: 'Time Off',
                  icon: <TimeOffIcon />,
                },
              },
              {
                name: 'time-offs',
                list: '/manager/requests',
                identifier: 'requests',
                meta: {
                  parent: 'manager',
                  scope: Role.MANAGER,
                  label: 'Requests',
                  icon: <RequestsIcon />,
                },
              },
            ]}
            accessControlProvider={accessControlProvider}
            options={{
              reactQuery: {
                clientConfig: queryClient,
              },
              syncWithLocation: true,
              warnWhenUnsavedChanges: true,
              useNewQueryKeys: true,
            }}>
            <Routes>
              <Route
                element={
                  <Authenticated key='authenticated-routes' redirectOnFail='/login'>
                    <Outlet />
                  </Authenticated>
                }>
                <Route index element={<NavigateToResource resource='time-offs' />} />

                <Route
                  path='employee'
                  element={
                    <ThemeProvider role={Role.EMPLOYEE}>
                      <Layout>
                        <Outlet />
                      </Layout>
                    </ThemeProvider>
                  }>
                  <Route path='time-offs' element={<Outlet />}>
                    <Route index element={<PageEmployeeTimeOffsList />} />
                    <Route path='new' element={<PageEmployeeTimeOffsCreate />} />
                  </Route>
                </Route>
              </Route>

              <Route
                path='manager'
                element={
                  <ThemeProvider role={Role.MANAGER}>
                    <Layout>
                      <Outlet />
                    </Layout>
                  </ThemeProvider>
                }>
                <Route path='requests' element={<Outlet />}>
                  <Route index element={<PageManagerRequestsList />} />
                </Route>
              </Route>

              <Route
                element={
                  <Authenticated key='auth-pages' fallback={<Outlet />}>
                    <NavigateToResource resource='time-offs' />
                  </Authenticated>
                }>
                <Route path='/login' element={<PageLogin />} />
              </Route>

              <Route
                element={
                  <Authenticated key='catch-all'>
                    <Layout>
                      <Outlet />
                    </Layout>
                  </Authenticated>
                }>
                <Route path='*' element={<ErrorComponent />} />
              </Route>
            </Routes>

            <UnsavedChangesNotifier />
            <DocumentTitleHandler />
            <Toaster position='bottom-right' reverseOrder={false} />
            <DevtoolsPanel />
          </Refine>
        </DevtoolsProvider>
      </ThemeProvider>
    </BrowserRouter>
  )
}

export default App

Después de agregar estos cambios, puedes navegar a la ruta /manager/requests para ver la página de gestión de solicitudes de tiempo libre en acción

/manager/requests

Construyendo la Página de Detalles de Solicitud de Tiempo Libre

En este paso, crearemos una nueva página para mostrar los detalles de una solicitud de tiempo libre. Esta página mostrará el nombre del empleado, el tipo de tiempo libre, las fechas solicitadas y el estado actual. Los gerentes pueden aprobar o rechazar la solicitud desde esta página.

Construyendo el Componente <TimeOffRequestModal />

Primero, crea un archivo llamado use-get-employee-time-off-usage en la carpeta src/hooks/ y agrega el siguiente código:

src/hooks/use-get-employee-time-off-usage.ts
import { useList } from "@refinedev/core";
import { type TimeOff, TimeOffStatus, TimeOffType } from "@/types";
import { useMemo } from "react";
import dayjs from "dayjs";

export const useGetEmployeeTimeOffUsage = ({
  employeeId,
}: { employeeId?: number }) => {
  const query = useList<TimeOff>({
    resource: "time-offs",
    pagination: { pageSize: 999 },
    filters: [
      {
        field: "status",
        operator: "eq",
        value: TimeOffStatus.APPROVED,
      },
      {
        field: "employeeId",
        operator: "eq",
        value: employeeId,
      },
    ],
    queryOptions: {
      enabled: !!employeeId,
    },
  });
  const data = query?.data?.data;

  const { sick, casual, annual, sickCount, casualCount, annualCount } =
    useMemo(() => {
      const sick: TimeOff[] = [];
      const casual: TimeOff[] = [];
      const annual: TimeOff[] = [];
      let sickCount = 0;
      let casualCount = 0;
      let annualCount = 0;

      data?.forEach((timeOff) => {
        const duration =
          dayjs(timeOff.endsAt).diff(dayjs(timeOff.startsAt), "days") + 1;

        if (timeOff.timeOffType === TimeOffType.SICK) {
          sick.push(timeOff);
          sickCount += duration;
        } else if (timeOff.timeOffType === TimeOffType.CASUAL) {
          casual.push(timeOff);
          casualCount += duration;
        } else if (timeOff.timeOffType === TimeOffType.ANNUAL) {
          annual.push(timeOff);
          annualCount += duration;
        }
      });

      return {
        sick,
        casual,
        annual,
        sickCount,
        casualCount,
        annualCount,
      };
    }, [data]);

  return {
    query,
    sick,
    casual,
    annual,
    sickCount,
    casualCount,
    annualCount,
  };
};

Usaremos el hook useGetEmployeeTimeOffUsage para calcular el número total de días que un empleado ha tomado para cada tipo de tiempo libre. Esta información se mostrará en la página de detalles de la solicitud de tiempo libre.

Después de eso, crea un nuevo archivo llamado time-off-request-modal.tsx en la carpeta src/components/requests/ y agrega el siguiente código:

src/components/requests/time-off-request-modal.tsx
import type { ReactNode } from "react";
import { useInvalidate, useList, useUpdate } from "@refinedev/core";
import {
  Avatar,
  Box,
  Button,
  Divider,
  Tooltip,
  Typography,
} from "@mui/material";
import dayjs from "dayjs";
import { Modal } from "@/components/modal";
import {
  TimeOffStatus,
  TimeOffType,
  type Employee,
  type TimeOff,
} from "@/types";
import { RequestTypeIcon, ThumbsDownIcon, ThumbsUpIcon } from "@/icons";
import { useGetEmployeeTimeOffUsage } from "@/hooks/use-get-employee-time-off-usage";

type Props = {
  open: boolean;
  onClose: () => void;
  loading: boolean;
  onSuccess?: () => void;
  timeOff:
    | (TimeOff & {
        employee: Employee;
      })
    | null
    | undefined;
};

export const TimeOffRequestModal = ({
  open,
  timeOff,
  loading: loadingFromProps,
  onClose,
  onSuccess,
}: Props) => {
  const employeeUsedTimeOffs = useGetEmployeeTimeOffUsage({
    employeeId: timeOff?.employee.id,
  });

  const invalidate = useInvalidate();

  const { mutateAsync } = useUpdate<TimeOff>();

  const employee = timeOff?.employee;
  const duration =
    dayjs(timeOff?.endsAt).diff(dayjs(timeOff?.startsAt), "days") + 1;
  const remainingAnnualLeaveDays =
    (employee?.availableAnnualLeaveDays ?? 0) - duration;

  const { data: timeOffsData, isLoading: timeOffsLoading } = useList<
    TimeOff & { employee: Employee }
  >({
    resource: "time-offs",
    pagination: {
      pageSize: 999,
    },
    filters: [
      {
        field: "status",
        operator: "eq",
        value: TimeOffStatus.APPROVED,
      },
      {
        operator: "and",
        value: [
          {
            field: "startsAt",
            operator: "lte",
            value: timeOff?.endsAt,
          },
          {
            field: "endsAt",
            operator: "gte",
            value: timeOff?.startsAt,
          },
        ],
      },
    ],
    queryOptions: {
      enabled: !!timeOff,
    },
    meta: {
      join: ["employee"],
    },
  });
  const whoIsOutList = timeOffsData?.data || [];

  const handleSubmit = async (status: TimeOffStatus) => {
    await mutateAsync({
      resource: "time-offs",
      id: timeOff?.id,
      invalidates: ["resourceAll"],
      values: {
        status,
      },
    });

    onSuccess?.();
    invalidate({
      resource: "employees",
      invalidates: ["all"],
    });
  };

  const loading = timeOffsLoading || loadingFromProps;

  return (
    <Modal
      open={open}
      title="Time Off Request"
      loading={loading}
      sx={{
        maxWidth: "520px",
      }}
      onClose={onClose}
      footer={
        <>
          <Divider />
          <Box
            sx={{
              display: "flex",
              alignItems: "center",
              justifyContent: "space-between",
              gap: "8px",
              padding: "24px",
            }}
          >
            <Button
              sx={{
                backgroundColor: (theme) => theme.palette.error.light,
              }}
              startIcon={<ThumbsDownIcon />}
              onClick={() => handleSubmit(TimeOffStatus.REJECTED)}
            >
              Decline
            </Button>
            <Button
              sx={{
                backgroundColor: (theme) => theme.palette.success.light,
              }}
              onClick={() => handleSubmit(TimeOffStatus.APPROVED)}
              startIcon={<ThumbsUpIcon />}
            >
              Accept
            </Button>
          </Box>
        </>
      }
    >
      <Box
        sx={{
          display: "flex",
          alignItems: "center",
          padding: "24px",
          backgroundColor: (theme) => theme.palette.grey[50],
          borderBottom: (theme) => `1px solid ${theme.palette.divider}`,
        }}
      >
        <Avatar
          src={employee?.avatarUrl}
          alt={employee?.firstName}
          sx={{
            width: "80px",
            height: "80px",
            marginRight: "24px",
          }}
        />
        <Box
          sx={{
            display: "flex",
            flexDirection: "column",
          }}
        >
          <Typography
            variant="h2"
            fontSize="18px"
            lineHeight="28px"
            fontWeight="500"
          >
            {employee?.firstName} {employee?.lastName}
          </Typography>
          <Typography variant="caption">{employee?.jobTitle}</Typography>
          <Typography variant="caption">{employee?.role}</Typography>
        </Box>
      </Box>

      <Box
        sx={{
          padding: "24px",
        }}
      >
        <InfoRow
          loading={loading}
          label="Request Type"
          value={
            <Box
              component="span"
              sx={{
                display: "flex",
                alignItems: "center",
                gap: "8px",
              }}
            >
              <RequestTypeIcon type={timeOff?.timeOffType} />
              <Typography variant="body2" component="span">
                {timeOff?.timeOffType} Leave
              </Typography>
            </Box>
          }
        />
        <Divider />
        <InfoRow
          loading={loading}
          label="Duration"
          value={`${duration > 1 ? `${duration} days` : `${duration} day`}`}
        />
        <Divider />
        <InfoRow
          loading={loading}
          label={
            {
              [TimeOffType.ANNUAL]: "Remaining Annual Leave Days",
              [TimeOffType.SICK]: "Previously Used Sick Leave Days",
              [TimeOffType.CASUAL]: "Previously Used Casual Leave Days",
            }[timeOff?.timeOffType ?? TimeOffType.ANNUAL]
          }
          value={
            {
              [TimeOffType.ANNUAL]: remainingAnnualLeaveDays,
              [TimeOffType.SICK]: employeeUsedTimeOffs.sickCount,
              [TimeOffType.CASUAL]: employeeUsedTimeOffs.casualCount,
            }[timeOff?.timeOffType ?? TimeOffType.ANNUAL]
          }
        />
        <Divider />
        <InfoRow
          loading={loading}
          label="Start Date"
          value={dayjs(timeOff?.startsAt).format("MMMM DD")}
        />
        <Divider />
        <InfoRow
          loading={loading}
          label="End Date"
          value={dayjs(timeOff?.endsAt).format("MMMM DD")}
        />

        <Divider />
        <Box
          sx={{
            display: "flex",
            flexDirection: "column",
            gap: "8px",
            paddingY: "24px",
          }}
        >
          <Typography variant="body2" fontWeight={600}>
            Notes
          </Typography>
          <Typography
            variant="body2"
            sx={{
              height: "20px",
              fontStyle: timeOff?.notes ? "normal" : "italic",
            }}
          >
            {!loading && (timeOff?.notes || "No notes provided.")}
          </Typography>
        </Box>

        <Divider />
        <Box
          sx={{
            display: "flex",
            flexDirection: "column",
            gap: "8px",
            paddingY: "24px",
          }}
        >
          <Typography variant="body2" fontWeight={600}>
            Who's out between these days?
          </Typography>
          <Box
            sx={{
              display: "flex",
              alignItems: "center",
              flexWrap: "wrap",
              gap: "8px",
            }}
          >
            {whoIsOutList.length ? (
              whoIsOutList.map((whoIsOut) => (
                <Tooltip
                  key={whoIsOut.id}
                  sx={{
                    "& .MuiTooltip-tooltip": {
                      background: "red",
                    },
                  }}
                  title={
                    <Box
                      sx={{
                        display: "flex",
                        flexDirection: "column",
                        gap: "2px",
                      }}
                    >
                      <Typography variant="body2">
                        {whoIsOut.employee.firstName}{" "}
                        {whoIsOut.employee.lastName}
                      </Typography>
                      <Typography variant="caption">
                        {whoIsOut.timeOffType} Leave
                      </Typography>
                      <Typography variant="caption">
                        {dayjs(whoIsOut.startsAt).format("MMMM DD")} -{" "}
                        {dayjs(whoIsOut.endsAt).format("MMMM DD")}
                      </Typography>
                    </Box>
                  }
                  placement="top"
                >
                  <Avatar
                    src={whoIsOut.employee.avatarUrl}
                    alt={whoIsOut.employee.firstName}
                    sx={{
                      width: "32px",
                      height: "32px",
                    }}
                  />
                </Tooltip>
              ))
            ) : (
              <Typography
                variant="body2"
                sx={{
                  height: "32px",
                  fontStyle: "italic",
                }}
              >
                {loading ? "" : "No one is out between these days."}
              </Typography>
            )}
          </Box>
        </Box>
      </Box>
    </Modal>
  );
};

const InfoRow = ({
  label,
  value,
  loading,
}: { label: ReactNode; value: ReactNode; loading: boolean }) => {
  return (
    <Box
      sx={{
        display: "flex",
        justifyContent: "space-between",
        paddingY: "24px",
        height: "72px",
      }}
    >
      <Typography variant="body2">{label}</Typography>
      <Typography variant="body2">{loading ? "" : value}</Typography>
    </Box>
  );
};

Desglosamos el componente <TimeOffRequestModal />:

1. Recuperando el Uso de Tiempo Libre del Empleado

El hook useGetEmployeeTimeOffUsage se utiliza para obtener el uso de tiempo libre del empleado. Este hook calcula los días restantes de vacaciones anuales y los días de licencia por enfermedad y días de licencia casual utilizados previamente basados en el historial de tiempo libre del empleado.

2. Obtención de Solicitudes de Tiempo Libre Aprobadas que se Superponen
filters: [
  {
    field: "status",
    operator: "eq",
    value: TimeOffStatus.APPROVED,
  },
  {
    operator: "and",
    value: [
      {
        field: "startsAt",
        operator: "lte",
        value: timeOff?.endsAt,
      },
      {
        field: "endsAt",
        operator: "gte",
        value: timeOff?.startsAt,
      },
    ],
  },
];

El hook useList con los filtros anteriores obtiene todas las solicitudes de tiempo libre aprobadas que se superponen con la solicitud de tiempo libre actual. Esta lista se utiliza para mostrar a los empleados que están ausentes entre las fechas solicitadas.

3. Manejo de Aprobación/Rechazo de Solicitudes de Tiempo Libre

La función handleSubmit se llama cuando el gerente aprueba o rechaza la solicitud de tiempo libre.

const invalidate = useInvalidate();

// ...

const handleSubmit = async (status: TimeOffStatus) => {
  await mutateAsync({
    resource: "time-offs",
    id: timeOff?.id,
    invalidates: ["resourceAll"],
    values: {
      status,
    },
  });

  onSuccess?.();
  invalidate({
    resource: "employees",
    invalidates: ["all"],
  });
};

Refine invalida automáticamente la caché de recursos después de que el recurso se haya mutado (time-offs en este caso). Dado que el uso de tiempo libre del empleado se calcula en función del historial de tiempo libre, también invalidamos la caché de recursos employees para actualizar el uso de tiempo libre del empleado.

Agregando la Ruta “/manager/requests/:id”

En este paso, crearemos una nueva ruta para mostrar la página de detalles de la solicitud de tiempo libre, donde los gerentes pueden aprobar o rechazar las solicitudes.

Creemos un nuevo archivo llamado edit.tsx en la carpeta src/pages/manager/requests/time-offs/ y agreguemos el siguiente código:

src/pages/manager/requests/time-offs/edit.tsx
import { useGo, useShow } from "@refinedev/core";
import { TimeOffRequestModal } from "@/components/requests/time-off-request-modal";
import type { Employee, TimeOff } from "@/types";

export const PageManagerRequestsTimeOffsEdit = () => {
  const go = useGo();

  const { query: timeOffRequestQuery } = useShow<
    TimeOff & { employee: Employee }
  >({
    meta: {
      join: ["employee"],
    },
  });

  const loading = timeOffRequestQuery.isLoading;

  return (
    <TimeOffRequestModal
      open
      loading={loading}
      timeOff={timeOffRequestQuery?.data?.data}
      onClose={() =>
        go({
          to: {
            resource: "requests",
            action: "list",
          },
        })
      }
      onSuccess={() => {
        go({
          to: {
            resource: "requests",
            action: "list",
          },
        });
      }}
    />
  );
};

Ahora necesitamos agregar la nueva ruta para renderizar la página de detalles de la solicitud de tiempo libre. Actualicemos el archivo App.tsx para incluir esta ruta:

src/App.tsx
import { Authenticated, ErrorComponent, Refine } from '@refinedev/core'
import { DevtoolsProvider, DevtoolsPanel } from '@refinedev/devtools'
import dataProvider from '@refinedev/nestjsx-crud'
import routerProvider, {
  UnsavedChangesNotifier,
  DocumentTitleHandler,
  NavigateToResource,
} from '@refinedev/react-router-v6'
import { BrowserRouter, Routes, Route, Outlet } from 'react-router-dom'
import { Toaster } from 'react-hot-toast'

import { PageEmployeeTimeOffsList } from '@/pages/employee/time-offs/list'
import { PageEmployeeTimeOffsCreate } from '@/pages/employee/time-offs/create'
import { PageManagerRequestsList } from '@/pages/manager/requests/list'
import { PageManagerRequestsTimeOffsEdit } from '@/pages/manager/requests/time-offs/edit'
import { PageLogin } from '@/pages/login'

import { Layout } from '@/components/layout'

import { ThemeProvider } from '@/providers/theme-provider'
import { authProvider } from '@/providers/auth-provider'
import { accessControlProvider } from '@/providers/access-control'
import { useNotificationProvider } from '@/providers/notification-provider'
import { queryClient } from '@/providers/query-client'

import { BASE_URL } from '@/utilities/constants'
import { axiosInstance } from '@/utilities/axios'

import { RequestsIcon, TimeOffIcon } from '@/icons'

import { Role } from '@/types'

import '@/utilities/init-dayjs'

function App() {
  return (
    <BrowserRouter>
      <ThemeProvider>
        <DevtoolsProvider>
          <Refine
            authProvider={authProvider}
            routerProvider={routerProvider}
            dataProvider={dataProvider(BASE_URL, axiosInstance)}
            notificationProvider={useNotificationProvider}
            resources={[
              {
                name: 'employee',
                meta: {
                  scope: Role.EMPLOYEE,
                  order: 2,
                },
              },
              {
                name: 'manager',
                meta: {
                  scope: Role.MANAGER,
                  order: 1,
                },
              },
              {
                name: 'time-offs',
                list: '/employee/time-offs',
                create: '/employee/time-offs/new',
                meta: {
                  parent: 'employee',
                  scope: Role.EMPLOYEE,
                  label: 'Time Off',
                  icon: <TimeOffIcon />,
                },
              },
              {
                name: 'time-offs',
                list: '/manager/requests',
                edit: '/manager/requests/:id/edit',
                identifier: 'requests',
                meta: {
                  parent: 'manager',
                  scope: Role.MANAGER,
                  label: 'Requests',
                  icon: <RequestsIcon />,
                },
              },
            ]}
            accessControlProvider={accessControlProvider}
            options={{
              reactQuery: {
                clientConfig: queryClient,
              },
              syncWithLocation: true,
              warnWhenUnsavedChanges: true,
              useNewQueryKeys: true,
            }}>
            <Routes>
              <Route
                element={
                  <Authenticated key='authenticated-routes' redirectOnFail='/login'>
                    <Outlet />
                  </Authenticated>
                }>
                <Route index element={<NavigateToResource resource='time-offs' />} />

                <Route
                  path='employee'
                  element={
                    <ThemeProvider role={Role.EMPLOYEE}>
                      <Layout>
                        <Outlet />
                      </Layout>
                    </ThemeProvider>
                  }>
                  <Route path='time-offs' element={<Outlet />}>
                    <Route index element={<PageEmployeeTimeOffsList />} />
                    <Route path='new' element={<PageEmployeeTimeOffsCreate />} />
                  </Route>
                </Route>
              </Route>

              <Route
                path='manager'
                element={
                  <ThemeProvider role={Role.MANAGER}>
                    <Layout>
                      <Outlet />
                    </Layout>
                  </ThemeProvider>
                }>
                <Route
                  path='requests'
                  element={
                    <PageManagerRequestsList>
                      <Outlet />
                    </PageManagerRequestsList>
                  }>
                  <Route path=':id/edit' element={<PageManagerRequestsTimeOffsEdit />} />
                </Route>
              </Route>

              <Route
                element={
                  <Authenticated key='auth-pages' fallback={<Outlet />}>
                    <NavigateToResource resource='time-offs' />
                  </Authenticated>
                }>
                <Route path='/login' element={<PageLogin />} />
              </Route>

              <Route
                element={
                  <Authenticated key='catch-all'>
                    <Layout>
                      <Outlet />
                    </Layout>
                  </Authenticated>
                }>
                <Route path='*' element={<ErrorComponent />} />
              </Route>
            </Routes>

            <UnsavedChangesNotifier />
            <DocumentTitleHandler />
            <Toaster position='bottom-right' reverseOrder={false} />
            <DevtoolsPanel />
          </Refine>
        </DevtoolsProvider>
      </ThemeProvider>
    </BrowserRouter>
  )
}

export default App

Veamos más de cerca los cambios:

<Route
  path="requests"
  element={
    <PageManagerRequestsList>
      <Outlet />
    </PageManagerRequestsList>
  }
>
  <Route path=":id/edit" element={<PageManagerRequestsTimeOffsEdit />} />
</Route>

El código anterior establece una estructura de rutas anidadas donde se muestra un modal al navegar a una ruta secundaria específica. El componente <PageManagerRequestsTimeOffsEdit /> es un modal y se renderiza como un hijo del componente <PageManagerRequestsList />. Esta estructura nos permite mostrar el modal sobre la página de la lista mientras mantenemos la página de la lista visible en el fondo.

Cuando navegas a la ruta /manager/requests/:id/edit o haces clic en una solicitud de tiempo libre en la lista, se mostrará la página de detalles de la solicitud de tiempo libre como un modal sobre la página de la lista.

/manager/requests/:id/edit

Paso 6 — Implementación de Autorización y Control de Acceso

La autorización es un componente crítico en las aplicaciones a nivel empresarial, desempeñando un papel clave tanto en la seguridad como en la eficiencia operativa. Asegura que solo los usuarios autorizados puedan acceder a recursos específicos, protegiendo datos y funcionalidades sensibles. El sistema de autorización de Refine proporciona la infraestructura necesaria para proteger sus recursos y garantizar que los usuarios interactúen con su aplicación de manera segura y controlada. En este paso, implementaremos la autorización y el control de acceso para la gestión de solicitudes de tiempo libre. Restringiremos el acceso a las rutas /manager/requests y /manager/requests/:id/edit solo a los gerentes con la ayuda del componente <CanAccess />.

En este momento, cuando inicias sesión como empleado, no puedes ver el enlace a la página de Solicitudes en la barra lateral, pero aún puedes acceder a la ruta /manager/requests escribiendo la URL en el navegador. Agregaremos una protección para evitar el acceso no autorizado a estas rutas.

Actualicemos el archivo App.tsx para incluir las verificaciones de autorización:

src/App.tsx
import { Authenticated, CanAccess, ErrorComponent, Refine } from '@refinedev/core'
import { DevtoolsProvider, DevtoolsPanel } from '@refinedev/devtools'
import dataProvider from '@refinedev/nestjsx-crud'
import routerProvider, {
  UnsavedChangesNotifier,
  DocumentTitleHandler,
  NavigateToResource,
} from '@refinedev/react-router-v6'
import { BrowserRouter, Routes, Route, Outlet } from 'react-router-dom'
import { Toaster } from 'react-hot-toast'

import { PageEmployeeTimeOffsList } from '@/pages/employee/time-offs/list'
import { PageEmployeeTimeOffsCreate } from '@/pages/employee/time-offs/create'
import { PageManagerRequestsList } from '@/pages/manager/requests/list'
import { PageManagerRequestsTimeOffsEdit } from '@/pages/manager/requests/time-offs/edit'
import { PageLogin } from '@/pages/login'

import { Layout } from '@/components/layout'

import { ThemeProvider } from '@/providers/theme-provider'
import { authProvider } from '@/providers/auth-provider'
import { accessControlProvider } from '@/providers/access-control'
import { useNotificationProvider } from '@/providers/notification-provider'
import { queryClient } from '@/providers/query-client'

import { BASE_URL } from '@/utilities/constants'
import { axiosInstance } from '@/utilities/axios'

import { RequestsIcon, TimeOffIcon } from '@/icons'

import { Role } from '@/types'

import '@/utilities/init-dayjs'

function App() {
  return (
    <BrowserRouter>
      <ThemeProvider>
        <DevtoolsProvider>
          <Refine
            authProvider={authProvider}
            routerProvider={routerProvider}
            dataProvider={dataProvider(BASE_URL, axiosInstance)}
            notificationProvider={useNotificationProvider}
            resources={[
              {
                name: 'employee',
                meta: {
                  scope: Role.EMPLOYEE,
                  order: 2,
                },
              },
              {
                name: 'manager',
                meta: {
                  scope: Role.MANAGER,
                  order: 1,
                },
              },
              {
                name: 'time-offs',
                list: '/employee/time-offs',
                create: '/employee/time-offs/new',
                meta: {
                  parent: 'employee',
                  scope: Role.EMPLOYEE,
                  label: 'Time Off',
                  icon: <TimeOffIcon />,
                },
              },
              {
                name: 'time-offs',
                list: '/manager/requests',
                edit: '/manager/requests/:id/edit',
                identifier: 'requests',
                meta: {
                  parent: 'manager',
                  scope: Role.MANAGER,
                  label: 'Requests',
                  icon: <RequestsIcon />,
                },
              },
            ]}
            accessControlProvider={accessControlProvider}
            options={{
              reactQuery: {
                clientConfig: queryClient,
              },
              syncWithLocation: true,
              warnWhenUnsavedChanges: true,
              useNewQueryKeys: true,
            }}>
            <Routes>
              <Route
                element={
                  <Authenticated key='authenticated-routes' redirectOnFail='/login'>
                    <Outlet />
                  </Authenticated>
                }>
                <Route index element={<NavigateToResource resource='time-offs' />} />

                <Route
                  path='employee'
                  element={
                    <ThemeProvider role={Role.EMPLOYEE}>
                      <Layout>
                        <Outlet />
                      </Layout>
                    </ThemeProvider>
                  }>
                  <Route path='time-offs' element={<Outlet />}>
                    <Route index element={<PageEmployeeTimeOffsList />} />
                    <Route path='new' element={<PageEmployeeTimeOffsCreate />} />
                  </Route>
                </Route>
              </Route>

              <Route
                path='manager'
                element={
                  <ThemeProvider role={Role.MANAGER}>
                    <Layout>
                      <CanAccess action='manager' fallback={<NavigateToResource resource='time-offs' />}>
                        <Outlet />
                      </CanAccess>
                    </Layout>
                  </ThemeProvider>
                }>
                <Route
                  path='requests'
                  element={
                    <PageManagerRequestsList>
                      <Outlet />
                    </PageManagerRequestsList>
                  }>
                  <Route path=':id/edit' element={<PageManagerRequestsTimeOffsEdit />} />
                </Route>
              </Route>

              <Route
                element={
                  <Authenticated key='auth-pages' fallback={<Outlet />}>
                    <NavigateToResource resource='time-offs' />
                  </Authenticated>
                }>
                <Route path='/login' element={<PageLogin />} />
              </Route>

              <Route
                element={
                  <Authenticated key='catch-all'>
                    <Layout>
                      <Outlet />
                    </Layout>
                  </Authenticated>
                }>
                <Route path='*' element={<ErrorComponent />} />
              </Route>
            </Routes>

            <UnsavedChangesNotifier />
            <DocumentTitleHandler />
            <Toaster position='bottom-right' reverseOrder={false} />
            <DevtoolsPanel />
          </Refine>
        </DevtoolsProvider>
      </ThemeProvider>
    </BrowserRouter>
  )
}

export default App

En el código anterior, agregamos el componente <CanAccess /> a la ruta “/manager”. Este componente verifica si el usuario tiene el rol de “gerente” antes de renderizar las rutas secundarias. Si el usuario no tiene el rol de “gerente”, será redirigido a la página de lista de tiempo libre para empleados.

Ahora, cuando inicies sesión como empleado e intentes acceder a la ruta /manager/requests, serás redirigido a la página de lista de tiempo libre para empleados.

Paso 7 — Desplegando en la plataforma de aplicaciones de DigitalOcean

En este paso, desplegaremos la aplicación en la plataforma de aplicaciones de DigitalOcean. Para hacer eso, alojaremos el código fuente en GitHub y conectaremos el repositorio de GitHub a la plataforma de aplicaciones.

Subiendo el código a GitHub

Inicia sesión en tu cuenta de GitHub y crea un nuevo repositorio llamado refine-hr. Puedes hacer el repositorio público o privado:

Después de crear el repositorio, navega al directorio del proyecto y ejecuta el siguiente comando para inicializar un nuevo repositorio Git:

git init

Luego, agrega todos los archivos al repositorio Git con este comando:

git add .

Después, confirma los archivos con este comando:

git commit -m "Initial commit"

Luego, agrega el repositorio de GitHub como un repositorio remoto con este comando:

git remote add origin <your-github-repository-url>

Después, especifica que deseas enviar tu código a la rama main con este comando:

git branch -M main

Finalmente, empuja el código al repositorio de GitHub con este comando:

git push -u origin main

Cuando se te pida, ingresa tus credenciales de GitHub para empujar tu código.

Recibirás un mensaje de éxito después de que el código se haya empujado al repositorio de GitHub.

En esta sección, empujaste tu proyecto a GitHub para que puedas acceder a él utilizando DigitalOcean Apps. El siguiente paso es crear una nueva App de DigitalOcean usando tu proyecto y configurar la implementación automática.

Desplegando en la Plataforma de Apps de DigitalOcean

Durante esto, tomarías una aplicación de React y la prepararías para su implementación a través de la Plataforma de Apps de DigitalOcean. Vincularías tu repositorio de GitHub a DigitalOcean, configurarías cómo se construirá la aplicación y luego crearías una implementación inicial de un proyecto. Después de que el proyecto se despliegue, los cambios adicionales que realices se reconstruirán y actualizarán automáticamente.

Al final de este paso, tendrás tu aplicación desplegada en DigitalOcean con entrega continua configurada.

Inicia sesión en tu cuenta de DigitalOcean y navega a la página de Apps. Haz clic en el botón Crear App:

Si no has conectado tu cuenta de GitHub a DigitalOcean, se te pedirá que lo hagas. Haz clic en el botón Conectar con GitHub. Se abrirá una nueva ventana pidiéndote que autorices a DigitalOcean a acceder a tu cuenta de GitHub.

Después de autorizar a DigitalOcean, serás redirigido de nuevo a la página de Aplicaciones de DigitalOcean. El siguiente paso es seleccionar tu repositorio de GitHub. Después de seleccionar tu repositorio, se te pedirá que elijas una rama para implementar. Selecciona la rama main y haz clic en el botón Siguiente.

Después de eso, verás los pasos de configuración para tu aplicación. En este tutorial, puedes hacer clic en el botón Siguiente para omitir los pasos de configuración. Sin embargo, también puedes configurar tu aplicación según desees.

Espera a que se complete la compilación. Después de que la compilación esté completa, presiona Aplicación en vivo para acceder a tu proyecto en el navegador. Será igual al proyecto que probaste localmente, pero este estará en vivo en la web con una URL segura. Además, puedes seguir este tutorial disponible en el sitio de la comunidad de DigitalOcean para aprender cómo implementar aplicaciones basadas en React en la Plataforma de Aplicaciones.

Nota: En caso de que la compilación no se implemente correctamente, puedes configurar tu comando de compilación en DigitalOcean para usar npm install --production=false && npm run build && npm prune --production en lugar de npm run build

Conclusión

En este tutorial, construimos una aplicación de gestión de recursos humanos desde cero utilizando Refine y nos familiarizamos con cómo construir una aplicación CRUD totalmente funcional.

También, demostraremos cómo implementar su aplicación en la Plataforma de Aplicaciones de DigitalOcean.

Si desea aprender más sobre Refine, puede consultar la documentación y si tiene alguna pregunta o comentario, puede unirse al Servidor de Discord de Refine.

Source:
https://www.digitalocean.com/community/developer-center/building-and-deploying-an-hr-app-using-refine