/**
  * Move download permissions from original order to the new subscription created for the order.
  *
  * @param WC_Subscription $subscription A subscription object
  * @param int $subscription_item_id ID of the product line item on the subscription
  * @param WC_Order $original_order The original order that was created to purchase the subscription
  * @since 2.0
  */
 private static function migrate_download_permissions($subscription, $subscription_item_id, $order)
 {
     global $wpdb;
     $product_id = wcs_get_canonical_product_id(wcs_get_order_item($subscription_item_id, $subscription));
     $rows_affected = $wpdb->update($wpdb->prefix . 'woocommerce_downloadable_product_permissions', array('order_id' => $subscription->id, 'order_key' => $subscription->order_key), array('order_id' => $order->id, 'order_key' => $order->order_key, 'product_id' => $product_id, 'user_id' => absint($subscription->get_user_id())), array('%d', '%s'), array('%d', '%s', '%d', '%d'));
     WCS_Upgrade_Logger::add(sprintf('For subscription %d: migrated %d download permissions for product %d', $subscription->id, $rows_affected, $product_id));
 }

 /**
  * Checks a given product / coupon combination to determine if the subscription should be discounted
  *
  * @since 1.2
  */
 private static function is_subscription_discountable($cart_item, $coupon)
 {
     $product_cats = wp_get_post_terms($cart_item['product_id'], 'product_cat', array('fields' => 'ids'));
     $this_item_is_discounted = false;
     // Specific products get the discount
     if (sizeof($coupon->product_ids) > 0) {
         if (in_array(wcs_get_canonical_product_id($cart_item), $coupon->product_ids) || in_array($cart_item['data']->get_parent(), $coupon->product_ids)) {
             $this_item_is_discounted = true;
         }
         // Category discounts
     } elseif (sizeof($coupon->product_categories) > 0) {
         if (sizeof(array_intersect($product_cats, $coupon->product_categories)) > 0) {
             $this_item_is_discounted = true;
         }
     } else {
         // No product ids - all items discounted
         $this_item_is_discounted = true;
     }
     // Specific product ID's excluded from the discount
     if (sizeof($coupon->exclude_product_ids) > 0) {
         if (in_array(wcs_get_canonical_product_id($cart_item), $coupon->exclude_product_ids) || in_array($cart_item['data']->get_parent(), $coupon->exclude_product_ids)) {
             $this_item_is_discounted = false;
         }
     }
     // Specific categories excluded from the discount
     if (sizeof($coupon->exclude_product_categories) > 0) {
         if (sizeof(array_intersect($product_cats, $coupon->exclude_product_categories)) > 0) {
             $this_item_is_discounted = false;
         }
     }
     // Apply filter
     return apply_filters('woocommerce_item_is_discounted', $this_item_is_discounted, $cart_item, $before_tax = false);
 }

 /**
  * Returns the billing interval for a each subscription product in an order.
  *
  * For example, this would return 3 for a subscription charged every 3 months or 1 for a subscription charged every month.
  *
  * @param mixed $order A WC_Order object or the ID of the order which the subscription was purchased in.
  * @param int $product_id (optional) The post ID of the subscription WC_Product object purchased in the order. Defaults to the ID of the first product purchased in the order.
  * @return int The billing interval for a each subscription product in an order.
  * @since 1.0
  */
 public static function get_subscription_interval($order, $product_id = '')
 {
     _deprecated_function(__METHOD__, '2.0', 'the billing interval for each individual subscription object. Since Subscriptions v2.0, an order can be used to create multiple different subscriptions with different billing schedules, so use the subscription object');
     $billing_interval = '';
     foreach (wcs_get_subscriptions_for_order($order, array('order_type' => 'parent')) as $subscription) {
         // Find the billing interval for all recurring items
         if (empty($product_id)) {
             $billing_interval = $subscription->billing_interval;
             break;
         } else {
             // We want the billing interval for a specific item (so we need to find if this subscription contains that item)
             foreach ($subscription->get_items() as $line_item) {
                 if (wcs_get_canonical_product_id($line_item) == $product_id) {
                     $billing_interval = $subscription->billing_interval;
                     break 2;
                 }
             }
         }
     }
     return $billing_interval;
 }

 /**
  * When adding an item to an order/subscription via the Add/Edit Subscription administration interface, check if we should be setting
  * the sync meta on the subscription.
  *
  * @param int The order item ID of an item that was just added to the order
  * @param array The order item details
  * @since 2.0
  */
 public static function ajax_maybe_add_meta_for_item($item_id, $item)
 {
     check_ajax_referer('order-item', 'security');
     if (self::is_product_synced(wcs_get_canonical_product_id($item))) {
         self::maybe_add_subscription_meta(absint($_POST['order_id']));
     }
 }

 /**
  * Revoke download permissions granted on the old switch item.
  *
  * @since 2.0.9
  * @param WC_Subscription $subscription
  * @param array $new_item
  * @param array $old_item
  */
 public static function remove_download_permissions_after_switch($subscription, $new_item, $old_item)
 {
     if (!is_object($subscription)) {
         $subscription = wcs_get_subscription($subscription);
     }
     $product_id = wcs_get_canonical_product_id($old_item);
     WCS_Download_Handler::revoke_downloadable_file_permission($product_id, $subscription->id, $subscription->customer_user);
 }

 /**
  * Returns a cart item's product ID. For a variation, this will be a variation ID, for a simple product,
  * it will be the product's ID.
  *
  * @since 1.5
  */
 public static function get_items_product_id($cart_item)
 {
     _deprecated_function(__METHOD__, '2.0', 'wcs_get_canonical_product_id( $cart_item )');
     return wcs_get_canonical_product_id($cart_item);
 }

 /**
  * WooCommerce's function receives the original order ID, the item and the list of files. This does not work for
  * download permissions stored on the subscription rather than the original order as the URL would have the wrong order
  * key. This function takes the same parameters, but queries the database again for download ids belonging to all the
  * subscriptions that were in the original order. Then for all subscriptions, it checks all items, and if the item
  * passed in here is in that subscription, it creates the correct download link to be passsed to the email.
  *
  * @param array $files List of files already included in the list
  * @param array $item An item (you get it by doing $order->get_items())
  * @param WC_Order $order The original order
  * @return array List of files with correct download urls
  */
 public static function get_item_downloads($files, $item, $order)
 {
     global $wpdb;
     if (wcs_order_contains_subscription($order, 'any')) {
         $subscriptions = wcs_get_subscriptions_for_order($order, array('order_type' => array('any')));
     } else {
         return $files;
     }
     $product_id = wcs_get_canonical_product_id($item);
     foreach ($subscriptions as $subscription) {
         foreach ($subscription->get_items() as $subscription_item) {
             if (wcs_get_canonical_product_id($subscription_item) === $product_id) {
                 $files = $subscription->get_item_downloads($subscription_item);
             }
         }
     }
     return $files;
 }

 /**
  * Add a cart item to a subscription.
  *
  * @since 2.0
  */
 public static function add_cart_item($subscription, $cart_item, $cart_item_key)
 {
     $item_id = $subscription->add_product($cart_item['data'], $cart_item['quantity'], array('variation' => $cart_item['variation'], 'totals' => array('subtotal' => $cart_item['line_subtotal'], 'subtotal_tax' => $cart_item['line_subtotal_tax'], 'total' => $cart_item['line_total'], 'tax' => $cart_item['line_tax'], 'tax_data' => $cart_item['line_tax_data'])));
     if (!$item_id) {
         // translators: placeholder is an internal error number
         throw new Exception(sprintf(__('Error %d: Unable to create subscription. Please try again.', 'woocommerce-subscriptions'), 402));
     }
     $cart_item_product_id = 0 != $cart_item['variation_id'] ? $cart_item['variation_id'] : $cart_item['product_id'];
     if (WC_Subscriptions_Product::get_trial_length(wcs_get_canonical_product_id($cart_item)) > 0) {
         wc_add_order_item_meta($item_id, '_has_trial', 'true');
     }
     // Allow plugins to add order item meta
     do_action('woocommerce_add_order_item_meta', $item_id, $cart_item, $cart_item_key);
     do_action('woocommerce_add_subscription_item_meta', $item_id, $cart_item, $cart_item_key);
     return $item_id;
 }

 /**
  * Check if a given line item on the subscription had a sign-up fee, and if so, return the value of the sign-up fee.
  *
  * The single quantity sign-up fee will be returned instead of the total sign-up fee paid. For example, if 3 x a product
  * with a 10 BTC sign-up fee was purchased, a total 30 BTC was paid as the sign-up fee but this function will return 10 BTC.
  *
  * @param array|int Either an order item (in the array format returned by self::get_items()) or the ID of an order item.
  * @return bool
  * @since 2.0
  */
 public function get_items_sign_up_fee($line_item)
 {
     if (!is_array($line_item)) {
         $line_item = wcs_get_order_item($line_item, $this);
     }
     // If there was no original order, nothing was paid up-front which means no sign-up fee
     if (empty($this->order)) {
         $sign_up_fee = 0;
     } else {
         $original_order_item = '';
         // Find the matching item on the order
         foreach ($this->order->get_items() as $order_item) {
             if (wcs_get_canonical_product_id($line_item) == wcs_get_canonical_product_id($order_item)) {
                 $original_order_item = $order_item;
                 break;
             }
         }
         // No matching order item, so this item wasn't purchased in the original order
         if (empty($original_order_item)) {
             $sign_up_fee = 0;
         } elseif (isset($line_item['item_meta']['_has_trial'])) {
             // Sign up was was total amount paid for this item on original order
             $sign_up_fee = $original_order_item['line_total'] / $original_order_item['qty'];
         } else {
             // Sign-up fee is any amount on top of recurring amount
             $sign_up_fee = max($original_order_item['line_total'] / $original_order_item['qty'] - $line_item['line_total'] / $line_item['qty'], 0);
         }
     }
     return apply_filters('woocommerce_subscription_items_sign_up_fee', $sign_up_fee, $line_item, $this);
 }

 /**
  * Check if a given line item on the subscription had a sign-up fee, and if so, return the value of the sign-up fee.
  *
  * The single quantity sign-up fee will be returned instead of the total sign-up fee paid. For example, if 3 x a product
  * with a 10 BTC sign-up fee was purchased, a total 30 BTC was paid as the sign-up fee but this function will return 10 BTC.
  *
  * @param array|int Either an order item (in the array format returned by self::get_items()) or the ID of an order item.
  * @param  string $tax_inclusive_or_exclusive Whether or not to adjust sign up fee if prices inc tax - ensures that the sign up fee paid amount includes the paid tax if inc
  * @return bool
  * @since 2.0
  */
 public function get_items_sign_up_fee($line_item, $tax_inclusive_or_exclusive = 'exclusive_of_tax')
 {
     if (!is_array($line_item)) {
         $line_item = wcs_get_order_item($line_item, $this);
     }
     // If there was no original order, nothing was paid up-front which means no sign-up fee
     if (empty($this->order)) {
         $sign_up_fee = 0;
     } else {
         $original_order_item = '';
         // Find the matching item on the order
         foreach ($this->order->get_items() as $order_item) {
             if (wcs_get_canonical_product_id($line_item) == wcs_get_canonical_product_id($order_item)) {
                 $original_order_item = $order_item;
                 break;
             }
         }
         // No matching order item, so this item wasn't purchased in the original order
         if (empty($original_order_item)) {
             $sign_up_fee = 0;
         } elseif (isset($line_item['item_meta']['_has_trial'])) {
             // Sign up was was total amount paid for this item on original order
             $sign_up_fee = $original_order_item['line_total'] / $original_order_item['qty'];
         } else {
             // Sign-up fee is any amount on top of recurring amount
             $sign_up_fee = max($original_order_item['line_total'] / $original_order_item['qty'] - $line_item['line_total'] / $line_item['qty'], 0);
         }
         // If prices inc tax, ensure that the sign up fee amount includes the tax
         if ('inclusive_of_tax' === $tax_inclusive_or_exclusive && !empty($original_order_item) && 'yes' == $this->prices_include_tax) {
             $proportion = $sign_up_fee / ($original_order_item['line_total'] / $original_order_item['qty']);
             $sign_up_fee += round($original_order_item['line_tax'] * $proportion, 2);
         }
     }
     return apply_filters('woocommerce_subscription_items_sign_up_fee', $sign_up_fee, $line_item, $this, $tax_inclusive_or_exclusive);
 }

 /**
  * Check if a subscription was created prior to 2.0.0 and has some dates that need to be updated
  * because the meta was borked during the 2.0.0 upgrade process. If it does, then update the dates
  * to the new values.
  *
  * @return bool true if the subscription was repaired, otherwise false
  */
 protected static function maybe_repair_subscription($subscription)
 {
     $repaired_subscription = false;
     // if the subscription doesn't have an order, it must have been created in 2.0, so we can ignore it
     if (false === $subscription->order) {
         WCS_Upgrade_Logger::add(sprintf('For subscription %d: no need to repair: it has no order.', $subscription->id));
         return $repaired_subscription;
     }
     $subscription_line_items = $subscription->get_items();
     // if the subscription has more than one line item, it must have been created in 2.0, so we can ignore it
     if (count($subscription_line_items) > 1) {
         WCS_Upgrade_Logger::add(sprintf('For subscription %d: no need to repair: it has more than one line item.', $subscription->id));
         return $repaired_subscription;
     }
     $subscription_line_item_id = key($subscription_line_items);
     $subscription_line_item = array_shift($subscription_line_items);
     // Get old order item's meta
     foreach ($subscription->order->get_items() as $line_item_id => $line_item) {
         if (wcs_get_canonical_product_id($line_item) == wcs_get_canonical_product_id($subscription_line_item)) {
             $matching_line_item_id = $line_item_id;
             $matching_line_item = $line_item;
             break;
         }
     }
     // we couldn't find a matching line item so we can't repair it
     if (!isset($matching_line_item)) {
         WCS_Upgrade_Logger::add(sprintf('For subscription %d: can not repair: it has no matching line item.', $subscription->id));
         return $repaired_subscription;
     }
     $matching_line_item_meta = $matching_line_item['item_meta'];
     // if the order item doesn't have migrated subscription data, the subscription wasn't migrated from 1.5
     if (!isset($matching_line_item_meta['_wcs_migrated_subscription_status']) && !isset($matching_line_item_meta['_wcs_migrated_subscription_start_date'])) {
         WCS_Upgrade_Logger::add(sprintf('For subscription %d: no need to repair: matching line item has no migrated meta data.', $subscription->id));
         return $repaired_subscription;
     }
     if (false !== self::maybe_repair_line_tax_data($subscription_line_item_id, $matching_line_item_id, $matching_line_item)) {
         WCS_Upgrade_Logger::add(sprintf('For subscription %d: repaired missing line tax data.', $subscription->id));
         $repaired_subscription = true;
     } else {
         WCS_Upgrade_Logger::add(sprintf('For subscription %d: line tax data not added.', $subscription->id));
     }
     // if the subscription has been cancelled, we don't need to repair any other data
     if ($subscription->has_status(array('pending-cancel', 'cancelled'))) {
         WCS_Upgrade_Logger::add(sprintf('For subscription %d: no need to repair: it has cancelled status.', $subscription->id));
         return $repaired_subscription;
     }
     $dates_to_update = array();
     if (false !== ($repair_date = self::check_trial_end_date($subscription, $matching_line_item_meta))) {
         $dates_to_update['trial_end'] = $repair_date;
     }
     if (false !== ($repair_date = self::check_next_payment_date($subscription))) {
         $dates_to_update['next_payment'] = $repair_date;
     }
     if (false !== ($repair_date = self::check_end_date($subscription, $matching_line_item_meta))) {
         $dates_to_update['end'] = $repair_date;
     }
     if (!empty($dates_to_update)) {
         WCS_Upgrade_Logger::add(sprintf('For subscription %d: repairing dates = %s', $subscription->id, str_replace(array('{', '}', '"'), '', wcs_json_encode($dates_to_update))));
         try {
             $subscription->update_dates($dates_to_update);
             WCS_Upgrade_Logger::add(sprintf('For subscription %d: repaired dates = %s', $subscription->id, str_replace(array('{', '}', '"'), '', wcs_json_encode($dates_to_update))));
         } catch (Exception $e) {
             WCS_Upgrade_Logger::add(sprintf('!! For subscription %d: unable to repair dates (%s), exception "%s"', $subscription->id, str_replace(array('{', '}', '"'), '', wcs_json_encode($dates_to_update)), $e->getMessage()));
         }
         try {
             self::maybe_repair_status($subscription, $matching_line_item_meta, $dates_to_update);
         } catch (Exception $e) {
             WCS_Upgrade_Logger::add(sprintf('!! For subscription %d: unable to repair status. Exception: "%s"', $subscription->id, $e->getMessage()));
         }
         $repaired_subscription = true;
     }
     if (!empty($subscription->order->customer_note) && empty($subscription->customer_note)) {
         $post_data = array('ID' => $subscription->id, 'post_excerpt' => $subscription->order->customer_note);
         $updated_post_id = wp_update_post($post_data, true);
         if (!is_wp_error($updated_post_id)) {
             WCS_Upgrade_Logger::add(sprintf('For subscription %d: repaired missing customer note.', $subscription->id));
             $repaired_subscription = true;
         } else {
             WCS_Upgrade_Logger::add(sprintf('!! For subscription %d: unable to repair missing customer note. Exception: "%s"', $subscription->id, $updated_post_id->get_error_message()));
         }
     }
     return $repaired_subscription;
 }

 /**
  * Set the subscription prices to be used in calculating totals by @see WC_Subscriptions_Cart::calculate_subscription_totals()
  *
  * @since 2.0
  */
 public static function calculate_prorated_totals($cart)
 {
     if (false === self::cart_contains_switches()) {
         return;
     }
     // Maybe charge an initial amount to account for upgrading from a cheaper subscription
     $apportion_recurring_price = get_option(WC_Subscriptions_Admin::$option_prefix . '_apportion_recurring_price', 'no');
     $apportion_sign_up_fee = get_option(WC_Subscriptions_Admin::$option_prefix . '_apportion_sign_up_fee', 'no');
     $apportion_length = get_option(WC_Subscriptions_Admin::$option_prefix . '_apportion_length', 'no');
     foreach (WC()->cart->get_cart() as $cart_item_key => $cart_item) {
         if (!isset($cart_item['subscription_switch']['subscription_id'])) {
             continue;
         }
         $subscription = wcs_get_subscription($cart_item['subscription_switch']['subscription_id']);
         $existing_item = wcs_get_order_item($cart_item['subscription_switch']['item_id'], $subscription);
         if (empty($existing_item)) {
             WC()->cart->remove_cart_item($cart_item_key);
             continue;
         }
         $item_data = $cart_item['data'];
         $product_id = wcs_get_canonical_product_id($cart_item);
         $product = get_product($product_id);
         $is_virtual_product = $product->is_virtual();
         // Set when the first payment and end date for the new subscription should occur
         WC()->cart->cart_contents[$cart_item_key]['subscription_switch']['first_payment_timestamp'] = $cart_item['subscription_switch']['next_payment_timestamp'];
         WC()->cart->cart_contents[$cart_item_key]['subscription_switch']['end_timestamp'] = $end_timestamp = strtotime(WC_Subscriptions_Product::get_expiration_date($product_id, $subscription->get_date('last_payment')));
         // Add any extra sign up fees required to switch to the new subscription
         if ('yes' == $apportion_sign_up_fee) {
             // Because product add-ons etc. don't apply to sign-up fees, it's safe to use the product's sign-up fee value rather than the cart item's
             $sign_up_fee_due = $product->subscription_sign_up_fee;
             $sign_up_fee_paid = $subscription->get_items_sign_up_fee($existing_item);
             // Make sure total prorated sign-up fee is prorated across total amount of sign-up fee so that customer doesn't get extra discounts
             if ($cart_item['quantity'] > $existing_item['qty']) {
                 $sign_up_fee_paid = $sign_up_fee_paid * $existing_item['qty'] / $cart_item['quantity'];
             }
             WC()->cart->cart_contents[$cart_item_key]['data']->subscription_sign_up_fee = max($sign_up_fee_due - $sign_up_fee_paid, 0);
         } elseif ('no' == $apportion_sign_up_fee) {
             // $0 the initial sign-up fee
             WC()->cart->cart_contents[$cart_item_key]['data']->subscription_sign_up_fee = 0;
         }
         // Get the current subscription's last payment date
         $last_payment_timestamp = $subscription->get_time('last_payment');
         $days_since_last_payment = floor((gmdate('U') - $last_payment_timestamp) / (60 * 60 * 24));
         // Get the current subscription's next payment date
         $next_payment_timestamp = $cart_item['subscription_switch']['next_payment_timestamp'];
         $days_until_next_payment = ceil(($next_payment_timestamp - gmdate('U')) / (60 * 60 * 24));
         // Find the number of days between the two
         $days_in_old_cycle = $days_until_next_payment + $days_since_last_payment;
         // Find the actual recurring amount charged for the old subscription (we need to use the '_recurring_line_total' meta here rather than '_subscription_recurring_amount' because we want the recurring amount to include extra from extensions, like Product Add-ons etc.)
         $old_recurring_total = $existing_item['line_total'];
         if ('yes' == $subscription->prices_include_tax || true === $subscription->prices_include_tax) {
             // WC_Abstract_Order::$prices_include_tax can be set to true in __construct() or to 'yes' in populate()
             $old_recurring_total += $existing_item['line_tax'];
         }
         // Find the $price per day for the old subscription's recurring total
         $old_price_per_day = $old_recurring_total / $days_in_old_cycle;
         // Find the price per day for the new subscription's recurring total
         // If the subscription uses the same billing interval & cycle as the old subscription,
         if ($item_data->subscription_period == $subscription->billing_period && $item_data->subscription_period_interval == $subscription->billing_interval) {
             $days_in_new_cycle = $days_in_old_cycle;
             // Use $days_in_old_cycle to make sure they're consistent
         } else {
             // We need to figure out the price per day for the new subscription based on its billing schedule
             switch ($item_data->subscription_period) {
                 case 'day':
                     $days_in_new_cycle = $item_data->subscription_period_interval;
                     break;
                 case 'week':
                     $days_in_new_cycle = $item_data->subscription_period_interval * 7;
                     break;
                 case 'month':
                     $days_in_new_cycle = $item_data->subscription_period_interval * 30.4375;
                     // Average days per month over 4 year period
                     break;
                 case 'year':
                     $days_in_new_cycle = $item_data->subscription_period_interval * 365.25;
                     // Average days per year over 4 year period
                     break;
             }
         }
         // We need to use the cart items price to ensure we include extras added by extensions like Product Add-ons
         $new_price_per_day = $item_data->price * $cart_item['quantity'] / $days_in_new_cycle;
         if ($old_price_per_day < $new_price_per_day) {
             WC()->cart->cart_contents[$cart_item_key]['subscription_switch']['upgraded_or_downgraded'] = 'upgraded';
         } elseif ($old_price_per_day > $new_price_per_day && $new_price_per_day > 0) {
             WC()->cart->cart_contents[$cart_item_key]['subscription_switch']['upgraded_or_downgraded'] = 'downgraded';
         }
         // Now lets see if we should add a prorated amount to the sign-up fee (for upgrades) or extend the next payment date (for downgrades)
         if (in_array($apportion_recurring_price, array('yes', 'yes-upgrade')) || in_array($apportion_recurring_price, array('virtual', 'virtual-upgrade')) && $is_virtual_product) {
             // If the customer is upgrading, we may need to add a gap payment to the sign-up fee or to reduce the pre-paid period (or both)
             if ($old_price_per_day < $new_price_per_day) {
                 // The new subscription may be more expensive, but it's also on a shorter billing cycle, so reduce the next pre-paid term
                 if ($days_in_old_cycle > $days_in_new_cycle) {
                     // Find out how many days at the new price per day the customer would receive for the total amount already paid
                     // (e.g. if the customer paid $10 / month previously, and was switching to a $5 / week subscription, she has pre-paid 14 days at the new price)
//.........这里部分代码省略.........

 /**
  * Process the remove or re-add a line item from a subscription request.
  *
  * @since 2.0
  */
 public static function maybe_remove_or_add_item_to_subscription()
 {
     if (isset($_GET['subscription_id']) && (isset($_GET['remove_item']) || isset($_GET['undo_remove_item'])) && isset($_GET['_wpnonce'])) {
         $subscription = wcs_is_subscription($_GET['subscription_id']) ? wcs_get_subscription($_GET['subscription_id']) : false;
         $undo_request = isset($_GET['undo_remove_item']) ? true : false;
         $item_id = $undo_request ? $_GET['undo_remove_item'] : $_GET['remove_item'];
         if (false === $subscription) {
             wc_add_notice(sprintf(_x('Subscription #%d does not exist.', 'hash before subscription ID', 'woocommerce-subscriptions'), $_GET['subscription_id']), 'error');
             wp_safe_redirect(wc_get_page_permalink('myaccount'));
             exit;
         }
         if (self::validate_remove_items_request($subscription, $item_id, $undo_request)) {
             if ($undo_request) {
                 // handle undo request
                 $removed_item = WC()->session->get('removed_subscription_items', array());
                 if (!empty($removed_item[$item_id]) && $subscription->id == $removed_item[$item_id]) {
                     // restore the item
                     wc_update_order_item($item_id, array('order_item_type' => 'line_item'));
                     unset($removed_item[$item_id]);
                     WC()->session->set('removed_subscription_items', $removed_item);
                     // restore download permissions for this item
                     $line_items = $subscription->get_items();
                     $line_item = $line_items[$item_id];
                     $_product = $subscription->get_product_from_item($line_item);
                     $product_id = wcs_get_canonical_product_id($line_item);
                     if ($_product && $_product->exists() && $_product->is_downloadable()) {
                         $downloads = $_product->get_files();
                         foreach (array_keys($downloads) as $download_id) {
                             wc_downloadable_file_permission($download_id, $product_id, $subscription, $line_item['qty']);
                         }
                     }
                     // translators: 1$: product name, 2$: product id
                     $subscription->add_order_note(sprintf(_x('Customer added "%1$s" (Product ID: #%2$d) via the My Account page.', 'used in order note', 'woocommerce-subscriptions'), wcs_get_line_item_name($line_item), $product_id));
                 } else {
                     wc_add_notice(__('Your request to undo your previous action was unsuccessful.', 'woocommerce-subscriptions'));
                 }
             } else {
                 // handle remove item requests
                 WC()->session->set('removed_subscription_items', array($item_id => $subscription->id));
                 // remove download access for the item
                 $line_items = $subscription->get_items();
                 $line_item = $line_items[$item_id];
                 $product_id = wcs_get_canonical_product_id($line_item);
                 WCS_Download_Handler::revoke_downloadable_file_permission($product_id, $subscription->id, $subscription->get_user_id());
                 // remove the line item from subscription but preserve its data in the DB
                 wc_update_order_item($item_id, array('order_item_type' => 'line_item_removed'));
                 // translators: 1$: product name, 2$: product id
                 $subscription->add_order_note(sprintf(_x('Customer removed "%1$s" (Product ID: #%2$d) via the My Account page.', 'used in order note', 'woocommerce-subscriptions'), wcs_get_line_item_name($line_item), $product_id));
                 // translators: placeholders are 1$: item name, and, 2$: opening and, 3$: closing link tags
                 wc_add_notice(sprintf(__('You have successfully removed "%1$s" from your subscription. %2$sUndo?%3$s', 'woocommerce-subscriptions'), $line_item['name'], '<a href="' . esc_url(self::get_undo_remove_url($subscription->id, $item_id, $subscription->get_view_order_url())) . '" >', '</a>'));
             }
         }
         $subscription->calculate_totals();
         wp_safe_redirect($subscription->get_view_order_url());
         exit;
     }
 }

 /**
  * Creates a 2.0 updated version of the "subscriptions_switched" callback for developers to hook onto.
  *
  * The subscription passed to the new `woocommerce_subscriptions_switched_item` callback is strictly the subscription
  * to which the `$new_order_item` belongs to; this may be a new or the original subscription.
  *
  * @since 2.0.5
  * @param WC_Order $order
  */
 public static function maybe_add_switched_callback($order)
 {
     if (wcs_order_contains_switch($order)) {
         $subscriptions = wcs_get_subscriptions_for_order($order);
         foreach ($subscriptions as $subscription) {
             foreach ($subscription->get_items() as $new_order_item) {
                 if (isset($new_order_item['switched_subscription_item_id'])) {
                     $product_id = wcs_get_canonical_product_id($new_order_item);
                     // we need to check if the switch order contains the line item that has just been switched so that we don't call the hook on items that were previously switched in another order
                     foreach ($order->get_items() as $order_item) {
                         if (wcs_get_canonical_product_id($order_item) == $product_id) {
                             do_action('woocommerce_subscriptions_switched_item', $subscription, $new_order_item, WC_Subscriptions_Order::get_item_by_id($new_order_item['switched_subscription_item_id']));
                             break;
                         }
                     }
                 }
             }
         }
     }
 }