Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
78.64%
265 / 337
29.41%
5 / 17
 CRAP
0.00%
0 / 1
Blaze
78.64%
265 / 337
29.41%
5 / 17
 191.66
0.00%
0 / 1
 init
88.89%
8 / 9
0.00%
0 / 1
 7.07
 add_post_links_actions
100.00%
3 / 3
100.00%
1 / 1
 2
 is_dashboard_enabled
100.00%
4 / 4
100.00%
1 / 1
 3
 enable_blaze_menu
96.88%
31 / 32
0.00%
0 / 1
 8
 is_standalone_blaze_ads_active
100.00%
4 / 4
100.00%
1 / 1
 3
 get_menu_parent
55.56%
5 / 9
0.00%
0 / 1
 11.30
 add_migration_notice_menu
100.00%
11 / 11
100.00%
1 / 1
 2
 render_migration_notice
96.49%
55 / 57
0.00%
0 / 1
 4
 redirect_legacy_advertising_url
50.00%
2 / 4
0.00%
0 / 1
 2.50
 get_legacy_advertising_redirect_target
92.86%
13 / 14
0.00%
0 / 1
 9.03
 site_supports_blaze
91.67%
22 / 24
0.00%
0 / 1
 10.06
 get_active_campaigns_status
97.37%
37 / 38
0.00%
0 / 1
 11
 get_unknown_active_campaigns_status
100.00%
7 / 7
100.00%
1 / 1
 2
 should_initialize
45.45%
20 / 44
0.00%
0 / 1
 35.37
 get_campaign_management_url
62.96%
17 / 27
0.00%
0 / 1
 4.81
 jetpack_blaze_row_action
0.00%
0 / 23
0.00%
0 / 1
 42
 enqueue_block_editor_assets
96.30%
26 / 27
0.00%
0 / 1
 6
