For example, a product may have an original price of €100 EUR on the main shop, while another synchronized shop uses USD. The product on the second shop should have its price automatically converted to the local currency.

The Daily Currency Price Synchronization code provides a simple way to keep these prices updated automatically.

How It Works

When a product is synchronized to another shop using the WP Global Cart Product Synchronisation functionality, two additional pieces of information are sent along with the product:

• Origin product currency – the currency used by the original shop.
• Origin product price – the original product price in that currency.

These values are stored with the synchronized product as:

_origin_product_currency
_origin_product_price

The destination shop then uses this information to calculate the correct price in its own WooCommerce currency.

For example:

Origin shop:

Price:    100 EUR
Currency: EUR

Destination shop:

Currency: USD
Price:    automatically converted from 100 EUR

The conversion is performed using the lightweight WOOGC_Currency_Converter class, which uses European Central Bank (ECB) exchange rates. This means there is no need to install an additional currency converter or multi-currency plugin for this functionality. [article here]

Automatic Daily Updates

The price synchronization runs automatically once per day ( or custom-defined). It takes the stored origin price and converts it to the current currency of the local WooCommerce shop.

This is important because the conversion is always performed from the original price, rather than converting the previously converted price. As exchange rates change, the local product price can therefore be updated accordingly without accumulating conversion errors.

The solution works with WooCommerce simple products, variable products, and product variations, allowing synchronized product catalogs to maintain appropriate local prices.

Ideal for Multi-Shop Stores

This feature is particularly useful when a WP Global Cart network contains shops operating with different currencies. Each shop can maintain its own local WooCommerce currency while synchronized products automatically receive prices converted from their original shop currency.

This provides a lightweight solution for maintaining consistent and up-to-date product pricing across a multi-currency WooCommerce network.

