PHP WC_Subscriptions::is_woocommerce_pre方法代码示例

 /**
  * Show the subscription template when view a subscription instead of loading the default order template.
  *
  * @param $located
  * @param $template_name
  * @param $args
  * @param $template_path
  * @param $default_path
  * @since 2.0
  */
 public static function add_view_subscription_template($located, $template_name, $args, $template_path, $default_path)
 {
     global $wp;
     if ('myaccount/my-account.php' == $template_name && !empty($wp->query_vars['view-subscription']) && WC_Subscriptions::is_woocommerce_pre('2.6')) {
         $located = wc_locate_template('myaccount/view-subscription.php', $template_path, plugin_dir_path(WC_Subscriptions::$plugin_file) . 'templates/');
     }
     return $located;
 }

 /**
  * Create a simple subscription product object.
  *
  * @access public
  * @param mixed $product
  */
 public function __construct($product, $args = array())
 {
     parent::__construct($product, $args = array());
     $this->parent_product_type = $this->product_type;
     $this->product_type = 'subscription_variation';
     $this->subscription_variation_level_meta_data = array('subscription_price' => 0, 'subscription_period' => '', 'subscription_period_interval' => 'day', 'subscription_length' => 0, 'subscription_trial_length' => 0, 'subscription_trial_period' => 'day', 'subscription_sign_up_fee' => 0, 'subscription_payment_sync_date' => 0);
     if (WC_Subscriptions::is_woocommerce_pre('2.2')) {
         // WC 2.1
         // Convert selected subscription meta fields for easy access
         foreach ($this->subscription_variation_level_meta_data as $meta_key => $default_value) {
             if (!empty($this->product_custom_fields['_' . $meta_key][0])) {
                 $this->{$meta_key} = maybe_unserialize($this->product_custom_fields['_' . $meta_key][0]);
             } else {
                 $this->{$meta_key} = $this->subscription_variation_level_meta_data[$meta_key];
             }
         }
     } else {
         $this->variation_level_meta_data = array_merge($this->variation_level_meta_data, $this->subscription_variation_level_meta_data);
     }
 }

 /**
  * When a new order is inserted, add subscriptions related order meta.
  *
  * @since 1.0
  */
 public static function add_order_meta($order_id, $posted)
 {
     global $woocommerce;
     if (!WC_Subscriptions_Cart::cart_contains_subscription_renewal('child') && WC_Subscriptions_Order::order_contains_subscription($order_id)) {
         // This works because the 'woocommerce_add_order_item_meta' runs before the 'woocommerce_checkout_update_order_meta' hook
         // Set the recurring totals so totals display correctly on order page
         update_post_meta($order_id, '_order_recurring_discount_cart', WC_Subscriptions_Cart::get_recurring_discount_cart());
         update_post_meta($order_id, '_order_recurring_discount_cart_tax', WC_Subscriptions_Cart::get_recurring_discount_cart_tax());
         update_post_meta($order_id, '_order_recurring_discount_total', WC_Subscriptions_Cart::get_recurring_discount_total());
         update_post_meta($order_id, '_order_recurring_shipping_tax_total', WC_Subscriptions_Cart::get_recurring_shipping_tax_total());
         update_post_meta($order_id, '_order_recurring_shipping_total', WC_Subscriptions_Cart::get_recurring_shipping_total());
         update_post_meta($order_id, '_order_recurring_tax_total', WC_Subscriptions_Cart::get_recurring_total_tax());
         update_post_meta($order_id, '_order_recurring_total', WC_Subscriptions_Cart::get_recurring_total());
         // Set the recurring payment method - it starts out the same as the original by may change later
         update_post_meta($order_id, '_recurring_payment_method', get_post_meta($order_id, '_payment_method', true));
         update_post_meta($order_id, '_recurring_payment_method_title', get_post_meta($order_id, '_payment_method_title', true));
         $order = new WC_Order($order_id);
         $order_fees = $order->get_fees();
         // the fee order items have already been set, we just need to to add the recurring total meta
         $cart_fees = $woocommerce->cart->get_fees();
         foreach ($order->get_fees() as $item_id => $order_fee) {
             // Find the matching fee in the cart
             foreach ($cart_fees as $fee_index => $cart_fee) {
                 if (sanitize_title($order_fee['name']) == $cart_fee->id) {
                     woocommerce_add_order_item_meta($item_id, '_recurring_line_total', wc_format_decimal($cart_fee->recurring_amount));
                     woocommerce_add_order_item_meta($item_id, '_recurring_line_tax', wc_format_decimal($cart_fee->recurring_tax));
                     unset($cart_fees[$fee_index]);
                     break;
                 }
             }
         }
         // Get recurring taxes into same format as _order_taxes
         $order_recurring_taxes = array();
         foreach (WC_Subscriptions_Cart::get_recurring_taxes() as $tax_key => $tax_amount) {
             $item_id = woocommerce_add_order_item($order_id, array('order_item_name' => WC_Tax::get_rate_code($tax_key), 'order_item_type' => 'recurring_tax'));
             if ($item_id) {
                 wc_add_order_item_meta($item_id, 'rate_id', $tax_key);
                 wc_add_order_item_meta($item_id, 'label', WC_Tax::get_rate_label($tax_key));
                 wc_add_order_item_meta($item_id, 'compound', absint(WC_Tax::is_compound($tax_key) ? 1 : 0));
                 wc_add_order_item_meta($item_id, 'tax_amount', wc_format_decimal(isset(WC()->cart->recurring_taxes[$tax_key]) ? WC()->cart->recurring_taxes[$tax_key] : 0));
                 wc_add_order_item_meta($item_id, 'shipping_tax_amount', wc_format_decimal(isset(WC()->cart->recurring_shipping_taxes[$tax_key]) ? WC()->cart->recurring_shipping_taxes[$tax_key] : 0));
             }
         }
         $payment_gateways = $woocommerce->payment_gateways->payment_gateways();
         if ('yes' == get_option(WC_Subscriptions_Admin::$option_prefix . '_turn_off_automatic_payments', 'no')) {
             update_post_meta($order_id, '_wcs_requires_manual_renewal', 'true');
         } elseif (isset($payment_gateways[$posted['payment_method']]) && !$payment_gateways[$posted['payment_method']]->supports('subscriptions')) {
             update_post_meta($order_id, '_wcs_requires_manual_renewal', 'true');
         }
         $cart_item = WC_Subscriptions_Cart::cart_contains_subscription_renewal();
         if (isset($cart_item['subscription_renewal']) && 'parent' == $cart_item['subscription_renewal']['role']) {
             update_post_meta($order_id, '_original_order', $cart_item['subscription_renewal']['original_order']);
         }
         // WC 2.1+
         if (!WC_Subscriptions::is_woocommerce_pre('2.1')) {
             // Recurring coupons
             if ($applied_coupons = $woocommerce->cart->get_coupons()) {
                 foreach ($applied_coupons as $code => $coupon) {
                     if (!isset($woocommerce->cart->recurring_coupon_discount_amounts[$code])) {
                         continue;
                     }
                     $item_id = woocommerce_add_order_item($order_id, array('order_item_name' => $code, 'order_item_type' => 'recurring_coupon'));
                     // Add line item meta
                     if ($item_id) {
                         woocommerce_add_order_item_meta($item_id, 'discount_amount', isset($woocommerce->cart->recurring_coupon_discount_amounts[$code]) ? $woocommerce->cart->recurring_coupon_discount_amounts[$code] : 0);
                     }
                 }
             }
             // Add recurring shipping order items
             if (WC_Subscriptions_Cart::cart_contains_subscriptions_needing_shipping()) {
                 $packages = $woocommerce->shipping->get_packages();
                 $checkout = $woocommerce->checkout();
                 foreach ($packages as $i => $package) {
                     if (isset($package['rates'][$checkout->shipping_methods[$i]])) {
                         $method = $package['rates'][$checkout->shipping_methods[$i]];
                         $item_id = woocommerce_add_order_item($order_id, array('order_item_name' => $method->label, 'order_item_type' => 'recurring_shipping'));
                         if ($item_id) {
                             woocommerce_add_order_item_meta($item_id, 'method_id', $method->id);
                             woocommerce_add_order_item_meta($item_id, 'cost', WC_Subscriptions::format_total($method->cost));
                             woocommerce_add_order_item_meta($item_id, 'taxes', array_map('wc_format_decimal', $method->taxes));
                             do_action('woocommerce_subscriptions_add_recurring_shipping_order_item', $order_id, $item_id, $i);
                         }
                     }
                 }
             }
             // Remove shipping on original order if it was added but is not required
             if (!WC_Subscriptions_Cart::charge_shipping_up_front()) {
                 foreach ($order->get_shipping_methods() as $order_item_id => $shipping_method) {
                     woocommerce_update_order_item_meta($order_item_id, 'cost', WC_Subscriptions::format_total(0));
                 }
             }
         } else {
             update_post_meta($order_id, '_recurring_shipping_method', get_post_meta($order_id, '_shipping_method', true), true);
             update_post_meta($order_id, '_recurring_shipping_method_title', get_post_meta($order_id, '_shipping_method_title', true), true);
         }
//.........这里部分代码省略.........

 /**
  * Check if a renewal order subscription has any coupons applied and if so add pseudo renewal coupon equivalents to ensure the discount is still applied
  *
  * @param object $subscription subscription
  * @since 2.0.10
  */
 public function maybe_setup_discounts($subscription)
 {
     if (wcs_is_subscription($subscription)) {
         $used_coupons = $subscription->get_used_coupons();
         // Add any used coupon discounts to the cart (as best we can) using our pseudo renewal coupons
         if (!empty($used_coupons)) {
             $coupon_items = $subscription->get_items('coupon');
             foreach ($coupon_items as $coupon_item) {
                 $coupon = new WC_Coupon($coupon_item['name']);
                 $coupon_code = '';
                 // If the coupon still exists we can use the existing/available coupon properties
                 if (true === $coupon->exists) {
                     // But we only want to handle recurring coupons that have been applied to the subscription
                     if (in_array($coupon->type, array('recurring_percent', 'recurring_fee'))) {
                         // Set the coupon type to be a renewal equivalent for correct validation and calculations
                         if ('recurring_percent' == $coupon->type) {
                             $coupon->type = 'renewal_percent';
                         } elseif ('recurring_fee' == $coupon->type) {
                             $coupon->type = 'renewal_fee';
                         }
                         // Adjust coupon code to reflect that it is being applied to a renewal
                         $coupon_code = $coupon->code;
                     }
                 } else {
                     // If the coupon doesn't exist we can only really apply the discount amount we know about - so we'll apply a cart style pseudo coupon and then set the amount
                     $coupon->type = 'renewal_cart';
                     $coupon->amount = $coupon_item['item_meta']['discount_amount']['0'];
                     // Adjust coupon code to reflect that it is being applied to a renewal
                     $coupon_code = $coupon->code;
                 }
                 // Now that we have a coupon we know we want to apply
                 if (!empty($coupon_code)) {
                     // Set renewal order products as the product ids on the coupon
                     if (!WC_Subscriptions::is_woocommerce_pre('2.5')) {
                         $coupon->product_ids = $this->get_products($subscription);
                     }
                     // Store the coupon info for later
                     $this->store_coupon($subscription->id, $coupon);
                     // Add the coupon to the cart - the actually coupon values / data are grabbed when needed later
                     if (WC()->cart && !WC()->cart->has_discount($coupon_code)) {
                         WC()->cart->add_discount($coupon_code);
                     }
                 }
             }
             // If there are no coupons but there is still a discount (i.e. it might have been manually added), we need to account for that as well
         } elseif (!empty($subscription->cart_discount)) {
             $coupon = new WC_Coupon('discount_renewal');
             // Apply our cart style pseudo coupon and the set the amount
             $coupon->type = 'renewal_cart';
             $coupon->amount = $subscription->cart_discount;
             // Set renewal order products as the product ids on the coupon
             if (!WC_Subscriptions::is_woocommerce_pre('2.5')) {
                 $coupon->product_ids = $this->get_products($subscription);
             }
             // Store the coupon info for later
             $this->store_coupon($subscription->id, $coupon);
             // Add the coupon to the cart
             if (WC()->cart && !WC()->cart->has_discount('discount_renewal')) {
                 WC()->cart->add_discount('discount_renewal');
             }
         }
     }
 }

 /**
  * Save variation meta data when it is bulk edited from the Edit Product screen
  *
  * @param string $bulk_action The bulk edit action being performed
  * @param array $data An array of data relating to the bulk edit action. $data['value'] represents the new value for the meta.
  * @param int $variable_product_id The post ID of the parent variable product.
  * @param array $variation_ids An array of post IDs for the variable prodcut's variations.
  * @since 1.5.29
  */
 public static function bulk_edit_variations($bulk_action, $data, $variable_product_id, $variation_ids)
 {
     if (!isset($data['value'])) {
         return;
     } elseif (WC_Subscriptions::is_woocommerce_pre('2.5')) {
         // Pre 2.5 we don't have the product type information available so we have to check if it is a subscription - downside here is this only works if the product has already been saved
         if (!self::is_subscription($variable_product_id)) {
             return;
         }
     } else {
         // Since 2.5 we have the product type information available so we don't have to wait for the product to be saved to check if it is a subscription
         if (empty($_POST['security']) || !wp_verify_nonce($_POST['security'], 'bulk-edit-variations') || 'variable-subscription' !== $_POST['product_type']) {
             return;
         }
     }
     $meta_key = str_replace('variable', '', $bulk_action);
     // Update the subscription price when updating regular price on a variable subscription product
     if ('_regular_price' == $meta_key) {
         $meta_key = '_subscription_price';
     }
     if (in_array($meta_key, self::$subscription_meta_fields)) {
         foreach ($variation_ids as $variation_id) {
             update_post_meta($variation_id, $meta_key, stripslashes($data['value']));
         }
     } elseif (in_array($meta_key, array('_regular_price_increase', '_regular_price_decrease'))) {
         $operator = '_regular_price_increase' == $meta_key ? '+' : '-';
         $value = wc_clean($data['value']);
         foreach ($variation_ids as $variation_id) {
             $subscription_price = get_post_meta($variation_id, '_subscription_price', true);
             if ('%' === substr($value, -1)) {
                 $percent = wc_format_decimal(substr($value, 0, -1));
                 $subscription_price += $subscription_price / 100 * $percent * "{$operator}1";
             } else {
                 $subscription_price += $value * "{$operator}1";
             }
             update_post_meta($variation_id, '_subscription_price', $subscription_price);
         }
     }
 }

 /**
  * Save variation meta data when it is bulk edited from the Edit Product screen
  *
  * @param string $bulk_action The bulk edit action being performed
  * @param array $data An array of data relating to the bulk edit action. $data['value'] represents the new value for the meta.
  * @param int $variable_product_id The post ID of the parent variable product.
  * @param array $variation_ids An array of post IDs for the variable prodcut's variations.
  * @since 1.5.29
  */
 public static function bulk_edit_variations($bulk_action, $data, $variable_product_id, $variation_ids)
 {
     if (WC_Subscriptions::is_woocommerce_pre('2.5')) {
         // Pre 2.5 we don't have the product type information available so we have to check if it is a subscription - downside here is this only works if the product has already been saved
         if (!self::is_subscription($variable_product_id)) {
             return;
         }
     } else {
         // Since 2.5 we have the product type information available so we don't have to wait for the product to be saved to check if it is a subscription
         if (empty($_POST['security']) || !wp_verify_nonce($_POST['security'], 'bulk-edit-variations') || 'variable-subscription' !== $_POST['product_type']) {
             return;
         }
     }
     $meta_key = str_replace('variable', '', $bulk_action);
     // Update the subscription price when updating regular price on a variable subscription product
     if ('_regular_price' == $meta_key) {
         $meta_key = '_subscription_price';
     }
     if (in_array($meta_key, self::$subscription_meta_fields)) {
         foreach ($variation_ids as $variation_id) {
             update_post_meta($variation_id, $meta_key, stripslashes($data['value']));
         }
     }
 }

 /**
  * Generate an order items table using a WC compatible version of the function.
  *
  * @param object $order
  * @param array $args {
  *     @type bool  'show_download_links'
  *     @type bool  'show_sku'
  *     @type bool  'show_purchase_note'
  *     @type array 'image_size'
  *     @type bool  'plain_text'
  * }
  * @return string email order items table html
  */
 public static function email_order_items_table($order, $args = array())
 {
     $items_table = '';
     if (is_numeric($order)) {
         $order = wc_get_order($order);
     }
     if (is_a($order, 'WC_Abstract_Order')) {
         if (WC_Subscriptions::is_woocommerce_pre('2.5')) {
             $items_table = call_user_func_array(array($order, 'email_order_items_table'), $args);
         } else {
             // 2.5 doesn't support both the show_download_links or show_purchase_note parameters but uses $order->is_download_permitted and  $order->is_paid instead
             $show_download_links_callback = isset($args['show_download_links']) && $args['show_download_links'] ? '__return_true' : '__return_false';
             $show_purchase_note_callback = isset($args['show_purchase_note']) && $args['show_purchase_note'] ? '__return_true' : '__return_false';
             unset($args['show_download_links']);
             unset($args['show_purchase_note']);
             add_filter('woocommerce_order_is_download_permitted', $show_download_links_callback);
             add_filter('woocommerce_order_is_paid', $show_purchase_note_callback);
             $items_table = $order->email_order_items_table($args);
             remove_filter('woocommerce_order_is_download_permitted', $show_download_links_callback);
             remove_filter('woocommerce_order_is_paid', $show_purchase_note_callback);
         }
     }
     return $items_table;
 }

 /**
  * Add the sync setting fields to the variation section of the Edit Product screen
  *
  * @since 1.5
  */
 public static function variable_subscription_product_fields($loop, $variation_data, $variation)
 {
     if (self::is_syncing_enabled()) {
         // Set month as the default billing period
         if (!($subscription_period = get_post_meta($variation->ID, '_subscription_period', true))) {
             $subscription_period = 'month';
         }
         $display_week_month_select = !in_array($subscription_period, array('month', 'week')) ? ' style="display: none;"' : '';
         $display_annual_select = 'year' != $subscription_period ? ' style="display: none;"' : '';
         $payment_day = self::get_products_payment_day($variation->ID);
         // An annual sync date is already set in the form: array( 'day' => 'nn', 'month' => 'nn' ), create a MySQL string from those values (year and time are irrelvent as they are ignored)
         if (is_array($payment_day)) {
             $payment_month = $payment_day['month'];
             $payment_day = $payment_day['day'];
         } else {
             $payment_month = date('m');
         }
         if (WC_Subscriptions::is_woocommerce_pre('2.3')) {
             include plugin_dir_path(WC_Subscriptions::$plugin_file) . 'templates/admin/deprecated/html-variation-synchronisation.php';
         } else {
             include plugin_dir_path(WC_Subscriptions::$plugin_file) . 'templates/admin/html-variation-synchronisation.php';
         }
     }
 }

 /**
  * If the order is a renewal order, don't send core emails.
  *
  * @param int $user_id The ID of the user who the subscription belongs to
  * @param string $subscription_key A subscription key of the form created by @see self::get_subscription_key()
  * @return void
  */
 public static function maybe_reattach_woocommerce_email($order_id)
 {
     global $woocommerce;
     if (WC_Subscriptions_Renewal_Order::is_renewal($order_id, array('order_role' => 'child')) || WC_Subscriptions_Switcher::order_contains_subscription_switch($order_id)) {
         if (WC_Subscriptions::is_woocommerce_pre('2.3')) {
             add_action(current_filter(), array($woocommerce, 'send_transactional_email'));
         } else {
             add_action(current_filter(), array('WC_Emails', 'send_transactional_email'));
         }
     }
 }

 /**
  * Set the chosen shipping method for recurring cart calculations
  *
  * In WC_Shipping::calculate_shipping(), WooCommerce tries to determine the chosen shipping method
  * based on the package index and stores rates. However, for recurring cart shipping selection, we
  * use the recurring cart key instead of numeric index. Therefore, we need to hook in to override
  * the default shipping method when WooCommerce could not find a matching shipping method.
  *
  * @param string $default_method the default shipping method for the customer/store returned by WC_Shipping::get_default_method()
  * @param array $available_methods set of shipping rates for this calculation
  * @param int $package_index WC doesn't pass the package index to callbacks on the 'woocommerce_shipping_chosen_method' filter (yet) so we set a default value of 0 for it in the function params
  * @since 2.0.12
  */
 public static function set_chosen_shipping_method($default_method, $available_methods, $package_index = 0)
 {
     $chosen_methods = WC()->session->get('chosen_shipping_methods');
     $recurring_cart_package_key = self::get_recurring_shipping_package_key(self::$recurring_cart_key, $package_index);
     if ('none' !== self::$recurring_cart_key && isset($chosen_methods[$recurring_cart_package_key]) && isset($available_methods[$chosen_methods[$recurring_cart_package_key]])) {
         $default_method = $chosen_methods[$recurring_cart_package_key];
         // Our dummy rate ended up being set as the default method (probably because it has no priority) so we need to re-run some logic from WC_Shipping::get_default_method() to find the actual default method
     } elseif ('wcs_dummy_rate' === $default_method && !empty($available_methods)) {
         unset($available_methods['wcs_dummy_rate']);
         // Order by priorities and costs
         $selection_priority = get_option('woocommerce_shipping_method_selection_priority', array());
         $prioritized_methods = array();
         foreach ($available_methods as $method_key => $method) {
             // Some IDs contain : if they have multiple rates so use $method->method_id
             $priority = isset($selection_priority[$method->method_id]) ? absint($selection_priority[$method->method_id]) : 1;
             if (empty($prioritized_methods[$priority])) {
                 $prioritized_methods[$priority] = array();
             }
             $prioritized_methods[$priority][$method_key] = $method->cost;
         }
         ksort($prioritized_methods);
         $prioritized_methods = current($prioritized_methods);
         asort($prioritized_methods);
         $default_method = current(array_keys($prioritized_methods));
         // Set the chosen shipping method (if available) to workaround a bug with WC_Shipping::get_default_method() in WC < 2.6 which leads to the default shipping method always being used instead of a valid chosen shipping method
     } elseif (isset($chosen_methods[$package_index]) && $default_method !== $chosen_methods[$package_index] && WC_Subscriptions::is_woocommerce_pre('2.6')) {
         $default_method = $chosen_methods[$package_index];
     }
     return $default_method;
 }

    /**
     * Prompt the store manager to enter their PayPal API credentials if they are using
     * PayPal and have yet not entered their API credentials.
     *
     * @return void
     */
    public static function maybe_show_admin_notice()
    {
        if (isset($_GET['wcs_disable_paypal_invalid_profile_id_notice'])) {
            update_option('wcs_paypal_invalid_profile_id', 'disabled');
        }
        // Check if the API credentials are being saved - we can't do this on the 'woocommerce_update_options_payment_gateways_paypal' hook because it is triggered after 'admin_notices'
        if (isset($_POST['woocommerce_paypal_api_username']) || isset($_POST['woocommerce_paypal_api_password']) || isset($_POST['woocommerce_paypal_api_signature'])) {
            $current_options = self::get_wc_paypal_settings();
            $credentials_updated = false;
            if (isset($_POST['woocommerce_paypal_api_username']) && $_POST['woocommerce_paypal_api_username'] != $current_options['api_username']) {
                $credentials_updated = true;
            } elseif (isset($_POST['woocommerce_paypal_api_password']) && $_POST['woocommerce_paypal_api_password'] != $current_options['api_password']) {
                $credentials_updated = true;
            } elseif (isset($_POST['woocommerce_paypal_api_signature']) && $_POST['woocommerce_paypal_api_signature'] != $current_options['api_signature']) {
                $credentials_updated = true;
            }
            if ($credentials_updated) {
                delete_option('wcs_paypal_credentials_error');
            }
        }
        if (!in_array(get_woocommerce_currency(), apply_filters('woocommerce_paypal_supported_currencies', array('AUD', 'BRL', 'CAD', 'MXN', 'NZD', 'HKD', 'SGD', 'USD', 'EUR', 'JPY', 'TRY', 'NOK', 'CZK', 'DKK', 'HUF', 'ILS', 'MYR', 'PHP', 'PLN', 'SEK', 'CHF', 'TWD', 'THB', 'GBP', 'RMB')))) {
            $valid_for_use = false;
        } else {
            $valid_for_use = true;
        }
        if (WC_Subscriptions::is_woocommerce_pre('2.1')) {
            $payment_gateway_tab_url = admin_url('admin.php?page=woocommerce_settings&tab=payment_gateways&section=WC_Gateway_Paypal');
        } else {
            $payment_gateway_tab_url = admin_url('admin.php?page=wc-settings&tab=checkout&section=wc_gateway_paypal');
        }
        if (!self::are_credentials_set() && $valid_for_use && 'yes' == self::$paypal_settings['enabled'] && !has_action('admin_notices', 'WC_Subscriptions_Admin::admin_installed_notice') && current_user_can('manage_options')) {
            ?>
<div id="message" class="updated error">
	<p><?php 
            printf(__('PayPal is inactive for subscription transactions. Please %sset up the PayPal IPN%s and %senter your API credentials%s to enable PayPal for Subscriptions.', 'woocommerce-subscriptions'), '<a href="http://docs.woothemes.com/document/subscriptions/store-manager-guide/#section-4" target="_blank">', '</a>', '<a href="' . $payment_gateway_tab_url . '">', '</a>');
            ?>
	</p>
</div>
<?php 
        }
        if (false !== get_option('wcs_paypal_credentials_error')) {
            ?>
<div id="message" class="updated error">
	<p><?php 
            printf(__('There is a problem with PayPal. Your API credentials may be incorrect. Please update your %sAPI credentials%s. %sLearn more%s.', 'woocommerce-subscriptions'), '<a href="' . $payment_gateway_tab_url . '">', '</a>', '<a href="https://support.woothemes.com/hc/en-us/articles/202882473#paypal-credentials" target="_blank">', '</a>');
            ?>
	</p>
</div>
<?php 
        }
        if ('yes' == get_option('wcs_paypal_invalid_profile_id')) {
            ?>
<div id="message" class="updated error">
	<p><?php 
            printf(__('There is a problem with PayPal. Your PayPal account is issuing out-of-date subscription IDs. %sLearn more%s. %sDismiss%s.', 'woocommerce-subscriptions'), '<a href="https://support.woothemes.com/hc/en-us/articles/202882473#old-paypal-account" target="_blank">', '</a>', '<a href="' . esc_url(add_query_arg('wcs_disable_paypal_invalid_profile_id_notice', 'true')) . '">', '</a>');
            ?>
	</p>
</div>
<?php 
        }
    }

//.........这里部分代码省略.........
                 if (isset($sign_up_tax['cart_tax']) && $sign_up_tax['cart_tax'] > 0) {
                     $order_taxes[$index]['cart_tax'] += $sign_up_tax['cart_tax'];
                 }
             }
         }
         if (false == self::$is_wc_version_2) {
             // Doing it right: updated Subs *before* updating WooCommerce, the WooCommerce updater will take care of data migration
             update_post_meta($order_id, '_order_taxes', $order_taxes);
         } else {
             // Doing it wrong: updated Subs *after* updating WooCommerce, need to store in WC2.0 tax structure
             $index = 0;
             $new_order_taxes = $order->get_taxes();
             foreach ($new_order_taxes as $item_id => $order_tax) {
                 $index = $index + 1;
                 if (!isset($order_taxes[$index]['label']) || !isset($order_taxes[$index]['cart_tax']) || !isset($order_taxes[$index]['shipping_tax'])) {
                     continue;
                 }
                 // Add line item meta
                 if ($item_id) {
                     woocommerce_update_order_item_meta($item_id, 'compound', absint(isset($order_taxes[$index]['compound']) ? $order_taxes[$index]['compound'] : 0));
                     woocommerce_update_order_item_meta($item_id, 'tax_amount', WC_Subscriptions::format_total($order_taxes[$index]['cart_tax']));
                     woocommerce_update_order_item_meta($item_id, 'shipping_tax_amount', WC_Subscriptions::format_total($order_taxes[$index]['shipping_tax']));
                 }
             }
         }
         /* Upgrade each order item to use new Item Meta schema */
         $order_subscription_periods = WC_Subscriptions_Order::get_meta($order_id, '_order_subscription_periods', array());
         $order_subscription_intervals = WC_Subscriptions_Order::get_meta($order_id, '_order_subscription_intervals', array());
         $order_subscription_lengths = WC_Subscriptions_Order::get_meta($order_id, '_order_subscription_lengths', array());
         $order_subscription_trial_lengths = WC_Subscriptions_Order::get_meta($order_id, '_order_subscription_trial_lengths', array());
         $order_items = $order->get_items();
         foreach ($order_items as $index => $order_item) {
             $product_id = WC_Subscriptions_Order::get_items_product_id($order_item);
             if (WC_Subscriptions::is_woocommerce_pre('2.4')) {
                 $item_meta = new WC_Order_Item_Meta($order_item['item_meta']);
             } else {
                 $item_meta = new WC_Order_Item_Meta($order_item);
             }
             $subscription_interval = isset($order_subscription_intervals[$product_id]) ? $order_subscription_intervals[$product_id] : 1;
             $subscription_length = isset($order_subscription_lengths[$product_id]) ? $order_subscription_lengths[$product_id] : 0;
             $subscription_trial_length = isset($order_subscription_trial_lengths[$product_id]) ? $order_subscription_trial_lengths[$product_id] : 0;
             $subscription_sign_up_fee = WC_Subscriptions_Order::get_meta($order, '_cart_contents_sign_up_fee_total', 0);
             if ($sign_up_fee_total > 0) {
                 // Discounted price * Quantity
                 $sign_up_fee_line_total = WC_Subscriptions_Order::get_meta($order, '_cart_contents_sign_up_fee_total', 0);
                 $sign_up_fee_line_tax = WC_Subscriptions_Order::get_meta($order, '_sign_up_fee_tax_total', 0);
                 // Base price * Quantity
                 $sign_up_fee_line_subtotal = WC_Subscriptions_Order::get_meta($order, '_cart_contents_sign_up_fee_total', 0) + WC_Subscriptions_Order::get_meta($order, '_sign_up_fee_discount_cart', 0);
                 $sign_up_fee_propotion = $sign_up_fee_line_total > 0 ? $sign_up_fee_line_subtotal / $sign_up_fee_line_total : 0;
                 $sign_up_fee_line_subtotal_tax = WC_Subscriptions_Manager::get_amount_from_proportion(WC_Subscriptions_Order::get_meta($order, '_sign_up_fee_tax_total', 0), $sign_up_fee_propotion);
                 if ($has_trial) {
                     // Set line item totals equal to sign up fee totals
                     $order_item['line_subtotal'] = $sign_up_fee_line_subtotal;
                     $order_item['line_subtotal_tax'] = $sign_up_fee_line_subtotal_tax;
                     $order_item['line_total'] = $sign_up_fee_line_total;
                     $order_item['line_tax'] = $sign_up_fee_line_tax;
                 } else {
                     // No trial period, sign up fees need to be added to order totals
                     $order_item['line_subtotal'] += $sign_up_fee_line_subtotal;
                     $order_item['line_subtotal_tax'] += $sign_up_fee_line_subtotal_tax;
                     $order_item['line_total'] += $sign_up_fee_line_total;
                     $order_item['line_tax'] += $sign_up_fee_line_tax;
                 }
             }
             // Upgrading with WC 1.x
             if (method_exists($item_meta, 'add')) {

 /**
  * Parse recurring shipping rates from the front end and put them into the $_POST['shipping_method'] used by WooCommerce.
  *
  * When WooCommerce takes the value of inputs for shipping methods selection from the cart and checkout pages, it uses a
  * JavaScript array and therefore, can only use numerical indexes. This works for WC core, because it only needs shipping
  * selection for different packages. However, we want to use string indexes to differentiate between different recurring
  * cart shipping selection inputs *and* packages. To do this, we need to get our shipping methods from the $_POST['post_data']
  * values and manually add them $_POST['shipping_method'] array.
  *
  * We can't do this on the cart page unfortunately because it doesn't pass the entire forms post data and instead only
  * sends the shipping methods with a numerical index.
  *
  * @return null
  * @since 2.0.12
  */
 public static function add_shipping_method_post_data()
 {
     if (!WC_Subscriptions::is_woocommerce_pre('2.6')) {
         return;
     }
     check_ajax_referer('update-order-review', 'security');
     parse_str($_POST['post_data'], $form_data);
     // In case we have only free trials/sync'd products in the cart and shipping methods aren't being displayed
     if (!isset($_POST['shipping_method'])) {
         $_POST['shipping_method'] = array();
     }
     if (!isset($form_data['shipping_method'])) {
         $form_data['shipping_method'] = array();
     }
     foreach ($form_data['shipping_method'] as $key => $methods) {
         if (!is_numeric($key) && !array_key_exists($key, $_POST['shipping_method'])) {
             $_POST['shipping_method'][$key] = $methods;
         }
     }
 }

 /**
  * Restore renewal flag when cart is reset and modify Product object with
  * renewal order related info
  *
  * @since 1.3
  */
 public static function get_cart_item_from_session($session_data, $values, $key)
 {
     if (isset($values['subscription_renewal'])) {
         $session_data['subscription_renewal'] = $values['subscription_renewal'];
         // Need to get the original order price, not the current price
         $original_order_id = $values['subscription_renewal']['original_order'];
         $order_items = WC_Subscriptions_Order::get_recurring_items($original_order_id);
         $first_order_item = reset($order_items);
         $price = $first_order_item['subscription_recurring_amount'];
         /*
          * Modify the Cart $_product object.
          * All the cart calculations and cart/checkout/mini-cart displays will use this object.
          * So by modifying it here, we take care of all those cases.
          */
         $_product = $session_data['data'];
         $_product->price = $price;
         // Don't carry over any sign up fee
         $_product->subscription_sign_up_fee = 0;
         if (WC_Subscriptions::is_woocommerce_pre('2.2')) {
             $_product->product_custom_fields['_subscription_sign_up_fee'][0] = 0;
         }
         // Make sure the original subscription terms perisist
         if ('parent' == $session_data['subscription_renewal']['role']) {
             $_product->subscription_price = $price;
             $_product->subscription_period = $first_order_item['subscription_period'];
             $_product->subscription_period_interval = $first_order_item['subscription_interval'];
             $_product->subscription_trial_period = $first_order_item['subscription_trial_period'];
             $_product->subscription_length = $first_order_item['subscription_length'];
             // Never give a free trial period again
             $_product->subscription_trial_length = 0;
             if (WC_Subscriptions::is_woocommerce_pre('2.2')) {
                 $_product->product_custom_fields['_subscription_price'][0] = $price;
                 $_product->product_custom_fields['_subscription_period'][0] = $first_order_item['subscription_period'];
                 $_product->product_custom_fields['_subscription_period_interval'][0] = $first_order_item['subscription_interval'];
                 $_product->product_custom_fields['_subscription_trial_period'][0] = $first_order_item['subscription_trial_period'];
                 $_product->product_custom_fields['_subscription_length'][0] = $first_order_item['subscription_length'];
                 $_product->product_custom_fields['_subscription_trial_length'][0] = 0;
             }
         }
         $_product->post->post_title = apply_filters('woocommerce_subscriptions_renewal_product_title', $_product->get_title(), $_product);
         // Make sure the same quantity is renewed
         $session_data['quantity'] = $first_order_item['qty'];
     }
     return $session_data;
 }

 /**
  * Apply sign up fee or recurring fee discount
  *
  * @since 1.2
  */
 public static function apply_subscription_discount($original_price, $cart_item, $cart)
 {
     _deprecated_function(__METHOD__, '2.0.10', 'Have moved to filtering on "woocommerce_coupon_get_discount_amount" to return discount amount. See: ' . __CLASS__ . '::get_discount_amount()');
     $product_id = $cart_item['data']->is_type(array('subscription_variation')) ? $cart_item['data']->variation_id : $cart_item['data']->id;
     if (!WC_Subscriptions_Product::is_subscription($product_id)) {
         return $original_price;
     }
     $price = $calculation_price = $original_price;
     $calculation_type = WC_Subscriptions_Cart::get_calculation_type();
     if (!empty($cart->applied_coupons)) {
         foreach ($cart->applied_coupons as $code) {
             $coupon = new WC_Coupon($code);
             // Pre 2.5 is_valid_for_product() does not use wc_get_product_coupon_types()
             if (WC_Subscriptions::is_woocommerce_pre('2.5')) {
                 $is_valid_for_product = true;
             } else {
                 $is_valid_for_product = $coupon->is_valid_for_product(wc_get_product($product_id), $cart_item);
             }
             if ($coupon->apply_before_tax() && $coupon->is_valid() && $is_valid_for_product) {
                 $apply_recurring_coupon = $apply_recurring_percent_coupon = $apply_initial_coupon = $apply_initial_percent_coupon = false;
                 // Apply recurring fee discounts to recurring total calculations
                 if ('recurring_total' == $calculation_type) {
                     $apply_recurring_coupon = 'recurring_fee' == $coupon->type ? true : false;
                     $apply_recurring_percent_coupon = 'recurring_percent' == $coupon->type ? true : false;
                 }
                 if ('none' == $calculation_type) {
                     // If all items have a free trial we don't need to apply recurring coupons to the initial total
                     if (!WC_Subscriptions_Cart::all_cart_items_have_free_trial()) {
                         if ('recurring_fee' == $coupon->type) {
                             $apply_initial_coupon = true;
                         }
                         if ('recurring_percent' == $coupon->type) {
                             $apply_initial_percent_coupon = true;
                         }
                     }
                     // Apply sign-up discounts to initial total
                     if (!empty($cart_item['data']->subscription_sign_up_fee)) {
                         if ('sign_up_fee' == $coupon->type) {
                             $apply_initial_coupon = true;
                         }
                         if ('sign_up_fee_percent' == $coupon->type) {
                             $apply_initial_percent_coupon = true;
                         }
                         $calculation_price = $cart_item['data']->subscription_sign_up_fee;
                     }
                 }
                 if ($apply_recurring_coupon || $apply_initial_coupon) {
                     $discount_amount = $calculation_price < $coupon->amount ? $calculation_price : $coupon->amount;
                     // Recurring coupons only apply when there is no free trial (carts can have a mix of free trial and non free trial items)
                     if ($apply_initial_coupon && 'recurring_fee' == $coupon->type && !empty($cart_item['data']->subscription_trial_length)) {
                         $discount_amount = 0;
                     }
                     $cart->discount_cart = $cart->discount_cart + $discount_amount * $cart_item['quantity'];
                     $cart = self::increase_coupon_discount_amount($cart, $coupon->code, $discount_amount * $cart_item['quantity']);
                     $price = $price - $discount_amount;
                 } elseif ($apply_recurring_percent_coupon) {
                     $discount_amount = round($calculation_price / 100 * $coupon->amount, WC()->cart->dp);
                     $cart->discount_cart = $cart->discount_cart + $discount_amount * $cart_item['quantity'];
                     $cart = self::increase_coupon_discount_amount($cart, $coupon->code, $discount_amount * $cart_item['quantity']);
                     $price = $price - $discount_amount;
                 } elseif ($apply_initial_percent_coupon) {
                     // Recurring coupons only apply when there is no free trial (carts can have a mix of free trial and non free trial items)
                     if ('recurring_percent' == $coupon->type && empty($cart_item['data']->subscription_trial_length)) {
                         $amount_to_discount = $cart_item['data']->subscription_price;
                     } else {
                         $amount_to_discount = 0;
                     }
                     // Sign up fee coupons only apply to sign up fees
                     if ('sign_up_fee_percent' == $coupon->type) {
                         $amount_to_discount = $cart_item['data']->subscription_sign_up_fee;
                     }
                     $discount_amount = round($amount_to_discount / 100 * $coupon->amount, WC()->cart->dp);
                     $cart->discount_cart = $cart->discount_cart + $discount_amount * $cart_item['quantity'];
                     $cart = self::increase_coupon_discount_amount($cart, $coupon->code, $discount_amount * $cart_item['quantity']);
                     $price = $price - $discount_amount;
                 }
             }
         }
         if ($price < 0) {
             $price = 0;
         }
     }
     return $price;
 }