Share
En el último tutorial analizamos la exportación de datos desde una tabla personalizada. Por supuesto, esto es solo la mitad de la historia, obviamente necesitamos proporcionar una forma de importar esos datos. Naturalmente, WordPress no maneja esto, así que una vez más necesitamos rodar los nuestros..
En el artículo anterior de esta serie, notamos que si nuestros datos contienen referencias a una de las tablas nativas de WordPress (por ejemplo, una ID de publicación), entonces encontramos dificultades rápidamente. El motivo es que al importar dichos datos, es posible que la ID de publicación a la que se hace referencia no exista y, si lo hace, puede que no sea la ID correcta. Esto se debe a que cuando se importan las publicaciones, su ID puede cambiar para evitar colisiones en la base de datos (IDs debe ser único).
Normalmente esto está bien: los datos vinculados se importan juntos y las referencias se actualizan durante la rutina de importación para garantizar que los cambios se propaguen a lo largo de todo el conjunto de datos. Sin embargo, como se explicó en el artículo anterior, en realidad es muy difícil (excepto en casos particulares) importar nuestros datos personalizados junto con los datos nativos. Por lo tanto, las advertencias mencionadas en ese artículo continúan con esta, y como antes, aunque el siguiente ejemplo hace referencia a las tablas de WordPress, se usa simplemente para mantener la coherencia con el resto de la serie..
Queremos permitir que nuestros usuarios importen datos del archivo de exportación generado en el último artículo de esta serie, así que comencemos agregando un formulario que permita al usuario cargar ese archivo. Haremos esto modificando la clase que definimos en el último tutorial..
Accentsconagua
clase WPTuts_Log_Export_Admin_Page / ** * El sufijo de enlace de página * / static $ hook_suffix = "; static static load () add_action ('admin_menu', array (__CLASS__, 'add_submenu')); add_action ('admin_init', array (__CLASS__ , 'maybe_download')); add_action ('admin_init', array (__CLASS__, 'maybe_upload')); add_action ('admin_notices', array (__CLASS__, 'admin_notices')); static static add_submenu () / * Defined in artículo anterior * / función estática maybe_download () / * definida en artículo anterior * / función estática pantalla () / * definida en artículo anterior, pero haremos algunas modificaciones * / función estática maybe_upload () función estática admin_notices () función estática import () función estática parse () WPTuts_Log_Export_Admin_Page :: load (); Anteriormente hemos añadido los siguientes métodos.
maybe_upload () - que actuará como un oyente para un archivo que se envía para la importación.admin_notices () - que mostrará un aviso de éxito o error después de intentar importar un archivo.importar() - el cual recibirá un archivo cargado e importará los datos..analizar gramaticalmente() - una función auxiliar llamada por importar() para analizar el archivo cargado y extraer los registros que contiene.Pero primero, agregaremos un formulario mediante el cual podemos subir un archivo. Agregaremos esto debajo del botón de exportación que creamos en el artículo anterior. Para ello necesitaremos realizar algunas modificaciones en el monitor() Método, responsable de producir el marcado de nuestra página de administración. Dado que este segundo formulario enviará un archivo, debemos establecer el tipo de codificación en 'multipart / form-data'.
'; screen_icon (); eco ''. __ ('Exportar registros de actividad', 'wptuts-log'). '
'; ?>
A continuación, queremos escuchar cuando se envía el formulario anterior y activar la rutina de importación. Antes de hacer eso es importante realizar algunas comprobaciones:
opciones de gestión la capacidad de subir.Opcionalmente, puede establecer un límite en el tamaño del archivo cargado como una especie de "comprobación de validez". En este ejemplo lo he limitado a 2MB. (Una función útil para formatear el tamaño de los archivos en una "forma legible por humanos" es la función tamaño_formato).
función estática maybe_upload () / * Escuchar el envío del formulario * / if (empty ($ _POST ['action']) || 'import-logs'! == $ _POST ['action']) return; / * Comprobar permisos y permisos * / if (! Current_user_can ('manage_options')) wp_die ("); check_admin_referer ('wptuts-import-logs', '_wplnonce'); / * Realizar verificaciones en el archivo: * / // Sanity verifique si (vacío ($ _FILES ["wptuts_import"])) wp_die ('No se encontró el archivo'); $ file = $ _FILES ["wptuts_import"]; // ¿Es del tipo esperado? if ($ file ["type "]! =" text / xml ") wp_die (sprintf (__ (" Se produjo un error al importar los registros. Tipo de archivo detectado: '% s'. 'texto / xml' esperado ", 'wptuts-log'), $ archivo ['tipo'])); // Imponer un límite en el tamaño del archivo cargado. Máx. 2097152 bytes = 2MB si ($ archivo ["tamaño"]> 2097152) $ tamaño = tamaño_formato ($ archivo ['tamaño '], 2); wp_die (sprintf (__ (' Tamaño de archivo demasiado grande (% s). Máximo 2MB ',' registros de importación '), $ tamaño)); if ($ archivo ["error"]> 0 ) wp_die (sprintf (__ ("Error encontrado:% d", 'wptuts-import'), $ archivo ["error"])); / * Si hemos llegado hasta aquí, podemos importar los datos * / $ imports = self :: import ($ file ['tmp_name']); / * Todo está completo, ahora re volver directamente a la página * / wp_redirect (add_query_arg ('importado', $ importado)); salida(); A continuación tenemos que importar el archivo. Primero tendremos que extraer los registros del archivo cargado, y delegaremos ese trabajo a la analizar gramaticalmente() Método (llegaremos a ese método en un momento).
Una vez que tengamos estos registros, primero verificaremos si ya existen (para evitar cualquier duplicación accidental), antes de insertarlos. Al revisar los registros, solo verificaremos la ID de usuario y la fecha de la actividad. Podríamos, si quisiéramos, ser más estrictos (verificar la actividad, la identificación del objeto y el tipo, etc.) pero tendríamos que regresar y ampliar nuestra API (específicamente wptuts_get_logs ()).
Una vez que hemos importado los registros, redirigimos al usuario a nuestra página de administración. Agregaremos una variable de consulta a la URL (importado) para almacenar cuántos registros se importaron (si los hay). De esta manera podemos mostrar un mensaje de administrador apropiado.
función de importación ($ archivo) // Parse file $ logs = self :: parse ($ archivo); // ¿No se encontraron registros? - entonces abortó. if (! $ logs) devuelve 0; // Inicializa una variable almacenando el número de registros importados exitosamente. $ importado = 0; // Ir a través de cada registro foreach ($ logs como $ log_id => $ log) / * * Verificar si el registro ya existe: * Solo verificaremos la fecha y la ID del usuario, pero podríamos verificar otros detalles * si extendimos nuestros wptuts_get_logs () API * / $ existencia = wptuts_get_logs (array ('id_usuario' => $ log ['id_usuario'], 'desde' => mysql2date ('G', $ log ['activity_date'], false) , 'until' => mysql2date ('G', $ log ['activity_date'], false),)); // Si existe, no lo importe si ($ existe) continúe; // Inserte el log $ success = wptuts_insert_log (array ('user_id' => $ log ['user_id'], 'date' => mysql2date ('G', $ log ['activity_date'], false), 'object_id' => $ log ['object_id'], 'object_type' => $ log ['object_type'], 'activity' => $ log ['activity'], 'activity_date' => $ log ['activity_date'],) ); si ($ exitoso) $ importado ++; devolver $ importado; Todavía tenemos que definir el analizar gramaticalmente() método que, dado el archivo cargado, debe extraer los datos y devolverlos como una matriz de registros. Afortunadamente, con el controlador XML incorporado de PHP, esta es una tarea bastante simple.
función de análisis ($ archivo) // Cargar el archivo xml $ xml = simplexml_load_file ($ archivo); // detener si la carga produce un error si (! $ xml) devuelve falso; // Inicial logs array $ logs = array (); foreach ($ xml-> xpath ('/ logs / item') como $ log_obj) $ log = $ log_obj-> children (); $ log_id = (int) $ log-> log_id; $ logs [$ log_id] = array ('user_id' => (int) $ log-> user_id, 'object_id' => (int) $ log-> object_id, 'object_type' => (string) $ log-> object_type , 'activty' => (string) $ log-> activity, 'activity_date' => (string) $ log-> activity_date,); devolver $ logs; Finalmente, queremos definir nuestra admin_notices () Método para mostrar un mensaje apropiado después de que se haya cargado el archivo. Recuerde que una vez que la rutina de importación ha finalizado, redirigimos al usuario a nuestra página de administración, con la variable de consulta importado agregado, almacenando el número de registros importados. Usamos esto para determinar si debemos mostrar un error o un mensaje de éxito.
También verificamos la identificación de la pantalla para que solo podamos mostrar el aviso en nuestra página de administración. Si no está seguro de cuál es el ID de pantalla de su página de administrador, consulte este artículo.
function admin_notices () // ¿Se intentó realizar una importación y estamos en la página de administración correcta? if (! isset ($ _GET ['importado']) || 'tools_page_wptuts-export'! == get_current_screen () -> id) devuelve; $ importado = intval ($ _GET ['importado']); if (1 == $ importado) printf ('% s
', __ (' 1 log log importado con éxito ',' wptuts-import ')); elseif (intval ($ _GET ['importado'))) printf ('% s
', sprintf (__ ('% d logs importados exitosamente ',' wptuts-import '), $ importados)); else printf ('% s
', __ (' No se importaron registros ',' wptuts-import '));
