1322 lines
45 KiB
PHP
1322 lines
45 KiB
PHP
<?php
|
|
|
|
use Aventura\Wprss\Core\Model\AdminAjaxNotice\ServiceProvider;
|
|
use Dhii\Di\WritableContainerInterface;
|
|
use Aventura\Wprss\Core\Model\AdminAjaxNotice\NoticeInterface;
|
|
|
|
define ('WPRSS_NOTICE_SERVICE_ID_PREFIX', WPRSS_SERVICE_ID_PREFIX . 'notice.');
|
|
|
|
|
|
add_action( 'wp_ajax_wprss_hide_admin_notification', 'wprss_hide_admin_notification' );
|
|
/**
|
|
* JavaScript callback used to hide the administration notice when the 'Dismiss' anchor is clicked on the front end.
|
|
*
|
|
* @since 3.0
|
|
*/
|
|
function wprss_hide_admin_notification() {
|
|
|
|
// First, check the nonce to make sure it matches what we created when displaying the message.
|
|
// If not, we won't do anything.
|
|
if( wp_verify_nonce( $_REQUEST['nonce'], 'ajax-notification-nonce' ) ) {
|
|
|
|
// If the update to the option is successful, send 1 back to the browser;
|
|
// Otherwise, send 0.
|
|
$general_settings = get_option( 'wprss_settings_notices' );
|
|
$general_settings = true;
|
|
|
|
if( update_option( 'wprss_settings_notices', $general_settings ) ) {
|
|
die( '1' );
|
|
} else {
|
|
die( '0' );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Checks if the addon notices option exists in the database, and creates it
|
|
* if it does not.
|
|
*
|
|
* @return The addon notices option
|
|
* @since 3.4.2
|
|
*/
|
|
function wprss_check_addon_notice_option() {
|
|
$option = get_option( 'wprss_addon_notices' );
|
|
if ( $option === FALSE ) {
|
|
update_option( 'wprss_addon_notices', array() );
|
|
return array();
|
|
}
|
|
return $option;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* This function is called through AJAX to dismiss a particular addon notification.
|
|
*
|
|
* @since 3.4.2
|
|
*/
|
|
function wprss_dismiss_addon_notice() {
|
|
$addon = ( isset( $_POST['addon'] ) === TRUE )? $_POST['addon'] : null;
|
|
if ( $addon === null ) {
|
|
echo 'false';
|
|
die();
|
|
}
|
|
$notice = ( isset( $_POST['notice'] ) === TRUE )? $_POST['notice'] : null;
|
|
if ( $notice === null ){
|
|
echo 'false';
|
|
die();
|
|
}
|
|
|
|
$notices = wprss_check_addon_notice_option();
|
|
if ( isset( $notices[$addon] ) === FALSE ) {
|
|
$notices[$addon] = array();
|
|
}
|
|
if ( isset( $notices[$addon][$addon] ) === FALSE ) {
|
|
$notices[$addon][$notice] = '1';
|
|
}
|
|
update_option( 'wprss_addon_notices', $notices );
|
|
echo 'true';
|
|
|
|
die();
|
|
}
|
|
|
|
add_action( 'wp_ajax_wprss_dismiss_addon_notice', 'wprss_dismiss_addon_notice' );
|
|
|
|
|
|
|
|
|
|
/**
|
|
* AJAX action for the tracking pointer
|
|
*
|
|
* @since 3.6
|
|
*/
|
|
function wprss_tracking_ajax_opt() {
|
|
if ( isset( $_POST['opted'] ) ){
|
|
$opted = $_POST['opted'];
|
|
$settings = get_option( 'wprss_settings_general' );
|
|
$settings['tracking'] = $opted;
|
|
update_option( 'wprss_settings_general', $settings );
|
|
}
|
|
die();
|
|
}
|
|
|
|
add_action( 'wp_ajax_wprss_tracking_ajax_opt', 'wprss_tracking_ajax_opt' );
|
|
|
|
|
|
/**
|
|
* Responsible for tracking and outputting admin notices
|
|
*
|
|
* Usage:
|
|
* Initialize by calling {@see init()} early, before `admin_init`. On `plugins_loaded`
|
|
* is a good place.
|
|
* Do not add notices conditionally. Instead, add them always, but specify
|
|
* the `condition` index to {@see add_notice()}.
|
|
*
|
|
* @since 4.7.4
|
|
*/
|
|
class WPRSS_Admin_Notices {
|
|
|
|
// How should a set of conditions be evaluated
|
|
const CONDITION_TYPE_ALL = 'all'; // Requires all conditions to be true
|
|
const CONDITION_TYPE_ANY = 'any'; // Requires one condition to be true
|
|
const CONDITION_TYPE_NONE = 'none'; // Requires none of the conditions to be true
|
|
const CONDITION_TYPE_ALMOST = 'almost'; // Requires at least one of the conditions to be false
|
|
|
|
// What happens if a condition encounters an error
|
|
// const CONDITION_ON_ERROR_STOP_FALSE = 'stop_false'; // Assume that the condition was not satisfied, and do not evaluate other conditions
|
|
// const CONDITION_ON_ERROR_STOP_TRUE = 'stop_true'; // Assume that the condition was satisfied, and do not evaluate other conditions
|
|
// const CONDITION_ON_ERROR_CONTINUE_FALSE = 'continue_false'; // Assume that the condition was not satisfied, and continue evaluating
|
|
// const CONDITION_ON_ERROR_CONTINUE_TRUE = 'continue_true'; // Assume that the condition was satisfied, and continue evaluating
|
|
const CONDITION_ON_ERROR_THROW_EXCEPTION = 'throw_exception'; // Just halt
|
|
|
|
|
|
protected $_notices = array();
|
|
protected $_setting_code;
|
|
protected $_id_prefix;
|
|
protected $_text_domain;
|
|
protected $_notice_base_class;
|
|
protected $_nonce_base_class;
|
|
protected $_btn_close_base_class;
|
|
protected $_dismiss_mode_class_prefix;
|
|
|
|
|
|
/**
|
|
*
|
|
* @since 4.7.4
|
|
* @param null|array The settings of this instance.
|
|
* Possible values are:
|
|
* - 'setting_code': The code of the database setting used for storing and managing notices of this instance.
|
|
* See {@link set_setting_code()}.
|
|
* If a string is passed as data, this is what it is assumed to be.
|
|
* - 'id_prefix': The prefix of all IDs generated by this instance.
|
|
* See {@link set_id_prefix()}.
|
|
* - 'text_domain': The text domain to use for translation.
|
|
* See {@link set_text_domain()}.
|
|
* - 'notice_base_class': The class for all notice elements.
|
|
* See {@link set_notice_base_class()}.
|
|
* - 'nonce_base_class': The class for all notice nonce elements.
|
|
* See {@link set_nonce_base_class()}.
|
|
*/
|
|
public function __construct( $data = array() ) {
|
|
if ( is_string( $data ) )
|
|
$data = array( 'setting_code' => $data );
|
|
|
|
if ( isset( $data['setting_code'] ) )
|
|
$this->set_setting_code ( $data['setting_code'] );
|
|
|
|
if ( isset( $data['id_prefix'] ) )
|
|
$this->set_id_prefix( $data['id_prefix'] );
|
|
|
|
if ( isset( $data['text_domain'] ) )
|
|
$this->set_text_domain( $data['text_domain'] );
|
|
|
|
// Common class for all notices
|
|
if ( !isset( $data['notice_base_class'] ) )
|
|
$data['notice_base_class'] = $this->prefix( 'admin-notice' );
|
|
$this->set_notice_base_class( $data['notice_base_class'] );
|
|
|
|
// Common class for all nonces
|
|
if ( !isset( $data['nonce_base_class'] ) )
|
|
$data['nonce_base_class'] = $this->prefix( 'admin-notice-nonce' );
|
|
$this->set_nonce_base_class( $data['nonce_base_class'] );
|
|
|
|
// Common class for all close buttons
|
|
if ( !isset( $data['btn_close_base_class'] ) )
|
|
$data['btn_close_base_class'] = $this->prefix( 'admin-notice-btn-close' );
|
|
$this->set_btn_close_base_class( $data['btn_close_base_class'] );
|
|
|
|
// Class prefix for dismiss mode
|
|
if ( !isset( $data['dismiss_mode_class_prefix'] ) )
|
|
$data['dismiss_mode_class_prefix'] = 'dismiss-mode-';
|
|
$this->set_dismiss_mode_class_prefix($data['dismiss_mode_class_prefix']);
|
|
|
|
$this->_construct();
|
|
}
|
|
|
|
|
|
/**
|
|
* Internal, parameter-less constructor.
|
|
*
|
|
* @since 4.7.4
|
|
*/
|
|
protected function _construct() {
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Initializes the instance for use with WP.
|
|
*
|
|
* Essentially, this is what prepares it and hooks the handlers in.
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-action admin_notice_before_init To expose the object before initialization
|
|
* @uses-action admin_notice_before_init To expose the object after initialization
|
|
* @return \WPRSS_Admin_Notices This instance.
|
|
*/
|
|
public function init() {
|
|
do_action( $this->prefix( 'admin_notice_before_init' ), $this );
|
|
add_action( 'admin_notices', array( $this, 'output_allowed_notices' ) );
|
|
do_action( $this->prefix( 'admin_notice_after_init' ), $this );
|
|
|
|
return $this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the prefix for dismiss mode class name.
|
|
*
|
|
* @since 4.11
|
|
*
|
|
* @param string $prefix The prefix.
|
|
* @return $this This instance.
|
|
*/
|
|
public function set_dismiss_mode_class_prefix($prefix) {
|
|
$this->_dismiss_mode_class_prefix = trim($prefix);
|
|
return $this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the prefix for dismiss mode class name.
|
|
*
|
|
* @since 4.11
|
|
*
|
|
* @return string The prefix.
|
|
*/
|
|
public function get_dismiss_mode_class_prefix() {
|
|
return $this->_dismiss_mode_class_prefix;
|
|
}
|
|
|
|
/**
|
|
* Get the ID prefix, or a prefixed string.
|
|
*
|
|
* This function is also used internally by this class to prefix generated
|
|
* IDs that are specific to this instance.
|
|
* Currently, this prefix is used in HTML of the notices, and in names
|
|
* of hooks.
|
|
*
|
|
* @param null|string $string The string to prefix.
|
|
* @return string The prefix, or prefixed string
|
|
*/
|
|
public function prefix( $string = null ) {
|
|
$prefix = (string)$this->_id_prefix;
|
|
return is_null( $string ) ? $prefix : $prefix . $string;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets a prefix that will be added to IDs specific to this collection.
|
|
*
|
|
* @since 4.7.4
|
|
* @param string $prefix The prefix to set.
|
|
* @return \WPRSS_Admin_Notices This instance.
|
|
*/
|
|
public function set_id_prefix( $prefix ) {
|
|
$this->_id_prefix = $prefix;
|
|
return $this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the name of the setting to store the notices in.
|
|
*
|
|
* @since 4.7.4
|
|
* @see get_setting_name()
|
|
* @param string $name The name of the notices setting to use.
|
|
* @return \WPRSS_Admin_Notices This instance.
|
|
*/
|
|
public function set_setting_code( $name ) {
|
|
$this->_setting_code = $name;
|
|
return $this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Get the name of the notices setting.
|
|
*
|
|
* @since 4.7.4
|
|
* @see set_setting_name()
|
|
* @return string The name of the setting which stores notices and their states.
|
|
*/
|
|
public function get_setting_name() {
|
|
return $this->_setting_code;
|
|
}
|
|
|
|
|
|
/**
|
|
* Retrieve the text domain that is used for translation by this instance.
|
|
*
|
|
* @since 4.7.4
|
|
* @return string The text domain.
|
|
*/
|
|
public function get_text_domain() {
|
|
return $this->_text_domain;
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the text domain that is used for translation by this instance.
|
|
*
|
|
* @since 4.7.4
|
|
* @param string $text_domain The text domain.
|
|
* @return \WPRSS_Admin_Notices This instance.
|
|
*/
|
|
public function set_text_domain( $text_domain ) {
|
|
$this->_text_domain = $text_domain;
|
|
return $this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Get the class that is the base, common class for all notices' top HTML elements.
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter admin_notice_base_class To modify return value.
|
|
* @return string The class common to all notices
|
|
*/
|
|
public function get_notice_base_class() {
|
|
return apply_filters( $this->prefix( 'admin_notice_base_class' ), $this->_notice_base_class );
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the class that will be the base, common class for all notices' top HTML elements.
|
|
*
|
|
* @since 4.7.4
|
|
* @param string $class The class name that will be common to all notices.
|
|
* @return \WPRSS_Admin_Notices This instance.
|
|
*/
|
|
public function set_notice_base_class( $class ) {
|
|
$this->_notice_base_class = $class;
|
|
return $this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Get the class that is the base, common class for all notices' nonces' HTML elements.
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter admin_notice_nonce_base_class To modify return value.
|
|
* @return string The class common to all nonces
|
|
*/
|
|
public function get_nonce_base_class() {
|
|
return apply_filters( $this->prefix( 'admin_notice_nonce_base_class' ), $this->_nonce_base_class );
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the class that will be the base, common class for all notices' nonces' HTML elements.
|
|
*
|
|
* @since 4.7.4
|
|
* @param string $class The class name that will be common to all nonces.
|
|
* @return \WPRSS_Admin_Notices This instance.
|
|
*/
|
|
public function set_nonce_base_class( $class ) {
|
|
$this->_nonce_base_class = $class;
|
|
return $this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Get the class that is the base, common class for all notices' close buttons' HTML elements.
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter admin_notice_btn_close_base_class To modify return value.
|
|
* @return string The class common to all close buttons
|
|
*/
|
|
public function get_btn_close_base_class() {
|
|
return apply_filters( $this->prefix( 'admin_notice_btn_close_base_class' ), $this->_btn_close_base_class );
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the class that will be the base, common class for all notices' close buttons' HTML elements.
|
|
*
|
|
* @since 4.7.4
|
|
* @param string $class The class name that will be common to close buttons.
|
|
* @return \WPRSS_Admin_Notices This instance.
|
|
*/
|
|
public function set_btn_close_base_class( $class ) {
|
|
$this->_btn_close_base_class = $class;
|
|
return $this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Adds an admin notice.
|
|
*
|
|
* - If 'id' is not passed, a unique ID will be auto-generated.
|
|
* - If 'nonce' is not passed, a nonce will be auto-generated based on the ID.
|
|
* - A 'condition' is one or more callbacks. If none are passed, the notice will be displayed on all admin pages.
|
|
* - A 'condition_type' is one of the CONDITION_TYPE_* class constants. By default, all conditions have to be true.
|
|
* - The 'class' index determinces what type of notice it is. Currently, the valid values are 'updated', 'error' and 'update-nag'.
|
|
* See https://codex.wordpress.org/Plugin_API/Action_Reference/admin_notices
|
|
* - The 'content' index is the literal content of the notice.
|
|
* - If 'btn_close_id' is not passed, it will be auto-generated based on the ID.
|
|
* - The 'btn_close_class' index determines the class that the close button will have, in addition to the default 'btn-close'.
|
|
* - The 'btn_close_content' index determines the literal content of the element of the close button. HTML allowed.
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter admin_notice_add_before_normalize To allow pre-normalization modification of notice.
|
|
* @uses-filter admin_notice_add_before To allow post-normalization modification of notice.
|
|
* @uses-action admin_notice_add_after To expose data of added notice. This will not be fired if notice was not added.
|
|
* @param array $notice Data of the notice to add.
|
|
* @return \WPRSS_Admin_Notices This instance.
|
|
*/
|
|
public function add_notice( $notice ) {
|
|
$notice = apply_filters( $this->prefix( 'admin_notice_add_before_normalize' ), $notice, $this );
|
|
$notice = $this->normalize_notice_data( $notice );
|
|
$notice = apply_filters( $this->prefix( 'admin_notice_add_before' ), $notice, $this );
|
|
$this->set_notice( $notice );
|
|
do_action( $this->prefix( 'admin_notice_add_after' ), $notice, $this );
|
|
|
|
return $this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the data for a notice with the specified ID.
|
|
*
|
|
* No normalization or checks are made, except for the presence of an ID.
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter admin_notice_set_before To alter the data of the notice before setting.
|
|
* @uses-action admin_notice_set_after To expose the data of the notice after setting.
|
|
* @param array $notice Data of the notice.
|
|
* @param null|string $id The ID of the notice. If set, overrides 'id' index in notice data.
|
|
* @return \WPRSS_Admin_Notices This instance.
|
|
* @throws Exception If ID is missing.
|
|
*/
|
|
public function set_notice( $notice, $id = null ) {
|
|
$notice = apply_filters( $this->prefix( 'admin_notice_set_before' ), $notice, $id, $this );
|
|
$id = isset( $notice['id'] ) ? $notice['id'] : $id;
|
|
if ( is_null( $id ) )
|
|
throw new Exception( 'Could not set admin notice: ID must be specified in either notice data, or as separate argument' );
|
|
|
|
$this->_notices[ $id ] = $notice;
|
|
do_action( $this->prefix( 'admin_notice_set_after' ), $notice, $id, $this );
|
|
return $this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Normalize data of a notice, adding defaults.
|
|
*
|
|
* Auto-generating 'id', 'nonce', 'btn_close_id', 'nonce_element_id', 'btn_close_id'.
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter admin_notice_defaults Default values, before addin auto-generated values.
|
|
* @uses-filter admin_notice_defaults_autogenerated Default values, after adding auto-generated values.
|
|
* @param array $data The notice data to normalize
|
|
* @return array $data The normalized data of a notice
|
|
*/
|
|
public function normalize_notice_data( $data ) {
|
|
$data = wp_parse_args( $data, apply_filters( $this->prefix( 'admin_notice_defaults' ), array(
|
|
'id' => null, // ID of the notice. Unique for the notice in this collection.
|
|
'nonce' => null, // Nonce for the notice. Prevents unauthorised manipulation.
|
|
'condition' => array(), // These callbacks will decide whether or not the nonce is to be displayed
|
|
'condition_type' => self::CONDITION_TYPE_ALL, // Which of the conditions have to be satisfied
|
|
'conditon_on_error' => self::CONDITION_ON_ERROR_THROW_EXCEPTION,
|
|
'is_active' => true, // Whether this notice should be assumed to be active, unless set otherwise
|
|
'nonce_element_class' => $this->prefix( 'admin-notice-nonce' ), // HTML class for the element that contains the nonce
|
|
'nonce_element_id' => null,
|
|
'class' => '', // HTML class for the element of the notice
|
|
'notice_type' => 'updated', // Type of the notice.
|
|
'notice_element_class' => $this->prefix( 'admin-notice' ),
|
|
'content' => '', // The content of this notice
|
|
'btn_close_id' => null, // The HTML ID for the close button
|
|
'btn_close_class' => 'btn-close', // The HTML class for the close button, in addition to default
|
|
'btn_close_content' => __( 'Dismiss this notification', $this->get_text_domain() ), // The content of the close button. HTML allowed.
|
|
'dismiss_mode' => NoticeInterface::DISMISS_MODE_AJAX
|
|
)));
|
|
|
|
// Auto-generate ID
|
|
if ( is_null( $data['id'] ) )
|
|
$data['id'] = $this->generate_unique_id( 'admin-notice-', $data );
|
|
|
|
// Prefix ID
|
|
$data['id'] = $this->prefix( $data['id'] );
|
|
|
|
// Auto-generate nonce
|
|
if ( is_null( $data['nonce'] ) && !is_null( $data['id'] ) ) {
|
|
$me = $this;
|
|
$data['nonce'] = wprss()->getAdminHelper()->createCommand(function() use ($me, $data) {
|
|
$nonce = $me->generate_nonce_for_notice( $data['id'] );
|
|
return $nonce;
|
|
});
|
|
}
|
|
|
|
// Auto-generate nonce element ID
|
|
if ( is_null( $data['nonce_element_id'] ) && !is_null( $data['id'] ) )
|
|
$data['nonce_element_id'] = sprintf( '%1$s-nonce', $data['id'] );
|
|
|
|
// Auto-generate close button ID
|
|
if ( is_null( $data['btn_close_id'] ) && !is_null( $data['id'] ) )
|
|
$data['btn_close_id'] = sprintf( 'close-%1$s', $data['id'] );
|
|
|
|
return apply_filters( $this->prefix( 'admin_notice_defaults_autogenerated' ), $data );
|
|
}
|
|
|
|
|
|
/**
|
|
* Removes a notice from this collection.
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter admin_notice_remove_before To modify the notice ID that will be removed. Returning falsy value prevents removal.
|
|
* @uses-action admin_notice_remove_after To expose notice ID after removal.
|
|
* @param array|int $notice A notice, or notice ID.
|
|
* @return \WPRSS_Admin_Notices This instance.
|
|
*/
|
|
public function remove_notice( $notice ) {
|
|
if ( is_array( $notice ) )
|
|
$notice = isset( $notice['id'] ) ? $notice['id'] : null;
|
|
|
|
if ( is_null( $notice ) )
|
|
return $this;
|
|
|
|
if ( !$this->has_notice( $notice ) )
|
|
return $this;
|
|
|
|
$notice = apply_filters( $this->prefix( 'admin_notice_remove_before' ), $notice, $this );
|
|
if( !$notice ) return $this;
|
|
|
|
$this->_remove_notice ( $notice, $this->_notices);
|
|
do_action( $this->prefix( 'admin_notice_remove_after' ), $notice, $this );
|
|
|
|
return $this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Removes a notice by ID from the supplied array.
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter admin_notice_internal_remove_before To modify notice before removal. Returning falsy value prevents removal.
|
|
* @uses-action admin_notice_internal_remove_after To expose data of notice after removal.
|
|
* @param array|string $notice A notice, or notice ID
|
|
* @param array $array The array, from which to remove the notice.
|
|
* @return \WPRSS_Admin_Notices This instance.
|
|
* @throws Exception If no ID specified.
|
|
*/
|
|
protected function _remove_notice( $notice, &$array = null ) {
|
|
if ( is_array( $notice ) )
|
|
$notice = isset( $notice['id'] ) ? $notice['id'] : null;
|
|
|
|
if ( is_null( $notice ) )
|
|
throw new Exception( 'Could not remove notice: an ID must be specified' );
|
|
|
|
if ( is_null( $array ) )
|
|
$array = &$this->_notices;
|
|
|
|
if ( !array_key_exists( $notice, $array ) )
|
|
return $this;
|
|
|
|
$notice = apply_filters( $this->prefix( 'admin_notice_internal_remove_before' ), $notice, $array, $this );
|
|
if ( !$notice ) return $this;
|
|
|
|
unset( $array[ $notice ] );
|
|
do_action( $this->prefix( 'admin_notice_internal_remove_after' ), $notice, $array, $this );
|
|
|
|
return $this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Checks whether a notice already exists.
|
|
*
|
|
* @since 4.7.4
|
|
* @param array|int $notice A notice, or notice ID to check for.
|
|
* @return boolean True if notice already exists; false otherwise.
|
|
*/
|
|
public function has_notice( $notice ) {
|
|
if ( is_array( $notice ) )
|
|
$notice = isset( $notice['id'] ) ? $notice['id'] : null;
|
|
|
|
return array_key_exists( $notice , $this->_notices );
|
|
}
|
|
|
|
|
|
/**
|
|
* Get all notices, or a notice with the specified ID.
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter admin_notice_get_all To modify all notices returned.
|
|
* @uses-filter admin_notice_get To modify single returned notice.
|
|
* @param null|string $id The ID of a notice to retrieve.
|
|
* @param null $default What to return if notice not found.
|
|
* @return array Retrieve all or one notice. See {@link normalize_notice_data()} for data keys.
|
|
*/
|
|
public function get_notices( $id = null, $default = null ) {
|
|
if ( is_null( $id ) )
|
|
return apply_filters( $this->prefix( 'admin_notice_get_all' ), $this->_notices, $this );
|
|
|
|
return apply_filters( $this->prefix( 'admin_notice_get' ),
|
|
isset( $this->_notices[ $id ] ) ? $this->_notices[ $id ] : $default,
|
|
$id,
|
|
$default,
|
|
$this );
|
|
}
|
|
|
|
|
|
/**
|
|
* Get all notices that are active.
|
|
*
|
|
* @since 4.7.4
|
|
* @see is_notice_active()
|
|
* @return array Notices that are currently active;
|
|
*/
|
|
public function get_active_notices( $is_default_active = null ) {
|
|
if ( is_null( $is_default_active ) )
|
|
$is_default_active = true;
|
|
|
|
$active_notices = array();
|
|
foreach ( $this->get_notices() as $_id => $_notice ) {
|
|
if ( $this->is_notice_active( $_notice, $is_default_active ) )
|
|
$active_notices[ $_id ] = $_notice;
|
|
}
|
|
|
|
return $active_notices;
|
|
}
|
|
|
|
|
|
/**
|
|
* Determine whether the specified notice is active.
|
|
*
|
|
* If data array is passed, it's 'is_active' key will be used as default.
|
|
* Otherwise, data will be retrieved by ID and compared to database.
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter admin_notice_is_active To modify return value. Used in several places.
|
|
* @param array|string $notice Notice or notice ID.
|
|
* @param boolean $default What to return if no notice state data exists.
|
|
* @return boolean Whether or not the specified notice is active.
|
|
* @throws Exception If ID not specified.
|
|
*/
|
|
public function is_notice_active( $notice, $default = null ) {
|
|
// State if no state provided
|
|
if ( is_null( $default ) )
|
|
$default = true;
|
|
|
|
// If ID passed, retrieve the notice
|
|
if ( !is_array( $notice ) )
|
|
$notice = $this->get_notices( $notice, array() );
|
|
// Last resort defaults
|
|
$id = isset( $notice['id'] ) ? $notice['id'] : null;
|
|
$is_active_default = isset( $notice['is_active'] ) ? (bool)$notice['is_active'] : $default;
|
|
|
|
if ( is_null( $id ) )
|
|
throw new Exception( 'Could not determine notice state: ID must be specified' );
|
|
|
|
// Settings from DB
|
|
$settings = $this->get_notices_settings( $id );
|
|
|
|
// If no state, assume default
|
|
if ( !isset( $settings['is_active'] ) )
|
|
return apply_filters( $this->prefix( 'admin_notice_is_active' ), $is_active_default, $id, $this );
|
|
|
|
return apply_filters( $this->prefix( 'admin_notice_is_active' ), (bool)$settings['is_active'], $id, $this );
|
|
}
|
|
|
|
|
|
/**
|
|
* Set notice active state.
|
|
*
|
|
* @since 4.7.4
|
|
* @param array|string $notice Notice data or ID.
|
|
* @param null|boolean $is_active If true, notice state will be set to active; if false - to inactive. Default: true.
|
|
*/
|
|
public function set_notice_active( $notice, $is_active = null ) {
|
|
if ( is_null( $is_active ) )
|
|
$is_active = true;
|
|
|
|
$this->set_notices_settings( $notice, (bool)$is_active );
|
|
return $this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets all notices that pass their conditions according to the condition type.
|
|
*
|
|
* Allowed notices are also only active ones. Inactive notices are not evaluated.
|
|
*
|
|
* @since 4.7.4
|
|
* @see is_notice_allowed()
|
|
* @uses-filter admin_notice_all_allowed To modify return value.
|
|
* @return array Allowed notices.
|
|
*/
|
|
public function get_allowed_notices() {
|
|
$allowed_notices = array();
|
|
foreach ( $this->get_active_notices() as $_id => $_notice ) {
|
|
if ( $this->is_notice_allowed( $_notice) )
|
|
$allowed_notices[ $_id ] = $_notice;
|
|
}
|
|
|
|
return apply_filters( $this->prefix( 'admin_notice_all_allowed' ), $allowed_notices, $this );
|
|
}
|
|
|
|
|
|
/**
|
|
* Checks if the specified notice is allowed.
|
|
*
|
|
* To determine that, the notice's conditions are evaluated according
|
|
* to the condition type.
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter admin_notice_is_allowed To modify return value.
|
|
* @param array|string $notice Notice or notice ID.
|
|
* @return bool Whether or not the specified notice passed it's conditions to be allowed.
|
|
* @throws Exception If ID not specified.
|
|
*/
|
|
public function is_notice_allowed( $notice ) {
|
|
if ( !is_array( $notice ) )
|
|
$notice = $this->get_notices( $notice );
|
|
|
|
$conditions = isset( $notice['condition'] ) ? $notice['condition'] : array();
|
|
$condition_type = isset( $notice['condition_type'] ) ? $notice['condition_type'] : self::CONDITION_TYPE_ALL;
|
|
$is_allowed = $this->evaluate_conditions( $conditions, $condition_type, array( $notice ) );
|
|
return apply_filters( $this->prefix( 'admin_notice_is_allowed' ), $is_allowed, $notice );
|
|
}
|
|
|
|
|
|
/**
|
|
* Generates a nonce for a notice ID.
|
|
*
|
|
* @since 4.7.4
|
|
* @see wp_create_nonce()
|
|
* @see generate_nonce_code()
|
|
* @uses-filter admin_notice_nonce_for_notice
|
|
* @param array|string $notice Notice or notice ID.
|
|
* @return string The nonce.
|
|
* @throws Exception If ID not specified.
|
|
*/
|
|
public function generate_nonce_for_notice( $notice ) {
|
|
if ( is_array( $notice ) )
|
|
$notice = isset( $notice['id'] ) ? $notice['id'] : null;
|
|
|
|
if ( is_null( $notice ) )
|
|
throw new Exception( 'Could not get nonce for notice: notice ID must be specified' );
|
|
|
|
$nonce_code = $this->generate_nonce_code( $notice );
|
|
$nonce = wp_create_nonce( $nonce_code );
|
|
|
|
return apply_filters( $this->prefix( 'admin_notice_nonce_for_notice' ), $nonce, $notice, $nonce_code, $this );
|
|
}
|
|
|
|
|
|
/**
|
|
* Generates a code that is used to generate a nonce for a notice.
|
|
*
|
|
* @since 4.7.4
|
|
* @see wp_create_nonce()
|
|
* @see generate_nonce_for_notice()
|
|
* @uses-filter admin_notice_nonce_code To modify return value.
|
|
* @param array|string $notice Notice or notice ID;
|
|
* @return string Code (action) for the nonce.
|
|
* @throws Exception If nonce ID not specified.
|
|
*/
|
|
public function generate_nonce_code( $notice ) {
|
|
if ( is_array( $notice ) )
|
|
$notice = isset( $notice['id'] ) ? $notice['id'] : null;
|
|
|
|
if ( is_null( $notice ) )
|
|
throw new Exception( 'Could not generate nonce code for notice: notice ID must be specified' );
|
|
|
|
return apply_filters( $this->prefix( 'admin_notice_nonce_code' ), sprintf( '%1$s-nonce', $notice ), $notice, $this );
|
|
}
|
|
|
|
|
|
/**
|
|
* Evaluates a condition or group of conditions based on the condition type.
|
|
*
|
|
* A condition is a callable that returns true or false (no type checking is done here).
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter admin_notice_conditions_evaluated To modify the return value.
|
|
* @uses-filter admin_notice_condition_result To alter the result of each condition's evaluated.
|
|
* @param array|callable $conditions A callable or an array of callables.
|
|
* @param string $condition_type One of the CONDITION_TYPE_* class constants. Default: CONDITION_TYPE_ALL.
|
|
* @param array $args These args will be passed to the condition callable.
|
|
* @return boolean Whether or not the conditions evaluate according to the condition type.
|
|
* @throws Exception If a condition cannot be called.
|
|
*/
|
|
public function evaluate_conditions( $conditions, $condition_type = self::CONDITION_TYPE_ALL, $args = array() ) {
|
|
$event_name = $this->prefix( 'admin_notice_conditions_evaluated' );
|
|
$result = true; // By default, evaluation passes
|
|
if ( empty( $conditions ) ) return apply_filters ( $event_name, $result, $condition_type, $this ); // Unconditional ;)
|
|
if ( !is_array( $conditions ) ) $conditions = array($conditions); // Normalizing
|
|
|
|
foreach ( $conditions as $_idx => $_condition ) {
|
|
$func = is_array( $_condition ) && isset( $_condition['func'] )
|
|
? $_condition['func']
|
|
: $_condition;
|
|
$args = array_merge( // Appending our args to the passed args
|
|
array_values( isset( $_condition['args'] ) ? (array)$_condition['args'] : array() ),
|
|
array_values( $args ));
|
|
|
|
if ( !is_callable( $func ) )
|
|
throw new Exception ( sprintf( 'Could not evaluate condition %1$d: condition must contain a callable', $_idx ) );
|
|
|
|
$_value = call_user_func_array( $func, $args );
|
|
$_value = apply_filters( $this->prefix( 'admin_notice_condition_result' ), $_value, $_idx, $condition_type, $_condition, $args, $this );
|
|
switch ( $condition_type ) {
|
|
case self::CONDITION_TYPE_ANY: // At least one must be true
|
|
if ( (bool)$_value ) return apply_filters ( $event_name, true, $condition_type, $this );
|
|
$result = false;
|
|
break;
|
|
|
|
case self::CONDITION_TYPE_ALMOST: // At least one must be false
|
|
if ( !(bool)$_value ) return apply_filters ( $event_name, true, $condition_type, $this );
|
|
$result = false;
|
|
break;
|
|
|
|
case self::CONDITION_TYPE_NONE: // All must be false
|
|
if ( (bool)$_value ) return apply_filters ( $event_name, false, $condition_type, $this );
|
|
$result = true;
|
|
break;
|
|
|
|
default:
|
|
case self::CONDITION_TYPE_ALL: // All must be true
|
|
if ( !(bool)$_value ) return apply_filters ( $event_name, false, $condition_type, $this );
|
|
$result = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return apply_filters ( $event_name, $result, $condition_type, $this );
|
|
}
|
|
|
|
|
|
/**
|
|
* Get settings for all notices, or just one.
|
|
*
|
|
* It appears that options are already being cached by WP.
|
|
* Also, some notices in the returned array may not be registered for display,
|
|
* in which case they will not be displayed. And vice-versa: some of the registered
|
|
* notices will not have any settings associated with them, in which case
|
|
* defaults are assumed. See {@link is_notice_active()} for information.
|
|
* The settings contain states, not notice information.
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter admin_notice_get_notices_settings_all To modify settings of all notices.
|
|
* @uses-filter admin_notice_get_notices_settings To modify settings of just one notice. May have been modified by admin_notice_get_notices_settings_all.
|
|
* @param null|string $id Notice ID
|
|
* @param null|mixed $default What to return if no settings for notice. Default: empty array.
|
|
* @return array An array, where key is notice ID, and value is boolean indicating whether or not it is active.
|
|
*/
|
|
public function get_notices_settings( $id = null, $default = null ) {
|
|
if( is_null( $default ) )
|
|
$default = array();
|
|
|
|
$settings = apply_filters( $this->prefix( 'admin_notice_get_notices_settings_all' ),
|
|
get_option( $this->get_setting_name(), array() ),
|
|
$this );
|
|
|
|
if ( is_null( $id ) )
|
|
return $settings;
|
|
|
|
// Normalize
|
|
$settings = isset( $settings[ $id ] ) ? $settings[ $id ] : $default;
|
|
$settings = $this->normalize_notice_data_from_db( $settings );
|
|
|
|
return apply_filters( $this->prefix( 'admin_notice_get_notices_settings' ),
|
|
$settings,
|
|
$id,
|
|
$default,
|
|
$this );
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter admin_notice_set_settings_before To modify what gets saved. Also see {@link prepare_notice_data_for_db()}.
|
|
* @uses-action admin_notice_set_settings_after To expose data that has been saved.
|
|
* @param string|array $notice The notice data, or notice ID, to save.
|
|
* @param null|array|boolean $settings The settings, or just the active state, to save.
|
|
* @return \WPRSS_Admin_Notices This instance.
|
|
* @throws Exception If an ID is nowhere to be found. How to save? :S
|
|
*/
|
|
public function set_notices_settings( $notice, $settings = null ) {
|
|
// Normalizing notice data
|
|
if ( !is_array( $notice ) )
|
|
$notice = array( 'id' => $notice );
|
|
// If using just the notice data to save everything
|
|
if ( is_null( $settings ) )
|
|
$settings = $notice;
|
|
// If saving just the active state
|
|
if ( is_bool( $settings ) )
|
|
$settings = array( 'is_active' => $settings );
|
|
|
|
// Making sure notice ID isn't overwritten
|
|
if( isset( $settings['id'] ) )
|
|
unset( $settings['id'] );
|
|
|
|
// Merging the data together to get all data to save
|
|
$settings = wp_parse_args( $settings, $notice );
|
|
|
|
// Making sure that an ID ultimately exists
|
|
if ( !isset( $settings['id'] ) )
|
|
throw new Exception( 'Could not set notice settings: ID must be specified' );
|
|
|
|
$id = $settings['id'];
|
|
$db_settings = $this->get_notices_settings( $id );
|
|
|
|
// Merge again to only update what is in the database
|
|
$settings = wp_parse_args( $settings, $db_settings );
|
|
|
|
// Get all settings data
|
|
$all_settings = $this->get_notices_settings();
|
|
// Set and finally save
|
|
$settings = apply_filters( $this->prefix( 'admin_notice_set_settings_before' ), $settings, $id, $this );
|
|
$settings = $this->prepare_notice_data_for_db( $settings );
|
|
$all_settings[ $id ] = $settings;
|
|
$this->set_notices_settings_all( $all_settings );
|
|
do_action( $this->prefix( 'admin_notice_set_settings_after' ), $settings, $id, $this );
|
|
|
|
return $this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Saves the data of all specified notices to the database.
|
|
*
|
|
* The passed data will replace all data currently stored in the option.
|
|
*
|
|
* @since 4.7.4
|
|
* @see get_setting_name()
|
|
* @uses-filter admin_notice_set_settings_all_before To modify what gets saved.
|
|
* @uses-action admin_notice_set_settings_all_after To expose saved data.
|
|
* @param array $settings An array containing data of all notices.
|
|
* @return \WPRSS_Admin_Notices This instance.
|
|
*/
|
|
public function set_notices_settings_all( $settings ) {
|
|
$settings = apply_filters( $this->prefix( 'admin_notice_set_settings_all_before' ), $settings, $this );
|
|
update_option( $this->get_setting_name(), $settings );
|
|
do_action( $this->prefix( 'admin_notice_set_settings_all_after' ), $settings, $this );
|
|
|
|
return $this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Normalize a single notice's data that was returned from the database.
|
|
*
|
|
* @since4.8.2
|
|
* @uses-filter admin_notice_normalize_notice_data_from_db To modify the return value.
|
|
* @param null|mixed|array $data The individual notice's data to normalize.
|
|
* @return array The notice data returned from the database.
|
|
*/
|
|
public function normalize_notice_data_from_db( $data ) {
|
|
if ( is_null( $data ) )
|
|
$data = array();
|
|
|
|
if ( !is_array( $data ) )
|
|
$data = array( 'is_active' => (bool)$data );
|
|
|
|
return apply_filters( $this->prefix( 'admin_notice_normalize_notice_data_from_db' ), $data, $this );
|
|
}
|
|
|
|
|
|
/**
|
|
* Prepares data of a single notice to be saved to the database.
|
|
*
|
|
* Is responsible for preserving only allowed fields, and adding some
|
|
* required ones, if necessary and possible.
|
|
*
|
|
* @since4.8.2
|
|
* @uses-filter admin_notice_prepare_notice_data_for_db To modify the resulting prepared data.
|
|
* @param array $data The data to prepare.
|
|
* @return array The data that should be saved to the database.
|
|
*/
|
|
public function prepare_notice_data_for_db( $data ) {
|
|
$prepared_data = array();
|
|
if ( isset( $data['is_active'] ) )
|
|
$prepared_data['is_active'] = (bool)$data['is_active'];
|
|
|
|
return apply_filters( $this->prefix( 'admin_notice_prepare_notice_data_for_db' ), $prepared_data, $data, $this );
|
|
}
|
|
|
|
|
|
/**
|
|
* Generates a unique ID.
|
|
*
|
|
* This ID will be unique to this collection.
|
|
*
|
|
* @since 4.7.4
|
|
* @see uniqid()
|
|
* @uses-filter admin_notice_generate_unique_id To allow modification of ID.
|
|
* @param string $prefix The prefix to give to the generated ID.
|
|
* @return string A notice ID unique to this instance in the scope of this collection.
|
|
*/
|
|
public function generate_unique_id( $prefix = '', $data = null ) {
|
|
do {
|
|
$id = is_null($data) ? uniqid( $prefix ) : $prefix . $this->hash($data);
|
|
} while ( $this->has_notice( $id ) );
|
|
|
|
return apply_filters( $this->prefix( 'admin_notice_generate_unique_id' ), $id, $prefix, $this );
|
|
}
|
|
|
|
public function hash($data) {
|
|
return md5(serialize($data));
|
|
}
|
|
|
|
|
|
/**
|
|
* Generate the HTML for all allowed notices, sequentially.
|
|
*
|
|
* @since 4.7.4
|
|
* @return string The rendered HTML.
|
|
*/
|
|
public function render_allowed_notices() {
|
|
$output = '';
|
|
foreach ( $this->get_allowed_notices() as $_id => $_notice ) {
|
|
$output .= $this->render_notice( $_notice );
|
|
}
|
|
|
|
return $output;
|
|
}
|
|
|
|
|
|
/**
|
|
* Directly output the rendered HTML of all allowed notices.
|
|
*
|
|
* @since 4.7.4
|
|
* @return \WPRSS_Admin_Notices This instance.
|
|
*/
|
|
public function output_allowed_notices() {
|
|
echo $this->render_allowed_notices();
|
|
return $this;
|
|
}
|
|
|
|
|
|
/**
|
|
* Generate the HTML of a notice.
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter admin_notice_render_before To allow modification of notice data before rendering.
|
|
* @uses-action admin_notice_render_after To allow injection inside the notice HTML.
|
|
* @uses-filter admin_notice_rendered To allow modification of rendered HTML.
|
|
* @param array|string $id Notice, or notice ID.
|
|
* @return string The HTML output of the notice.
|
|
* @throws Exception If no notice found for ID.
|
|
*/
|
|
public function render_notice( $id ) {
|
|
$notice = is_array( $id )
|
|
? $id
|
|
: $this->get_notices( $id );
|
|
|
|
if ( !$notice )
|
|
throw new Exception( sprintf( 'Could not render notice: no notice found for ID "%1$s"', $id ) );
|
|
|
|
$helper = wprss()->getAdminHelper();
|
|
|
|
ob_start();
|
|
$notice = apply_filters( $this->prefix( 'admin_notice_render_before' ), $notice, $this );
|
|
?>
|
|
|
|
<div id="<?php echo $notice['id'] ?>" class="<?php echo $notice['notice_type'] ?> <?php echo $notice['notice_element_class'] ?> <?php echo $this->get_notice_base_class() ?> dismiss-mode-<?php echo $notice['dismiss_mode'] ?>">
|
|
<div class="notice-content">
|
|
<?php echo $notice['content'] ?>
|
|
</div>
|
|
<?php if ($notice['dismiss_mode'] !== NoticeInterface::DISMISS_MODE_NONE): ?>
|
|
<a href="javascript:;" id="<?php echo $notice['btn_close_id'] ?>" style="float:right;" class="<?php echo $this->get_btn_close_base_class() ?> <?php echo $notice['btn_close_class'] ?>"><?php echo $notice['btn_close_content'] ?></a>
|
|
<?php endif ?>
|
|
<span id="<?php echo $notice['nonce_element_id'] ?>" class="hidden <?php echo $notice['nonce_element_class'] ?> <?php echo $this->get_nonce_base_class() ?>"><?php echo $helper->resolveValue($notice['nonce']) ?></span>
|
|
</div>
|
|
<?php
|
|
do_action( $this->prefix( 'admin_notice_render_after' ), $notice, $this );
|
|
$output = ob_get_clean();
|
|
|
|
return apply_filters( $this->prefix( 'admin_notice_rendered' ), $output, $notice, $this );
|
|
}
|
|
|
|
|
|
/**
|
|
* Used to hide a notice, typically responding to a frontend event.
|
|
*
|
|
* @since 4.7.4
|
|
* @param array|string $notice Notice or notice ID.
|
|
* @param string $nonce The nonce from the frontend.
|
|
* @return \WPRSS_Admin_Notices This instance.
|
|
* @throws Exception If no notice ID specified, or no notice found for it,
|
|
* or specified nonce does not belong to the notice, or the nonce is not right.
|
|
*/
|
|
public function hide_notice( $notice, $nonce ) {
|
|
if ( is_array( $notice ) )
|
|
$notice = isset( $notice['id'] ) ? $notice['id'] : null;
|
|
|
|
$notice_id = $notice;
|
|
if ( is_null( $notice ) )
|
|
throw new Exception( sprintf( 'Could not hide notice: Notice ID must be specified' ) );
|
|
if ( is_null( $nonce ) )
|
|
throw new Exception( sprintf( 'Could not hide notice: nonce must be specified' ) );
|
|
if ( !($notice = $this->get_notices( $notice ) ) )
|
|
throw new Exception( sprintf( 'Could not hide notice: No notice found for ID "%1$s"', $notice_id ) );
|
|
|
|
// Is it the right nonce?
|
|
$noticeNonce = wprss()->getAdminHelper()->resolveValue($notice['nonce']);
|
|
if ( $noticeNonce !== $nonce )
|
|
throw new Exception( sprintf( 'Could not hide notice: Nonce "%1$s" does not belong to notice "%2$s"', $nonce, $notice_id ) );
|
|
|
|
// Verify nonce
|
|
if( !wp_verify_nonce( $nonce, $this->generate_nonce_code( $notice ) ) )
|
|
throw new Exception( sprintf( 'Could not hide notice: Nonce "%1$s" is incorrect', $nonce ) );
|
|
|
|
wprss_admin_notice_get_collection()->set_notice_active( $notice, false );
|
|
|
|
return $this;
|
|
}
|
|
}
|
|
|
|
|
|
// This should initialize the notice collection before anything can use it
|
|
add_action( 'init', 'wprss_admin_notice_get_collection', 9 );
|
|
|
|
// Trigger the component to initialize
|
|
add_action('wprss_pre_init', function() {
|
|
wprss_wp_container()->get(\WPRSS_SERVICE_ID_PREFIX.'admin_ajax_notices');
|
|
});
|
|
|
|
|
|
/**
|
|
* Returns the singleton, plugin-wide instane of the admin notices controller.
|
|
* Initializes it if necessary.
|
|
*
|
|
* @since 4.7.4
|
|
* @staticvar WPRSS_Admin_Notices $collection The singleton instance.
|
|
* @return \WPRSS_Admin_Notices|null The singleton instance of notice collection, or null if it is unavailable.
|
|
*/
|
|
function wprss_admin_notice_get_collection() {
|
|
static $collection = null;
|
|
|
|
if ( is_null( $collection ) && is_admin() ) {
|
|
$collection = wprss_wp_container()->get(\WPRSS_SERVICE_ID_PREFIX.'admin_ajax_notice_controller');
|
|
add_action( \WPRSS_EVENT_PREFIX.'admin_exclusive_scripts_styles', 'wprss_admin_notices_collection_enqueue_scripts' );
|
|
}
|
|
|
|
return $collection;
|
|
}
|
|
|
|
/**
|
|
* Enqueues the scripts for a notice collection.
|
|
*
|
|
* @since 4.7.8
|
|
*/
|
|
function wprss_admin_notices_collection_enqueue_scripts() {
|
|
$notices = wprss()->getAdminAjaxNotices();
|
|
$notices->_registerAssets();
|
|
$notices->enqueueAssets();
|
|
}
|
|
|
|
/**
|
|
* Centralizes access to the name of the AJAX action handler for dismissing admin notices.
|
|
*
|
|
* This is necessary for configuration of the frontend.
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter wprss_admin_notice_action_code To modify return value.
|
|
* @return string The action code
|
|
*/
|
|
function wprss_admin_notice_get_action_code() {
|
|
return apply_filters( 'wprss_admin_notice_action_code', 'wprss_admin_notice_hide' );
|
|
}
|
|
|
|
|
|
/**
|
|
* Adds a notice to be displayed on top of an admin page.
|
|
*
|
|
* @since 4.7.4
|
|
* @param array $notice Data of the notice
|
|
* @return bool|WP_Error True if notice added, false if collection unavailable, or WP_Error if something went wrong.
|
|
*/
|
|
function wprss_admin_notice_add( $notice ) {
|
|
try {
|
|
if ( !($collection = wprss_admin_notice_get_collection()) )
|
|
return false;
|
|
|
|
$collection->add_notice( $notice );
|
|
} catch ( Exception $e ) {
|
|
return new WP_Error( 'could_not_add_admin_notice', $e->getMessage() );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
add_action( sprintf( 'wp_ajax_%1$s', wprss_admin_notice_get_action_code() ), 'wprss_admin_notice_hide' );
|
|
/**
|
|
* This is what handles the AJAX action of dismissing admin notices.
|
|
*
|
|
* @see WPRSS_Admin_Notices::hide_notice()
|
|
* @since 4.7.4
|
|
*/
|
|
function wprss_admin_notice_hide() {
|
|
$notice_id = isset( $_REQUEST['notice_id'] ) ? $_REQUEST['notice_id'] : null;
|
|
$nonce = isset( $_REQUEST['nonce'] ) ? $_REQUEST['nonce'] : null;
|
|
|
|
try {
|
|
wprss_admin_notice_get_collection()->hide_notice( $notice_id, $nonce );
|
|
} catch (Exception $e) {
|
|
// Failure
|
|
echo $e->getMessage();
|
|
exit();
|
|
}
|
|
|
|
// Success
|
|
exit( '1' );
|
|
}
|
|
|
|
|
|
/**
|
|
* Check whether the current page is related to WP RSS Aggregator.
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter wprss_is_wprss_page To modify return value.
|
|
* @global string $typenow Post type of the current page.
|
|
* @return boolean True if the current page is a WPRSS-related page; false otherwise.
|
|
*/
|
|
function wprss_is_wprss_page() {
|
|
global $typenow;
|
|
|
|
$postType = $typenow;
|
|
if ( empty( $postType ) && isset( $_GET['post'] ) && !empty( $_GET['post'] ) ) {
|
|
$post = get_post(filter_var($_GET['post'], FILTER_SANITIZE_NUMBER_INT));
|
|
if ( $post !== NULL && !is_wp_error( $post ) )
|
|
$postType = $post->post_type;
|
|
}
|
|
|
|
$filterFlags = FILTER_FLAG_STRIP_BACKTICK | FILTER_FLAG_STRIP_LOW | FILTER_FLAG_STRIP_HIGH;
|
|
if (empty($postType) && isset($_GET['post_type'])) {
|
|
$postType = filter_var(trim($_GET['post_type']), FILTER_SANITIZE_STRING, $filterFlags);
|
|
}
|
|
|
|
$pagenow = isset($_GET['page']) ? filter_var($_GET['page'], FILTER_SANITIZE_STRING, $filterFlags) : null;
|
|
$wprss_post_types = apply_filters('wprss_post_types', array(
|
|
'wprss_feed',
|
|
'wprss_feed_item',
|
|
'wprss_blacklist',
|
|
));
|
|
$wprss_pages = apply_filters('wprss_page_slugs', array(
|
|
'wprss-aggregator',
|
|
'wprss-aggregator-settings',
|
|
'wprss-import-export-settings',
|
|
'wprss-debugging',
|
|
'wprss-addons',
|
|
'wprss-welcome',
|
|
'wprss-help',
|
|
'wpra-intro',
|
|
'wpra-update',
|
|
));
|
|
|
|
$is_wprss_post = in_array($postType, $wprss_post_types, true);
|
|
$is_wprss_page = in_array($pagenow, $wprss_pages, true);
|
|
return apply_filters( 'wprss_is_wprss_page', $is_wprss_post || $is_wprss_page );
|
|
}
|
|
|
|
|
|
/**
|
|
* Check whether the currently logged in user can manage WP options.
|
|
*
|
|
* This normally describes the administrator.
|
|
*
|
|
* @since 4.7.4
|
|
* @uses-filter wprss_user_can_manage_options To modify return value.
|
|
* @return bool True if the currently logged in user has the 'manage_options' privilege; false otherwise.
|
|
*/
|
|
function wprss_user_can_manage_options() {
|
|
return apply_filters( 'wprss_user_can_manage_options', current_user_can( 'manage_options' ) );
|
|
}
|
|
|
|
// Adds the AJAX notice service provider to the core container
|
|
add_filter(WPRSS_EVENT_PREFIX .'core_container_init', function(WritableContainerInterface $container) {
|
|
$noticeProvider = wprss_core_admin_ajax_notices_service_provider();
|
|
$container->register($noticeProvider);
|
|
});
|
|
|
|
/**
|
|
* Retrieves the service provider that provides notice service definitions.
|
|
*
|
|
* @since 4.11
|
|
*
|
|
* @staticvar ServiceProvider $provider
|
|
* @return ServiceProvider
|
|
*/
|
|
function wprss_core_admin_ajax_notices_service_provider()
|
|
{
|
|
static $provider = null;
|
|
|
|
if(is_null($provider)) {
|
|
$provider = new ServiceProvider(array(
|
|
'notice_service_id_prefix' => \WPRSS_NOTICE_SERVICE_ID_PREFIX,
|
|
'service_id_prefix' => \WPRSS_SERVICE_ID_PREFIX,
|
|
'event_prefix' => \WPRSS_EVENT_PREFIX,
|
|
));
|
|
}
|
|
|
|
return $provider;
|
|
}
|