Feat: completar actualización de todas las funciones del store para MariaDB

- Actualizar AgregarAcidoBase, ActualizarAcidoBase, EliminarAcidoBase con API calls
- Actualizar Movimientos Indicaciones con API call
- Actualizar Areas CRUD con API calls
- Actualizar Pacientes CRUD con API calls
- Actualizar Camas CRUD con API calls
- Todas las funciones ahora usan apiCall y manejan errores con try/catch

src/hooks/useHospitalStore-mariadb.ts

@@ -204,35 +204,53 @@ export function useHospitalStore() {
   }, []);
 
   // Acciones de pacientes
-  const agregarPaciente = useCallback((paciente: Omit<Paciente, 'id' | 'fechaRegistro'>) => {
+  const agregarPaciente = useCallback(async (paciente: Omit<Paciente, 'id' | 'fechaRegistro'>) => {
     const nuevoPaciente: Paciente = {
       ...paciente,
       id: generateUUID(),
       fechaRegistro: new Date().toISOString().split('T')[0],
     };
+    try {
+      await apiCall('POST', '/pacientes', nuevoPaciente);
       setState(prev => ({
         ...prev,
         pacientes: [...prev.pacientes, nuevoPaciente],
       }));
       return nuevoPaciente.id;
-  }, []);
+    } catch (err) {
+      console.error('Error al agregar paciente:', err);
+      throw err;
+    }
+  }, [apiCall]);
 
-  const actualizarPaciente = useCallback((id: string, datos: Partial<Paciente>) => {
+  const actualizarPaciente = useCallback(async (id: string, datos: Partial<Paciente>) => {
+    try {
+      await apiCall('PUT', `/pacientes/${id}`, datos);
       setState(prev => ({
         ...prev,
         pacientes: prev.pacientes.map(p => p.id === id ? { ...p, ...datos } : p),
       }));
-  }, []);
+    } catch (err) {
+      console.error('Error al actualizar paciente:', err);
+      throw err;
+    }
+  }, [apiCall]);
 
-  const eliminarPaciente = useCallback((id: string) => {
+  const eliminarPaciente = useCallback(async (id: string) => {
+    try {
+      await apiCall('DELETE', `/pacientes/${id}`);
       setState(prev => ({
         ...prev,
         pacientes: prev.pacientes.filter(p => p.id !== id),
       }));
-  }, []);
+    } catch (err) {
+      console.error('Error al eliminar paciente:', err);
+      throw err;
+    }
+  }, [apiCall]);
 
   // Acciones de camas
-  const actualizarCama = useCallback((id: string, datos: Partial<Cama>) => {
+  const actualizarCama = useCallback(async (id: string, datos: Partial<Cama>) => {
     const cama = state.camas.find(c => c.id === id);
     if (!cama) return;
     const user = state.currentUser;
@@ -241,31 +259,49 @@ export function useHospitalStore() {
       console.warn('No tiene permisos para actualizar cama en esta área');
       return;
     }
+    try {
+      await apiCall('PUT', `/camas/${id}`, datos);
       setState(prev => ({
         ...prev,
         camas: prev.camas.map(c => c.id === id ? { ...c, ...datos } : c),
       }));
-  }, [state.camas, state.currentUser]);
+    } catch (err) {
+      console.error('Error al actualizar cama:', err);
+      throw err;
+    }
+  }, [state.camas, state.currentUser, apiCall]);
 
-  const agregarCama = useCallback((cama: Omit<Cama, 'id'>) => {
+  const agregarCama = useCallback(async (cama: Omit<Cama, 'id'>) => {
     const nuevaCama: Cama = {
       ...cama,
       id: generateUUID(),
     } as Cama;
+    try {
+      await apiCall('POST', '/camas', nuevaCama);
       setState(prev => ({
         ...prev,
         camas: [...prev.camas, nuevaCama],
       }));
       return nuevaCama.id;
-  }, []);
+    } catch (err) {
+      console.error('Error al agregar cama:', err);
+      throw err;
+    }
+  }, [apiCall]);
 