The code should be placed inside a custom file in the /wp-content/mu-plugins/ folder.

    /**
     * Scheduled currency price sync for WooCommerce products.
     *
     * Runs on a recurring WP-Cron schedule (default: once per day) and updates
     * the price of every product — simple, variable (per variation), external,
     * grouped, etc. — that carries both the '_origin_product_currency' and
     * '_origin_product_price' meta keys, converting the stored origin price
     * into the shop's current currency via WOOGC_Currency_Converter::convert().
     *
     * Products/variations missing EITHER meta key are skipped and the loop
     * continues to the next one.
     *
     * USAGE:
     * Paste this into a custom/mu-plugin file, or into your theme's
     * functions.php. Requires the plugin that provides WOOGC_Currency_Converter
     * to be active.
     */

    if ( ! defined( 'ABSPATH' ) ) {
	    exit;
    }

    define( 'CUSTOM_PRICE_SYNC_HOOK', 'custom_price_sync_cron_hook' );
    
    
    add_filter( 'woogc/ps/synchronize_product/origin_product/meta_data', 'custom_woogc_add_site_currency', 10, 1 );
    function custom_woogc_add_site_currency( $args )
        {
            $product    =   wc_get_product( $args[ 'origin_product_id' ] );
            
            $args['product_meta']['_origin_product_currency'][] = get_option( 'woocommerce_currency' );
            $args['product_meta']['_origin_product_price'][]    = $product->get_price();

            return $args;
        }
        

    /**
     *
     * Change the interval via the 'custom_price_sync_interval_seconds' filter,
     * e.g. add_filter( 'custom_price_sync_interval_seconds', fn() => HOUR_IN_SECONDS * 6 );
     *
     * NOTE: if you change this after the event is already scheduled, run
     * custom_price_sync_unschedule_event() once (or deactivate/reactivate)
     * so WordPress picks up the new interval — WP doesn't reschedule an
     * already-queued event automatically.
     */
    add_filter( 'cron_schedules', 'custom_price_sync_register_interval' );
    function custom_price_sync_register_interval( $schedules ) {
	    $schedules['custom_price_sync_interval'] = array(
		    'interval' => apply_filters( 'custom_price_sync_interval_seconds', DAY_IN_SECONDS ),
		    'display'  => __( 'Custom Price Sync Interval', 'custom-price-sync' ),
	    );
	    return $schedules;
    }

    /**
     * Schedule the event if it isn't already scheduled.
     */
    add_action( 'init', 'custom_price_sync_schedule_event' );
    function custom_price_sync_schedule_event() {
	    if ( ! wp_next_scheduled( CUSTOM_PRICE_SYNC_HOOK ) ) {
		    wp_schedule_event( time(), 'custom_price_sync_interval', CUSTOM_PRICE_SYNC_HOOK );
	    }
    }

    /**
     * Unschedule helper — call this from a plugin deactivation hook if you turn
     * this into its own plugin file:
     *   register_deactivation_hook( __FILE__, 'custom_price_sync_unschedule_event' );
     */
    function custom_price_sync_unschedule_event() {
	    $timestamp = wp_next_scheduled( CUSTOM_PRICE_SYNC_HOOK );
	    if ( $timestamp ) {
		    wp_unschedule_event( $timestamp, CUSTOM_PRICE_SYNC_HOOK );
	    }
    }

    /**
     * The cron callback: loops through every product in batches and updates
     * prices for any product/variation carrying the origin currency/price meta.
     */
    add_action( CUSTOM_PRICE_SYNC_HOOK, 'custom_price_sync_run' );
    function custom_price_sync_run() {

	    if ( ! class_exists( 'WOOGC_Currency_Converter' ) ) {
		    custom_price_sync_log( 'WOOGC_Currency_Converter class not found. Aborting sync.' );
		    return;
	    }

	    $batch_size = apply_filters( 'custom_price_sync_batch_size', 300 );
	    $paged      = 1;

	    do {
		    $query = new WP_Query( array(
			    'post_type'              => 'product',
			    'post_status'            => 'publish',
			    'posts_per_page'         => $batch_size,
			    'paged'                  => $paged,
			    'fields'                 => 'ids',
			    'orderby'                => 'ID',
			    'order'                  => 'ASC',
			    'no_found_rows'          => true,
			    'update_post_meta_cache' => false,
			    'update_post_term_cache' => false,
		    ) );

		    if ( empty( $query->posts ) ) {
			    break;
		    }

		    foreach ( $query->posts as $product_id ) {

			    $product = wc_get_product( $product_id );

			    if ( ! $product ) {
				    continue;
			    }

			    if ( $product->is_type( 'variable' ) ) {

				    $updated_any_variation = false;

				    foreach ( $product->get_children() as $variation_id ) {
					    $variation = wc_get_product( $variation_id );

					    if ( ! $variation ) {
						    continue;
					    }

					    if ( custom_price_sync_maybe_update_product( $variation ) ) {
						    $updated_any_variation = true;
					    }
				    }

				    // Refresh the parent's cached price range after variations change.
				    if ( $updated_any_variation && class_exists( 'WC_Product_Variable' ) ) {
					    WC_Product_Variable::sync( $product_id );
					    wc_delete_product_transients( $product_id );
				    }
			    } else {
				    // Simple, external, grouped, etc.
				    custom_price_sync_maybe_update_product( $product );
			    }
		    }

		    $paged++;

	    } while ( true );

	    custom_price_sync_log( 'Price sync run completed.' );
    }

    /**
     * Updates a single product/variation's price from its origin currency/price
     * meta, if both metas exist. Returns true if the price was updated.
     *
     * @param WC_Product $product
     * @return bool
     */
    function custom_price_sync_maybe_update_product( $product ) {

	    $product_id = $product->get_id();

	    // Skip products that don't have BOTH meta keys set (this is the correct
	    // existence check — get_post_meta()/get_meta() return '' both when a
	    // meta is missing AND when it's set to an empty string).
	    if ( ! metadata_exists( 'post', $product_id, '_origin_product_currency' )
		    || ! metadata_exists( 'post', $product_id, '_origin_product_price' ) ) {
		    return false;
	    }

	    $origin_currency = $product->get_meta( '_origin_product_currency', true );
	    $origin_price    = $product->get_meta( '_origin_product_price', true );

	    if ( '' === $origin_currency || '' === $origin_price || ! is_numeric( $origin_price ) ) {
		    custom_price_sync_log( sprintf( 'Product #%d has invalid origin meta, skipping.', $product_id ) );
		    return false;
	    }

	    $shop_currency = get_option( 'woocommerce_currency' );

	    // Nothing to convert if origin currency already matches the shop currency.
	    if ( $origin_currency === $shop_currency ) {
		    $new_price = floatval( $origin_price );
	    } else {
		    $new_price = WOOGC_Currency_Converter::convert(
			    floatval( $origin_price ),
			    $origin_currency,
			    $shop_currency
		    );

		    if ( false === $new_price ) {
			    custom_price_sync_log( sprintf(
				    'Currency conversion failed for product #%d (%s -> %s), skipping.',
				    $product_id,
				    $origin_currency,
				    $shop_currency
			    ) );
			    return false;
		    }
	    }

	    $new_price = wc_format_decimal( $new_price, wc_get_price_decimals() );

	    $old_regular_price = $product->get_regular_price();
	    $old_sale_price    = $product->get_sale_price();

	    $product->set_regular_price( $new_price );

	    // If there's no active sale price, keep the active price in sync too.
	    // (If a sale price exists, we leave it as-is rather than guessing a new one.)
	    if ( '' === $old_sale_price ) {
		    $product->set_price( $new_price );
	    }

	    $product->save();

	    custom_price_sync_log( sprintf(
		    'Product #%d price updated: %s %s -> %s %s (regular price %s -> %s).',
		    $product_id,
		    $origin_price,
		    $origin_currency,
		    $new_price,
		    $shop_currency,
		    $old_regular_price,
		    $new_price
	    ) );

	    return true;
    }

    /**
     * Simple logging helper — writes to WooCommerce > Status > Logs
     * (source: custom-price-sync). Disable with:
     *   add_filter( 'custom_price_sync_enable_logging', '__return_false' );
     */
    function custom_price_sync_log( $message ) {
	    if ( ! apply_filters( 'custom_price_sync_enable_logging', true ) ) {
		    return;
	    }

	    if ( function_exists( 'wc_get_logger' ) ) {
		    wc_get_logger()->info( $message, array( 'source' => 'custom-price-sync' ) );
	    }
    }