1<?php
2/**
3 * Attract high-quality traffic to your site.
4 *
5 * @package automattic/jetpack-blaze
6 */
7
8namespace Automattic\Jetpack;
9
10use Automattic\Jetpack\Admin_UI\Admin_Menu;
11use Automattic\Jetpack\Blaze\Dashboard as Blaze_Dashboard;
12use Automattic\Jetpack\Blaze\Dashboard_REST_Controller as Blaze_Dashboard_REST_Controller;
13use Automattic\Jetpack\Blaze\REST_Controller;
14use Automattic\Jetpack\Connection\Client;
15use Automattic\Jetpack\Connection\Initial_State as Connection_Initial_State;
16use Automattic\Jetpack\Connection\Manager as Jetpack_Connection;
17use Automattic\Jetpack\Status\Host;
18use Automattic\Jetpack\Sync\Settings as Sync_Settings;
19use WP_Post;
20
21/**
22 * Class for promoting posts.
23 */
24class Blaze {
25    /**
26     * Script handle for the JS file we enqueue in the post editor.
27     *
28     * @var string
29     */
30    const SCRIPT_HANDLE = 'jetpack-promote-editor';
31
32    /**
33     * Transient prefix for active campaign status checks.
34     *
35     * @var string
36     */
37    const ACTIVE_CAMPAIGNS_STATUS_TRANSIENT_PREFIX = 'jetpack_blaze_active_campaigns_status_';
38
39    /**
40     * Transient TTL for active campaign status checks that find campaigns.
41     *
42     * @var int
43     */
44    const ACTIVE_CAMPAIGNS_STATUS_TRANSIENT_TTL = HOUR_IN_SECONDS;
45
46    /**
47     * Transient TTL for active campaign status checks that cannot determine campaign status.
48     *
49     * @var int
50     */
51    const UNKNOWN_ACTIVE_CAMPAIGNS_STATUS_TRANSIENT_TTL = 5 * MINUTE_IN_SECONDS;
52
53    /**
54     * Minimum campaign statuses that should trigger a warning.
55     *
56     * @var string[]
57     */
58    const ACTIVE_CAMPAIGN_STATUSES = array( 'active' );
59
60    /**
61     * Path of the JS file we enqueue in the post editor.
62     *
63     * @var string
64     */
65    public static $script_path = '../build/editor.js';
66
67    /**
68     * Initializer.
69     * Used to configure the blaze package, eg when called via the Config package.
70     *
71     * @return void
72     */
73    public static function init() {
74        // On the edit screen, add a row action to promote the post.
75        add_action( 'load-edit.php', array( __CLASS__, 'add_post_links_actions' ) );
76        // After the quick-edit screen is processed, ensure the blaze row action is still present
77        if ( 'edit.php' === $GLOBALS['pagenow'] ||
78            // phpcs:ignore WordPress.Security.NonceVerification.Missing -- Nonce verification is not needed here, we're not saving anything.
79            ( 'admin-ajax.php' === $GLOBALS['pagenow'] && ! empty( $_POST['post_view'] ) && 'list' === $_POST['post_view'] && ! empty( $_POST['action'] ) && 'inline-save' === $_POST['action'] ) ) {
80            self::add_post_links_actions();
81        }
82        // In the post editor, add a post-publish panel to allow promoting the post.
83        add_action( 'enqueue_block_editor_assets', array( __CLASS__, 'enqueue_block_editor_assets' ) );
84        // Add a Blaze Menu.
85        add_action( 'admin_menu', array( __CLASS__, 'enable_blaze_menu' ), 999 );
86        // Redirect legacy/duplicate advertising URLs (the old tools.php location, or the
87        // admin.php?page=advertising slug when the standalone Blaze Ads plugin owns the
88        // menu). Runs late (after WooCommerce and core register their menus, so
89        // get_menu_parent() resolves the real parent) but still before WordPress
90        // validates the page parameter.
91        add_action( 'admin_menu', array( __CLASS__, 'redirect_legacy_advertising_url' ), 999 );
92        // Add Blaze dashboard app REST API endpoints.
93        add_action( 'rest_api_init', array( Blaze_Dashboard_REST_Controller::class, 'register' ) );
94        // Add general Blaze REST API endpoints.
95        add_action( 'rest_api_init', array( REST_Controller::class, 'register' ) );
96    }
97
98    /**
99     * Add links under each published post in the wp-admin post list.
100     *
101     * @return void
102     */
103    public static function add_post_links_actions() {
104        if ( self::should_initialize()['can_init'] ) {
105            add_filter( 'post_row_actions', array( __CLASS__, 'jetpack_blaze_row_action' ), 10, 2 );
106            add_filter( 'page_row_actions', array( __CLASS__, 'jetpack_blaze_row_action' ), 10, 2 );
107        }
108    }
109
110    /**
111     * Is the wp-admin Dashboard enabled?
112     * That dashboard is not available or necessary on WordPress.com sites when the nav redesign is disabled.
113     *
114     * @return bool
115     */
116    public static function is_dashboard_enabled() {
117        $is_dashboard_enabled = true;
118
119        // On WordPress.com sites, the dashboard is not needed if the nav redesign is not enabled.
120        if ( get_option( 'wpcom_admin_interface' ) !== 'wp-admin' && ( new Host() )->is_wpcom_platform() ) {
121            $is_dashboard_enabled = false;
122        }
123
124        /**
125         * Enable a wp-admin dashboard for Blaze campaign management.
126         *
127         * @since 0.7.0
128         *
129         * @param bool $should_enable Should the dashboard be enabled?
130         */
131        return apply_filters( 'jetpack_blaze_dashboard_enable', $is_dashboard_enabled );
132    }
133
134    /**
135     * Enable the Blaze menu.
136     *
137     * @return void
138     */
139    public static function enable_blaze_menu() {
140        if ( ! self::should_initialize()['can_init'] ) {
141            return;
142        }
143
144        /**
145         * Filter the menu page slug used for the Blaze dashboard.
146         *
147         * @since 0.28.0
148         *
149         * @param string $menu_slug The menu page slug. Default 'advertising'.
150         */
151        $menu_slug = apply_filters( 'jetpack_blaze_menu_slug', 'advertising' );
152
153        // Avoid a duplicate Blaze Ads menu when the standalone Blaze Ads plugin
154        // (Automattic/blaze-ads) is also active. Releases <= 0.9.0 register their own
155        // menu and leave our slug at the default 'advertising', so we bail to avoid a
156        // second entry; the standalone owns the menu under 'wp-blaze' and
157        // redirect_legacy_advertising_url() forwards 'advertising' links there. When the
158        // standalone instead delegates registration to us by filtering the slug (e.g. to
159        // 'wp-blaze'), we are the only registrant and must register normally -- the
160        // non-default slug is what tells the two cases apart.
161        if ( 'advertising' === $menu_slug && self::is_standalone_blaze_ads_active() ) {
162            return;
163        }
164
165        /**
166         * Filter the menu label for the Blaze dashboard menu item.
167         *
168         * @since 0.28.0
169         *
170         * @param string $menu_label The menu label. Default 'Blaze Ads'.
171         */
172        $menu_label = apply_filters( 'jetpack_blaze_menu_label', 'Blaze Ads' ); // Product name, do not translate.
173
174        /**
175         * Filter the CSS class prefix for the Blaze dashboard.
176         *
177         * @since 0.28.0
178         *
179         * @param string $css_prefix The CSS class prefix. Default 'jp-blaze'.
180         */
181        $css_prefix = apply_filters( 'jetpack_blaze_dashboard_css_prefix', 'jp-blaze' );
182
183        $parent_slug     = self::get_menu_parent();
184        $blaze_dashboard = new Blaze_Dashboard( 'admin.php', $menu_slug, $css_prefix );
185
186        if ( self::is_dashboard_enabled() || ( new Host() )->is_wpcom_platform() ) {
187            if ( 'jetpack' === $parent_slug ) {
188                // Register through Admin_Menu: on WordPress.com Simple sites the Jetpack
189                // parent menu does not exist yet at this priority, and registering the
190                // submenu before its parent produces a broken menu URL.
191                $page_suffix = Admin_Menu::add_menu(
192                    esc_attr( $menu_label ),
193                    $menu_label,
194                    'manage_options',
195                    $menu_slug,
196                    array( $blaze_dashboard, 'render' ),
197                    null,
198                    // Not $menu_slug: that is filterable, and a host naming it would lose
199                    // the item the moment anything changed it.
200                    array( 'key' => 'jetpack-blaze' )
201                );
202            } else {
203                // Other parents already exist at this priority, so add_submenu_page is safe.
204                $page_suffix = add_submenu_page(
205                    $parent_slug,
206                    esc_attr( $menu_label ),
207                    $menu_label,
208                    'manage_options',
209                    $menu_slug,
210                    array( $blaze_dashboard, 'render' ),
211                    1
212                );
213            }
214            add_action( 'load-' . $page_suffix, array( $blaze_dashboard, 'admin_init' ) );
215
216            // Temporary entry at the old Tools location; remove ~1 month after the move ships.
217            if ( 'tools.php' !== $parent_slug ) {
218                self::add_migration_notice_menu();
219            }
220        }
221    }
222
223    /**
224     * Detect whether the standalone Blaze Ads plugin (Automattic/blaze-ads) is active.
225     *
226     * Both this package and the standalone plugin can register a Blaze Ads menu, which
227     * would result in a duplicate entry when both are active on the same site (for
228     * example a WooCommerce store running Jetpack alongside the standalone plugin). When
229     * the standalone plugin is present it owns the menu, so this package defers to it.
230     *
231     * Detection relies on a class/constant defined by the standalone plugin rather than
232     * on any cooperation from it, so it works with every released version of the plugin,
233     * including ones that predate the jetpack_blaze_menu_* filters.
234     *
235     * @return bool True if the standalone Blaze Ads plugin is active.
236     */
237    public static function is_standalone_blaze_ads_active() {
238        $is_active = defined( 'BLAZEADS_PLUGIN_FILE' )
239            || defined( 'BLAZE_ADS_VERSION_NUMBER' )
240            || class_exists( 'Blaze_Ads' );
241
242        /**
243         * Filter whether the standalone Blaze Ads plugin (Automattic/blaze-ads) is
244         * considered active. When active and this package is still using the default
245         * menu slug, the package skips registering its own Blaze Ads menu to avoid a
246         * duplicate entry.
247         *
248         * @since 0.28.0
249         *
250         * @param bool $is_active Whether the standalone Blaze Ads plugin is active.
251         */
252        return (bool) apply_filters( 'jetpack_blaze_standalone_active', $is_active );
253    }
254
255    /**
256     * Determine the appropriate parent menu slug based on the installation context.
257     *
258     * - WooCommerce active (Marketing menu registered): parent is 'woocommerce-marketing'
259     * - WordPress.com platform or Jetpack connected: parent is 'jetpack'
260     * - Otherwise: parent is 'tools.php'
261     *
262     * @return string The parent menu slug.
263     */
264    public static function get_menu_parent() {
265        if ( class_exists( 'WooCommerce' ) ) {
266            // Only use woocommerce-marketing if the menu is actually registered.
267            global $menu;
268            foreach ( (array) $menu as $item ) {
269                if ( isset( $item[2] ) && 'woocommerce-marketing' === $item[2] ) {
270                    /**
271                     * Filter the parent menu slug for the Blaze dashboard submenu item.
272                     *
273                     * @since 0.28.0
274                     *
275                     * @param string $parent The parent menu slug.
276                     */
277                    return apply_filters( 'jetpack_blaze_menu_parent', 'woocommerce-marketing' );
278                }
279            }
280        }
281
282        if ( ( new Host() )->is_wpcom_platform() ) {
283            /** This filter is documented above. */
284            return apply_filters( 'jetpack_blaze_menu_parent', 'jetpack' );
285        }
286
287        if ( ( new Jetpack_Connection() )->is_connected() ) {
288            /** This filter is documented above. */
289            return apply_filters( 'jetpack_blaze_menu_parent', 'jetpack' );
290        }
291
292        /** This filter is documented above. */
293        return apply_filters( 'jetpack_blaze_menu_parent', 'tools.php' );
294    }
295
296    /**
297     * Register a temporary "moved" notice page at the old Tools menu location.
298     *
299     * The menu keeps its old "Advertising" label so users who knew it by that
300     * name still recognize it; the page itself explains the move to Blaze Ads.
301     *
302     * @return void
303     */
304    public static function add_migration_notice_menu() {
305        /**
306         * Filter whether to show the temporary migration notice at the old
307         * Tools > Advertising location.
308         *
309         * @since 0.28.0
310         *
311         * @param bool $show_notice Whether to show the migration notice. Default true.
312         */
313        if ( ! apply_filters( 'jetpack_blaze_show_migration_notice', true ) ) {
314            return;
315        }
316
317        add_submenu_page(
318            'tools.php',
319            esc_attr__( 'Advertising', 'jetpack-blaze' ),
320            __( 'Advertising', 'jetpack-blaze' ),
321            'manage_options',
322            'advertising-moved',
323            array( __CLASS__, 'render_migration_notice' ),
324            1
325        );
326    }
327
328    /**
329     * Render the temporary migration notice shown at the old Tools menu location.
330     *
331     * @return void
332     */
333    public static function render_migration_notice() {
334        /** This filter is documented in Blaze::enable_blaze_menu() */
335        $menu_slug = apply_filters( 'jetpack_blaze_menu_slug', 'advertising' );
336
337        $parent_slug  = self::get_menu_parent();
338        $parent_label = 'woocommerce-marketing' === $parent_slug
339            ? __( 'Marketing', 'jetpack-blaze' )
340            : 'Jetpack';
341
342        $dashboard_url = admin_url( 'admin.php?page=' . $menu_slug );
343        $image_file    = 'woocommerce-marketing' === $parent_slug
344            ? 'blaze-ads-moved-woo.webp'
345            : 'blaze-ads-moved.webp';
346        $image_path    = dirname( __DIR__ ) . '/assets/images/' . $image_file;
347        $image_url     = plugins_url( 'assets/images/' . $image_file, __DIR__ );
348
349        ?>
350        <div class="wrap blaze-ads-migration">
351            <div class="blaze-ads-migration__header">
352                <svg class="blaze-ads-migration__logo" xmlns="http://www.w3.org/2000/svg" height="32" width="32" viewBox="0 0 32 32" aria-hidden="true" focusable="false">
353                    <path d="M16,0C7.2,0,0,7.2,0,16s7.2,16,16,16s16-7.2,16-16S24.8,0,16,0z" fill="#069e08" />
354                    <polygon points="15,19 7,19 15,3" fill="#fff" />
355                    <polygon points="17,29 17,13 25,13" fill="#fff" />
356                </svg>
357                <span class="blaze-ads-migration__brand">Blaze Ads</span>
358            </div>
359            <h1 class="blaze-ads-migration__title">
360                <?php
361                printf(
362                    /* translators: %s is the product name (not translatable). */
363                    esc_html__( '%s has moved', 'jetpack-blaze' ),
364                    'Blaze Ads'
365                );
366                ?>
367            </h1>
368            <p class="blaze-ads-migration__subtitle">
369                <?php
370                printf(
371                    /* translators: %s is the menu path where the section lives now, e.g. "Jetpack â†’ Blaze Ads" or "Marketing â†’ Blaze Ads". */
372                    esc_html__( "Now it's part of %s", 'jetpack-blaze' ),
373                    esc_html( $parent_label . ' â†’ Blaze Ads' )
374                );
375                ?>
376            </p>
377            <p>
378                <a class="button button-primary button-hero" href="<?php echo esc_url( $dashboard_url ); ?>">
379                    <?php
380                    printf(
381                        /* translators: %s is the product name (not translatable). */
382                        esc_html__( 'Check new %s', 'jetpack-blaze' ),
383                        'Blaze Ads'
384                    );
385                    ?>
386                </a>
387            </p>
388            <?php if ( file_exists( $image_path ) ) : ?>
389                <p class="blaze-ads-migration__image">
390                    <img
391                        src="<?php echo esc_url( $image_url ); ?>"
392                        alt="<?php echo esc_attr( sprintf( /* translators: %s is the product name (not translatable). */ __( '%s has moved', 'jetpack-blaze' ), 'Blaze Ads' ) ); ?>"
393                    />
394                </p>
395            <?php endif; ?>
396        </div>
397        <style>
398            .blaze-ads-migration__header { display: flex; align-items: center; gap: 8px; margin: 16px 0 24px; }
399            .blaze-ads-migration__brand { font-size: 1.65em; font-weight: 500; line-height: 1; }
400            .blaze-ads-migration__title { font-size: 2.5em; margin-bottom: 0.25em; padding: 0; }
401            .blaze-ads-migration__subtitle { font-size: 1.4em; margin-top: 0; color: #50575e; }
402            .blaze-ads-migration__image { margin-top: 3em; }
403            .blaze-ads-migration__image img { max-width: 100%; height: auto; }
404        </style>
405        <?php
406    }
407
408    /**
409     * Redirect legacy/duplicate Blaze dashboard URLs to wherever the menu actually lives.
410     *
411     * Runs early on admin_menu, before WordPress validates the ?page= parameter against
412     * registered submenus. The target is computed by get_legacy_advertising_redirect_target();
413     * this method only performs the redirect.
414     *
415     * @return void
416     */
417    public static function redirect_legacy_advertising_url() {
418        $target = self::get_legacy_advertising_redirect_target();
419        if ( null !== $target ) {
420            wp_safe_redirect( $target, 302 );
421            exit;
422        }
423    }
424
425    /**
426     * Compute where a legacy/duplicate `page=advertising` request should be redirected, or
427     * null if it should be left alone. Pure (no side effects) so it is unit-testable.
428     *
429     * Two cases produce a redirect:
430     *
431     * - Standard move: `tools.php?page=advertising` -> `admin.php?page=advertising`, once the
432     *   menu has moved away from Tools.
433     * - Standalone Blaze Ads plugin present: this package does not register the 'advertising'
434     *   page (the standalone owns the menu under 'wp-blaze'), so BOTH the tools.php and the
435     *   admin.php `page=advertising` entry points are forwarded to the standalone's page. We
436     *   forward both ourselves rather than relying on the standalone shipping its own
437     *   redirect, so correctness never depends on a particular standalone release.
438     *
439     * @return string|null The redirect URL, or null if no redirect should happen.
440     */
441    public static function get_legacy_advertising_redirect_target() {
442        global $pagenow;
443
444        if (
445            ! isset( $_GET['page'] ) // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- Read-only check to redirect, no data is processed.
446            || 'advertising' !== $_GET['page'] // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- Read-only check to redirect, no data is processed.
447        ) {
448            return null;
449        }
450
451        if ( ! self::should_initialize()['can_init'] ) {
452            return null;
453        }
454
455        if ( self::is_standalone_blaze_ads_active() ) {
456            // Only the two URLs that can carry the dashboard page parameter.
457            if ( 'admin.php' !== $pagenow && 'tools.php' !== $pagenow ) {
458                return null;
459            }
460            /**
461             * Filter the standalone Blaze Ads plugin's menu slug used as the redirect
462             * target when this package defers to it.
463             *
464             * @since 0.28.0
465             *
466             * @param string $standalone_slug The standalone menu slug. Default 'wp-blaze'.
467             */
468            $standalone_slug = apply_filters( 'jetpack_blaze_standalone_menu_slug', 'wp-blaze' );
469            return admin_url( 'admin.php?page=' . $standalone_slug );
470        }
471
472        if ( 'tools.php' !== $pagenow || 'tools.php' === self::get_menu_parent() ) {
473            return null;
474        }
475
476        /** This filter is documented in Blaze::enable_blaze_menu() */
477        $menu_slug = apply_filters( 'jetpack_blaze_menu_slug', 'advertising' );
478        return admin_url( 'admin.php?page=' . $menu_slug );
479    }
480
481    /**
482     * Check the WordPress.com REST API
483     * to ensure that the site supports the Blaze feature.
484     *
485     * - If the site is on WordPress.com Simple, we do not query the API.
486     * - Results are cached for a day after getting response from API.
487     * - If the API returns an error, we cache the result for an hour.
488     *
489     * @param int $blog_id The blog ID to check.
490     *
491     * @return bool
492     */
493    public static function site_supports_blaze( $blog_id ) {
494        $transient_name = 'jetpack_blaze_site_supports_blaze_' . $blog_id;
495
496        /*
497         * On WordPress.com, we don't need to make an API request,
498         * we can query directly.
499         */
500        if ( defined( 'IS_WPCOM' ) && IS_WPCOM && function_exists( 'blaze_is_site_eligible' ) ) {
501            return blaze_is_site_eligible( $blog_id );
502        }
503
504        $cached_result = get_transient( $transient_name );
505        if ( false !== $cached_result ) {
506            if ( is_array( $cached_result ) ) {
507                return $cached_result['approved'];
508            }
509
510            return (bool) $cached_result;
511        }
512
513        // Make the API request.
514        $url      = sprintf( '/sites/%d/blaze/status', $blog_id );
515        $response = Client::wpcom_json_api_request_as_blog(
516            $url,
517            '2',
518            array( 'method' => 'GET' ),
519            null,
520            'wpcom'
521        );
522
523        // If there was an error or malformed response, bail and save response for an hour.
524        if ( is_wp_error( $response ) || 200 !== wp_remote_retrieve_response_code( $response ) ) {
525            set_transient( $transient_name, array( 'approved' => false ), HOUR_IN_SECONDS );
526            return false;
527        }
528
529        // Decode the results.
530        $result = json_decode( wp_remote_retrieve_body( $response ), true );
531
532        // Bail if there were no results returned.
533        if ( ! is_array( $result ) || ! isset( $result['approved'] ) ) {
534            return false;
535        }
536
537        // Cache the result for 24 hours.
538        set_transient( $transient_name, array( 'approved' => (bool) $result['approved'] ), DAY_IN_SECONDS );
539
540        return (bool) $result['approved'];
541    }
542
543    /**
544     * Get the active campaign status for a site.
545     *
546     * @param int $blog_id The blog ID to check.
547     *
548     * @return array Active campaign status.
549     */
550    public static function get_active_campaigns_status( $blog_id ) {
551        $blog_id = absint( $blog_id );
552
553        if ( empty( $blog_id ) ) {
554            return self::get_unknown_active_campaigns_status();
555        }
556
557        $transient_name = self::ACTIVE_CAMPAIGNS_STATUS_TRANSIENT_PREFIX . $blog_id;
558        $cached_result  = get_transient( $transient_name );
559
560        if ( false !== $cached_result ) {
561            return $cached_result;
562        }
563
564        /**
565         * Filter the campaign statuses that should trigger the active campaign warning.
566         *
567         * @since 0.27.23
568         *
569         * @param string[] $statuses Campaign statuses to check.
570         * @param int      $blog_id  The blog ID being checked.
571         */
572        $statuses = apply_filters( 'jetpack_blaze_active_campaign_statuses', self::ACTIVE_CAMPAIGN_STATUSES, $blog_id );
573        $statuses = array_filter( array_map( 'sanitize_key', (array) $statuses ) );
574
575        if ( empty( $statuses ) ) {
576            $statuses = self::ACTIVE_CAMPAIGN_STATUSES;
577        }
578
579        $url = add_query_arg(
580            array(
581                'status' => implode( ',', $statuses ),
582                'limit'  => 1,
583            ),
584            sprintf( '/sites/%d/wordads/dsp/api/v1/search/campaigns/site/%d', $blog_id, $blog_id )
585        );
586
587        $response = Client::wpcom_json_api_request_as_user(
588            $url,
589            '2',
590            array( 'method' => 'GET' ),
591            null,
592            'wpcom'
593        );
594
595        if ( is_wp_error( $response ) || 200 !== wp_remote_retrieve_response_code( $response ) ) {
596            return self::get_unknown_active_campaigns_status( $transient_name );
597        }
598
599        $result = json_decode( wp_remote_retrieve_body( $response ), true );
600
601        if ( ! is_array( $result ) || ! isset( $result['campaigns'] ) || ! is_array( $result['campaigns'] ) ) {
602            return self::get_unknown_active_campaigns_status( $transient_name );
603        }
604
605        $has_active_campaigns = ! empty( $result['campaigns'] );
606        $status               = array(
607            'has_active_campaigns' => $has_active_campaigns,
608            'status'               => $has_active_campaigns ? 'active' : 'none',
609        );
610
611        if ( $has_active_campaigns ) {
612            set_transient( $transient_name, $status, self::ACTIVE_CAMPAIGNS_STATUS_TRANSIENT_TTL );
613        }
614
615        return $status;
616    }
617
618    /**
619     * Get the unknown active campaign status response.
620     *
621     * @param string|null $transient_name Optional transient name used to cache the unknown status.
622     * @return array Unknown active campaign status.
623     */
624    private static function get_unknown_active_campaigns_status( $transient_name = null ) {
625        $status = array(
626            'has_active_campaigns' => false,
627            'status'               => 'unknown',
628        );
629
630        if ( $transient_name ) {
631            set_transient( $transient_name, $status, self::UNKNOWN_ACTIVE_CAMPAIGNS_STATUS_TRANSIENT_TTL );
632        }
633
634        return $status;
635    }
636
637    /**
638     * Determines if criteria is met to enable Blaze features.
639     * Keep in mind that this makes remote requests, so we want to avoid calling it when unnecessary, like in the frontend.
640     *
641     * @return array
642     */
643    public static function should_initialize() {
644        $is_wpcom   = defined( 'IS_WPCOM' ) && IS_WPCOM;
645        $connection = new Jetpack_Connection();
646        $site_id    = Jetpack_Connection::get_site_id();
647
648        // Only admins should be able to Blaze posts on a site.
649        if ( ! current_user_can( 'manage_options' ) ) {
650            return array(
651                'can_init' => false,
652                'reason'   => 'user_not_admin',
653            );
654        }
655
656        // Allow short-circuiting the Blaze initialization via a filter.
657        if ( has_filter( 'jetpack_blaze_enabled' ) ) {
658            /**
659             * Filter to disable all Blaze functionality.
660             *
661             * @since 0.3.0
662             *
663             * @param bool $should_initialize Whether Blaze should be enabled. Default to true.
664             */
665            $should_init = apply_filters( 'jetpack_blaze_enabled', true );
666
667            return array(
668                'can_init' => $should_init,
669                'reason'   => $should_init ? null : 'initialization_disabled',
670            );
671        }
672
673        // On self-hosted sites, we must do some additional checks.
674        if ( ! $is_wpcom ) {
675            /*
676            * These features currently only work on WordPress.com,
677            * so the site must be connected to WordPress.com, and the user as well for things to work.
678            */
679            if (
680                is_wp_error( $site_id )
681            ) {
682                return array(
683                    'can_init' => false,
684                    'reason'   => 'wp_error',
685                );
686            }
687
688            if ( ! $connection->is_connected() ) {
689                return array(
690                    'can_init' => false,
691                    'reason'   => 'site_not_connected',
692                );
693            }
694
695            if ( ! $connection->is_user_connected() ) {
696                return array(
697                    'can_init' => false,
698                    'reason'   => 'user_not_connected',
699                );
700            }
701
702            // The whole thing is powered by Sync!
703            if ( ! Sync_Settings::is_sync_enabled() ) {
704                return array(
705                    'can_init' => false,
706                    'reason'   => 'sync_disabled',
707                );
708            }
709        }
710
711        // Check if the site supports Blaze.
712        if ( is_numeric( $site_id ) && ! self::site_supports_blaze( $site_id ) ) {
713            return array(
714                'can_init' => false,
715                'reason'   => 'site_not_eligible',
716            );
717        }
718
719        // Final fallback.
720        return array(
721            'can_init' => true,
722            'reason'   => null,
723        );
724    }
725
726    /**
727     * Get URL to create a Blaze campaign for a specific post.
728     *
729     * This can return 2 different types of URL:
730     * - Calypso Links
731     * - wp-admin Links if access to the wp-admin Blaze Dashboard is enabled.
732     *
733     * @param int|string $post_id Post ID.
734     *
735     * @return array An array with the link, and whether this is a Calypso or a wp-admin link.
736     */
737    public static function get_campaign_management_url( $post_id ) {
738        if ( self::is_dashboard_enabled() ) {
739            /** This filter is documented in Blaze::enable_blaze_menu() */
740            $menu_slug = apply_filters( 'jetpack_blaze_menu_slug', 'advertising' );
741
742            // When the standalone Blaze Ads plugin owns the menu under its own slug and
743            // this package did not register 'advertising', point the link straight at the
744            // standalone's page. Relying on the admin.php?page=advertising redirect would
745            // drop the #! route fragment and land the user on the dashboard home instead
746            // of the specific post's promotion flow.
747            if ( 'advertising' === $menu_slug && self::is_standalone_blaze_ads_active() ) {
748                /** This filter is documented in Blaze::redirect_legacy_advertising_url() */
749                $menu_slug = apply_filters( 'jetpack_blaze_standalone_menu_slug', 'wp-blaze' );
750            }
751
752            $admin_url = admin_url( 'admin.php?page=' . $menu_slug );
753            $hostname  = wp_parse_url( get_site_url(), PHP_URL_HOST );
754            // The dashboard SPA routes under its menu slug (see Dashboard), so the #! path
755            // prefix must match the slug rather than being hardcoded to 'advertising'.
756            $blaze_url = sprintf(
757                '%1$s#!/%2$s/posts/promote/post-%3$s/%4$s',
758                $admin_url,
759                $menu_slug,
760                esc_attr( $post_id ),
761                $hostname
762            );
763
764            return array(
765                'link'     => $blaze_url,
766                'external' => false,
767            );
768        }
769
770        // Default Calypso link.
771        $blaze_url = Redirect::get_url(
772            'jetpack-blaze',
773            array(
774                'query' => 'blazepress-widget=post-' . esc_attr( $post_id ),
775            )
776        );
777        return array(
778            'link'     => $blaze_url,
779            'external' => true,
780        );
781    }
782
783    /**
784     * Adds the Promote link to the posts list row action.
785     *
786     * @param array   $post_actions The current array of post actions.
787     * @param WP_Post $post The current post in the post list table.
788     *
789     * @return array
790     */
791    public static function jetpack_blaze_row_action( $post_actions, $post ) {
792        /**
793         * Allow third-party plugins to disable Blaze row actions.
794         *
795         * @since 0.16.0
796         *
797         * @param bool    $are_quick_links_enabled Should Blaze row actions be enabled.
798         * @param WP_Post $post                    The current post in the post list table.
799         */
800        $are_quick_links_enabled = apply_filters( 'jetpack_blaze_post_row_actions_enable', true, $post );
801
802        // Bail if we are not looking at one of the supported post types (post, page, or product).
803        if (
804            ! $are_quick_links_enabled
805            || ! in_array( $post->post_type, array( 'post', 'page', 'product' ), true )
806        ) {
807            return $post_actions;
808        }
809
810        // Bail if the post is not published.
811        if ( $post->post_status !== 'publish' ) {
812            return $post_actions;
813        }
814
815        // Bail if the post has a password.
816        if ( '' !== $post->post_password ) {
817            return $post_actions;
818        }
819
820        $blaze_url = self::get_campaign_management_url( $post->ID );
821        $text      = __( 'Promote with Blaze', 'jetpack-blaze' );
822        $title     = get_the_title( $post );
823        $label     = sprintf(
824            /* translators: post title */
825            __( 'Blaze &#8220;%s&#8221; to Tumblr and WordPress.com audiences.', 'jetpack-blaze' ),
826            $title
827        );
828
829        $post_actions['blaze'] = sprintf(
830            '<a href="%1$s" title="%2$s" aria-label="%2$s" %4$s>%3$s</a>',
831            esc_url( $blaze_url['link'] ),
832            esc_attr( $label ),
833            esc_html( $text ),
834            ( true === $blaze_url['external'] ? 'target="_blank" rel="noopener noreferrer"' : '' )
835        );
836
837        return $post_actions;
838    }
839
840    /**
841     * Enqueue block editor assets.
842     */
843    public static function enqueue_block_editor_assets() {
844        /*
845         * We do not want (nor need) Blaze in the site editor, or the widget editor, or the classic editor.
846         * We only want it in the post editor.
847         * Enqueueing the script in those editors would cause a fatal error.
848         * See #20357 for more info.
849        */
850        if ( ! function_exists( 'get_current_screen' ) ) { // When Gutenberg is loaded in the frontend.
851            return;
852        }
853        $current_screen = get_current_screen();
854        if (
855            empty( $current_screen )
856            || $current_screen->base !== 'post'
857            || ! $current_screen->is_block_editor()
858        ) {
859            return;
860        }
861        // Bail if criteria is not met to enable Blaze features.
862        if ( ! self::should_initialize()['can_init'] ) {
863            return;
864        }
865
866        Assets::register_script(
867            self::SCRIPT_HANDLE,
868            self::$script_path,
869            __FILE__,
870            array(
871                'enqueue'    => true,
872                'in_footer'  => true,
873                'textdomain' => 'jetpack-blaze',
874            )
875        );
876
877        // Adds Connection package initial state.
878        Connection_Initial_State::render_script( self::SCRIPT_HANDLE );
879
880        // Pass additional data to our script.
881        wp_localize_script(
882            self::SCRIPT_HANDLE,
883            'blazeInitialState',
884            array(
885                'blazeUrlTemplate' => self::get_campaign_management_url( '__POST_ID__' ),
886            )
887        );
888    }
889}