Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
57.38%
70 / 122
18.18%
2 / 11
 CRAP
n/a
0 / 0
Automattic\Jetpack\Extensions\Premium_Content\membership_checks
0.00%
0 / 5
0.00%
0 / 1
 12
Automattic\Jetpack\Extensions\Premium_Content\required_plan_checks
0.00%
0 / 3
0.00%
0 / 1
 6
Automattic\Jetpack\Extensions\Premium_Content\pre_render_checks
0.00%
0 / 1
0.00%
0 / 1
 6
Automattic\Jetpack\Extensions\Premium_Content\current_user_can_edit
0.00%
0 / 2
0.00%
0 / 1
 6
Automattic\Jetpack\Extensions\Premium_Content\maybe_renew_session_cookie
97.06%
33 / 34
0.00%
0 / 1
 11
Automattic\Jetpack\Extensions\Premium_Content\get_subscriptions_for_logged_in_user
100.00%
7 / 7
100.00%
1 / 1
 2
Automattic\Jetpack\Extensions\Premium_Content\prewarm_premium_content_session_cookie
93.33%
14 / 15
0.00%
0 / 1
 12.04
Automattic\Jetpack\Extensions\Premium_Content\current_visitor_can_access
88.24%
15 / 17
0.00%
0 / 1
 10.16
Automattic\Jetpack\Extensions\Premium_Content\visitor_can_access_plan_ids
100.00%
1 / 1
100.00%
1 / 1
 1
Automattic\Jetpack\Extensions\Premium_Content\visitor_has_subscription_access_to_plan_ids
0.00%
0 / 1
0.00%
0 / 1
 2
Automattic\Jetpack\Extensions\Premium_Content\check_subscription_plan_access
0.00%
0 / 35
0.00%
0 / 1
 306
