planilla/api/routes/asistencias/asistencias.js

import express from 'express';
const router = express.Router();
import { PrismaClient, Prisma } from '../../prisma/generated/client/index.js';
const prisma = new PrismaClient();

// GET all asistencias
router.get('/', async (req, res) => {
  try {
    const asistencias = await prisma.asistencia.findMany();
    res.json(asistencias);
  } catch (e) {
    console.error(e);
    res.status(500).json({ message: 'Error al obtener asistencias.' });
  }
});

// 🔍 GET /api/asistencias/search
router.get('/search', async (req, res) => {
  const {
    q,
    empleado_id,
    estado,
    desde,
    hasta,
    limit = 0,
  } = req.query;

  try {
    const where = {};

    if (empleado_id) where.empleado_id = BigInt(empleado_id);
    if (estado) where.estado = { contains: estado, mode: 'insensitive' };

    if (desde || hasta) {
      where.entrada = {};
      if (desde) where.entrada.gte = new Date(desde);
      if (hasta) where.entrada.lte = new Date(hasta);
    }

    if (q) {
      const qi = parseInt(q);
      where.OR = [
        ...(isNaN(qi) ? [] : [{ id: qi }, { empleado_id: qi }]),
        { estado: { contains: q, mode: 'insensitive' } },
        { observacion: { contains: q, mode: 'insensitive' } },
      ];
    }

    const take = parseInt(limit) || (Object.keys(where).length ? undefined : 100);

    const asistencias = await prisma.asistencia.findMany({
      where,
      take,
      orderBy: { id: 'desc' },
    });

    res.json(asistencias);
  } catch (e) {
    console.error(e);
    res.status(500).json({ message: 'Error al buscar asistencias.' });
  }
});

// GET asistencia by ID
router.get('/:id(\\d+)', async (req, res) => {
  const { id } = req.params;
  try {
    const asistencia = await prisma.asistencia.findUnique({
      where: { id: parseInt(id) },
    });
    if (asistencia) {
      res.json(asistencia);
    } else {
      res.status(404).json({ message: 'Asistencia no encontrada.' });
    }
  } catch (e) {
    console.error(e);
    res.status(500).json({ message: 'Error al obtener asistencia.' });
  }
});

// POST crear asistencia
router.post('/', async (req, res) => {
  const {
    empleado_id,
    entrada,
    salida,
    historial,
    observacion,
    estado,
    fecha_anulado,
    creador_id,
    modificado_id,
    anulador_id,
  } = req.body;

  if (!empleado_id)
    return res.status(400).json({ message: 'El campo empleado_id es obligatorio.' });

  try {
    const nuevaAsistencia = await prisma.asistencia.create({
      data: {
        empleado_id: BigInt(empleado_id),
        entrada: entrada ? new Date(entrada) : null,
        salida: salida ? new Date(salida) : null,
        historial,
        observacion,
        estado,
        fecha_anulado: fecha_anulado ? new Date(fecha_anulado) : null,
        creador_id,
        modificado_id,
        anulador_id,
      },
    });
    res.status(201).json(nuevaAsistencia);
  } catch (e) {
    if (e instanceof Prisma.PrismaClientKnownRequestError) {
      if (e.code === 'P2003') {
        return res.status(400).json({ message: 'El empleado_id proporcionado no existe.' });
      }
    }

    console.error(e);
    res.status(500).json({ message: 'Error al crear asistencia.' });
  }
});

// PUT actualizar asistencia
router.put('/:id(\\d+)', async (req, res) => {
  const { id } = req.params;
  const {
    empleado_id,
    entrada,
    salida,
    historial,
    observacion,
    estado,
    fecha_anulado,
    modificado_id,
    anulador_id,
  } = req.body;

  try {
    const updateData = {
      entrada: entrada ? new Date(entrada) : undefined,
      salida: salida ? new Date(salida) : undefined,
      historial,
      observacion,
      estado,
      fecha_anulado: fecha_anulado ? new Date(fecha_anulado) : undefined,
      modificado_id,
      anulador_id,
    };

    if (empleado_id !== undefined) {
      updateData.empleado_id = BigInt(empleado_id);
    }

    const asistenciaActualizada = await prisma.asistencia.update({
      where: { id: parseInt(id) },
      data: updateData,
    });

    res.json(asistenciaActualizada);
  } catch (e) {
    if (e instanceof Prisma.PrismaClientKnownRequestError) {
      if (e.code === 'P2025') {
        return res.status(404).json({ message: 'Asistencia no encontrada para actualizar.' });
      }
      if (e.code === 'P2003') {
        return res.status(400).json({ message: 'El empleado_id proporcionado no existe.' });
      }
    }

    console.error(e);
    res.status(500).json({ message: 'Error al actualizar asistencia.' });
  }
});

// DELETE asistencia
router.delete('/:id(\\d+)', async (req, res) => {
  const { id } = req.params;
  try {
    await prisma.asistencia.delete({
      where: { id: parseInt(id) },
    });
    res.status(204).send();
  } catch (e) {
    if (e instanceof Prisma.PrismaClientKnownRequestError) {
      if (e.code === 'P2025') {
        return res.status(404).json({ message: 'Asistencia no encontrada para eliminar.' });
      }
    }

    console.error(e);
    res.status(500).json({ message: 'Error al eliminar asistencia.' });
  }
});

export default router;