wpdk-wordpress-plugin.php

Go to the documentation of this file.

<?php
class WPDKWordPressPlugin extends WPDKPlugin {

  public $assetsURL;

  public $classesPath;

  public $cssURL;

  public $databasePath;

  public $folderName;

  public $imagesURL;

  public $javascriptURL;

  public $log;

  public $path;

  public $pluginBasename;

  public $protocol;

  public $slug;

  public $url;

  public $urlAjax;

  private $_wpxPluginClassLoadingPath;

  // -------------------------------------------------------------------------------------------------------------------
  // DEPRECATED
  // -------------------------------------------------------------------------------------------------------------------

  public $url_images;

  public $url_javascript;


  public function __construct( $file ) {

    parent::__construct( $file );

    /*
     * Load SPL autoload logic for this instance
     * NOTE: any WPX plugin has its own SPL autoload logic
     *
     */

    $this->_wpxPluginsClassesLoadingPath = array();
    spl_autoload_extensions( '.php' ); // for faster execution
    spl_autoload_register( array( $this, 'autoloadEnvironment' ) );

    // Path unix
    $this->path         = trailingslashit( plugin_dir_path( $file ) );
    $this->classesPath  = $this->path . 'classes/';
    $this->databasePath = $this->path . 'database/';

    // URL
    $this->url           = trailingslashit( plugin_dir_url( $file ) );
    $this->assetsURL     = $this->url . 'assets/';
    $this->cssURL        = $this->assetsURL . 'css/';
    $this->imagesURL     = $this->cssURL . 'images/';
    $this->javascriptURL = $this->assetsURL . 'js/';

    // Only folder name
    $this->folderName = trailingslashit( basename( dirname( $file ) ) );

    // WordPress slug plugin, Eg. wpx-smartshop/main.php
    $this->pluginBasename = plugin_basename( $file );

    // Built-in slug
    $this->slug = sanitize_title( $this->name );

    // Useful property
    $this->protocol = self::protocol();
    $this->urlAjax  = self::urlAjax();

    // Logs
    $this->log = new WPDKWatchDog( $this->path );

    // Load specific plugin environment ONLY when I'm sure plugin father is loaded
    add_action( 'init', array( $this, '_init' ) );

    // Admin init
    add_action( 'admin_init', array( $this, 'admin_init' ) );

    // Activation & Deactivation Hook
    register_activation_hook( $file, array( $this, 'activation' ) );
    register_deactivation_hook( $file, array( $this, 'deactivation' ) );

    /*
     * There are many pitfalls to using the uninstall hook. It ’ s a much cleaner, and easier, process to use the
     * uninstall.php method for removing plugin settings and options when a plugin is deleted in WordPress.
     *
     * Using uninstall.php file. This is typically the preferred method because it keeps all your uninstall code in a
     * separate file. To use this method, create an uninstall.php file and place it in the root directory of your
     * plugin. If this file exists WordPress executes its contents when the plugin is deleted from the WordPress
     * Plugins screen page.
     *
     */

    // register_uninstall_hook( $file, array( $this, 'uninstall' ) );

    // Widgets init
    add_action( 'widgets_init', array( $this, 'widgets' ) );
  }

  public static function protocol()
  {
    return ( isset( $_SERVER['HTTPS'] ) && 'on' == $_SERVER['HTTPS'] ) ? 'https://' : 'http://';
  }

  public static function urlAjax()
  {
    return admin_url( 'admin-ajax.php', self::protocol() );
  }

  public static function currentURL()
  {
    $protocol = self::protocol();
    $port     = ( '80' != $_SERVER['SERVER_PORT'] ) ? ':' . $_SERVER['SERVER_PORT'] : '';

    // Get host by HTTP_X_FORWARDED_HOST. This is available from PHP 5.1+ and in a proxy server
    if ( isset( $_SERVER['HTTP_X_FORWARDED_HOST'] ) ) {
      $host = $_SERVER['HTTP_X_FORWARDED_HOST'];
      if ( !empty( $host ) ) {
        $elements = explode( ',', $host );
        $host     = trim( end( $elements ) );
      }
    }
    else {
      $host = $_SERVER['HTTP_HOST'];
      if ( empty( $host ) ) {
        $host = $_SERVER['SERVER_NAME'];
        if ( empty( $host ) ) {
          $host = !empty( $_SERVER['SERVER_ADDR'] ) ? $_SERVER['SERVER_ADDR'] : '';
        }
      }
    }

    return sprintf( '%s%s%s%s', $protocol, $host, $port, $_SERVER['REQUEST_URI'] );
  }

