Skip to content
The Chat Archive
o1-preview-2024-09-12· OpenAI WildChat-4.8M (AI2)

En el siguiente archivo cuando se edita, modifica un user o se crea se puede seleccionar…

  1. User

    En el siguiente archivo cuando se edita, modifica un user o se crea se puede seleccionar worker rider y luego hay que seleccionar Tipo de Rider Externo: En la opcion vinculado_a_cooperativa, hay que agregar otra seleccion que es Cooperativas vinculadas: y los checkbox se las cooperativas para vincular pero es diferente al que ya existe, este se activa cuando se selecciona tipo de rider, como externo vinculado a cooperativa: // UsersPage.js

    import React, { useState, useEffect, useCallback, useMemo } from 'react'; import Layout from '../components/Layout'; import { useGlobalContext } from '../context/GlobalContext'; import styles from '../styles/Users.module.css'; import _ from 'lodash';

    // Definición de opciones para roles y tipos const ROLE_OPTIONS = ['customer', 'vendor/seller', 'worker', 'admin']; const VENDOR_TYPE_OPTIONS = ['al público', 'al por mayor', 'directo']; const WORKER_TYPE_OPTIONS = ['influencer', 'rider', 'freelance']; // Nuevas opciones para rider const RIDER_TYPES = ['interno', 'externo']; // Solo interno y externo const EXTERNAL_RIDER_TYPE_OPTIONS = ['independiente', 'vinculado_a_cooperativa']; // Tipos de externo const VEHICLE_TYPES = [ 'bicicleta', 'patineta_electrica', 'taxi', 'carro', 'carro_de_lujo', 'carro_antiguo', 'van', 'camion', 'tractomula', ];

    // Estado inicial del usuario const initialUserState = { username: '', email: '', password: '', fullName: '', phoneNumber: '', dateOfBirth: '', roles: [], vendorDetails: { vendorTypes: [], additionalInfo: {}, }, workerDetails: { workerTypes: [], riderDetails: { riderType: '', externalType: '', vehicleTypes: [], }, additionalInfo: {}, }, stores: [], cooperatives: [], };

    // Componente UserForm const UserForm = ({ addUser, selectedUser, updateUser, addStore, addCooperative, stores, cooperatives, onCancel, }) => { const [user, setUser] = useState(initialUserState); const [errors, setErrors] = useState({}); const [newStoreName, setNewStoreName] = useState(''); const [newCooperativeName, setNewCooperativeName] = useState(''); const [isSubmitting, setIsSubmitting] = useState(false); const [userExists, setUserExists] = useState(true); const [updateMessage, setUpdateMessage] = useState(''); const [formDisabled, setFormDisabled] = useState(false); const [userNotFoundError, setUserNotFoundError] = useState(false);

    // Actualizar formulario cuando cambia el usuario seleccionado useEffect(() => { if (selectedUser) { setUser({ ...initialUserState, ...selectedUser, vendorDetails: { vendorTypes: Array.isArray(selectedUser.vendorDetails?.vendorTypes) ? selectedUser.vendorDetails.vendorTypes : [], additionalInfo: selectedUser.vendorDetails?.additionalInfo || {}, }, workerDetails: { workerTypes: Array.isArray(selectedUser.workerDetails?.workerTypes) ? selectedUser.workerDetails.workerTypes : [], riderDetails: { riderTypes: Array.isArray(selectedUser.workerDetails?.riderDetails?.riderTypes) ? selectedUser.workerDetails.riderDetails.riderTypes : [], vehicleTypes: Array.isArray(selectedUser.workerDetails?.riderDetails?.vehicleTypes) ? selectedUser.workerDetails.riderDetails.vehicleTypes : [], // Include other properties with defaults riderType: selectedUser.workerDetails?.riderDetails?.riderType || '', externalType: selectedUser.workerDetails?.riderDetails?.externalType || '', cooperative: selectedUser.workerDetails?.riderDetails?.cooperative || '', vehicleType: selectedUser.workerDetails?.riderDetails?.vehicleType || '', }, additionalInfo: selectedUser.workerDetails?.additionalInfo || {}, }, }); setUserExists(true); setFormDisabled(false); } else { setUser(initialUserState); setUserExists(true); setFormDisabled(false); } }, [selectedUser]);

    // Validar datos del usuario const validateUser = useCallback( (user) => { const errors = {}; if (!user.username?.trim()) errors.username = 'El nombre de usuario es requerido'; if (!user.email?.trim()) { errors.email = 'El correo electrónico es requerido'; } else if (!/\S+@\S+.\S+/.test(user.email)) { errors.email = 'Ingrese un correo electrónico válido'; } if (!user.fullName?.trim()) errors.fullName = 'El nombre completo es requerido'; if (!selectedUser && !user.password?.trim()) { errors.password = 'La contraseña es requerida para nuevos usuarios'; } else if (user.password && user.password.length < 6) { errors.password = 'La contraseña debe tener al menos 6 caracteres'; } if (user.roles.length === 0) { errors.roles = 'Seleccione al menos un rol'; } if ( user.roles.includes('vendor/seller') && (!user.vendorDetails || user.vendorDetails.vendorTypes.length === 0) ) { errors.vendorTypes = 'Seleccione al menos un tipo de vendedor'; } if ( user.roles.includes('worker') && user.workerDetails.workerTypes.includes('rider') ) { if (!user.workerDetails.riderDetails.riderType) { errors['riderDetails.riderType'] = 'Seleccione un tipo de Rider'; } if ( user.workerDetails.riderDetails.riderType === 'externo' && !user.workerDetails.riderDetails.externalType ) { errors['riderDetails.externalType'] = 'Seleccione un tipo de Rider Externo'; } if (user.workerDetails.riderDetails.vehicleTypes.length === 0) { errors['riderDetails.vehicleTypes'] = 'Seleccione al menos un tipo de vehículo'; } } return errors; }, [selectedUser] );

    // Manejar cambios en los campos del formulario const handleChange = useCallback((e) => { const { name, value } = e.target; setUser((prevUser) => ({ ...prevUser, [name]: value })); setErrors((prevErrors) => ({ ...prevErrors, [name]: '' })); }, []);

    // Manejar cambios en los roles const handleRolesChange = useCallback((e) => { const role = e.target.value; setUser((prevUser) => ({ ...prevUser, roles: prevUser.roles.includes(role) ? prevUser.roles.filter((r) => r !== role) : [...prevUser.roles, role], })); setErrors((prevErrors) => ({ ...prevErrors, roles: '' })); }, []);

    // Manejar cambios en los tipos de vendedor (checkboxes) const handleVendorTypeCheckboxChange = useCallback((e) => { const { value } = e.target; setUser((prevUser) => { const vendorTypes = prevUser.vendorDetails.vendorTypes.includes(value) ? prevUser.vendorDetails.vendorTypes.filter((type) => type !== value) : [...prevUser.vendorDetails.vendorTypes, value]; return { ...prevUser, vendorDetails: { ...prevUser.vendorDetails, vendorTypes, }, }; }); setErrors((prevErrors) => ({ ...prevErrors, vendorTypes: '' })); }, []);

    // Manejar cambios en los tipos de trabajador const handleWorkerTypesChange = useCallback((e) => { const { value } = e.target; setUser((prevUser) => { const updatedWorkerTypes = prevUser.workerDetails.workerTypes.includes(value) ? prevUser.workerDetails.workerTypes.filter((t) => t !== value) : [...prevUser.workerDetails.workerTypes, value];

      return {
        ...prevUser,
        workerDetails: {
          ...prevUser.workerDetails,
          workerTypes: updatedWorkerTypes,
          riderDetails: updatedWorkerTypes.includes('rider')
            ? prevUser.workerDetails.riderDetails
            : {
                riderType: '',
                externalType: '',
                cooperative: '',
                vehicleType: '',
              },
        },
      };
    });
    setErrors((prevErrors) => ({ ...prevErrors, workerTypes: '' }));
    

    }, []);

    // Manejar cambios en las tiendas vinculadas (checkboxes) const handleStoresCheckboxChange = useCallback((e) => { const { value } = e.target; setUser((prevUser) => { const stores = prevUser.stores.includes(value) ? prevUser.stores.filter((storeId) => storeId !== value) : [...prevUser.stores, value]; return { ...prevUser, stores, }; }); }, []);

    // Manejar la creación de una nueva tienda const handleCreateStore = useCallback(() => { if (newStoreName.trim()) { const newStore = { name: newStoreName.trim() }; addStore(newStore, (createdStore) => { setUser((prevUser) => ({ ...prevUser, stores: [...prevUser.stores, createdStore._id], })); setNewStoreName(''); }); } }, [newStoreName, addStore]);

    // Manejar cambios en las cooperativas vinculadas (checkboxes) const handleCooperativesCheckboxChange = useCallback((e) => { const { value } = e.target; setUser((prevUser) => { const cooperatives = prevUser.cooperatives.includes(value) ? prevUser.cooperatives.filter((coopId) => coopId !== value) : [...prevUser.cooperatives, value]; return { ...prevUser, cooperatives, }; }); }, []);

    // Manejar cambios en los tipos de Rider const handleRiderTypesChange = useCallback((e) => { const { value } = e.target; setUser((prevUser) => ({ ...prevUser, workerDetails: { ...prevUser.workerDetails, riderDetails: { ...prevUser.workerDetails.riderDetails, riderType: value, // Actualiza riderType directamente }, }, })); }, []);

    // Manejar cambios en los tipos de Rider Externo const handleExternalRiderTypeChange = useCallback((e) => { const { value } = e.target; setUser((prevUser) => ({ ...prevUser, workerDetails: { ...prevUser.workerDetails, riderDetails: { ...prevUser.workerDetails.riderDetails, externalType: value, // Actualiza externalType directamente }, }, })); }, []);

    const handleVehicleTypesChange = useCallback((e) => { const { value } = e.target; setUser((prevUser) => ({ ...prevUser, workerDetails: { ...prevUser.workerDetails, riderDetails: { ...prevUser.workerDetails.riderDetails, vehicleTypes: prevUser.workerDetails.riderDetails?.vehicleTypes?.includes(value) ? prevUser.workerDetails.riderDetails.vehicleTypes.filter(type => type !== value) : [...(prevUser.workerDetails.riderDetails?.vehicleTypes || []), value], }, }, })); }, []);

    // Manejar la creación de una nueva cooperativa const handleCreateCooperative = useCallback(() => { if (newCooperativeName.trim()) { const newCooperative = { name: newCooperativeName.trim() }; addCooperative(newCooperative, (createdCooperative) => { setUser((prevUser) => ({ ...prevUser, cooperatives: [...prevUser.cooperatives, createdCooperative._id], })); setNewCooperativeName(''); }); } }, [newCooperativeName, addCooperative]);

    const handleSubmit = useCallback( async (e) => { e.preventDefault(); setErrors({}); setUpdateMessage('');

      const validationErrors = validateUser(user);
      if (Object.keys(validationErrors).length === 0) {
        setIsSubmitting(true);
        try {
          const userDataToSubmit = { ...user };
    
          // Si es una actualización y no se proporciona contraseña, eliminarla del objeto
          if (selectedUser && !userDataToSubmit.password) {
            delete userDataToSubmit.password;
          }
    
          // Manejar vendorDetails y workerDetails
          if (userDataToSubmit.roles.includes('vendor/seller')) {
            userDataToSubmit.vendorDetails = userDataToSubmit.vendorDetails || {};
            userDataToSubmit.vendorDetails.vendorTypes =
              userDataToSubmit.vendorDetails.vendorTypes || [];
          } else {
            delete userDataToSubmit.vendorDetails;
          }
    
          if (userDataToSubmit.roles.includes('worker')) {
            userDataToSubmit.workerDetails = userDataToSubmit.workerDetails || {};
            userDataToSubmit.workerDetails.workerTypes =
              userDataToSubmit.workerDetails.workerTypes || [];
            if (userDataToSubmit.workerDetails.workerTypes.includes('rider')) {
              userDataToSubmit.workerDetails.riderDetails =
                userDataToSubmit.workerDetails.riderDetails || {};
              userDataToSubmit.workerDetails.riderDetails.riderType =
                userDataToSubmit.workerDetails.riderDetails.riderType || '';
              if (userDataToSubmit.workerDetails.riderDetails.riderType === 'externo') {
                userDataToSubmit.workerDetails.riderDetails.externalType =
                  userDataToSubmit.workerDetails.riderDetails.externalType || '';
              } else {
                delete userDataToSubmit.workerDetails.riderDetails.externalType;
              }
            } else {
              delete userDataToSubmit.workerDetails.riderDetails;
            }
          } else {
            delete userDataToSubmit.workerDetails;
          }
    
          if (selectedUser) {
            const updatedFields = {
              roles: userDataToSubmit.roles,
            };
    
            if (userDataToSubmit.roles.includes('vendor/seller')) {
              updatedFields.vendorDetails = userDataToSubmit.vendorDetails;
            }
    
            if (userDataToSubmit.roles.includes('worker')) {
              updatedFields.workerDetails = userDataToSubmit.workerDetails;
              updatedFields.cooperatives = userDataToSubmit.cooperatives;
            } else {
              updatedFields.cooperatives = [];
            }
    
            // Comparar y agregar otros campos que hayan cambiado
            Object.keys(userDataToSubmit).forEach((key) => {
              if (!['roles', 'vendorDetails', 'workerDetails', 'cooperatives'].includes(key)) {
                if (!_.isEqual(userDataToSubmit[key], selectedUser[key])) {
                  updatedFields[key] = userDataToSubmit[key];
                }
              }
            });
    
            if (Object.keys(updatedFields).length > 0) {
              console.log('Campos a actualizar:', updatedFields);
              try {
                const updatedUser = await updateUser(selectedUser._id, updatedFields);
                console.log('Usuario actualizado exitosamente:', updatedUser);
                if (updatedUser) {
                  setUpdateMessage('Usuario actualizado exitosamente');
                  setUser(updatedUser);
                  setUserNotFoundError(false);
                } else {
                  throw new Error(
                    'La respuesta del servidor no contiene los datos del usuario actualizados'
                  );
                }
              } catch (updateError) {
                console.error('Error al actualizar usuario:', updateError);
                if (updateError.errors) {
                  setErrors(updateError.errors);
                  setUpdateMessage('Por favor, corrija los errores señalados.');
                } else {
                  setErrors({
                    submit: updateError.message || 'Error al actualizar el usuario',
                  });
                  setUpdateMessage('Error al actualizar el usuario. Por favor, inténtelo de nuevo.');
                }
              }
            } else {
              setUpdateMessage('No se detectaron cambios en el usuario');
            }
          } else {
            // Lógica para agregar un nuevo usuario
            try {
              const newUser = await addUser(userDataToSubmit);
              setUpdateMessage('Usuario agregado exitosamente');
              setUser(newUser);
            } catch (addError) {
              console.error('Error al agregar usuario:', addError);
              if (addError.errors) {
                setErrors(addError.errors);
                setUpdateMessage('Por favor, corrija los errores señalados.');
              } else {
                setErrors({ submit: addError.message || 'Error al agregar el usuario' });
                setUpdateMessage('Error al agregar el usuario. Por favor, inténtelo de nuevo.');
              }
            }
          }
        } catch (error) {
          console.error('Error inesperado al procesar el usuario:', error);
          setErrors(error.errors || { submit: error.message || 'Error inesperado' });
          setUpdateMessage(
            'Error al procesar el usuario. Por favor, revise los errores e intente nuevamente.'
          );
        } finally {
          setIsSubmitting(false);
        }
      } else {
        setErrors(validationErrors);
        setUpdateMessage('Por favor, corrija los errores antes de enviar.');
      }
    },
    [user, selectedUser, validateUser, updateUser, addUser]
    

    );

    // Resetear el formulario const resetForm = useCallback(() => { setUser( selectedUser ? { ...initialUserState, ...selectedUser, // Reutilizar la lógica de mapeo de 'useEffect' para asegurar consistencia vendorDetails: { vendorTypes: Array.isArray(selectedUser.vendorDetails?.vendorTypes) ? selectedUser.vendorDetails.vendorTypes : [], additionalInfo: selectedUser.vendorDetails?.additionalInfo || {}, }, workerDetails: { workerTypes: Array.isArray(selectedUser.workerDetails?.workerTypes) ? selectedUser.workerDetails.workerTypes : [], riderDetails: { riderType: selectedUser.workerDetails?.riderDetails?.riderType || '', externalType: selectedUser.workerDetails?.riderDetails?.externalType || '', vehicleTypes: Array.isArray(selectedUser.workerDetails?.riderDetails?.vehicleTypes) ? selectedUser.workerDetails.riderDetails.vehicleTypes : [], }, additionalInfo: selectedUser.workerDetails?.additionalInfo || {}, }, } : initialUserState ); setErrors({}); }, [selectedUser]);

    // Efecto para resetear el formulario cuando cambia el usuario seleccionado useEffect(() => { resetForm(); }, [selectedUser, resetForm]);

    return ( {userNotFoundError && ( Este usuario ya no existe en la base de datos. No se pueden realizar cambios. )} {/* Nombre de Usuario */} Nombre de usuario: <input id="username" type="text" name="username" value={user.username} onChange={handleChange} placeholder="Ingrese el nombre de usuario" required disabled={formDisabled || !userExists} /> {errors.username && {errors.username}}

      {/* Correo Electrónico */}
      <div className={styles.formGroup}>
        <label htmlFor="email">Correo electrónico:</label>
        <input
          id="email"
          type="email"
          name="email"
          value={user.email}
          onChange={handleChange}
          placeholder="Ingrese el correo electrónico"
          required
          disabled={formDisabled || !userExists}
        />
        {errors.email && <p className={styles.error}>{errors.email}</p>}
      </div>
    
      {/* Contraseña (solo para nuevos usuarios) */}
      <div className={styles.formGroup}>
        <label htmlFor="password">
          {selectedUser
            ? 'Nueva contraseña (dejar en blanco para mantener la actual):'
            : 'Contraseña:'}
        </label>
        <input
          id="password"
          type="password"
          name="password"
          value={user.password || ''}
          onChange={handleChange}
          placeholder={selectedUser ? 'Nueva contraseña (opcional)' : 'Ingrese la contraseña'}
          required={!selectedUser}
        />
        {errors.password && <p className={styles.error}>{errors.password}</p>}
      </div>
    
      {/* Nombre Completo */}
      <div className={styles.formGroup}>
        <label htmlFor="fullName">Nombre completo:</label>
        <input
          id="fullName"
          type="text"
          name="fullName"
          value={user.fullName}
          onChange={handleChange}
          placeholder="Ingrese el nombre completo"
          required
        />
        {errors.fullName && <p className={styles.error}>{errors.fullName}</p>}
      </div>
    
      {/* Número de Teléfono */}
      <div className={styles.formGroup}>
        <label htmlFor="phoneNumber">Número de teléfono:</label>
        <input
          id="phoneNumber"
          type="tel"
          name="phoneNumber"
          value={user.phoneNumber}
          onChange={handleChange}
          placeholder="Ingrese el número de teléfono"
        />
      </div>
    
      {/* Fecha de Nacimiento */}
      <div className={styles.formGroup}>
        <label htmlFor="dateOfBirth">Fecha de nacimiento:</label>
        <input
          id="dateOfBirth"
          type="date"
          name="dateOfBirth"
          value={user.dateOfBirth}
          onChange={handleChange}
        />
      </div>
    
      {/* Roles */}
      <div className={styles.formGroup}>
        <label>Roles:</label>
        <div className={styles.checkboxGroup}>
          {ROLE_OPTIONS.map((role) => (
            <label key={role} className={styles.checkboxLabel}>
              <input
                type="checkbox"
                value={role}
                checked={user.roles.includes(role)}
                onChange={handleRolesChange}
              />
              {role}
            </label>
          ))}
        </div>
      </div>
    
      {/* Tipos de Vendedor (checkboxes) */}
      {user.roles.includes('vendor/seller') && (
        <div className={styles.formGroup}>
          <label>Tipos de vendedor:</label>
          <div className={styles.checkboxGroup}>
            {VENDOR_TYPE_OPTIONS.map((type) => (
              <label key={type} className={styles.checkboxLabel}>
                <input
                  type="checkbox"
                  value={type}
                  checked={user.vendorDetails.vendorTypes.includes(type)}
                  onChange={handleVendorTypeCheckboxChange}
                />
                {type}
              </label>
            ))}
          </div>
          {errors.vendorTypes && <p className={styles.error}>{errors.vendorTypes}</p>}
        </div>
      )}
    
      {/* Tipos de Trabajador */}
      {user.roles.includes('worker') && (
        <div className={styles.formGroup}>
          <label>Tipos de trabajador:</label>
          <div className={styles.checkboxGroup}>
            {WORKER_TYPE_OPTIONS.map((type) => (
              <label key={type} className={styles.checkboxLabel}>
                <input
                  type="checkbox"
                  value={type}
                  checked={user.workerDetails.workerTypes.includes(type)}
                  onChange={handleWorkerTypesChange}
                />
                {type}
              </label>
            ))}
          </div>
          {errors.workerTypes && <p className={styles.error}>{errors.workerTypes}</p>}
        </div>
      )}
        {/* Detalles de Rider */}
        {user.workerDetails.workerTypes.includes('rider') && (
          <div className={styles.formGroup}>
            <label>Tipo de Rider:</label>
          <select
            value={user.workerDetails.riderDetails?.riderType || ''}
            onChange={handleRiderTypesChange}
          >
            <option value="">Seleccionar</option>
            {RIDER_TYPES.map((type) => (
              <option key={type} value={type}>
                {type}
              </option>
            ))}
          </select>
        </div>
        )}
        {user.workerDetails.riderDetails?.riderType === 'externo' && (
        <div className={styles.formGroup}>
          <label>Tipo de Rider Externo:</label>
          <select
            value={user.workerDetails.riderDetails?.externalType || ''}
            onChange={handleExternalRiderTypeChange}
          >
            <option value="">Seleccionar</option>
            {EXTERNAL_RIDER_TYPE_OPTIONS.map((type) => (
              <option key={type} value={type}>
                {type}
              </option>
            ))}
          </select>
        </div>
        )}
    
      {/* Tipos de vehículo (checkboxes) */}
      {user.workerDetails.workerTypes.includes('rider') && (
        <div className={styles.formGroup}>
          <label>Tipos de vehículo:</label>
          <div className={styles.checkboxGroup}>
            {VEHICLE_TYPES.map((type) => (
              <label key={type} className={styles.checkboxLabel}>
                <input
                  type="checkbox"
                  value={type}
                  checked={user.workerDetails.riderDetails?.vehicleTypes?.includes(type)}
                  onChange={handleVehicleTypesChange}
                />
                {type}
              </label>
            ))}
          </div>
          {errors['riderDetails.vehicleTypes'] && (
            <p className={styles.error}>{errors['riderDetails.vehicleTypes']}</p>
          )}
        </div>
      )}
    
      {/* Tiendas vinculadas (checkboxes) */}
      <div className={styles.formGroup}>
        <label>Tiendas vinculadas:</label>
        <div className={styles.checkboxGroup}>
          {stores.map((store) => (
            <label key={store._id} className={styles.checkboxLabel}>
              <input
                type="checkbox"
                value={store._id}
                checked={user.stores.includes(store._id)}
                onChange={handleStoresCheckboxChange}
              />
              {store.name}
            </label>
          ))}
        </div>
        {stores.length === 0 && (
          <p className={styles.noStoresMessage}>
            No hay tiendas disponibles. Por favor, cree una nueva tienda.
          </p>
        )}
        {user.stores.length === 0 && stores.length > 0 && (
          <p className={styles.noStoresMessage}>
            No tiene tiendas vinculadas. Seleccione una existente o cree una nueva.
          </p>
        )}
      </div>
      <div className={styles.formGroup}>
        <label>Crear nueva tienda:</label>
        <div className={styles.createStore}>
          <input
            type="text"
            placeholder="Nombre de la tienda"
            value={newStoreName}
            onChange={(e) => setNewStoreName(e.target.value)}
          />
          <button type="button" onClick={handleCreateStore} className={styles.createButton}>
            Crear Tienda
          </button>
        </div>
      </div>
    
      {/* Cooperativas vinculadas (checkboxes) */}
      {user.roles.includes('worker') && (
        <>
          <div className={styles.formGroup}>
            <label>Cooperativas vinculadas:</label>
            <div className={styles.checkboxGroup}>
              {cooperatives.map((coop) => (
                <label key={coop._id} className={styles.checkboxLabel}>
                  <input
                    type="checkbox"
                    value={coop._id}
                    checked={user.cooperatives.includes(coop._id)}
                    onChange={handleCooperativesCheckboxChange}
                  />
                  {coop.name}
                </label>
              ))}
            </div>
            {cooperatives.length === 0 && (
              <p className={styles.noStoresMessage}>
                No hay cooperativas disponibles. Por favor, cree una nueva cooperativa.
              </p>
            )}
            {user.cooperatives.length === 0 && cooperatives.length > 0 && (
              <p className={styles.noStoresMessage}>
                No tiene cooperativas vinculadas. Seleccione una existente o cree una nueva.
              </p>
            )}
          </div>
          <div className={styles.formGroup}>
            <label>Crear nueva cooperativa:</label>
            <div className={styles.createStore}>
              <input
                type="text"
                placeholder="Nombre de la cooperativa"
                value={newCooperativeName}
                onChange={(e) => setNewCooperativeName(e.target.value)}
              />
              <button
                type="button"
                onClick={handleCreateCooperative}
                className={styles.createButton}
              >
                Crear Cooperativa
              </button>
            </div>
          </div>
        </>
      )}
    
      {/* Mostrar Errores */}
      {Object.keys(errors).length > 0 && (
        <div className={styles.errorMessages}>
          {Object.entries(errors).map(([key, value]) => (
            <p key={key} className={styles.error}>
              {key === 'submit' ? value : `${value}`}
            </p>
          ))}
        </div>
      )}
    
      {/* Botones del Formulario */}
      <div className={styles.formButtons}>
        <button
          type="submit"
          className={styles.submitButton}
          disabled={isSubmitting || formDisabled || !userExists}
        >
          {selectedUser ? 'Actualizar' : 'Agregar'} Usuario
        </button>
        <button type="button" onClick={onCancel} className={styles.cancelButton}>
          Cancelar
        </button>
      </div>
      {updateMessage && (
        <p className={errors.submit ? styles.error : styles.success}>{updateMessage}</p>
      )}
    </form>
    

    ); }; // Componente UserList const UserList = React.memo( ({ users, setSelectedUser, deleteUser, allStores, allCooperatives, currentPage, itemsPerPage, totalUsers, onPageChange, onRetryLoadStores, onRetryLoadCooperatives, }) => { const sortedUsers = useMemo(() => { if (!Array.isArray(users)) { console.error('Error: users prop is invalid', users); return []; } return [...users].sort((a, b) => (a.username || '').localeCompare(b.username || '')); }, [users]);

    const getStoreName = useCallback(
      (storeId) => {
        if (!Array.isArray(allStores)) {
          console.error('Error: allStores is not an array', allStores);
          return 'Información de tienda no disponible';
        }
        const store = allStores.find((s) => s && s._id === storeId);
        return store ? store.name : 'Nombre de tienda no disponible';
      },
      [allStores]
    );
    
    const getCooperativeName = useCallback(
      (coopId) => {
        if (!Array.isArray(allCooperatives)) {
          console.error('Error: allCooperatives is not an array', allCooperatives);
          return 'Información de cooperativa no disponible';
        }
        const coop = allCooperatives.find((c) => c && c._id === coopId);
        return coop ? coop.name : 'Nombre de cooperativa no disponible';
      },
      [allCooperatives]
    );
    
    if (sortedUsers.length === 0) {
      return <p>No hay usuarios para mostrar en esta página.</p>;
    }
    
    const totalPages = Math.ceil(totalUsers / itemsPerPage);
    
    return (
      <div>
        <h2>Lista de Usuarios (Total: {totalUsers})</h2>
        {allStores.length === 0 && (
          <button onClick={onRetryLoadStores} className={styles.retryButton}>
            Reintentar carga de tiendas
          </button>
        )}
        {allCooperatives.length === 0 && (
          <button onClick={onRetryLoadCooperatives} className={styles.retryButton}>
            Reintentar carga de cooperativas
          </button>
        )}
        <table className={styles.userTable}>
          <thead>
            <tr>
              <th>Nombre de usuario</th>
              <th>Correo electrónico</th>
              <th>Nombre completo</th>
              <th>Roles</th>
              <th>Tiendas vinculadas</th>
              <th>Cooperativas vinculadas</th>
              <th>Tipos de vendedor/trabajador</th>
              <th>Acciones</th>
            </tr>
          </thead>
          <tbody>
            {sortedUsers.map((user) => (
              // En el componente UserList, dentro del <tr> de cada usuario
              <tr key={user._id || `user-${user.username || 'unknown'}`}>
                <td>{user.username || 'N/A'}</td>
                <td>{user.email || 'N/A'}</td>
                <td>{user.fullName || 'N/A'}</td>
                <td>{Array.isArray(user.roles) ? user.roles.join(', ') : 'Sin roles'}</td>
                <td>
    {Array.isArray(user.stores) && user.stores.length > 0 ? (
      <>
        <span>
          {user.stores.length} tienda{user.stores.length !== 1 ? 's' : ''}:
        </span>
        <ul>
          {user.stores.map((storeId) => (
            <li key={storeId}>{getStoreName(storeId)}</li>
          ))}
        </ul>
      </>
    ) : (
      <span>No tiene tiendas vinculadas</span>
    )}
        </td>
    

    // Componente principal UsersPage const UsersPage = () => { const { fetchUsers, fetchStores, fetchCooperatives, registerUser, updateUser, deleteUser, addStore, addCooperative, } = useGlobalContext();

    const [users, setUsers] = useState([]); const [userCount, setUserCount] = useState(0); const [selectedUser, setSelectedUser] = useState(null); const [message, setMessage] = useState({ text: '', type: '' }); const [isLoading, setIsLoading] = useState(true); const [isAdding, setIsAdding] = useState(false); const [stores, setStores] = useState([]); const [cooperatives, setCooperatives] = useState([]); const [currentPage, setCurrentPage] = useState(1); const [itemsPerPage] = useState(10);

    // Función para cargar datos (usuarios, tiendas y cooperativas) const loadData = useCallback(async () => { setIsLoading(true); setMessage({ text: '', type: '' }); let usersLoaded = false; let storesLoaded = false; let cooperativesLoaded = false;

    try {
      // Cargar usuarios con paginación
      let usersResponse;
      try {
        usersResponse = await fetchUsers(currentPage, itemsPerPage);
        console.log('Respuesta de fetchUsers:', usersResponse);
      } catch (fetchError) {
        console.error('Error al obtener usuarios:', fetchError);
        throw new Error(
          'No se pudo obtener la lista de usuarios: ' + (fetchError.message || 'Error desconocido')
        );
      }
    
      if (!usersResponse || typeof usersResponse !== 'object') {
        throw new Error('La respuesta de usuarios es inválida o vacía');
      }
    
      const { users, totalUsers } = usersResponse;
    
      if (!Array.isArray(users)) {
        throw new Error('Los datos de usuarios no son un array válido');
      }
    
      const validUsers = users.filter((user) => user && typeof user === 'object' && user._id);
      setUsers(validUsers);
      setUserCount(typeof totalUsers === 'number' ? totalUsers : validUsers.length);
      usersLoaded = true;
    
      if (validUsers.length === 0) {
        if (currentPage === 1) {
          setMessage({
            text: 'No se encontraron usuarios. La base de datos podría estar vacía.',
            type: 'info',
          });
        } else {
          setMessage({ text: 'No hay más usuarios para mostrar en esta página.', type: 'info' });
          setCurrentPage((prev) => Math.max(prev - 1, 1));
        }
      } else if (validUsers.length !== users.length) {
        console.warn(`Se filtraron ${users.length - validUsers.length} usuarios con estructura inválida`);
        setMessage((prev) => ({
          ...prev,
          text:
            (prev.text ? prev.text + ' ' : '') +
            'Algunos usuarios tienen datos inválidos y no se mostrarán.',
          type: 'warning',
        }));
      }
    
      // Verificar si el usuario seleccionado aún existe
      if (selectedUser && !validUsers.some((user) => user._id === selectedUser._id)) {
        setSelectedUser(null);
      }
    
      // Cargar tiendas
      let storesResponse;
      let validStores = [];
      try {
        storesResponse = await fetchStores();
        console.log('Respuesta de fetchStores:', storesResponse);
    
        if (!storesResponse) {
          throw new Error('La respuesta de tiendas es nula o indefinida');
        }
    
        if (!Array.isArray(storesResponse)) {
          console.warn('La respuesta de tiendas no es un array:', typeof storesResponse);
          if (typeof storesResponse === 'object') {
            // Intenta extraer un array de la respuesta si es un objeto
            const possibleArray = Object.values(storesResponse).find(Array.isArray);
            if (possibleArray) {
              storesResponse = possibleArray;
            } else {
              throw new Error('No se pudo extraer un array válido de la respuesta de tiendas');
            }
          } else {
            throw new Error('La respuesta de tiendas no es un array válido');
          }
        }
    
        validStores = storesResponse.filter(
          (store) => store && typeof store === 'object' && store._id && store.name
        );
    
        if (validStores.length === 0) {
          console.warn('No se encontraron tiendas válidas');
          setMessage((prev) => ({
            ...prev,
            text:
              (prev.text ? prev.text + ' ' : '') +
              'No se encontraron tiendas válidas. Algunas funcionalidades relacionadas con tiendas podrían no estar disponibles.',
            type: 'warning',
          }));
        } else if (validStores.length !== storesResponse.length) {
          console.warn(
            `Se filtraron ${storesResponse.length - validStores.length} tiendas con estructura inválida`
          );
          setMessage((prev) => ({
            ...prev,
            text:
              (prev.text ? prev.text + ' ' : '') +
              'Algunas tiendas tienen datos inválidos y no se mostrarán.',
            type: 'warning',
          }));
        }
    
        setStores(validStores);
        storesLoaded = validStores.length > 0;
      } catch (storesError) {
        console.error('Error al obtener tiendas:', storesError);
        setMessage((prev) => ({
          ...prev,
          text:
            (prev.text ? prev.text + ' ' : '') +
            'No se pudo obtener la lista de tiendas: ' +
            (storesError.message || 'Error desconocido'),
          type: 'error',
        }));
        setStores([]);
      }
    
      // Cargar cooperativas
      let cooperativesResponse;
      let validCooperatives = [];
      try {
        cooperativesResponse = await fetchCooperatives();
        console.log('Respuesta de fetchCooperatives:', cooperativesResponse);
    
        if (!cooperativesResponse) {
          throw new Error('La respuesta de cooperativas es nula o indefinida');
        }
    
        if (!Array.isArray(cooperativesResponse)) {
          console.warn('La respuesta de cooperativas no es un array:', typeof cooperativesResponse);
          if (typeof cooperativesResponse === 'object') {
            const possibleArray = Object.values(cooperativesResponse).find(Array.isArray);
            if (possibleArray) {
              cooperativesResponse = possibleArray;
            } else {
              throw new Error('No se pudo extraer un array válido de la respuesta de cooperativas');
            }
          } else {
            throw new Error('La respuesta de cooperativas no es un array válido');
          }
        }
    
        validCooperatives = cooperativesResponse.filter(
          (coop) => coop && typeof coop === 'object' && coop._id && coop.name
        );
    
        if (validCooperatives.length === 0) {
          console.warn('No se encontraron cooperativas válidas');
          setMessage((prev) => ({
            ...prev,
            text:
              (prev.text ? prev.text + ' ' : '') +
              'No se encontraron cooperativas válidas. Algunas funcionalidades relacionadas con cooperativas podrían no estar disponibles.',
            type: 'warning',
          }));
        } else if (validCooperatives.length !== cooperativesResponse.length) {
          console.warn(
            `Se filtraron ${
              cooperativesResponse.length - validCooperatives.length
            } cooperativas con estructura inválida`
          );
          setMessage((prev) => ({
            ...prev,
            text:
              (prev.text ? prev.text + ' ' : '') +
              'Algunas cooperativas tienen datos inválidos y no se mostrarán.',
            type: 'warning',
          }));
        }
    
        setCooperatives(validCooperatives);
        cooperativesLoaded = validCooperatives.length > 0;
      } catch (cooperativesError) {
        console.error('Error al obtener cooperativas:', cooperativesError);
        setMessage((prev) => ({
          ...prev,
          text:
            (prev.text ? prev.text + ' ' : '') +
            'No se pudo obtener la lista de cooperativas: ' +
            (cooperativesError.message || 'Error desconocido'),
          type: 'error',
        }));
        setCooperatives([]);
      }
    
      if (!storesLoaded) {
        setMessage((prev) => ({
          ...prev,
          text:
            (prev.text ? prev.text + ' ' : '') +
            'Las funcionalidades relacionadas con tiendas estarán limitadas. Puede intentar cargar las tiendas nuevamente haciendo clic en el botón "Reintentar carga de tiendas".',
          type: 'warning',
        }));
      }
    
      if (!cooperativesLoaded) {
        setMessage((prev) => ({
          ...prev,
          text:
            (prev.text ? prev.text + ' ' : '') +
            'Las funcionalidades relacionadas con cooperativas estarán limitadas. Puede intentar cargar las cooperativas nuevamente haciendo clic en el botón "Reintentar carga de cooperativas".',
          type: 'warning',
        }));
      }
    
      console.log(
        `Usuarios válidos cargados: ${validUsers.length}, Total de usuarios: ${
          totalUsers || validUsers.length
        }, Tiendas válidas: ${validStores.length}, Cooperativas válidas: ${validCooperatives.length}`
      );
    } catch (error) {
      console.error('Error detallado:', error);
      let errorMessage = 'Error al cargar datos';
    
      if (error instanceof TypeError && error.message === 'Failed to fetch') {
        errorMessage =
          'Error de conexión. Por favor, verifique su conexión a internet e intente nuevamente.';
      } else if (error.response && error.response.status) {
        switch (error.response.status) {
          case 401:
            errorMessage = 'No autorizado. Por favor, inicie sesión nuevamente.';
            break;
          case 403:
            errorMessage = 'Acceso prohibido. No tiene permisos para ver esta información.';
            break;
          case 404:
            errorMessage = 'Recurso no encontrado. La página o los datos solicitados no existen.';
            break;
          case 500:
            errorMessage = 'Error interno del servidor. Por favor, intente más tarde.';
            break;
          default:
            errorMessage = `Error del servidor (${error.response.status}). Por favor, intente más tarde.`;
        }
      } else if (error.message) {
        errorMessage += `: ${error.message}`;
      }
    
      setMessage({ text: errorMessage, type: 'error' });
      setUsers([]);
      setStores([]);
      setCooperatives([]);
    } finally {
      setIsLoading(false);
    
      if (!usersLoaded) {
        setMessage((prev) => ({
          ...prev,
          text:
            (prev.text ? prev.text + ' ' : '') +
            'Los datos de usuarios no se pudieron cargar correctamente. Intente recargar la página.',
          type: 'error',
        }));
      }
    
      if (usersLoaded && !storesLoaded) {
        setMessage((prev) => ({
          ...prev,
          text:
            (prev.text ? prev.text + ' ' : '') +
            'Las tiendas no se pudieron cargar completamente, pero los datos de usuarios están disponibles. Algunas funcionalidades relacionadas con tiendas podrían no funcionar correctamente.',
          type: 'warning',
        }));
      }
    
      if (usersLoaded && !cooperativesLoaded) {
        setMessage((prev) => ({
          ...prev,
          text:
            (prev.text ? prev.text + ' ' : '') +
            'Las cooperativas no se pudieron cargar completamente, pero los datos de usuarios están disponibles. Algunas funcionalidades relacionadas con cooperativas podrían no funcionar correctamente.',
          type: 'warning',
        }));
      }
    }
    

    }, [ fetchUsers, fetchStores, fetchCooperatives, currentPage, itemsPerPage, selectedUser, ]);

    // Cargar datos al montar el componente y cuando cambia la página actual useEffect(() => { loadData(); }, [loadData]);

    // Manejar la paginación si no hay usuarios en la página actual useEffect(() => { if (users.length === 0 && currentPage > 1) { setCurrentPage((prev) => Math.max(prev - 1, 1)); } }, [users, currentPage]);

    // Manejar agregar un usuario const handleAddUser = useCallback( async (userData) => { try { await registerUser(userData); setMessage({ text: 'Usuario agregado exitosamente', type: 'success' }); setIsAdding(false); loadData(); } catch (error) { let errorMessage = 'Error al agregar usuario'; if (error.response) { switch (error.response.status) { case 400: errorMessage = 'Datos de usuario inválidos. Por favor, verifique la información e intente nuevamente.'; break; case 409: errorMessage = 'El nombre de usuario o correo electrónico ya existe. Por favor, use uno diferente.'; break; default: errorMessage = Error del servidor (${error.response.status}). Por favor, intente más tarde.; } } setMessage({ text: errorMessage, type: 'error' }); } }, [registerUser, loadData] );

    // Manejar actualizar un usuario const handleUpdateUser = useCallback( async (userId, userData) => { try { console.log('Iniciando actualización de usuario:', userId); console.log('Datos a actualizar:', JSON.stringify(userData, null, 2));

        const updatedUser = await updateUser(userId, userData);
    
        console.log('Usuario actualizado exitosamente:', JSON.stringify(updatedUser, null, 2));
        setMessage({ text: 'Usuario actualizado exitosamente', type: 'success' });
    
        // Actualizar el usuario en la lista local
        setUsers((prevUsers) => {
          const updatedUsers = prevUsers.map((user) =>
            user._id === userId ? { ...user, ...updatedUser } : user
          );
          console.log('Lista de usuarios actualizada');
          return updatedUsers;
        });
    
        // Actualizar el usuario seleccionado si está siendo editado
        setSelectedUser((prevSelected) => {
          if (prevSelected && prevSelected._id === userId) {
            console.log('Actualizando usuario seleccionado');
            return { ...prevSelected, ...updatedUser };
          }
          return prevSelected;
        });
    
        setTimeout(() => {
          setMessage({ text: '', type: '' });
        }, 3000);
    
        return updatedUser;
      } catch (error) {
        console.error('Error detallado al actualizar usuario:', error);
        let errorMessage = 'Error al actualizar usuario';
        let errorType = 'error';
        let shouldReloadData = false;
        let shouldUpdateLocalData = false;
    
        if (error.response) {
          console.log('Respuesta de error del servidor:', error.response);
          switch (error.response.status) {
            case 400:
              errorMessage =
                'Datos de usuario inválidos. Por favor, verifique la información e intente nuevamente.';
              break;
            case 401:
              errorMessage = 'Su sesión ha expirado. Por favor, inicie sesión nuevamente.';
              errorType = 'warning';
              shouldReloadData = true;
              break;
            case 403:
              errorMessage =
                'No tiene permisos para realizar esta acción. Sus permisos pueden haber cambiado.';
              errorType = 'warning';
              shouldReloadData = true;
              break;
            case 404:
              errorMessage = 'Usuario no encontrado. Es posible que haya sido eliminado.';
              shouldUpdateLocalData = true;
              break;
            case 409:
              errorMessage =
                'El nombre de usuario o correo electrónico ya está en uso por otro usuario.';
              break;
            case 422:
              errorMessage =
                'Datos de usuario no válidos. Por favor, revise todos los campos e intente nuevamente.';
              break;
            default:
              errorMessage = `Error del servidor (${error.response.status}). Por favor, intente más tarde.`;
          }
          if (error.response.data && error.response.data.message) {
            errorMessage += ` Detalles: ${error.response.data.message}`;
          }
        } else if (error.request) {
          errorMessage =
            'No se recibió respuesta del servidor. Verifique su conexión e intente nuevamente.';
          console.log('Error de red:', error.request);
        } else {
          errorMessage = `Error inesperado: ${error.message}`;
          console.log('Error inesperado:', error.message);
        }
    
        setMessage({ text: errorMessage, type: errorType });
    
        if (shouldReloadData) {
          loadData();
        }
    
        if (shouldUpdateLocalData) {
          setUsers((prevUsers) => prevUsers.filter((user) => user._id !== userId));
          setUserCount((prevCount) => prevCount - 1);
          setSelectedUser(null);
        }
    
        // Limpiar el mensaje de error después de un tiempo
        setTimeout(() => {
          setMessage({ text: '', type: '' });
        }, 5000);
    
        throw new Error(errorMessage);
      }
    },
    [updateUser, setUsers, setSelectedUser, setMessage, loadData, setUserCount]
    

    );

    // Manejar eliminar un usuario const handleDeleteUser = useCallback( async (userId) => { if ( window.confirm( '¿Está seguro de que desea eliminar este usuario? Esta acción no se puede deshacer.' ) ) { try { await deleteUser(userId); setMessage({ text: 'Usuario eliminado exitosamente', type: 'success' }); loadData(); } catch (error) { let errorMessage = 'Error al eliminar usuario'; if (error.response) { switch (error.response.status) { case 404: errorMessage = 'Usuario no encontrado. Es posible que ya haya sido eliminado.'; break; default: errorMessage = Error del servidor (${error.response.status}). Por favor, intente más tarde.; } } setMessage({ text: errorMessage, type: 'error' }); } } }, [deleteUser, loadData] );

    // Manejar agregar una tienda const handleAddStore = useCallback( async (storeData, callback) => { // Validación básica de los datos de la tienda if (!storeData.name || typeof storeData.name !== 'string' || storeData.name.trim() === '') { setMessage({ text: 'El nombre de la tienda es inválido o está vacío. Por favor, proporcione un nombre válido.', type: 'error', }); return; }

      try {
        const newStore = await addStore(storeData);
        setMessage({ text: 'Tienda agregada exitosamente', type: 'success' });
        if (callback) callback(newStore);
        // Actualizar la lista de tiendas después de agregar una nueva
        setStores((prevStores) => [...prevStores, newStore]);
      } catch (error) {
        console.error('Error al agregar tienda:', error);
        let errorMessage = 'Error al agregar tienda: ';
        if (error.response && error.response.data && error.response.data.message) {
          errorMessage += error.response.data.message;
        } else if (error.message) {
          errorMessage += error.message;
        } else {
          errorMessage += 'Ocurrió un error desconocido.';
        }
        errorMessage += ' Por favor, verifique los datos e intente nuevamente.';
        setMessage({ text: errorMessage, type: 'error' });
      }
    },
    [addStore, setMessage, setStores]
    

    );

    // Manejar agregar una cooperativa const handleAddCooperative = useCallback( async (cooperativeData, callback) => { // Validación básica de los datos de la cooperativa if ( !cooperativeData.name || typeof cooperativeData.name !== 'string' || cooperativeData.name.trim() === '' ) { setMessage({ text: 'El nombre de la cooperativa es inválido o está vacío. Por favor, proporcione un nombre válido.', type: 'error', }); return; }

      try {
        const newCooperative = await addCooperative(cooperativeData);
        setMessage({ text: 'Cooperativa agregada exitosamente', type: 'success' });
        if (callback) callback(newCooperative);
        // Actualizar la lista de cooperativas después de agregar una nueva
        setCooperatives((prevCooperatives) => [...prevCooperatives, newCooperative]);
      } catch (error) {
        console.error('Error al agregar cooperativa:', error);
        let errorMessage = 'Error al agregar cooperativa: ';
        if (error.response && error.response.data && error.response.data.message) {
          errorMessage += error.response.data.message;
        } else if (error.message) {
          errorMessage += error.message;
        } else {
          errorMessage += 'Ocurrió un error desconocido.';
        }
        errorMessage += ' Por favor, verifique los datos e intente nuevamente.';
        setMessage({ text: errorMessage, type: 'error' });
      }
    },
    [addCooperative, setMessage, setCooperatives]
    

    );

    return ( Gestión de Usuarios (Total: {userCount}) {/* Mensajes de Feedback /} {message.text && ( <div className={${styles.message} ${styles[message.type]}}> {message.text} {message.type === 'error' && ( <button onClick={() => { setCurrentPage(1); loadData(); }} className={styles.retryButton} > Reintentar carga de datos )} )} {/ Columna de Lista de Usuarios /} {isLoading ? ( Cargando datos... Por favor, espere. ) : message.type === 'error' ? ( Error: Los datos de usuarios no están disponibles. Detalles: {message.text} <button onClick={() => { setCurrentPage(1); loadData(); }} className={styles.retryButton} > Intentar cargar nuevamente ) : users.length === 0 ? ( No se encontraron usuarios en la base de datos. <button onClick={() => setIsAdding(true)} className={styles.addUserButton}> Agregar Nuevo Usuario ) : ( <> <UserList users={users} setSelectedUser={setSelectedUser} deleteUser={handleDeleteUser} allStores={stores} allCooperatives={cooperatives} currentPage={currentPage} itemsPerPage={itemsPerPage} totalUsers={userCount} onPageChange={setCurrentPage} onRetryLoadStores={async () => { try { const response = await fetchStores(); console.log('Respuesta de fetchStores en retry:', response); if (Array.isArray(response)) { const validStores = response.filter( (store) => store && typeof store === 'object' && store._id && store.name ); setStores(validStores); setMessage({ text: Tiendas cargadas exitosamente. Se cargaron ${validStores.length} tiendas válidas., type: 'success', }); } else { throw new Error('La respuesta no es un array válido'); } } catch (error) { console.error('Error al recargar tiendas:', error); setMessage({ text: Error al cargar tiendas: ${error.message}. Por favor, intente nuevamente más tarde., type: 'error', }); } }} onRetryLoadCooperatives={async () => { try { const response = await fetchCooperatives(); console.log('Respuesta de fetchCooperatives en retry:', response); if (Array.isArray(response)) { const validCooperatives = response.filter( (coop) => coop && typeof coop === 'object' && coop._id && coop.name ); setCooperatives(validCooperatives); setMessage({ text: Cooperativas cargadas exitosamente. Se cargaron ${validCooperatives.length} cooperativas válidas., type: 'success', }); } else { throw new Error('La respuesta no es un array válido'); } } catch (error) { console.error('Error al recargar cooperativas:', error); setMessage({ text: Error al cargar cooperativas: ${error.message}. Por favor, intente nuevamente más tarde., type: 'error', }); } }} /> </> )} {/ Columna de Formulario de Usuario */} {selectedUser ? 'Editar Usuario' : 'Agregar Usuario'} {isAdding || selectedUser ? ( <UserForm addUser={handleAddUser} updateUser={handleUpdateUser} selectedUser={selectedUser} stores={stores} cooperatives={cooperatives} addStore={handleAddStore} addCooperative={handleAddCooperative} onCancel={() => { setSelectedUser(null); setIsAdding(false); loadData(); // Recargar datos después de cancelar para asegurar sincronización }} /> ) : ( <button onClick={() => setIsAdding(true)} className={styles.addUserButton}> Agregar Nuevo Usuario )} ); };

    export default UsersPage;

  2. Assistant

    Claro, para cumplir con tu requerimiento, necesitamos modificar el componente UserForm para que cuando se seleccione 'rider' como tipo de trabajador, y dentro de 'rider' se seleccione 'externo' como tipo de rider, y luego 'vinculado_a_cooperativa' como tipo de rider externo, se muestre una nueva sección llamada 'Cooperativas vinculadas' con checkboxes para seleccionar cooperativas, diferente de las cooperativas que aparecen cuando se selecciona el rol de 'worker' en general.

    A continuación, te detallo los pasos que debes seguir para implementar esta funcionalidad:

    1. Actualizar el estado inicial para incluir las cooperativas vinculadas al rider:

      En initialUserState, dentro de workerDetails.riderDetails, agrega una propiedad linkedCooperatives que será un array para almacenar las cooperativas seleccionadas:

      const initialUserState = {
        // ...otros campos
        workerDetails: {
          workerTypes: [],
          riderDetails: {
            riderType: '',
            externalType: '',
            vehicleTypes: [],
            linkedCooperatives: [], // Nueva propiedad
          },
          additionalInfo: {},
        },
        // ...otros campos
      };
      
    2. Actualizar el useEffect que sincroniza el usuario seleccionado con el estado del formulario:

      Asegúrate de que cuando se seleccione un usuario, la propiedad linkedCooperatives se cargue correctamente:

      useEffect(() => {
        if (selectedUser) {
          setUser({
            // ...otros campos
            workerDetails: {
              ...selectedUser.workerDetails,
              riderDetails: {
                ...selectedUser.workerDetails.riderDetails,
                linkedCooperatives: selectedUser.workerDetails.riderDetails?.linkedCooperatives || [],
                // ...otros campos
              },
            },
            // ...otros campos
          });
        }
        // ...resto del código
      }, [selectedUser]);
      
    3. Crear el manejador de cambios para las cooperativas vinculadas al rider:

      Define una función handleRiderLinkedCooperativesChange que actualice el estado cuando el usuario seleccione o deseleccione cooperativas en esta nueva sección:

      const handleRiderLinkedCooperativesChange = useCallback((e) => {
        const { value } = e.target;
        setUser((prevUser) => {
          const linkedCooperatives = prevUser.workerDetails.riderDetails.linkedCooperatives.includes(value)
            ? prevUser.workerDetails.riderDetails.linkedCooperatives.filter((coopId) => coopId !== value)
            : [...prevUser.workerDetails.riderDetails.linkedCooperatives, value];
          return {
            ...prevUser,
            workerDetails: {
              ...prevUser.workerDetails,
              riderDetails: {
                ...prevUser.workerDetails.riderDetails,
                linkedCooperatives,
              },
            },
          };
        });
      }, []);
      
    4. Modificar el formulario para mostrar la nueva sección cuando corresponda:

      Dentro del componente UserForm, después de la sección donde se selecciona el 'Tipo de Rider Externo', agrega la nueva sección que mostrará las 'Cooperativas vinculadas' si se cumplen las condiciones:

      {user.workerDetails.riderDetails?.riderType === 'externo' &&
        user.workerDetails.riderDetails?.externalType === 'vinculado_a_cooperativa' && (
          <div className={styles.formGroup}>
            <label>Cooperativas vinculadas al Rider:</label>
            <div className={styles.checkboxGroup}>
              {cooperatives.map((coop) => (
                <label key={coop._id} className={styles.checkboxLabel}>
                  <input
                    type="checkbox"
                    value={coop._id}
                    checked={user.workerDetails.riderDetails?.linkedCooperatives?.includes(coop._id)}
                    onChange={handleRiderLinkedCooperativesChange}
                  />
                  {coop.name}
                </label>
              ))}
            </div>
            {cooperatives.length === 0 && (
              <p className={styles.noStoresMessage}>
                No hay cooperativas disponibles. Por favor, cree una nueva cooperativa.
              </p>
            )}
            {user.workerDetails.riderDetails?.linkedCooperatives?.length === 0 && cooperatives.length > 0 && (
              <p className={styles.noStoresMessage}>
                No tiene cooperativas vinculadas. Seleccione una existente o cree una nueva.
              </p>
            )}
          </div>
        )}
      
    5. Agregar validación para la nueva sección:

      En la función validateUser, agrega una condición para validar que se haya seleccionado al menos una cooperativa cuando corresponda:

      const validateUser = useCallback(
        (user) => {
          const errors = {};
          // ...otras validaciones
          if (
            user.roles.includes('worker') &&
            user.workerDetails.workerTypes.includes('rider')
          ) {
            if (user.workerDetails.riderDetails.riderType === 'externo' &&
                user.workerDetails.riderDetails.externalType === 'vinculado_a_cooperativa') {
              if (user.workerDetails.riderDetails.linkedCooperatives.length === 0) {
                errors['riderDetails.linkedCooperatives'] = 'Seleccione al menos una cooperativa vinculada';
              }
            }
          }
          // ...resto del código
          return errors;
        },
        [selectedUser]
      );
      
    6. Mostrar errores en el formulario si no se cumplen las validaciones:

      Debajo de la sección de las 'Cooperativas vinculadas al Rider', agrega un mensaje de error si corresponde:

      {errors['riderDetails.linkedCooperatives'] && (
        <p className={styles.error}>{errors['riderDetails.linkedCooperatives']}</p>
      )}
      
    7. Asegurarte de que los datos se envíen correctamente al backend:

      En la función handleSubmit, verifica que userDataToSubmit incluya la nueva propiedad linkedCooperatives dentro de riderDetails cuando corresponda.

      const handleSubmit = useCallback(
        async (e) => {
          e.preventDefault();
          // ...resto del código
          // Asegúrate de que los detalles del rider incluyan 'linkedCooperatives' cuando corresponda
          if (userDataToSubmit.roles.includes('worker')) {
            if (
              userDataToSubmit.workerDetails.workerTypes.includes('rider') &&
              userDataToSubmit.workerDetails.riderDetails.riderType === 'externo' &&
              userDataToSubmit.workerDetails.riderDetails.externalType === 'vinculado_a_cooperativa'
            ) {
              // linkedCooperatives ya está incluido en riderDetails
            } else {
              // Si no aplica, eliminar 'linkedCooperatives' para evitar enviar datos innecesarios
              delete userDataToSubmit.workerDetails.riderDetails.linkedCooperatives;
            }
          }
          // ...resto del código
        },
        [user, selectedUser, validateUser, updateUser, addUser]
      );
      
    8. Actualizar el componente UserList para mostrar la información de las cooperativas vinculadas al rider:

      En el componente UserList, dentro de la sección que muestra los tipos de vendedor/trabajador, agrega el detalle de las cooperativas vinculadas al rider:

      {user.workerDetails.workerTypes.includes('rider') && (
        <>
          <strong>Tipo de Rider:</strong> {user.workerDetails.riderDetails?.riderType}
          {user.workerDetails.riderDetails?.riderType === 'externo' && (
            <>
              <br />
              <strong>Tipo de Rider Externo:</strong> {user.workerDetails.riderDetails?.externalType}
              {user.workerDetails.riderDetails?.externalType === 'vinculado_a_cooperativa' && (
                <>
                  <br />
                  <strong>Cooperativas vinculadas al Rider:</strong>
                  {Array.isArray(user.workerDetails.riderDetails?.linkedCooperatives) &&
                  user.workerDetails.riderDetails?.linkedCooperatives.length > 0 ? (
                    <ul>
                      {user.workerDetails.riderDetails.linkedCooperatives.map((coopId) => (
                        <li key={coopId}>{getCooperativeName(coopId)}</li>
                      ))}
                    </ul>
                  ) : (
                    <span>No tiene cooperativas vinculadas</span>
                  )}
                </>
              )}
            </>
          )}
        </>
      )}
      
    9. Ajustar la lógica en el backend para aceptar y guardar la nueva propiedad linkedCooperatives cuando se envíen los datos del usuario:

      Es necesario que el backend esté preparado para recibir y almacenar esta nueva información. Asegúrate de que el modelo de datos del usuario incluya esta propiedad y que se guarde correctamente en la base de datos.

    Nota: Es importante asegurarse de que los nombres de los campos y las estructuras de datos coincidan tanto en el frontend como en el backend para evitar errores al enviar y recibir datos.

    Con estos cambios, al seleccionar 'rider' como tipo de trabajador, 'externo' como tipo de rider, y 'vinculado_a_cooperativa' como tipo de rider externo, se mostrará una nueva sección en el formulario donde se podrán seleccionar las cooperativas vinculadas al rider, diferente de las cooperativas que se pueden seleccionar cuando se tienen otros roles o configuraciones.