Quickstart

export const crearCuenta = async (req: Request, res: Response, next: NextFunction) => {
  try {
    const parsed = crearCuentaSchema.safeParse(req.body);
    
    if (!parsed.success) {
      const errores = parsed.error.issues.map(e => e.message);
      throw new AppError(errores.join(", "), 400);
    }

    const usuario = await UserService.crear(parsed.data);
    
    return res.status(201).json(
      ApiResponse.success(usuario, "Usuario creado correctamente. Verifica tu email.", 201)
    );
  } catch (error) {
    next(error);
  }
};

async verificarEmail(idUsuario: string, token: string): Promise<void> {
  const tokenRecord = await prisma.verificarToken.findFirst({
    where: {
      idUsuario,
      tipo: 'verificacion',
      usadoEn: null,
      expiraEn: {
        gt: new Date()
      }
    }
  });

  if (!tokenRecord) {
    throw new AppError("Token de verificación inválido o expirado", 400);
  }

  const tokenValido = await bcrypt.compare(token, tokenRecord.tokenHash);
  
  if (!tokenValido) {
    throw new AppError("Token de verificación inválido", 400);
  }

  await prisma.$transaction([
    prisma.usuario.update({
      where: { idUsuario },
      data: { verificado: true }
    }),
    prisma.verificarToken.update({
      where: { tokenid: tokenRecord.tokenid },
      data: { usadoEn: new Date() }
    })
  ]);
}

export const crearEstablecimientoSchema = z.object({
  nombre: z.string().min(1, "El nombre es requerido"),
  localidad: z.string().min(1, "La localidad es requerida"),
  provincia: z.string().min(1, "La provincia es requerida")
});

static async crearLote(idUsuario: string, data: CrearLoteDTO) {
  const establecimiento = await prisma.establecimiento.findFirst({
    where: { idUsuario },
  });

  if (!establecimiento) {
    throw new AppError("El usuario no tiene un establecimiento registrado", 400);
  }

  const producto = await prisma.producto.findUnique({
    where: { idProducto: data.idProducto },
  });

  if (!producto) {
    throw new AppError("El producto seleccionado no existe", 400);
  }

  const ultimoLote = await prisma.loteProduccion.findFirst({
    where: { idEstablecimiento: establecimiento.idEstablecimiento },
    orderBy: { numeroLote: 'desc' }
  });

  const nuevoNumeroLote = ultimoLote ? ultimoLote.numeroLote + 1 : 1;

  const unidad: "kg" | "litros" = producto.categoria === "quesos" ? "kg" : "litros";

  const lote = await prisma.loteProduccion.create({
    data: {
      idProducto: data.idProducto,
      idEstablecimiento: establecimiento.idEstablecimiento,
      cantidad: data.cantidad,
      unidad,
      fechaProduccion: data.fechaProduccion ?? undefined,
      estado: data.estado ?? false,
      numeroLote: nuevoNumeroLote,
    },
    include: {
      producto: {
        select: {
          nombre: true,
          categoria: true
        }
      }
    }
  });

  return lote;
}

const { data, isPending } = useCurrentMonth()

const totalProduccion =
  (data?.data.actual.quesos || 0) + (data?.data.actual.leches || 0)

const porcentajeMermas =
  totalProduccion > 0
    ? ((data?.data.actual.mermas || 0) / totalProduccion) * 100
    : 0