1<?php
2/**
3 * Determine access to premium content.
4 *
5 * @package Automattic\Jetpack\Extensions\Premium_Content
6 */
7
8namespace Automattic\Jetpack\Extensions\Premium_Content;
9
10use Automattic\Jetpack\Extensions\Premium_Content\Subscription_Service\Abstract_Token_Subscription_Service;
11use Automattic\Jetpack\Extensions\Premium_Content\Subscription_Service\WPCOM_Online_Subscription_Service;
12
13require_once __DIR__ . '/subscription-service/include.php';
14
15/**
16 * Determines if the memberships module is set up.
17 *
18 * @return bool Whether the memberships module is set up.
19 */
20function membership_checks() {
21    // If Jetpack is not yet configured, don't show anything ...
22    if ( ! class_exists( '\Jetpack_Memberships' ) ) {
23        return false;
24    }
25    // if stripe not connected don't show anything...
26    if ( ! \Jetpack_Memberships::has_connected_account() ) {
27        return false;
28    }
29    return true;
30}
31
32/**
33 * Determines if the site has a plan that supports the
34 * Premium Content block.
35 *
36 * @return bool
37 */
38function required_plan_checks() {
39    $availability = \Jetpack_Gutenberg::get_cached_availability();
40    $slug         = 'premium-content/container';
41    return ( isset( $availability[ $slug ] ) && $availability[ $slug ]['available'] );
42}
43
44/**
45 * Determines if the block should be rendered. Returns true
46 * if the block passes all required checks, or if the user is
47 * an editor.
48 *
49 * @return bool Whether the block should be rendered.
50 */
51function pre_render_checks() {
52    return ( current_user_can_edit() || membership_checks() );
53}
54
55/**
56 * Determines whether the current user can edit.
57 *
58 * @return bool Whether the user can edit.
59 */
60function current_user_can_edit() {
61    $user = wp_get_current_user();
62
63    return 0 !== $user->ID && current_user_can( 'edit_post', get_the_ID() );
64}
65
66/**
67 * Mint and persist a fresh premium-content session cookie for the current visitor.
68 *
69 * When the WPCOM Memberships filter returns authoritative subscriptions for a logged-in
70 * visitor but no JWT cookie is present (e.g. the previous one expired or was cleared),
71 * we wrap those subscriptions in a JWT signed with the site's Jetpack blog token and
72 * persist it as the standard `wp-jp-premium-content-session` cookie. Subsequent requests
73 * within the cookie TTL take the fast cached path instead of the WPCOM round-trip.
74 *
75 * Returns the minted JWT so callers can act on it; returns null when no token should be
76 * minted because there are no subscriptions, a valid cookie already exists, or the
77 * signing key is unavailable. The cookie itself is set on a best-effort basis: if headers
78 * have already been sent, the token is still returned so the caller can decide what to do.
79 *
80 * @param object $paywall                   Subscription service (provides the signing key).
81 * @param int    $user_id                   User id the subscriptions belong to (WPCOM id when available, otherwise local).
82 * @param array  $abbreviated_subscriptions Subscriptions after `abbreviate_subscriptions()`.
83 * @return string|null The encoded JWT, or null when no cookie was minted.
84 */
85function maybe_renew_session_cookie( $paywall, $user_id, $abbreviated_subscriptions ) {
86    if ( empty( $abbreviated_subscriptions ) ) {
87        return null;
88    }
89    if ( Abstract_Token_Subscription_Service::has_token_from_cookie() ) {
90        $session_cookie_name = Abstract_Token_Subscription_Service::JWT_AUTH_TOKEN_COOKIE_NAME;
91        $existing_payload    = null;
92        if ( isset( $_COOKIE[ $session_cookie_name ] ) ) {
93            // phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized, WordPress.Security.ValidatedSanitizedInput.MissingUnslash
94            $existing_payload = $paywall->decode_token( $_COOKIE[ $session_cookie_name ] );
95        }
96        if ( ! empty( $existing_payload ) ) {
97            return null;
98        }
99    }
100
101    $key = $paywall->get_key();
102    if ( ! $key ) {
103        return null;
104    }
105
106    $payload_subscriptions = array();
107    foreach ( $abbreviated_subscriptions as $pid => $sub ) {
108        $sub                           = (array) $sub;
109        $payload_subscriptions[ $pid ] = array(
110            'status'     => 'active',
111            'end_date'   => $sub['end_date'] ?? gmdate( 'Y-m-d H:i:s', time() + MONTH_IN_SECONDS ),
112            'product_id' => (int) $pid,
113        );
114        if ( ! empty( $sub['is_comp'] ) ) {
115            $payload_subscriptions[ $pid ]['is_comp'] = true;
116        }
117    }
118
119    $token = JWT::encode(
120        array(
121            'user_id'       => $user_id,
122            'blog_sub'      => 'active',
123            'subscriptions' => $payload_subscriptions,
124        ),
125        $key
126    );
127
128    if ( ! ( defined( 'TESTING_IN_JETPACK' ) && TESTING_IN_JETPACK ) && ! headers_sent() ) {
129        // phpcs:ignore Jetpack.Functions.SetCookie.FoundNonHTTPOnlyFalse
130        setcookie( Abstract_Token_Subscription_Service::JWT_AUTH_TOKEN_COOKIE_NAME, $token, strtotime( '+1 month' ), '/', '', is_ssl(), false );
131    }
132
133    // Reflect the cookie in the current request so the render path (and any later code in
134    // this request) reads the freshly minted token instead of re-querying the filter.
135    $_COOKIE[ Abstract_Token_Subscription_Service::JWT_AUTH_TOKEN_COOKIE_NAME ] = $token;
136
137    return $token;
138}
139
140/**
141 * Resolve the current logged-in visitor's subscriptions from the authoritative
142 * WordPress.com Memberships filter.
143 *
144 * Translates the local user id to the WordPress.com user id (via the `wpcom_user_id`
145 * user_meta populated by Jetpack SSO) and queries the filter with the paywall's
146 * WordPress.com blog id (not get_current_blog_id(), which is the independent local id
147 * on Atomic/WoA). Shared by the access decision and the cookie self-heal.
148 *
149 * @param object $paywall Subscription service (provides the WordPress.com blog id).
150 * @return array{0:int,1:array,2:array} [ user_id (WPCOM id when available, otherwise local), raw_subscriptions, abbreviated_subscriptions ].
151 */
152function get_subscriptions_for_logged_in_user( $paywall ) {
153    $local_user_id = wp_get_current_user()->ID;
154    $wpcom_user_id = (int) get_user_meta( $local_user_id, 'wpcom_user_id', true );
155    $user_id       = $wpcom_user_id > 0 ? $wpcom_user_id : $local_user_id;
156    $site_id       = $paywall->get_site_id();
157
158    /**
159     * Filter the subscriptions attached to a specific user on a given site.
160     *
161     * @since 9.4.0
162     *
163     * @param array $subscriptions Array of subscriptions.
164     * @param int   $user_id The user's ID.
165     * @param int   $site_id ID of the current site.
166     */
167    $raw_subscriptions         = apply_filters( 'earn_get_user_subscriptions_for_site_id', array(), $user_id, $site_id );
168    $abbreviated_subscriptions = WPCOM_Online_Subscription_Service::abbreviate_subscriptions( $raw_subscriptions );
169
170    return array( $user_id, $raw_subscriptions, $abbreviated_subscriptions );
171}
172
173/**
174 * Pre-warm the premium-content session cookie before output starts.
175 *
176 * `current_visitor_can_access()` runs during `the_content`, by which point headers are
177 * already sent and `setcookie()` is a no-op. This `template_redirect` callback runs earlier —
178 * after the main query resolves but before the template renders — so the self-heal cookie can
179 * actually persist for subsequent requests. It does work only on front-end page views that
180 * contain the block, for logged-in visitors who do not already have a valid cookie.
181 *
182 * @return void
183 */
184function prewarm_premium_content_session_cookie() {
185    if ( ! is_user_logged_in() ) {
186        return;
187    }
188
189    // Front-end page views only — skip admin, REST, feeds and cron.
190    if ( is_admin() || is_feed() || ( defined( 'REST_REQUEST' ) && REST_REQUEST ) || ( defined( 'DOING_CRON' ) && DOING_CRON ) ) {
191        return;
192    }
193
194    // Only on singular content that actually contains the block, so we never pay the filter
195    // round-trip on unrelated pages.
196    $queried = get_queried_object();
197    if ( ! ( $queried instanceof \WP_Post ) || ! has_block( 'premium-content/container', $queried ) ) {
198        return;
199    }
200
201    // Editors/authors of this post already bypass gating in current_visitor_can_access(), so
202    // there is no cookie to pre-warm for them — skip the Memberships filter round-trip.
203    if ( current_user_can( 'edit_post', $queried->ID ) ) {
204        return;
205    }
206
207    $paywall = subscription_service();
208
209    // Already have a valid cached session? Nothing to heal — and don't query the filter.
210    $existing_payload = $paywall->decode_token( $paywall->get_and_set_token_from_request() );
211    if ( ! empty( $existing_payload ) ) {
212        return;
213    }
214
215    list( $user_id, , $abbreviated_subscriptions ) = get_subscriptions_for_logged_in_user( $paywall );
216    maybe_renew_session_cookie( $paywall, $user_id, $abbreviated_subscriptions );
217}
218
219/**
220 * Determines if the current user can view the protected content of the given block.
221 *
222 * @param array  $attributes Block attributes.
223 * @param object $block Block to check.
224 *
225 * @return bool Whether the use can view the content.
226 */
227function current_visitor_can_access( $attributes, $block ) {
228    /**
229     * If the current WordPress install has as signed in user
230     * they can see the content.
231     */
232
233    if ( current_user_can_edit() ) {
234        return true;
235    }
236
237    $selected_plan_ids = array();
238
239    if ( isset( $attributes['selectedPlanIds'] ) ) {
240        $selected_plan_ids = $attributes['selectedPlanIds'];
241    } elseif ( isset( $attributes['selectedPlanId'] ) ) {
242        $selected_plan_ids = array( $attributes['selectedPlanId'] );
243    }
244
245    if ( isset( $block ) && ! empty( $block->context['premium-content/planId'] ) ) {
246        $selected_plan_ids = array( $block->context['premium-content/planId'] );
247    } elseif ( isset( $block ) && ! empty( $block->context['premium-content/planIds'] ) ) {
248        $selected_plan_ids = $block->context['premium-content/planIds'];
249    }
250
251    if ( empty( $selected_plan_ids ) ) {
252        return false;
253    }
254
255    $can_view = visitor_can_access_plan_ids( $selected_plan_ids );
256
257    if ( $can_view ) {
258        /**
259         * Fires when a visitor can view protected content on a site.
260         *
261         * @since 9.4.0
262         */
263        do_action( 'jetpack_earn_remove_cache_headers' );
264    }
265
266    return $can_view;
267}
268
269/**
270 * Check plan access for rendering, including the subscription service's editorial exception.
271 *
272 * Playback callers must use visitor_has_subscription_access_to_plan_ids() to exclude editorial access.
273 *
274 * @since $$next-version$$
275 *
276 * @param array    $selected_plan_ids Plan ids the content is gated behind.
277 * @param int|null $post_id           Post the gated content belongs to. Defaults to the loop post, so
278 *                                    callers outside the loop must pass it.
279 *
280 * @return bool Whether the visitor can view the content.
281 */
282function visitor_can_access_plan_ids( $selected_plan_ids, $post_id = null ) {
283    return check_subscription_plan_access( $selected_plan_ids, $post_id, false );
284}
285
286/**
287 * Check the required plans without granting access for editing the embedding post.
288 *
289 * @since $$next-version$$
290 *
291 * @param array    $selected_plan_ids Required plan IDs from the stored content.
292 * @param int|null $post_id           Post to check, or the loop post when omitted.
293 * @return bool Whether the visitor has the required subscription entitlement.
294 */
295function visitor_has_subscription_access_to_plan_ids( $selected_plan_ids, $post_id = null ) {
296    return check_subscription_plan_access( $selected_plan_ids, $post_id, true );
297}
298
299/**
300 * Evaluate subscription plans for rendering or strict playback authorization.
301 *
302 * @since $$next-version$$
303 *
304 * @param array    $selected_plan_ids   Required subscription plan IDs.
305 * @param int|null $post_id             Post to check.
306 * @param bool     $require_entitlement Whether editorial access must be excluded.
307 * @return bool Whether access is granted.
308 */
309function check_subscription_plan_access( $selected_plan_ids, $post_id, $require_entitlement ) {
310    // Callers outside the block render can get here first; this also defines the constants the paywall reads.
311    require_once JETPACK__PLUGIN_DIR . 'modules/memberships/class-jetpack-memberships.php';
312
313    $can_view     = false;
314    $paywall      = subscription_service();
315    $access_level = Abstract_Token_Subscription_Service::POST_ACCESS_LEVEL_PAID_SUBSCRIBERS; // Only paid subscribers should be granted access to the premium content
316    $tier_ids     = \Jetpack_Memberships::get_all_newsletter_plan_ids();
317    $tier_ids     = array_intersect( $tier_ids, $selected_plan_ids );
318    if ( ! empty( $tier_ids ) ) {
319        // If the selected plan is a tier, we want to check directly if user has a higher "tier".
320        // This is to prevent situation where the user upgrades and lose access to premium-gated content
321
322        $subscriptions = array();
323
324        // Cookie/token first (fast cached path, no WPCOM round-trip). Also covers anonymous
325        // visitors arriving via a `?token=` magic link, which takes precedence over the cookie.
326        $token   = $paywall->get_and_set_token_from_request();
327        $payload = $paywall->decode_token( $token );
328        if ( ! empty( $payload ) ) {
329            $subscriptions = (array) $payload['subscriptions'];
330        }
331
332        // No valid cookie yet, but logged in: consult the authoritative WPCOM filter. This is
333        // the first-visit / expired-cookie path; the template_redirect pre-warm hook mints the
334        // cookie for subsequent requests. Keeps CM-584 fixed (expired cookie still grants access).
335        if ( empty( $subscriptions ) && is_user_logged_in() ) {
336            list( , , $subscriptions ) = get_subscriptions_for_logged_in_user( $paywall );
337        }
338
339        foreach ( $tier_ids as $tier_id ) {
340            $can_view = ! $paywall->maybe_gate_access_for_user_if_tier( $tier_id, $subscriptions );
341            if ( $can_view ) {
342                break;
343            }
344        }
345
346        // Refresh-before-deny for the tier path. If the tier check denied access but the
347        // token already references a subscription whose product_id maps to one of the
348        // requested tiers, the most likely cause is a stale end_date from a renewal —
349        // attempt a single refresh against the WordPress.com token-refresh endpoint and
350        // re-check with the fresh subscriptions. Mirrors the same gate inside
351        // visitor_can_view_content() for the non-tier path.
352        if (
353            ! $can_view
354            && method_exists( $paywall, 'token_has_matching_product' )
355            && $paywall->token_has_matching_product( $tier_ids, $subscriptions )
356        ) {
357            $fresh_payload = $paywall->refresh_token_payload();
358            if ( ! empty( $fresh_payload ) ) {
359                $subscriptions = isset( $fresh_payload['subscriptions'] ) ? (array) $fresh_payload['subscriptions'] : array();
360                foreach ( $tier_ids as $tier_id ) {
361                    $can_view = ! $paywall->maybe_gate_access_for_user_if_tier( $tier_id, $subscriptions );
362                    if ( $can_view ) {
363                        break;
364                    }
365                }
366            }
367        }
368    }
369
370    $non_tier_ids = array_diff( $selected_plan_ids, $tier_ids );
371    if ( ! $can_view ) {
372        if ( $require_entitlement ) {
373            // Older or external services without the entitlement check deny.
374            $can_view = is_callable( array( $paywall, 'visitor_has_subscription_access' ) )
375                && $paywall->visitor_has_subscription_access( $non_tier_ids, $access_level, $post_id );
376        } else {
377            // For selected plans that are not tiers, we want to check if the user has any of the selected plans.
378            // @phan-suppress-next-line PhanParamTooMany -- Concrete services accept the optional $post_id; interface omits it on purpose.
379            $can_view = $paywall->visitor_can_view_content( $non_tier_ids, $access_level, $post_id );
380        }
381    }
382
383    return $can_view;
384}