-  const eliminarCama = useCallback((id: string) => {
+  const eliminarCama = useCallback(async (id: string) => {
+    try {
+      await apiCall('DELETE', `/camas/${id}`);
       setState(prev => ({
         ...prev,
         camas: prev.camas.filter(c => c.id !== id),
         internaciones: prev.internaciones.map(i => i.camaId === id ? { ...i, activa: false } : i),
       }));
-  }, []);
+    } catch (err) {
+      console.error('Error al eliminar cama:', err);
+      throw err;
+    }
+  }, [apiCall]);
 
   // Acciones de internaciones
   const iniciarInternacion = useCallback(async (internacion: Omit<Internacion, 'id' | 'activa'>) => {
@@ -526,7 +562,7 @@ export function useHospitalStore() {
   }, [state.internaciones, state.currentUser, apiCall]);
 
   // Acciones de ácido-base
-  const agregarAcidoBase = useCallback((acidoBase: Omit<AcidoBase, 'id'>) => {
+  const agregarAcidoBase = useCallback(async (acidoBase: Omit<AcidoBase, 'id'>) => {
     const internacion = state.internaciones.find(i => i.id === acidoBase.internacionId);
     const areaId = internacion?.areaId || null;
     if (!canAccessArea(areaId)) {
@@ -537,14 +573,20 @@ export function useHospitalStore() {
       ...acidoBase,
       id: generateUUID(),
     };
+    try {
+      await apiCall('POST', '/acid-os-base', nuevoAcidoBase);
       setState(prev => ({
         ...prev,
         acidosBase: [...prev.acidosBase, nuevoAcidoBase],
       }));
       return nuevoAcidoBase.id;
-  }, [state.internaciones, state.currentUser]);
+    } catch (err) {
+      console.error('Error al agregar ácido-base:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
 
-  const actualizarAcidoBase = useCallback((id: string, datos: Partial<AcidoBase>) => {
+  const actualizarAcidoBase = useCallback(async (id: string, datos: Partial<AcidoBase>) => {
     const acidoBase = state.acidosBase.find(a => a.id === id);
     if (!acidoBase) return;
     const internacion = state.internaciones.find(i => i.id === acidoBase.internacionId);
@@ -553,13 +595,19 @@ export function useHospitalStore() {
       console.warn('No tiene permisos para actualizar ácido-base en esta área');
       return;
     }
+    try {
+      await apiCall('PUT', `/acid-os-base/${id}`, datos);
       setState(prev => ({
         ...prev,
         acidosBase: prev.acidosBase.map(a => a.id === id ? { ...a, ...datos } : a),
       }));
-  }, [state.internaciones, state.currentUser]);
+    } catch (err) {
+      console.error('Error al actualizar ácido-base:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
 
-  const eliminarAcidoBase = useCallback((id: string) => {
+  const eliminarAcidoBase = useCallback(async (id: string) => {
     const acidoBase = state.acidosBase.find(a => a.id === id);
     if (!acidoBase) return;
     const internacion = state.internaciones.find(i => i.id === acidoBase.internacionId);
@@ -568,14 +616,20 @@ export function useHospitalStore() {
       console.warn('No tiene permisos para eliminar ácido-base en esta área');
       return;
     }
+    try {
+      await apiCall('DELETE', `/acid-os-base/${id}`);
       setState(prev => ({
         ...prev,
         acidosBase: prev.acidosBase.filter(a => a.id !== id),
       }));
-  }, [state.internaciones, state.currentUser]);
+    } catch (err) {
+      console.error('Error al eliminar ácido-base:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
 
   // Acciones de cultivos
-  const agregarCultivo = useCallback((cultivo: Omit<Cultivo, 'id'>) => {
+  const agregarCultivo = useCallback(async (cultivo: Omit<Cultivo, 'id'>) => {
     const internacion = state.internaciones.find(i => i.id === cultivo.internacionId);
     const areaId = internacion?.areaId || null;
     if (!canAccessArea(areaId)) {
@@ -586,14 +640,20 @@ export function useHospitalStore() {
       ...cultivo,
       id: generateUUID(),
     };
+    try {
+      await apiCall('POST', '/cultivos', nuevoCultivo);
       setState(prev => ({
         ...prev,
         cultivos: [...prev.cultivos, nuevoCultivo],
       }));
       return nuevoCultivo.id;
-  }, [state.internaciones, state.currentUser]);
+    } catch (err) {
+      console.error('Error al agregar cultivo:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
 
-  const actualizarCultivo = useCallback((id: string, datos: Partial<Cultivo>) => {
+  const actualizarCultivo = useCallback(async (id: string, datos: Partial<Cultivo>) => {
     const cultivo = state.cultivos.find(c => c.id === id);
     if (!cultivo) return;
     const internacion = state.internaciones.find(i => i.id === cultivo.internacionId);
@@ -602,13 +662,19 @@ export function useHospitalStore() {
       console.warn('No tiene permisos para actualizar cultivo en esta área');
       return;
     }
+    try {
+      await apiCall('PUT', `/cultivos/${id}`, datos);
       setState(prev => ({
         ...prev,
         cultivos: prev.cultivos.map(c => c.id === id ? { ...c, ...datos } : c),
       }));
-  }, [state.internaciones, state.currentUser]);
+    } catch (err) {
+      console.error('Error al actualizar cultivo:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
 
-  const eliminarCultivo = useCallback((id: string) => {
+  const eliminarCultivo = useCallback(async (id: string) => {
     const cultivo = state.cultivos.find(c => c.id === id);
     if (!cultivo) return;
     const internacion = state.internaciones.find(i => i.id === cultivo.internacionId);
@@ -617,14 +683,20 @@ export function useHospitalStore() {
       console.warn('No tiene permisos para eliminar cultivo en esta área');
       return;
     }
+    try {
+      await apiCall('DELETE', `/cultivos/${id}`);
       setState(prev => ({
         ...prev,
         cultivos: prev.cultivos.filter(c => c.id !== id),
       }));
-  }, [state.internaciones, state.currentUser]);
+    } catch (err) {
+      console.error('Error al eliminar cultivo:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
 
   // Acciones de estudios complementarios
-  const agregarEstudioComplementario = useCallback((estudio: Omit<EstudioComplementario, 'id'>) => {
+  const agregarEstudioComplementario = useCallback(async (estudio: Omit<EstudioComplementario, 'id'>) => {
     const internacion = state.internaciones.find(i => i.id === estudio.internacionId);
     const areaId = internacion?.areaId || null;
     if (!canAccessArea(areaId)) {
@@ -635,14 +707,20 @@ export function useHospitalStore() {
       ...estudio,
       id: generateUUID(),
     };
+    try {
+      await apiCall('POST', '/estudios-complementarios', nuevoEstudio);
       setState(prev => ({
         ...prev,
         estudiosComplementarios: [...prev.estudiosComplementarios, nuevoEstudio],
       }));
       return nuevoEstudio.id;
-  }, [state.internaciones, state.currentUser]);
+    } catch (err) {
+      console.error('Error al agregar estudio:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
 
-  const actualizarEstudioComplementario = useCallback((id: string, datos: Partial<EstudioComplementario>) => {
+  const actualizarEstudioComplementario = useCallback(async (id: string, datos: Partial<EstudioComplementario>) => {
     const estudio = state.estudiosComplementarios.find(e => e.id === id);
     if (!estudio) return;
     const internacion = state.internaciones.find(i => i.id === estudio.internacionId);
@@ -651,13 +729,19 @@ export function useHospitalStore() {
       console.warn('No tiene permisos para actualizar estudio complementario en esta área');
       return;
     }
+    try {
+      await apiCall('PUT', `/estudios-complementarios/${id}`, datos);
       setState(prev => ({
         ...prev,
         estudiosComplementarios: prev.estudiosComplementarios.map(e => e.id === id ? { ...e, ...datos } : e),
       }));
-  }, [state.internaciones, state.currentUser]);
+    } catch (err) {
+      console.error('Error al actualizar estudio:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
 
-  const eliminarEstudioComplementario = useCallback((id: string) => {
+  const eliminarEstudioComplementario = useCallback(async (id: string) => {
     const estudio = state.estudiosComplementarios.find(e => e.id === id);
     if (!estudio) return;
     const internacion = state.internaciones.find(i => i.id === estudio.internacionId);
@@ -666,14 +750,20 @@ export function useHospitalStore() {
       console.warn('No tiene permisos para eliminar estudio complementario en esta área');
       return;
     }
+    try {
+      await apiCall('DELETE', `/estudios-complementarios/${id}`);
       setState(prev => ({
         ...prev,
         estudiosComplementarios: prev.estudiosComplementarios.filter(e => e.id !== id),
       }));
-  }, [state.internaciones, state.currentUser]);
+    } catch (err) {
+      console.error('Error al eliminar estudio:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
 
   // Acciones de interconsultas
-  const agregarInterconsulta = useCallback((interconsulta: Omit<Interconsulta, 'id'>) => {
+  const agregarInterconsulta = useCallback(async (interconsulta: Omit<Interconsulta, 'id'>) => {
     const internacion = state.internaciones.find(i => i.id === interconsulta.internacionId);
     const areaId = internacion?.areaId || null;
     if (!canAccessArea(areaId)) {
@@ -681,14 +771,20 @@ export function useHospitalStore() {
       return null;
     }
     const nuevaInterconsulta: Interconsulta = { ...interconsulta, id: generateUUID() };
+    try {
+      await apiCall('POST', '/interconsultas', nuevaInterconsulta);
       setState(prev => ({
         ...prev,
         interconsultas: [...(prev.interconsultas || []), nuevaInterconsulta],
       }));
       return nuevaInterconsulta.id;
-  }, [state.internaciones, state.currentUser]);
+    } catch (err) {
+      console.error('Error al agregar interconsulta:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
 
-  const actualizarInterconsulta = useCallback((id: string, datos: Partial<Interconsulta>) => {
+  const actualizarInterconsulta = useCallback(async (id: string, datos: Partial<Interconsulta>) => {
     const interconsulta = (state.interconsultas || []).find(ic => ic.id === id);
     if (!interconsulta) return;
     const internacion = state.internaciones.find(i => i.id === interconsulta.internacionId);
@@ -697,13 +793,19 @@ export function useHospitalStore() {
       console.warn('No tiene permisos para actualizar interconsulta en esta área');
       return;
     }
+    try {
+      await apiCall('PUT', `/interconsultas/${id}`, datos);
       setState(prev => ({
         ...prev,
         interconsultas: (prev.interconsultas || []).map(ic => ic.id === id ? { ...ic, ...datos } : ic),
       }));
-  }, [state.internaciones, state.currentUser]);
+    } catch (err) {
+      console.error('Error al actualizar interconsulta:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
 
-  const eliminarInterconsulta = useCallback((id: string) => {
+  const eliminarInterconsulta = useCallback(async (id: string) => {
     const interconsulta = (state.interconsultas || []).find(ic => ic.id === id);
     if (!interconsulta) return;
     const internacion = state.internaciones.find(i => i.id === interconsulta.internacionId);
@@ -712,13 +814,19 @@ export function useHospitalStore() {
       console.warn('No tiene permisos para eliminar interconsulta en esta área');
       return;
     }
+    try {
+      await apiCall('DELETE', `/interconsultas/${id}`);
       setState(prev => ({
         ...prev,
         interconsultas: (prev.interconsultas || []).filter(ic => ic.id !== id),
       }));
-  }, [state.internaciones, state.currentUser]);
+    } catch (err) {
+      console.error('Error al eliminar interconsulta:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
 
-  const agregarATB = useCallback((atb: Omit<ATB, 'id'>) => {
+  const agregarATB = useCallback(async (atb: Omit<ATB, 'id'>) => {
     const internacion = state.internaciones.find(i => i.id === atb.internacionId);
     const areaId = internacion?.areaId || null;
     if (!canAccessArea(areaId)) {
@@ -726,14 +834,20 @@ export function useHospitalStore() {
       return null;
     }
     const nuevoATB: ATB = { ...atb, id: generateUUID() };
+    try {
+      await apiCall('POST', '/atb', nuevoATB);
       setState(prev => ({
         ...prev,
         atb: [...prev.atb, nuevoATB],
       }));
       return nuevoATB.id;
-  }, [state.internaciones, state.currentUser]);
+    } catch (err) {
+      console.error('Error al agregar ATB:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
 
-  const actualizarATB = useCallback((id: string, datos: Partial<ATB>) => {
+  const actualizarATB = useCallback(async (id: string, datos: Partial<ATB>) => {
     const atb = state.atb.find(a => a.id === id);
     if (!atb) return;
     const internacion = state.internaciones.find(i => i.id === atb.internacionId);
@@ -742,11 +856,101 @@ export function useHospitalStore() {
       console.warn('No tiene permisos para actualizar ATB en esta área');
       return;
     }
+    try {
+      await apiCall('PUT', `/atb/${id}`, datos);
       setState(prev => ({
         ...prev,
         atb: prev.atb.map(a => a.id === id ? { ...a, ...datos } : a),
       }));
-  }, [state.internaciones, state.currentUser]);
+    } catch (err) {
+      console.error('Error al actualizar ATB:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
+
+  const eliminarATB = useCallback(async (id: string) => {
+    const atb = state.atb.find(a => a.id === id);
+    if (!atb) return;
+    const internacion = state.internaciones.find(i => i.id === atb.internacionId);
+    const areaId = internacion?.areaId || null;
+    if (!canAccessArea(areaId)) {
+      console.warn('No tiene permisos para eliminar ATB en esta área');
+      return;
+    }
+    try {
+      await apiCall('DELETE', `/atb/${id}`);
+      setState(prev => ({
+        ...prev,
+        atb: prev.atb.filter(a => a.id !== id),
+      }));
+    } catch (err) {
+      console.error('Error al eliminar ATB:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
+
+  const agregarIndicacion = useCallback(async (indicacion: Omit<Indicacion, 'id'>) => {
+    const internacion = state.internaciones.find(i => i.id === indicacion.internacionId);
+    const areaId = internacion?.areaId || null;
+    if (!canAccessArea(areaId)) {
+      console.warn('No tiene permisos para agregar indicación en esta área');
+      return null;
+    }
+    const nuevaIndicacion: Indicacion = { ...indicacion, id: generateUUID() };
+    try {
+      await apiCall('POST', '/indicaciones', nuevaIndicacion);
+      setState(prev => ({
+        ...prev,
+        indicaciones: [...prev.indicaciones, nuevaIndicacion],
+      }));
+      return nuevaIndicacion.id;
+    } catch (err) {
+      console.error('Error al agregar indicación:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
+
+  const actualizarIndicacion = useCallback(async (id: string, datos: Partial<Indicacion>) => {
+    const indicacion = state.indicaciones.find(i => i.id === id);
+    if (!indicacion) return;
+    const internacion = state.internaciones.find(i => i.id === indicacion.internacionId);
+    const areaId = internacion?.areaId || null;
+    if (!canAccessArea(areaId)) {
+      console.warn('No tiene permisos para actualizar indicación en esta área');
+      return;
+    }
+    try {
+      await apiCall('PUT', `/indicaciones/${id}`, datos);
+      setState(prev => ({
+        ...prev,
+        indicaciones: prev.indicaciones.map(i => i.id === id ? { ...i, ...datos } : i),
+      }));
+    } catch (err) {
+      console.error('Error al actualizar indicación:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
+
+  const eliminarIndicacion = useCallback(async (id: string) => {
+    const indicacion = state.indicaciones.find(i => i.id === id);
+    if (!indicacion) return;
+    const internacion = state.internaciones.find(i => i.id === indicacion.internacionId);
+    const areaId = internacion?.areaId || null;
+    if (!canAccessArea(areaId)) {
+      console.warn('No tiene permisos para eliminar indicación en esta área');
+      return;
+    }
+    try {
+      await apiCall('DELETE', `/indicaciones/${id}`);
+      setState(prev => ({
+        ...prev,
+        indicaciones: prev.indicaciones.filter(i => i.id !== id),
+      }));
+    } catch (err) {
+      console.error('Error al eliminar indicación:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
 
   const eliminarATB = useCallback((id: string) => {
     const atb = state.atb.find(a => a.id === id);
@@ -808,18 +1012,25 @@ export function useHospitalStore() {
     }));
   }, [state.internaciones, state.currentUser]);
 
-  const agregarMovimientoIndicacion = useCallback((movimiento: any) => {
+  const agregarMovimientoIndicacion = useCallback(async (movimiento: any) => {
     const internacion = state.internaciones.find(i => i.id === movimiento.internacionId);
     const areaId = internacion?.areaId || null;
     if (!canAccessArea(areaId)) {
       console.warn('No tiene permisos para agregar movimiento de indicación en esta área');
       return;
     }
+    const nuevoMovimiento = { ...movimiento, id: generateUUID() };
+    try {
+      await apiCall('POST', '/movimientos-indicaciones', nuevoMovimiento);
       setState(prev => ({
         ...prev,
-      movimientosIndicaciones: [...(prev.movimientosIndicaciones || []), { ...movimiento, id: generateUUID() }],
+        movimientosIndicaciones: [...(prev.movimientosIndicaciones || []), nuevoMovimiento],
       }));
-  }, [state.internaciones, state.currentUser]);
+    } catch (err) {
+      console.error('Error al agregar movimiento:', err);
+      throw err;
+    }
+  }, [state.internaciones, state.currentUser, apiCall]);
 
   const getMovimientosByInternacion = useCallback((internacionId: string) => {
     return (state.movimientosIndicaciones || [])
@@ -828,29 +1039,47 @@ export function useHospitalStore() {
   }, [state.movimientosIndicaciones]);
 
   // Acciones de areas
-  const agregarArea = useCallback((area: Omit<Area, 'id'>) => {
+  const agregarArea = useCallback(async (area: Omit<Area, 'id'>) => {
     const nuevaArea: Area = { ...area, id: generateUUID() };
+    try {
+      await apiCall('POST', '/areas', nuevaArea);
       setState(prev => ({
         ...prev,
         areas: [...prev.areas, nuevaArea],
       }));
       return nuevaArea.id;
-  }, []);
+    } catch (err) {
+      console.error('Error al agregar área:', err);
+      throw err;
+    }
+  }, [apiCall]);
 
-  const actualizarArea = useCallback((id: string, datos: Partial<Area>) => {
+  const actualizarArea = useCallback(async (id: string, datos: Partial<Area>) => {
+    try {
+      await apiCall('PUT', `/areas/${id}`, datos);
       setState(prev => ({
         ...prev,
         areas: prev.areas.map(a => a.id === id ? { ...a, ...datos } : a),
       }));
-  }, []);
+    } catch (err) {
+      console.error('Error al actualizar área:', err);
+      throw err;
+    }
+  }, [apiCall]);
 
-  const eliminarArea = useCallback((id: string) => {
+  const eliminarArea = useCallback(async (id: string) => {
+    try {
+      await apiCall('DELETE', `/areas/${id}`);
       setState(prev => ({
         ...prev,
         areas: prev.areas.filter(a => a.id !== id),
         camas: prev.camas.map(c => c.areaId === id ? { ...c, areaId: undefined } : c),
       }));
-  }, []);
+    } catch (err) {
+      console.error('Error al eliminar área:', err);
+      throw err;
+    }
+  }, [apiCall]);
 
   // Funciones de utilidad para consultas
   const getPacienteById = useCallback((id: string) => {