The post Daily Currency Price updates for the Synchronized Products appeared first on WooCommerce Global Cart - Single Site.

The class uses the European Central Bank (ECB) reference exchange rates as its source. ECB rates are published against the Euro, allowing the class to convert between any two supported currencies indirectly through EUR. For example, a product priced in RON can be converted to USD using the EUR/RON and EUR/USD rates. The rates are stored in WordPress options and reused between updates, so a temporary failure of the ECB service does not prevent conversions from working.

Conversion is performed with a simple function call:

$value = WOOGC_Currency_Converter::convert(
    $amount,
    $from_currency,
    $to_currency
);

For example:

$value = WOOGC_Currency_Converter::convert(
    100,
    'EUR',
    'USD'
);

This approach can eliminate the need for dedicated WooCommerce multi-currency plugins such as Aelia Currency Switcher, FOX Currency Switcher, or WooCommerce’s own Multicurrency extension when your requirement is simply to convert product prices programmatically rather than provide a customer-facing currency switcher. Aelia Currency Switcher is a premium product, while FOX follows a free/premium model with additional features available in its paid version.

The class is particularly useful with WP Global Cart, where products can originate from one WooCommerce shop while being synchronized to another shop using a different currency. The original product currency and price can be retained, and the destination shop can calculate its local price automatically using the latest stored ECB rates.

This keeps the currency conversion logic lightweight, avoids adding another plugin dependency, and allows WP Global Cart to control the conversion process directly as part of product synchronization.