  public function registerAutoloadClass( $sLoadingPath, $mClassName = '' )
  {

    // 1.
    if ( is_string( $sLoadingPath ) && is_string( $mClassName ) && !empty( $mClassName  ) ) {
      $sClassNameLowerCased                                    = strtolower( $mClassName );
      $this->_wpxPluginClassLoadingPath[$sClassNameLowerCased] = $sLoadingPath;
    }

    // 2.
    elseif ( is_array( $sLoadingPath ) ) {
      foreach ( $sLoadingPath as $path => $classes ) {
        if ( is_string( $classes ) ) {
          $class_name                                    = strtolower( $classes );
          $this->_wpxPluginClassLoadingPath[$class_name] = $path;
        }

        // 3.
        elseif ( is_array( $classes ) ) {
          foreach ( $classes as $class_name ) {
            $class_name                                    = strtolower( $class_name );
            $this->_wpxPluginClassLoadingPath[$class_name] = $path;
          }
        }
      }
    }
  }

  public function autoloadEnvironment( $sClassName )
  {
    // For backward compatibility and for better matching
    $sClassNameLowerCased = strtolower( $sClassName );
    if ( isset( $this->_wpxPluginClassLoadingPath[$sClassNameLowerCased] ) ) {
      require_once( $this->_wpxPluginClassLoadingPath[$sClassNameLowerCased] );
    }
  }

  public function reloadTextDomain()
  {
    load_plugin_textDomain( $this->textDomain, false, $this->textDomainPath );
  }

  // -------------------------------------------------------------------------------------------------------------------
  // HOOK DELEGATE
  // -------------------------------------------------------------------------------------------------------------------

  public function _init()
  {

    // Load the translation of the plugin
    load_plugin_textDomain( $this->textDomain, false, $this->textDomainPath );

    // Good place for init options
    $this->preferences();

    // Check Ajax
    if ( wpdk_is_ajax() ) {
      $this->ajax();
      return;
    }

    // Check admin backend
    if ( is_admin() ) {
      $this->admin();
    }

    // Improve since v1.4.13
    elseif( !in_array( $GLOBALS['pagenow'], array( 'wp-login.php', 'wp-register.php' ) ) ) {
      $this->theme();
    }
  }

  public function admin_init()
  {
    /* To override */
  }

  public function preferences()
  {
    /* To override. */
  }

  public function ajax()
  {
    /* To override. */
  }

  public function admin()
  {
    /* To override. */
  }

  public function activation()
  {
    /* To override. */
  }

  public function deactivation()
  {
    /* To override. */
  }

  public function theme()
  {
    /* To override. */
  }

  public function widgets()
  {
    /* To override. */
  }

  // -------------------------------------------------------------------------------------------------------------------
  // DEPRECATED
  // -------------------------------------------------------------------------------------------------------------------

  public function configuration()
  {
    _deprecated_function( __CLASS__ . '::' . __FUNCTION__, '1.2.0', 'preferences()' );
  }

  public function loaded()
  {
    _deprecated_function( __CLASS__ . '::' . __FUNCTION__, '1.4.20' );
  }

}


class WPDKPlugin {

  public $active = false;

  public $author = '';

  public $authorName = '';

  public $authorURI = '';

  public $description = '';

  public $file = '';

  public $icon = '';

  public $id = '';

  public $name = '';

  public $network = '';

  public $pluginURI = '';

  public $textDomain = '';

  public $textDomainPath = '';

  public $title = '';

  public $version = '';

