public/blog/wp-content/plugins/types/application/controllers/main.php line 171

  1. <?php
  3. use OTGS\Toolset\Types\TypeRegistration\Controller;
  5. /** @noinspection PhpFullyQualifiedNameUsageInspection */
  7. use OTGS\Toolset\Types\Controller\Compatibility\Gutenberg;
  9. /**
  10.  * Main Types controller.
  11.  *
  12.  * Determines if we're in admin or front-end mode or if an AJAX call is being performed. Handles tasks that are common
  13.  * to all three modes, if there are any.
  14.  *
  15.  * @since 2.0
  16.  */
  17. final class Types_Main {
  19.     private static $instance;
  22.     public static function get_instance() {
  23.         if( null == self::$instance ) {
  24.             self::$instance = new self();
  25.         }
  26.         return self::$instance;
  27.     }
  29.     public static function initialize() {
  30.         self::get_instance();
  31.     }
  35.     private function __construct() {
  36.         // Indicate that m2m can be activated with this plugin. This needs to happen very early, even before Toolset
  37.         // Common bootstrap is executed.
  38.         add_filter( 'toolset_is_m2m_ready', '__return_true' );
  40.         add_action( 'after_setup_theme', array( $this, 'after_setup_theme' ), 10 );
  42.         // important to be 11, because we register our post types on 10 (we should consider loading them earlier)
  43.         add_action( 'init', array( $this, 'on_init' ), 11 );
  45.         // attachment deletion
  46.         add_action( 'delete_attachment', static function( $attachment_post_id ) {
  47.             if( class_exists( 'Types_Media_Service' ) ) {
  48.                 $media_service = new Types_Media_Service();
  49.                 $media_service->delete_resized_images_by_attachment_id( $attachment_post_id );
  50.             }
  51.         } );
  52.     }
  56.     /**
  57.      * Determine in which mode we are and initialize the right dedicated controller.
  58.      *
  59.      * @since 2.0
  60.      */
  61.     public function on_init() {
  62.         if( is_admin() ) {
  63.             if( defined( 'DOING_AJAX' ) ) {
  64.                 $this->mode = self::MODE_AJAX;
  65.                 Types_Ajax::initialize();
  66.             } else {
  67.                 $this->mode = self::MODE_ADMIN;
  68.                 $admin_controller = new Types_Admin();
  69.                 $admin_controller->initialize();
  70.             }
  71.         } else {
  72.             $this->mode = self::MODE_FRONTEND;
  73.             Types_Frontend::initialize();
  74.         }
  76.         $dic = toolset_dic();
  78.         $m2m = $dic->make( Types_M2M::class );
  79.         $m2m->initialize();
  81.         // Initialize the "types" shortcode in all contexts.
  82.         $factory = new Types_Shortcode_Factory();
  83.         $types_shortcode = $factory->get_shortcode( 'types' );
  84.         if ( $types_shortcode ) {
  85.             add_shortcode( 'types', array( $types_shortcode, 'render' ) );
  86.         };
  88.         if ( in_array( $this->mode, [ self::MODE_ADMIN, self::MODE_AJAX ], true ) ) {
  89.             /** @var \OTGS\Toolset\Types\TypeRegistration\Controller $type_registration_controller */
  90.             /** @noinspection PhpUnhandledExceptionInspection */
  91.             $type_registration_controller = $dic->make( Controller::class );
  92.             $type_registration_controller->initialize();
  94.             /** @var Gutenberg $gutenberg */
  95.             /** @noinspection PhpUnhandledExceptionInspection */
  96.             $gutenberg = $dic->make( Gutenberg::class );
  97.             $gutenberg->initialize();
  98.         }
  99.     }
  102.     /**
  103.      * @var string One of the MODE_* constants.
  104.      */
  105.     private $mode = self::MODE_UNDEFINED;
  107.     const MODE_UNDEFINED = '';
  108.     const MODE_AJAX = 'ajax';
  109.     const MODE_ADMIN = 'admin';
  110.     const MODE_FRONTEND = 'frontend';
  112.     /**
  113.      * Get current plugin mode.
  114.      *
  115.      * Possible values are:
  116.      * - MODE_UNDEFINED before the main controller initialization is completed
  117.      * - MODE_AJAX when doing an AJAX request
  118.      * - MODE_ADMIN when showing a WP admin page
  119.      * - MODE_FRONTEND when rendering a frontend page
  120.      *
  121.      * @return string
  122.      * @since 2.1
  123.      */
  124.     public function get_plugin_mode() {
  125.         return $this->mode;
  126.     }
  129.     /**
  130.      * Set current plugin mode.
  131.      *
  132.      * @param string $new_mode the new plugin mode
  133.      * @return bool TRUE if set is succesfully done, FALSE otherwise
  134.      * @since 2.2
  135.      */
  136.     public function set_plugin_mode( $new_mode = self::MODE_UNDEFINED ) {
  137.         if ( !in_array( $new_mode, array( self::MODE_UNDEFINED, self::MODE_AJAX, self::MODE_ADMIN, self::MODE_FRONTEND ) ) ){
  138.             return false;
  139.         }
  140.         $this->mode = $new_mode;
  141.         return true;
  142.     }
  145.     /**
  146.      * Determine whether a WP admin page is being loaded.
  147.      *
  148.      * Note that the behaviour differs from the native is_admin() which will return true also for AJAX requests.
  149.      *
  150.      * @return bool
  151.      * @since 2.1
  152.      */
  153.     public function is_admin() {
  154.         return ( $this->get_plugin_mode() === self::MODE_ADMIN );
  155.     }
  158.     /**
  159.      * Early loading actions.
  160.      *
  161.      * @since 2.0
  162.      * @since m2m Load the shortcodes generator
  163.      */
  164.     public function after_setup_theme() {
  165.         
  167.         // Indicate that m2m can be activated with this plugin.
  168.         add_filter( 'toolset_is_m2m_ready', '__return_true' );
  170.         // Initialize the Toolset Common library
  171.         $toolset_common_bootstrap = Toolset_Common_Bootstrap::get_instance();
  173.         $this->setup_autoloader();
  174.         $this->setup_auryn();
  176.         // If an AJAX callback handler needs other assets, it should initialize the asset manager by itself.
  177.         if( $this->get_plugin_mode() !== self::MODE_AJAX ) {
  178.             Types_Assets::get_instance()->initialize_scripts_and_styles();
  179.         }
  181.         // Handle embedded plugin mode
  182.         Types_Embedded::initialize();
  184.         Types_Api::initialize();
  186.         $dic = types_dic();
  188.         $interop_mediator = $dic->make( \OTGS\Toolset\Types\Controller\Interop\InteropMediator::class );
  189.         $interop_mediator->initialize();
  191.         $plugin_cache = $dic->make( '\OTGS\Toolset\Types\Controller\Cache' );
  192.         $plugin_cache->initialize();
  194.         // Load the shortcodes generator and the blocks section.
  195.         $toolset_common_sections = array( 'toolset_shortcode_generator', Toolset_Common_Bootstrap::TOOLSET_BLOCKS );
  196.         $toolset_common_bootstrap->load_sections( $toolset_common_sections );
  197.         $types_shortcode_generator = new Types_Shortcode_Generator();
  198.         $types_shortcode_generator->initialize();
  199.     }
  202.     private function setup_autoloader() {
  204.         // It is possible to regenerate the classmap with Zend framework.
  205.         //
  206.         // See the "recreate_classmap.sh" script in the plugin root directory.
  207.         $classmap = include( TYPES_ABSPATH . '/application/autoload_classmap.php' );
  209.         // Use Toolset_Common_Autoloader
  210.         do_action( 'toolset_register_classmap', $classmap );
  212.     }
  215.     /**
  216.      * In some cases, it may not be clear what legacy files are includes and what aren't.
  217.      *
  218.      * This method should make sure all is covered (add files when needed). Use only when necessary.
  219.      *
  220.      * @since 2.0
  221.      */
  222.     public function require_legacy_functions() {
  223.         require_once WPCF_INC_ABSPATH . '/fields.php';
  224.     }
  227.     /**
  228.      * Configure Auryn so that it is able to inject our singleton instances properly.
  229.      *
  230.      * @since 3.2.2
  231.      */
  232.     private function setup_auryn() {
  233.         // This will initialize the DIC if it hasn't been done yet
  234.         $dic = types_dic();
  236.         // See utility/dic.php in Toolset Common for details. We're doing the same for Types here.
  237.         $singleton_delegates = array(
  238.             '\Types_Asset_Manager' => function() {
  239.                 return Types_Asset_Manager::get_instance();
  240.             }
  241.         );
  243.         foreach( $singleton_delegates as $class_name => $callback ) {
  244.             /** @noinspection PhpUnhandledExceptionInspection */
  245.             $dic->delegate( $class_name, function() use( $callback, $dic ) {
  246.                 $instance = $callback();
  247.                 $dic->share( $instance );
  248.                 return $instance;
  249.             });
  250.         }
  251.     }
  252. }