The code should be placed inside a custom file in the /wp-content/mu-plugins/ folder.

    /**
     * WP Global Cart - ECB Currency Converter
     *
     * Retrieves Euro foreign exchange reference rates from the ECB
     * and converts amounts between currencies using EUR as the base.
     */
    class WOOGC_Currency_Converter {

        /**
         * ECB daily XML feed.
         */
        const ECB_FEED_URL = 'https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml';

        /**
         * WordPress option used to store the rates.
         */
        const OPTION_RATES = 'woogc_ecb_currency_rates';

        /**
         * WordPress option used to store the date of the last
         * successfully downloaded ECB rates.
         */
        const OPTION_DATE = 'woogc_ecb_currency_rates_date';

        /**
         * WordPress option used to store the last update timestamp.
         */
        const OPTION_UPDATED = 'woogc_ecb_currency_rates_updated';

        /**
         * Convert an amount from one currency to another.
         *
         * Example:
         * 100 EUR -> USD
         * 100 RON -> USD
         *
         * @param float  $amount
         * @param string $from_currency
         * @param string $to_currency
         *
         * @return float|false
         */
        public static function convert( $amount, $from_currency, $to_currency ) {

            $amount = (float) $amount;

            $from_currency = strtoupper( trim( $from_currency ) );
            $to_currency   = strtoupper( trim( $to_currency ) );

            // Nothing to convert.
            if ( $from_currency === $to_currency ) {
                return $amount;
            }

            // Make sure we have current rates, or the latest available rates.
            $rates = self::get_rates();

            if ( ! is_array( $rates ) || empty( $rates ) ) {
                return false;
            }

            /*
             * EUR is the base currency.
             *
             * Example:
             * EUR = 1
             * USD = 1.1551
             * RON = 5.2568
             */
            $from_rate = 1.0;
            $to_rate   = 1.0;

            /*
             * Currency other than EUR must exist in the ECB rates.
             */
            if ( 'EUR' !== $from_currency ) {

                if ( ! isset( $rates[ $from_currency ] ) ) {
                    return false;
                }

                $from_rate = (float) $rates[ $from_currency ];
            }

            if ( 'EUR' !== $to_currency ) {

                if ( ! isset( $rates[ $to_currency ] ) ) {
                    return false;
                }

                $to_rate = (float) $rates[ $to_currency ];
            }

            /*
             * Convert:
             *
             * source currency -> EUR -> target currency
             *
             * Example RON -> USD:
             *
             * 100 / 5.2568 * 1.1551
             */
            return ( $amount / $from_rate ) * $to_rate;
        }

        /**
         * Get the currently stored ECB rates.
         *
         * This will attempt to update the rates once per day.
         * If today's update is unavailable, the previously stored
         * successful rates are returned.
         *
         * @return array|false
         */
        public static function get_rates() {

            $stored_rates = get_option( self::OPTION_RATES, array() );
            $stored_date  = get_option( self::OPTION_DATE, '' );

            /*
             * If we already have rates downloaded today, use them.
             */
            $today = current_time( 'Y-m-d' );

            if (
                ! empty( $stored_rates ) &&
                $stored_date === $today
            ) {
                return $stored_rates;
            }

            /*
             * Try to download fresh ECB rates.
             */
            $new_rates = self::update_rates();

            /*
             * Successful update.
             */
            if ( is_array( $new_rates ) && ! empty( $new_rates ) ) {
                return $new_rates;
            }

            /*
             * ECB unavailable / no new rates today.
             *
             * Fall back to the last successful rates.
             */
            if ( ! empty( $stored_rates ) ) {
                return $stored_rates;
            }

            return false;
        }

        /**
         * Download and store the latest ECB rates.
         *
         * @return array|false
         */
        public static function update_rates() {

            $response = wp_remote_get(
                self::ECB_FEED_URL,
                array(
                    'timeout'     => 15,
                    'redirection' => 3,
                    'sslverify'   => true,
                    'headers'     => array(
                        'Accept' => 'application/xml,text/xml',
                    ),
                )
            );

            if ( is_wp_error( $response ) ) {
                return false;
            }

            $status_code = wp_remote_retrieve_response_code( $response );

            if ( 200 !== $status_code ) {
                return false;
            }

            $body = wp_remote_retrieve_body( $response );

            if ( empty( $body ) ) {
                return false;
            }

            /*
             * Prevent XML external entity processing.
             */
            libxml_use_internal_errors( true );

            $xml = simplexml_load_string(
                $body,
                'SimpleXMLElement',
                LIBXML_NONET | LIBXML_NOCDATA
            );

            if ( false === $xml ) {
                libxml_clear_errors();
                return false;
            }

            libxml_clear_errors();

            $rates = array(
                'EUR' => 1.0,
            );

            /*
             * ECB XML structure:
             *
             * <Cube currency="USD" rate="1.1551"/>
             */
            $currency_nodes = $xml->xpath(
                '//*[local-name()="Cube"][@currency and @rate]'
            );

            if ( empty( $currency_nodes ) ) {
                return false;
            }

            foreach ( $currency_nodes as $node ) {

                $currency = strtoupper( (string) $node['currency'] );
                $rate     = (float) $node['rate'];

                if ( empty( $currency ) || $rate <= 0 ) {
                    continue;
                }

                $rates[ $currency ] = $rate;
            }

            /*
             * Make sure we got a reasonable set of rates.
             */
            if ( count( $rates ) < 2 ) {
                return false;
            }

            /*
             * Save only after successfully parsing the complete feed.
             *
             * This is important: a failed/invalid request must never
             * overwrite the last known-good rates.
             */
            $today = current_time( 'Y-m-d' );

            update_option(
                self::OPTION_RATES,
                $rates,
                false
            );

            update_option(
                self::OPTION_DATE,
                $today,
                false
            );

            update_option(
                self::OPTION_UPDATED,
                time(),
                false
            );

            return $rates;
        }

        /**
         * Get information about the currently stored rates.
         *
         * Useful for debugging/admin UI.
         *
         * @return array
         */
        public static function get_status() {

            return array(
                'date'    => get_option( self::OPTION_DATE, '' ),
                'updated' => get_option( self::OPTION_UPDATED, 0 ),
                'rates'   => get_option( self::OPTION_RATES, array() ),
            );
        }
    } 

