web-dev-qa-db-fra.com

Cron jobs in class

Ayant:

pluginname.php

// If this file is called directly, abort.
if ( ! defined( 'ABSPATH' ) ) {
    die();
}

define('PLUGINNAME_PLUGIN_URL', plugin_dir_url( __FILE__ ));
define('PLUGINNAME_PLUGIN_DIR', plugin_dir_path(__FILE__));

require_once( plugin_dir_path( __FILE__ ) . 'class-pluginname.php' );

// Register hooks that are fired when the plugin is activated, deactivated, and uninstalled, respectively.
register_activation_hook( __FILE__, array( 'PluginName', 'activate' ) );
register_deactivation_hook( __FILE__, array( 'PluginName', 'deactivate' ) );

PluginName::get_instance();

class-pluginname.php

    /**
     * Initialize the plugin
     *
     * @since     1.0.0
     */
    private function __construct()
    {
        #add_action('init', array($this, 'widget_add_vars'));

        #add_action('params', array($this, 'catch_widget_query'));
         add_action('dailyExport', array($this, '_generateJson'));

         if (!wp_next_scheduled('dailyExport')) {
             wp_schedule_event( time(), 'daily', 'dailyExport' );
         }
    }

    /**
     * Return an instance of this class.
     *
     * @since     1.0.0
     *
     * @return    object    A single instance of this class.
     */
    public static function get_instance()
    {
        // If the single instance hasn't been set, set it now.
        if ( null == self::$instance )
            self::$instance = new self;

        return self::$instance;
    }

    /**
     * Fired when the plugin is activated.
     *
     * @since    1.0.0
     */
    public static function activate()
    {
        self::_generateJson();
        wp_schedule_event(time(), 'daily', 'dailyExport');
    }

    /**
     * Fired when the plugin is deactivated.
     *
     * @since    1.0.0
     */
    public static function deactivate()
    {
        wp_clear_scheduled_hook('dailyExport');
    }

    public function dailyExport()
    {
        return self::_generateJson();
    }

Je me demandais, si vous pensez que c'est correct de définir comme static les fonctions activate et deactivate et si vous pensez que je travaille correctement avec l'événement cron, pour planifier des événements quotidiens.

J'ai écrit mon plugin, basé sur ce modèle https://github.com/tommcfarlin/WordPress-Plugin-Boilerplate

actionswp-croncustomization
4
w0rldart

Je travaillais avec wp_cron la semaine dernière dans un plugin et nous nous disputons et ne parlons plus, mais pour référence, c’est ce que je fais;

1) - Définir l’événement programmé sur register_activation_hook
2) - Supprimez l'événement cron planifié sur register_deactivation_hook

Si vous craignez que votre événement cron programmé ne soit effacé de la base de données, vous pouvez ajouter une routine, car vous devez déjà vérifier vos événements cron au prochain horodatage planifié.

if (!wp_next_scheduled('dailyExport')) { 
    //schedule event 
    wp_schedule_event( time(), 'daily', 'dailyExport' );
}

Mon exemple de classe;

register_activation_hook(__FILE__, array( 'Killa', 'activated' ) );
register_deactivation_hook( __FILE__, array( 'Killa', 'deactivated' ) );

add_action('plugins_loaded', array ( Killa::get_instance(), 'plugin_setup' ) );

class Killa
{
    protected static $instance = NULL;
    public static function get_instance()
    {
        if ( null === self::$instance )
        {
            self::$instance = new self;
            self::load_files();
        }
        return self::$instance; 
    }

    public function plugin_setup()
    {
        add_action('my_cron_event', array($this, 'my_callback_function'));     
    }

    public function __construct()
    {
        //empty
    } 

    public static function activated() 
    {
        wp_schedule_event( time(), 'hourly', 'my_cron_event');
    }

    public static function deactivated() 
    {
        wp_clear_scheduled_hook( 'my_cron_event' );
    }

    public function my_callback_function()
    {
       //do your thing here... such as generate JSON
    }
}

En bout de ligne, c’est parfaitement acceptable de définir vos crochets d’activation/désactivation de registre comme des fonctions statiques et, de manière plus appropriée, lorsque vous travaillez dans un modèle de type singleton ou lorsque vos fonctions activated()/deactivated() peuvent exister dans un autre appel de classe de votre contrôleur.

Il est également acceptable d'avoir vos crochets d'enregistrement au sein du constructeur, en fonction de la structure de votre classe.

7
userabuser