Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

/* hay que usar actualizarUrlArchivo($fileid, $publicurl); para el archivo original (no…

  1. User

    /* hay que usar actualizarUrlArchivo(fileid,file_id, public_url); para el archivo original (no el llite) ya que al renombrarlo tiene que actualizarse la url el file id puede encontrarlo buscando en la base de datos la url que recibe autProcesarAudio y viendo el file id que corresponde, creo

    function actualizarUrlArchivo(fileid,file_id, new_url) { global $wpdb;

    // Log del inicio de la operación
    guardarLog("Inicio de actualizarUrlArchivo para File ID: $file_id con nueva URL: $new_url");
    
    // Intentar actualizar la URL del archivo en la base de datos
    $resultado = $wpdb->update(
        "{$wpdb->prefix}file_hashes",
        array('file_url' => $new_url),  // Campos a actualizar
        array('id' => $file_id),        // Condición: ID del archivo
        array('%s'),                    // Formato del campo a actualizar
        array('%d')                     // Formato del campo condicional
    );
    
    if ($resultado !== false) {
        guardarLog("URL actualizada correctamente para File ID: $file_id");
    } else {
        guardarLog("Error al actualizar la URL para File ID: $file_id");
    }
    
    // Devolver el resultado de la actualización
    return $resu
    

    */

    function autProcesarAudio(audio_path) { // Verificar si el archivo existe if (!file_exists(audio_path)) { guardarLog("El archivo de audio no existe en la ruta proporcionada: {$audio_path}"); return; }

    // Obtener las partes del camino del archivo
    $path_parts = pathinfo($audio_path);
    $directory = $path_parts['dirname'];
    $extension = strtolower($path_parts['extension']);
    $basename = $path_parts['filename'];
    
    // Definir la ruta temporal para eliminar metadatos
    $temp_path = $directory . '/' . $basename . '_temp.' . $extension;
    
    // 1. Eliminar metadatos del archivo original usando ffmpeg
    $comando_strip_metadata = "/usr/bin/ffmpeg -i " . escapeshellarg($audio_path) . " -map_metadata -1 -c copy " . escapeshellarg($temp_path) . " -y";
    guardarLog("Ejecutando comando para eliminar metadatos: {$comando_strip_metadata}");
    exec($comando_strip_metadata, $output_strip, $return_strip);
    if ($return_strip !== 0) {
        guardarLog("Error al eliminar metadatos: " . implode("\n", $output_strip));
        // Opcional: manejar el error según sea necesario
        return;
    }
    
    // Reemplazar el archivo original con el archivo sin metadatos
    if (!rename($temp_path, $audio_path)) {
        guardarLog("Error al reemplazar el archivo original con la versión sin metadatos.");
        return;
    }
    guardarLog("Metadatos eliminados correctamente del archivo original.");
    
    // 2. Crear una versión lite del audio en MP3 a 128 kbps
    $lite_path = $directory . '/' . $basename . '_lite.mp3';
    $comando_lite = "/usr/bin/ffmpeg -i " . escapeshellarg($audio_path) . " -b:a 128k " . escapeshellarg($lite_path) . " -y";
    guardarLog("Ejecutando comando para crear versión lite: {$comando_lite}");
    exec($comando_lite, $output_lite, $return_lite);
    if ($return_lite !== 0) {
        guardarLog("Error al crear la versión lite: " . implode("\n", $output_lite));
        return;
    }
    guardarLog("Versión lite creada exitosamente: {$lite_path}");
    
    // 3. Enviar la versión lite a la IA para obtener un nombre limpio
    $nombre_limpio = generarNombreAudio($lite_path);
    if (empty($nombre_limpio)) {
        guardarLog("La IA no retornó un nombre válido.");
        return;
    }
    guardarLog("Nombre limpio generado por la IA: {$nombre_limpio}");
    
    // 4. Renombrar el archivo original
    $nuevo_nombre_original = $directory . '/' . $nombre_limpio . '.' . $extension;
    if (!rename($audio_path, $nuevo_nombre_original)) {
        guardarLog("Error al renombrar el archivo original a: {$nuevo_nombre_original}");
        return;
    }
    guardarLog("Archivo original renombrado a: {$nuevo_nombre_original}");
    
    // 5. Renombrar el archivo lite
    $nuevo_nombre_lite = $directory . '/' . $nombre_limpio . '_lite.mp3';
    if (!rename($lite_path, $nuevo_nombre_lite)) {
        guardarLog("Error al renombrar el archivo lite a: {$nuevo_nombre_lite}");
        return;
    }
    guardarLog("Archivo lite renombrado a: {$nuevo_nombre_lite}");
    
    // 6. Enviar ambos archivos a la función crearAutPost
    crearAutPost($nuevo_nombre_original, $nuevo_nombre_lite);
    guardarLog("Archivos enviados a crearAutPost: {$nuevo_nombre_original}, {$nuevo_nombre_lite}");
    

    }

  2. Assistant

    Entiendo que deseas integrar la función actualizarUrlArchivo en tu proceso de manejo de archivos de audio (autProcesarAudio). A continuación, te proporcionaré una versión completa y mejorada de ambas funciones, asegurando que actualizarUrlArchivo actualice correctamente la URL del archivo original en la base de datos después de renombrarlo.

    1. Completar la función actualizarUrlArchivo

    Primero, aseguremos que la función actualizarUrlArchivo esté completa y funcione correctamente. Además, agregaré validaciones y manejaré adecuadamente el retorno de la función.

    /**
     * Actualiza la URL de un archivo en la base de datos.
     *
     * @param int    $file_id  ID del archivo en la base de datos.
     * @param string $new_url  Nueva URL del archivo.
     * @return bool             True si la actualización fue exitosa, False en caso contrario.
     */
    function actualizarUrlArchivo($file_id, $new_url)
    {
        global $wpdb;
        
        // Log del inicio de la operación
        guardarLog("Inicio de actualizarUrlArchivo para File ID: $file_id con nueva URL: $new_url");
        
        // Intentar actualizar la URL del archivo en la base de datos
        $resultado = $wpdb->update(
            "{$wpdb->prefix}file_hashes",
            array('file_url' => $new_url),  // Campos a actualizar
            array('id' => $file_id),        // Condición: ID del archivo
            array('%s'),                    // Formato del campo a actualizar
            array('%d')                     // Formato del campo condicional
        );
    
        if ($resultado !== false) {
            guardarLog("URL actualizada correctamente para File ID: $file_id");
            return true;
        } else {
            guardarLog("Error al actualizar la URL para File ID: $file_id");
            return false;
        }
    }
    

    2. Integrar actualizarUrlArchivo en autProcesarAudio

    Ahora, actualizaré la función autProcesarAudio para que, después de renombrar el archivo original, se actualice la URL en la base de datos utilizando actualizarUrlArchivo. Para ello, necesitaremos obtener el file_id correspondiente al archivo original antes de renombrarlo.

    Assumamos que tienes una función obtenerFileIDPorURL($url) que busca en la base de datos el file_id correspondiente a una URL dada. Si no la tienes, también te proporcionaré una posible implementación.

    a. Implementación de obtenerFileIDPorURL

    /**
     * Obtiene el ID del archivo en la base de datos basado en su URL.
     *
     * @param string $url  URL del archivo.
     * @return int|false   ID del archivo si se encuentra, False en caso contrario.
     */
    function obtenerFileIDPorURL($url)
    {
        global $wpdb;
        
        $file_id = $wpdb->get_var(
            $wpdb->prepare(
                "SELECT id FROM {$wpdb->prefix}file_hashes WHERE file_url = %s",
                $url
            )
        );
    
        if ($file_id !== null) {
            return (int) $file_id;
        } else {
            guardarLog("No se encontró File ID para la URL: $url");
            return false;
        }
    }
    

    b. Actualización de autProcesarAudio

    Ahora, integraré las funciones anteriores en autProcesarAudio:

    function autProcesarAudio($audio_path) {
        // Verificar si el archivo existe
        if (!file_exists($audio_path)) {
            guardarLog("El archivo de audio no existe en la ruta proporcionada: {$audio_path}");
            return;
        }
    
        // Obtener las partes del camino del archivo
        $path_parts = pathinfo($audio_path);
        $directory = $path_parts['dirname'];
        $extension = strtolower($path_parts['extension']);
        $basename = $path_parts['filename'];
    
        // Definir la ruta temporal para eliminar metadatos
        $temp_path = $directory . '/' . $basename . '_temp.' . $extension;
    
        // 1. Eliminar metadatos del archivo original usando ffmpeg
        $comando_strip_metadata = "/usr/bin/ffmpeg -i " . escapeshellarg($audio_path) . " -map_metadata -1 -c copy " . escapeshellarg($temp_path) . " -y";
        guardarLog("Ejecutando comando para eliminar metadatos: {$comando_strip_metadata}");
        exec($comando_strip_metadata, $output_strip, $return_strip);
        if ($return_strip !== 0) {
            guardarLog("Error al eliminar metadatos: " . implode("\n", $output_strip));
            // Opcional: manejar el error según sea necesario
            return;
        }
    
        // Reemplazar el archivo original con el archivo sin metadatos
        if (!rename($temp_path, $audio_path)) {
            guardarLog("Error al reemplazar el archivo original con la versión sin metadatos.");
            return;
        }
        guardarLog("Metadatos eliminados correctamente del archivo original.");
    
        // 2. Crear una versión lite del audio en MP3 a 128 kbps
        $lite_path = $directory . '/' . $basename . '_lite.mp3';
        $comando_lite = "/usr/bin/ffmpeg -i " . escapeshellarg($audio_path) . " -b:a 128k " . escapeshellarg($lite_path) . " -y";
        guardarLog("Ejecutando comando para crear versión lite: {$comando_lite}");
        exec($comando_lite, $output_lite, $return_lite);
        if ($return_lite !== 0) {
            guardarLog("Error al crear la versión lite: " . implode("\n", $output_lite));
            return;
        }
        guardarLog("Versión lite creada exitosamente: {$lite_path}");
    
        // 3. Enviar la versión lite a la IA para obtener un nombre limpio
        $nombre_limpio = generarNombreAudio($lite_path);
        if (empty($nombre_limpio)) {
            guardarLog("La IA no retornó un nombre válido.");
            return;
        }
        guardarLog("Nombre limpio generado por la IA: {$nombre_limpio}");
    
        // 4. Renombrar el archivo original
        $nuevo_nombre_original = $directory . '/' . $nombre_limpio . '.' . $extension;
        if (!rename($audio_path, $nuevo_nombre_original)) {
            guardarLog("Error al renombrar el archivo original a: {$nuevo_nombre_original}");
            return;
        }
        guardarLog("Archivo original renombrado a: {$nuevo_nombre_original}");
    
        // 5. Renombrar el archivo lite
        $nuevo_nombre_lite = $directory . '/' . $nombre_limpio . '_lite.mp3';
        if (!rename($lite_path, $nuevo_nombre_lite)) {
            guardarLog("Error al renombrar el archivo lite a: {$nuevo_nombre_lite}");
            return;
        }
        guardarLog("Archivo lite renombrado a: {$nuevo_nombre_lite}");
    
        // 6. Actualizar la URL del archivo original en la base de datos
        // Obtener la URL pública del archivo original renombrado
        // Asumo que tienes una función o manera de determinar la URL pública a partir de la ruta del archivo
        $public_url_original = obtenerUrlPublica($nuevo_nombre_original); // Implementa esta función según tu lógica
    
        // Obtener el file_id correspondiente al archivo original antes de renombrarlo
        // Asumo que la URL antes del renombramiento es la original
        $file_id = obtenerFileIDPorURL(obtenerUrlPublica($audio_path)); // Implementa obtenerUrlPublica
    
        if ($file_id !== false) {
            $actualizacion_exitosa = actualizarUrlArchivo($file_id, $public_url_original);
            if (!$actualizacion_exitosa) {
                guardarLog("No se pudo actualizar la URL en la base de datos para File ID: $file_id");
                // Opcional: manejar el error según sea necesario
            }
        } else {
            guardarLog("No se encontró File ID para el archivo original. No se actualizará la URL.");
        }
    
        // 7. Enviar ambos archivos a la función crearAutPost
        crearAutPost($nuevo_nombre_original, $nuevo_nombre_lite);
        guardarLog("Archivos enviados a crearAutPost: {$nuevo_nombre_original}, {$nuevo_nombre_lite}");
    }
    

    3. Implementación de obtenerUrlPublica

    Necesitamos una función que convierta la ruta del archivo en una URL pública. Asumo que tus archivos están dentro del directorio de WordPress, por ejemplo, dentro de wp-content/uploads. Aquí tienes una posible implementación:

    /**
     * Obtiene la URL pública de un archivo dado su sistema de archivos.
     *
     * @param string $file_path  Ruta completa del archivo en el sistema de archivos.
     * @return string|false      URL pública del archivo o False si falla.
     */
    function obtenerUrlPublica($file_path)
    {
        // Obtener la ruta absoluta a WordPress
        $wp_content_dir = wp_content_dir(); // Puedes necesitar definir esta función o usar WP_CONTENT_DIR
        
        // Verificar si el archivo está dentro de wp-content
        if (strpos($file_path, WP_CONTENT_DIR) !== 0) {
            guardarLog("El archivo no está dentro del directorio wp-content: {$file_path}");
            return false;
        }
    
        // Obtener la ruta relativa
        $relative_path = str_replace(WP_CONTENT_DIR, '', $file_path);
    
        // Construir la URL pública
        $public_url = content_url($relative_path); // Esta función de WordPress construye la URL correcta
    
        return $public_url;
    }
    

    Asegúrate de definir obtenerUrlPublica correctamente según la estructura de tu servidor y cómo se servicen los archivos públicamente.

    4. Función de Logging guardarLog

    Para asegurar que las funciones de logging no causen errores, verifica que guardarLog esté correctamente implementada. Aquí hay una implementación básica:

    /**
     * Guarda un mensaje en el log personalizado.
     *
     * @param string $mensaje  Mensaje a guardar en el log.
     */
    function guardarLog($mensaje)
    {
        // Define la ruta del archivo de log
        $log_file = WP_CONTENT_DIR . '/logs/procesar_audio.log'; // Asegúrate de que este directorio exista y tenga permisos adecuados
    
        // Formatear el mensaje con fecha y hora
        $fecha = date("Y-m-d H:i:s");
        $mensaje_formateado = "[{$fecha}] {$mensaje}\n";
    
        // Escribir en el archivo de log
        error_log($mensaje_formateado, 3, $log_file);
    }
    

    Nota: Asegúrate de que el directorio de logs exista y que el servidor web tenga permisos de escritura en él.

    5. Resumen de Pasos Realizados en autProcesarAudio

    1. Verificación de Existencia: Comprueba si el archivo de audio existe en la ruta proporcionada.

    2. Eliminar Metadatos: Utiliza ffmpeg para crear una versión temporal del archivo sin metadatos y reemplaza el original.

    3. Crear Versión Lite: Crea una versión en MP3 a 128 kbps del archivo original.

    4. Generar Nombre Limpio: Envía la versión lite a una IA para obtener un nombre limpio.

    5. Renombrar Archivos: Renombra tanto el archivo original como la versión lite con el nombre limpio generado.

    6. Actualizar URL en la Base de Datos:

      • Obtiene la URL pública del archivo original renombrado.
      • Busca el file_id correspondiente al archivo original antes de renombrarlo.
      • Actualiza la URL en la base de datos utilizando actualizarUrlArchivo.
    7. Enviar a crearAutPost: Envía los archivos renombrados a la función crearAutPost para pasos posteriores.

    6. Consideraciones Finales

    • Seguridad: Asegúrate de validar y sanitizar todas las entradas y salidas, especialmente si las rutas de los archivos pueden ser manipuladas por usuarios.

    • Permisos de Archivos: Verifica que el servidor tenga los permisos adecuados para modificar, renombrar y crear archivos en los directorios utilizados.

    • Manejo de Errores: Puedes mejorar aún más el manejo de errores según las necesidades de tu aplicación, por ejemplo, intentando reintentos, alertando a administradores, etc.

    • Optimización: Dependiendo del tamaño y la cantidad de archivos, considera optimizar las llamadas a ffmpeg o paralelizar ciertos procesos si es necesario.

    Espero que esta integración cumpla con tus necesidades. Si tienes alguna duda adicional o necesitas ajustar alguna parte específica, no dudes en comentarlo.