The post Currency Conversion Using 3rd Exchange Rates appeared first on WooCommerce Global Cart - Single Site.

The woogc/ps/synchronize_product/child_product filter allows developers to modify the child product object immediately before it is returned to the WooCommerce Global Cart product synchronization process and saved on the destination shop.

This provides an opportunity to customize the synchronized product after the child product has been created or updated, but before the synchronization process completes.

The filter can be used to change standard WooCommerce product properties, add or modify custom metadata, synchronize additional product information, or implement custom business logic for individual child shops.

Arguments

$child_product

A WC_Product object representing the product on the destination/child shop. This is the object that can be modified using the standard WooCommerce product methods, such as:

$child_product>set_price( $price );
$child_product>set_stock_quantity( $quantity );
$child_product>set_status( 'publish' );
$child_product>update_meta_data( '_custom_field', $value );

$main_product_data

An array containing the synchronized data of the origin/main product. This can be used to inspect information received from the source product and apply additional logic to the child product.

$origin_product_blog_ID

The WordPress Multisite blog ID of the shop where the origin/main product is located.

Example
The following example increases the child product price by 10%:

    add_filter( 'woogc/ps/synchronize_product/child_product', 'custom_modify_child_product', 10, 3 );
    function custom_modify_child_product( $child_product, $main_product_data, $origin_product_blog_ID ) {
        $regular_price = $child_product->get_regular_price( 'edit' );

        if ( '' !== $regular_price ) {
            $child_product->set_regular_price( wc_format_decimal( (float) $regular_price * 1.10 ) );
        }

        $sale_price = $child_product->get_sale_price( 'edit' );

        if ( '' !== $sale_price ) {
            $child_product->set_sale_price( wc_format_decimal( (float) $sale_price * 1.10 ) );
        }

        return $child_product;
    }