  public function __construct( $file = null ) {

    $this->file = $file;

    if ( !is_null( $this->file ) ) {

      /* Use WordPress get_plugin_data() function for auto retrive plugin information. */
      if ( !function_exists( 'get_plugin_data' ) ) {
        require_once( ABSPATH . 'wp-admin/includes/plugin.php' );
      }
      $result = get_plugin_data( $this->file, false );

      $this->id             = plugin_basename( $this->file );
      $this->author         = $result['Author'];
      $this->authorURI      = $result['AuthorURI'];
      $this->authorName     = $result['AuthorName'];
      $this->description    = $result['Description'];
      $this->icon           = sprintf( '%s%s%s', WPDKWordPressPaths::pluginsURL(), trailingslashit( basename( dirname( $this->file ) ) ), 'assets/css/images/logo-64x64.png' );
      $this->name           = $result['Name'];
      $this->network        = $result['Network'];
      $this->pluginURI      = $result['PluginURI'];
      $this->textDomain     = $result['TextDomain'];
      $this->textDomainPath = trailingslashit( basename( dirname( $this->file ) ) ) . $result['DomainPath'];
      $this->title          = $result['Title'];
      $this->version        = $result['Version'];
      $this->active         = is_plugin_active( $this->id );

    }
  }

  /* @todo Active plugin */
  public function active() {}

  /* @todo Deactive plugin */
  public function deactive() {}

  /* @todo Unistall plugin */
  public function uninstall() {}

  public function readMetadata( $aWPXHeaders )
  {
    _deprecated_function( __CLASS__ . '::' . __FUNCTION__, '1.1.4', 'get_file_data()' );

    // Check input param
    if( empty( $aWPXHeaders )) {
      return FALSE;
    }

    // Get first 8K of file
    $sContent = file_get_contents( $this->file, FALSE, NULL, 0, 8192);
    if( FALSE === $sContent ) {
      return FALSE;
    }

    // Make sure we catch CR-only line endings.
    $sContent = str_replace( "\r", "\n", $sContent );

    // Get WPX metadata from header
    foreach ( $aWPXHeaders as $sKey => $sValue  ) {
      if ( preg_match( '/^[ \t\/*#@]*' . preg_quote( $sKey, '/' ) . ':(.*)$/mi', $sContent, $aMatch ) && $aMatch[1] ) {
        $aWPXHeaders[ $sKey ] = _cleanup_header_comment( $aMatch[1] );
      }
      else {
        $aWPXHeaders[ $sKey ] = '';
      }
    }

    // Return WPX metadata
    return $aWPXHeaders;

  }

}

class WPDKPlugins {

  public $plugins;

  public $wpxPlugins;

  private $_activePlugins;

  private function __construct()
  {
    $this->_init();
    $this->_initPluginsLists();
  }

  private function _init()
  {
    $this->_activePlugins = array();
    $this->plugins        = array();
    $this->wpxPlugins     = array();
  }

  private function _initPluginsLists()
  {

    if ( empty( $this->plugins ) ) {

      // Get all installed plugins
      $all_plugins = get_plugins();

      // Get all active plugins
      $this->_activePlugins = get_option( 'active_plugins' );

      foreach ( $all_plugins as $key => $value ) {
        $file   = sprintf( '%s%s', trailingslashit( WP_PLUGIN_DIR ), $key );
        $plugin = new WPDKPlugin( $file );

        // Put this WPDKPlugin in wpXtreme list
        if ( 'https://wpxtre.me' == $value['PluginURI'] ) {
          $this->wpxPlugins[$key] = $plugin;
        }

        // Put this WPDKPlugin in generic list
        else {
          $this->plugins[$key] = $plugin;
        }
      }
    }
  }

  static function getInstance()
  {
    static $instance = null;
    if ( is_null( $instance ) ) {
      $instance = new WPDKPlugins();
    }
    return $instance;
  }

}

class WPDKWordPressPaths {

  public static function homeURL( $blog_id = null, $path = '', $scheme = null )
  {
    return trailingslashit( get_home_url( $blog_id, $path, $scheme ) );
  }

  public static function adminURL( $blog_id = null, $path = '', $scheme = 'admin' )
  {
    return trailingslashit( get_admin_url( $blog_id, $path, $scheme ) );
  }

  public static function includesURL( $path = '' )
  {
    return trailingslashit( includes_url( $path ) );
  }

  public static function pluginsURL( $path = '', $plugin = '' )
  {
    return trailingslashit( plugins_url( $path, $plugin ) );
  }

}