537 lines
23 KiB
PHP
537 lines
23 KiB
PHP
<?php
|
|
/* vim: set expandtab tabstop=4 shiftwidth=4: */
|
|
/**
|
|
* Copyright 2012 Mike Walsh - mpwalsh8@gmail.com
|
|
*
|
|
* This code is derived from the Custom List Table Example plugin.
|
|
*
|
|
* @see http://codex.wordpress.org/Class_Reference/WP_List_Table
|
|
* @see http://wordpress.org/extend/plugins/custom-list-table-example/
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
?>
|
|
|
|
<?php
|
|
if (!current_user_can('manage_options')) {
|
|
wp_die(printf('<div class="error fade"><p>%s</p></div>',
|
|
__('You are not allowed to view the submission log.', WPGFORM_I18N_DOMAIN)));
|
|
}
|
|
|
|
/*************************** LOAD THE BASE CLASS *******************************
|
|
*******************************************************************************
|
|
* The WP_List_Table class isn't automatically available to plugins, so we need
|
|
* to check if it's available and load it if necessary.
|
|
*/
|
|
if(!class_exists('WP_List_Table')){
|
|
require_once( ABSPATH . 'wp-admin/includes/class-wp-list-table.php' );
|
|
}
|
|
|
|
|
|
/************************** CREATE A PACKAGE CLASS *****************************
|
|
*******************************************************************************
|
|
* Create a new list table package that extends the core WP_List_Table class.
|
|
* WP_List_Table contains most of the framework for generating the table, but we
|
|
* need to define and override some methods so that our data can be displayed
|
|
* exactly the way we need it to be.
|
|
*
|
|
* To display this example on a page, you will first need to instantiate the class,
|
|
* then call $yourInstance->prepare_items() to handle any data manipulation, then
|
|
* finally call $yourInstance->display() to render the table to the page.
|
|
*
|
|
*/
|
|
class wpGForms_List_Table extends WP_List_Table {
|
|
|
|
/** ************************************************************************
|
|
* REQUIRED. Set up a constructor that references the parent constructor. We
|
|
* use the parent reference to set some default configs.
|
|
***************************************************************************/
|
|
function __construct() {
|
|
global $status, $page;
|
|
|
|
//Set parent defaults
|
|
parent::__construct( array(
|
|
'singular' => 'form', //singular name of the listed records
|
|
'plural' => 'forms', //plural name of the listed records
|
|
'ajax' => false //does this table support ajax?
|
|
) );
|
|
|
|
}
|
|
|
|
|
|
/** ************************************************************************
|
|
* Recommended. This method is called when the parent class can't find a method
|
|
* specifically build for a given column. Generally, it's recommended to include
|
|
* one method for each column you want to render, keeping your package class
|
|
* neat and organized. For example, if the class needs to process a column
|
|
* named 'last_name', it would first see if a method named $this->column_last_name()
|
|
* exists - if it does, that method will be used. If it doesn't, this one will
|
|
* be used. Generally, you should try to use custom column methods as much as
|
|
* possible.
|
|
*
|
|
* Since we have defined a column_last_name() method later on, this method doesn't
|
|
* need to concern itself with any column with a name of 'last_name'. Instead, it
|
|
* needs to handle everything else.
|
|
*
|
|
* For more detailed insight into how columns are handled, take a look at
|
|
* WP_List_Table::single_row_columns()
|
|
*
|
|
* @param array $item A singular item (one full row's worth of data)
|
|
* @param array $column_name The name/slug of the column to be processed
|
|
* @return string Text or HTML to be placed inside the column <td>
|
|
**************************************************************************/
|
|
function column_default($item, $column_name) {
|
|
switch($column_name){
|
|
case 'timestamp':
|
|
case 'url':
|
|
case 'remote_addr':
|
|
case 'remote_host':
|
|
case 'http_referer':
|
|
case 'http_user_agent':
|
|
case 'form':
|
|
case 'post_id':
|
|
return $item->$column_name;
|
|
default:
|
|
return print_r($item,true); //Show the whole array for troubleshooting purposes
|
|
}
|
|
}
|
|
|
|
|
|
/** ************************************************************************
|
|
* Recommended. This is a custom column method and is responsible for what
|
|
* is rendered in any column with a name/slug of 'last_name'. Every time the class
|
|
* needs to render a column, it first looks for a method named
|
|
* column_{$column_last_name} - if it exists, that method is run. If it doesn't
|
|
* exist, column_default() is called instead.
|
|
*
|
|
* This example also illustrates how to implement rollover actions. Actions
|
|
* should be an associative array formatted as 'slug'=>'link html' - and you
|
|
* will need to generate the URLs yourself. You could even ensure the links
|
|
*
|
|
*
|
|
* @see WP_List_Table::single_row_columns()
|
|
* @param array $item A singular item (one full row's worth of data)
|
|
* @return string Text to be placed inside the column <td> (last_name only)
|
|
**************************************************************************/
|
|
function column_timestamp($item) {
|
|
|
|
//Build row actions
|
|
$actions = array(
|
|
// 'edit' => sprintf('<a href="%s%s%s">Edit User Profile</a>',
|
|
// get_admin_url(), 'user-edit.php?user_id=',$item->ID),
|
|
'delete' => sprintf('<a href="%s%s%s">Delete Log Entry</a>',
|
|
get_admin_url(), 'edit.php?post_type=' . WPGFORM_CPT_FORM .
|
|
'&page=wpgform-entry-log-page&action=delete&form=', $item->form),
|
|
);
|
|
|
|
//Return the last_name contents
|
|
return sprintf('%1$s <span style="color:silver">(id:%2$s)</span>%3$s',
|
|
/*$1%s*/ $item->timestamp,
|
|
/*$2%s*/ $item->form,
|
|
/*$3%s*/ $this->row_actions($actions)
|
|
);
|
|
}
|
|
|
|
/** ************************************************************************
|
|
* REQUIRED if displaying checkboxes or using bulk actions! The 'cb' column
|
|
* is given special treatment when columns are processed. It ALWAYS needs to
|
|
* have it's own method.
|
|
*
|
|
* @see WP_List_Table::single_row_columns()
|
|
* @param array $item A singular item (one full row's worth of data)
|
|
* @return string Text to be placed inside the column <td> (movie title only)
|
|
**************************************************************************/
|
|
function column_cb($item){
|
|
return sprintf(
|
|
'<input type="checkbox" name="%1$s[]" value="%2$s" />',
|
|
/*$1%s*/ $this->_args['singular'], //Let's simply repurpose the table's singular label ("last_name")
|
|
/*$2%s*/ $item->form //The value of the checkbox should be the record's id
|
|
);
|
|
}
|
|
|
|
|
|
/** ************************************************************************
|
|
* REQUIRED! This method dictates the table's columns and titles. This should
|
|
* return an array where the key is the column slug (and class) and the value
|
|
* is the column's title text. If you need a checkbox for bulk actions, refer
|
|
* to the $columns array below.
|
|
*
|
|
* The 'cb' column is treated differently than the rest. If including a checkbox
|
|
* column in your table you must create a column_cb() method. If you don't need
|
|
* bulk actions or checkboxes, simply leave the 'cb' entry out of your array.
|
|
*
|
|
* @see WP_List_Table::::single_row_columns()
|
|
* @return array An associative array containing column information: 'slugs'=>'Visible Titles'
|
|
**************************************************************************/
|
|
function get_columns(){
|
|
$columns = array(
|
|
'cb' => '<input type="checkbox" />', //Render a checkbox instead of text
|
|
'timestamp' => __('Timestamp', WPGFORM_I18N_DOMAIN),
|
|
'url' => __('URL', WPGFORM_I18N_DOMAIN),
|
|
'remote_addr' => __('Remote Addr', WPGFORM_I18N_DOMAIN),
|
|
'remote_host' => __('Remote Host', WPGFORM_I18N_DOMAIN),
|
|
'http_referer' => __('HTTP Refer', WPGFORM_I18N_DOMAIN),
|
|
'http_user_agent' => __('HTTP User Agent', WPGFORM_I18N_DOMAIN),
|
|
//'form' => __('wpGForm Id', WPGFORM_I18N_DOMAIN),
|
|
//'post_id' => __('Post Id', WPGFORM_I18N_DOMAIN)
|
|
);
|
|
return $columns;
|
|
}
|
|
|
|
/** ************************************************************************
|
|
* Optional. If you want one or more columns to be sortable (ASC/DESC toggle),
|
|
* you will need to register it here. This should return an array where the
|
|
* key is the column that needs to be sortable, and the value is db column to
|
|
* sort by. Often, the key and value will be the same, but this is not always
|
|
* the case (as the value is a column name from the database, not the list table).
|
|
*
|
|
* This method merely defines which columns should be sortable and makes them
|
|
* clickable - it does not handle the actual sorting. You still need to detect
|
|
* the ORDERBY and ORDER querystring variables within prepare_items() and sort
|
|
* your data accordingly (usually by modifying your query).
|
|
*
|
|
* @return array An associative array containing all the columns that should be sortable: 'slugs'=>array('data_values',bool)
|
|
**************************************************************************/
|
|
function get_sortable_columns() {
|
|
$sortable_columns = array(
|
|
'timestamp' => array('timestamp',true), //true means its already sorted
|
|
'url' => array('url',false),
|
|
'remote_addr' => array('remote_addr',false),
|
|
'remote_host' => array('remote_host',false),
|
|
'http_referer' => array('http_referer',false),
|
|
'http_user_agent' => array('http_user_agent',false),
|
|
//'form' => array('form',false),
|
|
//'post_id' => array('post_id',false)
|
|
);
|
|
return $sortable_columns;
|
|
}
|
|
|
|
|
|
/** ************************************************************************
|
|
* Optional. If you need to include bulk actions in your list table, this is
|
|
* the place to define them. Bulk actions are an associative array in the format
|
|
* 'slug'=>'Visible Title'
|
|
*
|
|
* If this method returns an empty value, no bulk action will be rendered. If
|
|
* you specify any bulk actions, the bulk actions box will be rendered with
|
|
* the table automatically on display().
|
|
*
|
|
* Also note that list tables are not automatically wrapped in <form> elements,
|
|
* so you will need to create those manually in order for bulk actions to function.
|
|
*
|
|
* @return array An associative array containing all the bulk actions: 'slugs'=>'Visible Titles'
|
|
**************************************************************************/
|
|
function get_bulk_actions() {
|
|
$actions = array(
|
|
'delete' => __('Delete', WPGFORM_I18N_DOMAIN)
|
|
);
|
|
return $actions;
|
|
}
|
|
|
|
|
|
/** ************************************************************************
|
|
* Optional. You can handle your bulk actions anywhere or anyhow you prefer.
|
|
* For this example package, we will handle it in the class to keep things
|
|
* clean and organized.
|
|
*
|
|
* @see $this->prepare_items()
|
|
**************************************************************************/
|
|
function process_bulk_action() {
|
|
|
|
$c = 0 ;
|
|
$actions = $this->get_bulk_actions() ;
|
|
|
|
if (($this->current_action() !== false) && array_key_exists('form', $_GET))
|
|
{
|
|
/* -- Fetch the items -- */
|
|
$raw_meta_values = $this->get_meta_key_values(WPGFORM_LOG_ENTRY_META_KEY, '', -1);
|
|
|
|
// Since the log entries are serialized by WordPress' meta process,
|
|
// they need to be unserialized and turned into the proper array of
|
|
// objects before they can be used identify the proper meta value.
|
|
|
|
$meta_values = array() ;
|
|
|
|
foreach ($raw_meta_values as $raw_meta_value)
|
|
{
|
|
$meta_value = wpGFormArrayToObject(array_merge(maybe_unserialize($raw_meta_value->mv),
|
|
array('meta_value' => $raw_meta_value->mv))) ;
|
|
$meta_values[$meta_value->form] = $meta_value ;
|
|
}
|
|
|
|
// Make sure we handle the case where the form id isn't in an array
|
|
|
|
$forms = is_array($_GET['form']) ? $_GET['form'] : array($_GET['form']) ;
|
|
|
|
// Loop through the form ids and delete the entries which match
|
|
|
|
foreach ($forms as $form)
|
|
{
|
|
switch ($this->current_action())
|
|
{
|
|
case 'delete':
|
|
$c++ ;
|
|
delete_post_meta($meta_values[$form]->form,
|
|
WPGFORM_LOG_ENTRY_META_KEY, maybe_unserialize($meta_values[$form]->meta_value)) ;
|
|
break ;
|
|
}
|
|
}
|
|
|
|
printf('<div class="updated fade"><h4>%s completed for %d log entr%s.</h4></div>',
|
|
$actions[$this->current_action()], $c, $c == 1 ? 'y' : 'ies') ;
|
|
}
|
|
else if ($this->current_action() !== false)
|
|
{
|
|
printf('<div class="error fade"><h4>%s.</h4></div>',
|
|
__('No log entries selected', WPGFORM_I18N_DOMAIN)) ;
|
|
}
|
|
|
|
$_SERVER['REQUEST_URI'] = remove_query_arg( array( 'delete', 'page', 'post_type',
|
|
'action', 'action2', 'form', '_wp_http_referer', '_wp_nonce' ), $_SERVER['REQUEST_URI'] );
|
|
}
|
|
|
|
|
|
/**
|
|
* Overload of parent class in order to make the pagination work with the Custom Post Type
|
|
*
|
|
*/
|
|
function pagination($which) {
|
|
$_SERVER['REQUEST_URI'] = add_query_arg(array(
|
|
'post_type' => WPGFORM_CPT_FORM
|
|
,'page' => 'wpgform-entry-log-page'
|
|
), $_SERVER['REQUEST_URI']) ;
|
|
|
|
parent::pagination($which) ;
|
|
}
|
|
|
|
/** ************************************************************************
|
|
* REQUIRED! This is where you prepare your data for display. This method will
|
|
* usually be used to query the database, sort and filter the data, and generally
|
|
* get it ready to be displayed. At a minimum, we should set $this->items and
|
|
* $this->set_pagination_args(), although the following properties and methods
|
|
* are frequently interacted with here...
|
|
*
|
|
* @uses $this->_column_headers
|
|
* @uses $this->items
|
|
* @uses $this->get_columns()
|
|
* @uses $this->get_sortable_columns()
|
|
* @uses $this->get_pagenum()
|
|
* @uses $this->set_pagination_args()
|
|
**************************************************************************/
|
|
function prepare_items() {
|
|
global $wpdb, $_wp_column_headers;
|
|
$screen = get_current_screen() ;
|
|
|
|
/**
|
|
* First, lets decide how many records per page to show
|
|
*/
|
|
//$per_page = wpgform_get_user_settings_table_rows() ;
|
|
$per_page = 10 ;
|
|
|
|
if ($per_page === false) $per_page = 10 ;
|
|
|
|
/* -- Pagination parameters -- */
|
|
//Number of elements in your table?
|
|
$totalitems = $this->get_meta_key_count(WPGFORM_LOG_ENTRY_META_KEY);
|
|
|
|
//Which page is this?
|
|
$paged = !empty($_GET['paged']) ? mysql_real_escape_string($_GET['paged']) : '';
|
|
|
|
//Page Number
|
|
if (empty($paged) || !is_numeric($paged) || $paged <= 0 ) $paged=1;
|
|
|
|
//How many pages do we have in total?
|
|
$totalpages = ceil($totalitems[0]->count/$per_page);
|
|
|
|
/* -- Register the pagination -- */
|
|
$this->set_pagination_args( array(
|
|
'total_items' => $totalitems[0]->count,
|
|
'total_pages' => $totalpages,
|
|
'per_page' => $per_page,
|
|
'post_type' => WPGFORM_CPT_FORM,
|
|
'page' => 'wpgform-entry-log-page'
|
|
) );
|
|
//The pagination links are automatically built according to those parameters
|
|
|
|
/**
|
|
* REQUIRED. Now we need to define our column headers. This includes a complete
|
|
* array of columns to be displayed (slugs & titles), a list of columns
|
|
* to keep hidden, and a list of columns that are sortable. Each of these
|
|
* can be defined in another method (as we've done here) before being
|
|
* used to build the value for our _column_headers property.
|
|
*/
|
|
$columns = $this->get_columns();
|
|
$hidden = array();
|
|
$sortable = $this->get_sortable_columns();
|
|
|
|
|
|
/**
|
|
* REQUIRED. Finally, we build an array to be used by the class for column
|
|
* headers. The $this->_column_headers property takes an array which contains
|
|
* 3 other arrays. One for all columns, one for hidden columns, and one
|
|
* for sortable columns.
|
|
*/
|
|
$this->_column_headers = array($columns, $hidden, $sortable);
|
|
|
|
|
|
/**
|
|
* Optional. You can handle your bulk actions however you see fit. In this
|
|
* case, we'll handle them within our package just to keep things clean.
|
|
*/
|
|
$this->process_bulk_action();
|
|
|
|
/* -- Fetch the items -- */
|
|
$raw_meta_values = $this->get_meta_key_values(WPGFORM_LOG_ENTRY_META_KEY, $paged, $per_page);
|
|
|
|
// Since the log entries are serialized by WordPress' meta process,
|
|
// they need to be unserialized and turned into the proper array of
|
|
// objects before they can be used to construct the table.
|
|
|
|
foreach ($raw_meta_values as $raw_meta_value)
|
|
$this->items[] = wpGFormArrayToObject(array_merge(maybe_unserialize($raw_meta_value->mv),
|
|
array('meta_value' => $raw_meta_value->mv))) ;
|
|
}
|
|
|
|
function get_meta_key_values($key = '', $paged = '', $per_page = 10, $type = 'wpgform', $status = 'publish')
|
|
{
|
|
global $wpdb;
|
|
|
|
if (empty($key)) return ;
|
|
|
|
//adjust the query to take pagination into account
|
|
|
|
if(!empty($paged) && !empty($per_page))
|
|
{
|
|
$offset=($paged-1)*$per_page;
|
|
|
|
$r = $wpdb->get_results($wpdb->prepare( "
|
|
SELECT pm.meta_value AS mv FROM {$wpdb->postmeta} pm
|
|
LEFT JOIN {$wpdb->posts} p ON p.ID = pm.post_id
|
|
WHERE pm.meta_key = '%s'
|
|
AND pm.meta_value != ''
|
|
AND p.post_type = '%s'
|
|
GROUP BY pm.meta_id
|
|
ORDER BY pm.meta_id
|
|
LIMIT %d,%d
|
|
", $key, $type, (int)$offset, (int)$per_page)
|
|
);
|
|
}
|
|
else
|
|
{
|
|
$r = $wpdb->get_results($wpdb->prepare( "
|
|
SELECT pm.meta_value AS mv FROM {$wpdb->postmeta} pm
|
|
LEFT JOIN {$wpdb->posts} p ON p.ID = pm.post_id
|
|
WHERE pm.meta_key = '%s'
|
|
AND pm.meta_value != ''
|
|
AND p.post_type = '%s'
|
|
GROUP BY pm.meta_id
|
|
ORDER BY pm.meta_id
|
|
", $key, $type)
|
|
);
|
|
}
|
|
|
|
return $r;
|
|
}
|
|
|
|
/**
|
|
* Determine how many post meta values there for the specified key
|
|
*
|
|
* @param $Key string meta key
|
|
* @param $type string post type
|
|
* @param $status optional string status of post
|
|
* @return mixed count of post meta values
|
|
*/
|
|
function get_meta_key_count($key = '', $type = 'wpgform', $status = 'publish') {
|
|
global $wpdb;
|
|
|
|
if (empty($key)) return ;
|
|
|
|
$r = $wpdb->get_results( $wpdb->prepare( "
|
|
SELECT count(*) AS count FROM {$wpdb->postmeta} pm
|
|
LEFT JOIN {$wpdb->posts} p ON p.ID = pm.post_id
|
|
WHERE pm.meta_key = '%s'
|
|
AND pm.meta_value != ''
|
|
AND p.post_type = '%s'
|
|
", $key, $type)
|
|
);
|
|
|
|
return $r;
|
|
}
|
|
}
|
|
|
|
|
|
/***************************** RENDER PAGE CONTENT ********************************
|
|
**********************************************************************************
|
|
* This function renders the admin page and the example list table. Although it's
|
|
* possible to call prepare_items() and display() from the constructor, there
|
|
* are often times where you may need to include logic here between those steps,
|
|
* so we've instead called those methods explicitly. It keeps things flexible, and
|
|
* it's the way the list tables are used in the WordPress core.
|
|
*/
|
|
function wpgform_render_list_page(){
|
|
|
|
//Create an instance of our package class...
|
|
$wpgformListTable = new wpGForms_List_Table();
|
|
|
|
//Fetch, prepare, sort, and filter our data...
|
|
$wpgformListTable->prepare_items();
|
|
|
|
?>
|
|
<div class="wrap">
|
|
|
|
<div id="icon-users" class="icon32"><br/></div>
|
|
<h2>WordPress Google Form Submission Log</h2>
|
|
|
|
<!-- Forms are NOT created automatically, so you need to wrap the table in one to use features like bulk actions -->
|
|
<form id="wpgform-log-entries-filter" method="get">
|
|
<!-- For plugins, we also need to ensure that the form posts back to our current page -->
|
|
<input type="hidden" name="post_type" value="<?php echo WPGFORM_CPT_FORM ?>" />
|
|
<input type="hidden" name="page" value="<?php echo $_REQUEST['page'] ?>" />
|
|
<input type="hidden" name="_wp_http_referer" value="<?php echo admin_url('edit.php?post_type=' . WPGFORM_CPT_FORM . '&page=wpgform-entry-log-page' ); ?>" />
|
|
<!-- Now we can render the completed list table -->
|
|
<?php //$wpgformListTable->search_box(__('Search', WPGFORM_I18N_DOMAIN), 'search_id'); ?>
|
|
<?php $wpgformListTable->display() ; ?>
|
|
</form>
|
|
|
|
</div>
|
|
<?php
|
|
}
|
|
|
|
/**
|
|
* Map an array into a standard PHP object
|
|
*
|
|
* @param $d array
|
|
* @return stdObject
|
|
*/
|
|
function wpGFormArrayToObject($d)
|
|
{
|
|
if (is_array($d)) {
|
|
/*
|
|
* Return array converted to object
|
|
* Using __FUNCTION__ (Magic constant)
|
|
* for recursive call
|
|
*/
|
|
return (object) array_map(__FUNCTION__, $d);
|
|
}
|
|
else {
|
|
// Return object
|
|
return $d;
|
|
}
|
|
}
|
|
|
|
// Render the page ...
|
|
wpgform_render_list_page() ;
|
|
?>
|