The modified $child_product object must always be returned so that WooCommerce Global Cart can continue the synchronization process.

Modify Different Product Properties

Because the filter provides the actual WC_Product object, standard WooCommerce product methods can be used to modify its properties.

For example, the following changes the product status and adds a custom metadata field:

add_filter( 'woogc/ps/synchronize_product/child_product', 'customize_child_product', 10, 3 );

function customize_child_product( $child_product, $main_product_data, $origin_product_blog_ID ) {

    $child_product->set_status( 'draft' );

    $child_product->update_meta_data(
        '_my_custom_value',
        'This value is specific to the child shop'
    );

    return $child_product;
}

This approach is useful when a destination shop needs to have slightly different product information from the origin shop.

Working With Custom Taxonomies or Metadata

The filter can also be used when additional data needs to be assigned to the child product that is not handled by the standard synchronization process.

For example:

add_filter( 'woogc/ps/synchronize_product/child_product', 'custom_child_product_data', 10, 3 );

function custom_child_product_data( $child_product, $main_product_data, $origin_product_blog_ID ) {

    $child_product->update_meta_data(
        '_my_custom_field',
        'Custom value'
    );

    return $child_product;
}

For custom taxonomy synchronization, the filter can also be used to retrieve the required taxonomy information from the origin shop and assign it to the synchronized child product.

Important

This filter operates on the child product object. It should therefore be used when the objective is to modify the product being created or updated on the destination shop.

When you need to prevent a particular metadata field or property from being synchronized altogether, use the woogc/ps/synchronize_product/ignore_meta_key filter instead.

When you need to execute custom logic for individual synchronized product properties, the woogc/ps/synchronize_product/synchronize_product_data action may be more appropriate.

The $child_product object should be returned from the filter even when no changes are made:

return $child_product;

This filter is particularly useful for networks where the same product is shared between multiple WooCommerce shops but certain product properties, metadata, pricing rules, or other destination-specific information need to be customized.

Custom code using this filter can be placed in the active theme’s functions.php file or, preferably, in a custom file within:

/wp-content/mu-plugins/

The post woogc/ps/synchronize_product/child_product appeared first on WooCommerce Global Cart - Single Site.

Filter being used to exclude specific properties, meta keys, or core post fields from being applied to a child product during the product synchronization process.

By default, the synchronization routine applies every property and meta key found on the remote (main) product object onto the local child product. To prevent one or more of these fields from being overwritten on the child — for example, to preserve a locally customized SEO description, or to stop a child product’s stock status from being overridden — a callback can be registered through the ‘woogc/ps/synchronize_product/ignore_meta_key’ filter, returning TRUE for any key that should be skipped. The following sample code snippets demonstrate common scenarios, including skipping a single meta key, skipping the core post_title, post_status, post_content and post_excerpt fields, and applying conditional logic based on the origin blog or the child product’s current state.

Sample Usage

Skip syncing a specific meta key entirely:

add_filter('woogc/ps/synchronize_product/ignore_meta_key', 'my_woogc_ignore_seo_metadesc', 10, 6);
function my_woogc_ignore_seo_metadesc( $ignore, $prop_title, $value, $child_product, $main_product_data, $origin_product_blog_ID )
    {
        if ( '_yoast_wpseo_metadesc' === $prop_title )
            return TRUE;

        return $ignore;
    }

Skip syncing the product name/title:

add_filter('woogc/ps/synchronize_product/ignore_meta_key', 'my_woogc_ignore_product_title', 10, 6);
function my_woogc_ignore_product_title( $ignore, $prop_title, $value, $child_product, $main_product_data, $origin_product_blog_ID )
    {
        if ( 'post_title' === $prop_title )
            return TRUE;

        return $ignore;
    }

Skip syncing status and short description together:

add_filter('woogc/ps/synchronize_product/ignore_meta_key', 'my_woogc_ignore_status_and_excerpt', 10, 6);
function my_woogc_ignore_status_and_excerpt( $ignore, $prop_title, $value, $child_product, $main_product_data, $origin_product_blog_ID )
    {
        $ignored_fields = array( 'post_status', 'post_excerpt' );

        if ( in_array( $prop_title, $ignored_fields, TRUE ) )
            return TRUE;

        return $ignore;
    }

Conditionally ignore, based on which blog the data originated from:

add_filter('woogc/ps/synchronize_product/ignore_meta_key', 'my_woogc_ignore_price_unless_blog_three', 10, 6);
function my_woogc_ignore_price_unless_blog_three( $ignore, $prop_title, $value, $child_product, $main_product_data, $origin_product_blog_ID )
    {
        $price_keys = array( '_price', '_regular_price', '_sale_price' );

        if ( in_array( $prop_title, $price_keys, TRUE ) && $origin_product_blog_ID !== 3 )
            return TRUE;

        return $ignore;
    }

Inspect $child_product before deciding:

add_filter('woogc/ps/synchronize_product/ignore_meta_key', 'my_woogc_preserve_outofstock_status', 10, 6);
function my_woogc_preserve_outofstock_status( $ignore, $prop_title, $value, $child_product, $main_product_data, $origin_product_blog_ID )
    {
        if ( '_stock_status' === $prop_title && $child_product->get_stock_status() === 'outofstock' )
            return TRUE;

        return $ignore;
    }

Using a class method instead of a standalone function:

class My_Woogc_Sync_Customizations {

    public function __construct() {
        add_filter( 'woogc/ps/synchronize_product/ignore_meta_key', array( $this, 'ignore_product_title' ), 10, 6 );
    }

    public function ignore_product_title( $ignore, $prop_title, $value, $child_product, $main_product_data, $origin_product_blog_ID ) {

        if ( 'post_title' === $prop_title )
            return TRUE;

        return $ignore;
    }
}

new My_Woogc_Sync_Customizations();

The post woogc/ps/synchronize_product/ignore_meta_key appeared first on WooCommerce Global Cart - Single Site.

Filter being used to acknowledge the plugin engine to proceed with synchronization, usually following a custom AJAX call which is not being recognized as a WooCommerce default. (e.g. wc-ajax=add_to_cart,  wc-ajax=get_refreshed_fragments)

Certain plugins and themes use their own methods to handle the cart operations like add, remove.  To create a compatibility between such code and the WooCommerce Global Cart plugin, at least a POST parameter must be registered through the ‘woogc/sync/on_post_vars’ filter, recommended to be a unique field. The following sample code, inform the plugin engine to trigger a synchronization procedure right after a POST call has completed and included a field action => woocommerce_add_to_cart_variable_rc

Sample Usage

add_filter('woogc/sync/on_post_vars', 'woogc_sync_on_post_vars');
function woogc_sync_on_post_vars( $PostVars )
    {
        $PostVars[] = 'action=add_to_cart';
        $PostVars[] = 'action=woocommerce_add_to_cart_variable_rc';
        $PostVars[] = 'action=product_remove';

        return $PostVars ;
    }

The post woogc/sync/on_post_vars appeared first on WooCommerce Global Cart - Single Site.

The filter is being used to disable the Global Cart functionality.

    add_filter( 'woogc/disable_global_cart',     'WooGC_Disable_GlobalCart', 10, 2 );
    function  WooGC_Disable_GlobalCart ( $status, $_blog_id = '' )
        {
            
            return TRUE;   
        }

The code should be placed inside a php file on wp-content/mu-plugins folder.

The post woogc/disable_global_cart appeared first on WooCommerce Global Cart - Single Site.