ecommerce_cart.inc

<?php
require_once SQ_PACKAGES_PATH.'/cms/listing_engine/listing_engine.inc';
require_once SQ_PACKAGES_PATH.'/ecommerce/lib/ecommerce_cart_processor.inc';

define('SQ_CART_PRESET_QUANTITY', 'Quantity');
define('SQ_CART_PRESET_REMOVE', 'Remove');


class Ecommerce_Cart extends Listing_Engine
{

    
    var $_cart = NULL;
    
    
    var $insufficient_quantities = FALSE;


    var $insufficient_quantity_assets = NULL;


    function __construct($assetid=0)
    {
        parent::__construct($assetid);

    }//end constructor


    function _createBodycopies()
    {
        $GLOBALS['SQ_SYSTEM']->am->includeAsset('bodycopy');
        $asset = new Bodycopy();
        $copy_link = Array('asset' => &$this, 'value' => 'page_contents' ,'link_type' => SQ_LINK_TYPE_2, 'is_dependant' => 1, 'is_exclusive' => 1);
        $asset->setAttrValue('name', 'Page Contents');
        return $asset->create($copy_link);

    }//end _createBodycopies()


    function &_getCart()
    {
        if (is_null($this->_cart)) {
            $cart = new Ecommerce_Cart_Processor($this->attr('ecommerce_checkout_id'));
    
            if ($this->attr('use_local_cart')) {
                $cart->setCartContainer($_SESSION['sq_local_cart_contents']['cart_contents']);
            }
            
            $this->_cart = $cart;
        }

        return $this->_cart;

    }//end _getCart()


    function getAssetList()
    {
        $cart =& $this->_getCart();
        $cart_contents = $cart->getCart();

        $asset_list = Array();

        $group_by = $this->attr('group_by');

        foreach ($cart_contents as $product_assetid => $product_info) {
            $product_asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($product_assetid);
            if (!empty($product_asset)) {
                if ($group_by == 'letter') {
                    $asset_list[$product_assetid] = Array( 0 => Array(
                                                                    'type_code'     => $product_asset->type(),
                                                                    'first_letter'  => substr($product_asset->attr('name'), 0, 1),
                                                                )
                                                    );
                } else {
                    $asset_list[$product_assetid] = Array( 0 => Array(
                                                                    'type_code' => $product_asset->type()
                                                                    )
                                                        );
                }
            }
        }

        if (empty($asset_list)) $asset_list = '';

        return $asset_list;

    }//end getAssetList()


    function _getAllowedLinks()
    {
        $page_links = parent::_getAllowedLinks();
        $page_links[SQ_LINK_TYPE_1]['folder']   = Array('card' => 'M');
        $page_links[SQ_LINK_TYPE_1]['product']  = Array('card' => 'M');
        $page_links[SQ_LINK_TYPE_2]['bodycopy'] = Array('card' => 'M');
        return $page_links;

    }//end _getAllowedLinks()


    protected function _getName($short_name=FALSE, $contextid=NULL)
    {
        // No context specified, using the current context
        if ($contextid === NULL) {
            $contextid = $GLOBALS['SQ_SYSTEM']->getContextId();
        }//end if

        // Obtain the attribute value for Name from the specified Context
        $attr = ($short_name) ? 'short_name' : 'name';
        $values = $GLOBALS['SQ_SYSTEM']->am->getAttributeValuesByName($attr, $this->type(), Array($this->id), $contextid);
        if (empty($values) === TRUE) {
            return parent::_getName($short_name, $contextid);
        } else {
            return $values[$this->id];
        }

    }//end _getName()


    function printFrontend()
    {
        // Tie the process and following paint together using db2 in order to
        // avoid possible replication slowdown on db1
        $GLOBALS['SQ_SYSTEM']->changeDatabaseConnection('db2');

        $this->processAssetSelections();
        parent::printFrontend();

        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();

    }//end printFrontend()


    function getRootNodes()
    {
        return Array();

    }//end getRootNodes()


    function printContents()
    {
        $bodycopy_link = $GLOBALS['SQ_SYSTEM']->am->getLink($this->id, SQ_LINK_TYPE_2, 'bodycopy', TRUE, 'page_contents');
        if (empty($bodycopy_link)) return FALSE;

        $format_bodycopy = $GLOBALS['SQ_SYSTEM']->am->getAsset($bodycopy_link['minorid'], $bodycopy_link['minor_type_code']);
        if (is_null($format_bodycopy)) return FALSE;

        require_once SQ_FUDGE_PATH.'/general/text.inc';
        $keywords = $format_bodycopy->getKeywords();
        $replacements = Array();

        if (!in_array('asset_listing', $keywords)) {
            // there is no asset listing keyword in the contents, so we dont
            // need to do all the extra processing for the listing
            $format_bodycopy->printBody();
            return;
        }

        // the children here will refer to the contents of this cart
        $children = $this->getAssetList();
        $num_kids = count($children);
        $this->filterAssetList($children);

        // the list is sorted and positions set, now we can split to groups
        if ($this->attr('group_by') == 'grouped') {
            $this->groupAssetsRecursively($this->attr('asset_grouping'), $children, $children);
            $this->sortGroups($this->attr('asset_grouping'), $children, $children);
        }

        foreach ($keywords as $word) {
            $replacements[$word] = $this->getKeywordReplacement($word);
        }

        // get any extra keyword replacements from this asset
        $replacements = $this->getContentsKeywordReplacements($keywords) + $replacements;

        if (!empty($this->_tmp['cart_updated'])) {
            $replacements['cart_updated'] = $this->attr('cart_updated_text');
        } else {
            $replacements['cart_updated'] = '';
        }

        $num_per_page = $this->_getNumPerPage();

        $asset_result_page_var   = 'result_'.$this->id.'_result_page';
        $generic_result_page_var = 'result_page';

        // have [assetid]_result_page take precedence over result_page
        $result_page = 1;
        if (isset($_REQUEST[$generic_result_page_var])) {
            $result_page = (int)$_REQUEST[$generic_result_page_var];
        }
        if (isset($_REQUEST[$asset_result_page_var])) {
            $result_page = (int)$_REQUEST[$asset_result_page_var];
        }

        if ($result_page <= 0) $result_page = 1;

        // get our page chunk here
        if (empty($children)) {
            $replacements['asset_listing'] = $this->attr('no_items_text');
            $replacements['next_page'] = '';
            $replacements['previous_page'] = '';
            $replacements['total_pages'] = 1;

            // page list is one page
            $replacements['page_list'] = '1';
            $global_contents = $replacements['asset_listing'];
            $num_assets_showing = 0;
            $num_kids = 0;
            ?>
            <script type="text/javascript">
            <!--
                select_list = [];
            //-->
            </script>
            <?php
        } else {
            $todo =& $this->getChunk($children, $replacements, Array(), $result_page, $num_per_page);
            $num_assets_showing = count($todo);

            ob_start();
                $this->printAssetList($todo);
                $global_contents = ob_get_contents();
            ob_end_clean();
        }

        // if we have any blank keywords, replace them with nothing
        $global_contents = preg_replace('|%[^%\W]+%|', '', $global_contents);

        // cart must pass on to an ecommerce checkout
        $checkout_id = $this->attr('ecommerce_checkout_id');
        $checkout_cart_button = '';
        $checkout_cart_href   = '';
        if (!empty($checkout_id) && !empty($children)) {
            if (!$GLOBALS['SQ_SYSTEM']->am->assetExists($checkout_id)) {
                trigger_localised_error('ECOM003', E_USER_WARNING, $checkout_id);
            } else {
                $checkout_cart_href = $GLOBALS['SQ_SYSTEM']->am->getAssetURL($checkout_id);
                ob_start();
                    ?><input type="button" onclick="location.href = '<?php echo addslashes($checkout_cart_href); ?>'" value="<?php echo $this->attr('checkout_text'); ?>" /><?php
                    $checkout_cart_button = ob_get_contents();
                ob_end_clean();
            }
        }


        // pagination

        if ($num_per_page > 0) {
            $this->registerFormField('result_page');
            hidden_field('result_page', $result_page);
        }

        // line below see above
        $replacements['checkout_cart_button']  = $checkout_cart_button;
        $replacements['checkout_cart_href']    = $checkout_cart_href;


        if (in_array('cart_update_button', $keywords)) {
            $replacements['cart_update_button']    = $this->getSubmitButtonKeywordReplacement();
        }
        $replacements['asset_listing']         = $global_contents;
        $replacements['asset_count']           = $num_kids;
        $replacements['page_asset_count']      = $num_assets_showing;
        $replacements['page_number']           = $result_page;
        $replacements['first_asset_position']  = $num_per_page * ($result_page - 1) + 1;
        $replacements['last_asset_position']   = min($num_kids, $num_per_page * $result_page);
        $replacements['root_nodes']            = implode(',', $this->getRootNodes());

        $replacements['select_all_js_code'] = $this->getSelectAllJSCodeKeywordReplacement();

        // print the contents of page - replacing the global keywords
        $format_bodycopy->setKeywordReplacements($replacements);

        ob_start();
            if (!in_array('select_all_js_code', $keywords)) {
                // there is no asset listing keyword in the contents, so we dont
                // need to do all the extra processing for the listing
                echo $this->getSelectAllJSCodeKeywordReplacement();
            }
            $format_bodycopy->printBody();
        ob_end_flush();

    }//end printContents()


    function getAssetSelectionValue($selection_name, $assetid)
    {
        $cart =& $this->_getCart();
        $cart_contents = $cart->getCart();

        $selections = $this->attr('asset_selections');

        // if the hardcoded asset selection 'Quantity'
        if ($selection_name == 'Quantity' && isset($cart_contents[$assetid]['quantity'])) {
            return $cart_contents[$assetid]['quantity'];
        }

        // fallback
        return 0;

    }//end getAssetSelectionValue()


    function _printAsset($assetid, $list_position, $keywords=Array())
    {
        ob_start();
        parent::_printAsset($assetid, $list_position, $keywords);
        $element_contents = ob_get_contents();
        ob_end_clean();

        // summon the quantities
        $cart =& $this->_getCart();
        $cart_contents = $cart->getCart();

        $element_replacements = Array(
                                    'product_quantity'  => $cart_contents[$assetid]['quantity'],
                                );
        $sub_total = $cart_contents[$assetid]['quantity'] * $cart_contents[$assetid]['price'];
        $element_replacements['product_total'] = sprintf("%.{$this->attr('float_precision')}f", $sub_total);
        $element_contents = replace_keywords($element_contents, $element_replacements);

        echo $element_contents;

    }//end _printAsset()


    function getExtendedAssetKeywordReplacements()
    {
        // We are only replacing them with their own replacement so they can be
        // cached out like this, then score and result number can be added later
        return Array(
                'product_quantity'  => '%product_quantity%',
                'product_total'     => '%product_total%',
               );

    }//end getExtendedAssetKeywordReplacements()


    function processAssetSelections()
    {
        $cart =& $this->_getCart();
        $cart_contents = $cart->getCart();

        $parameter_map = $this->getAttribute('parameter_map');
        $this->_tmp['cart_updated'] = FALSE;

        $add_items = $parameter_map->getParameterValue('add_item');
        if (!empty($add_items)) {
            foreach ($add_items as $assetid => $quantity) {
                if (empty($assetid) || !strlen($quantity)) {
                    continue;
                }

                if (isset($cart_contents[$assetid]['quantity'])) {
                    // we updated the quantity for the product
                    $amount = $cart_contents[$assetid]['quantity'];
                    $asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($assetid);
                    if ($asset instanceof Donation) {
                        //if the asset is a Donation, remove the existing amount to use the update amount only. Do not confuse the users how much he has donated
                        $amount = 0;
                    }
                    
                    if ($cart->updateItem($assetid, $this->_validateItemUpdate(SQ_CART_PRESET_QUANTITY, $amount+$quantity, $assetid))) {
                        $this->_tmp['cart_updated'] = TRUE;
                    }

                } else if ($this->_validateItemUpdate(SQ_CART_PRESET_QUANTITY, $quantity, $assetid) == $quantity) {
                    // only add if it's not going to break our Quantity selection
                    if ($cart->addItem($assetid, $quantity)) {
                        $this->_tmp['cart_updated'] = TRUE;
                    }
                }
            }
        }

        // internal, preset asset selections
        // quantity (update)
        if (isset($_REQUEST[SQ_CART_PRESET_QUANTITY])) {
            $quantity = $_REQUEST[SQ_CART_PRESET_QUANTITY];
            if (is_array($quantity)) {
                // checkbox, textbox, or drop-down
                $asset_list = $this->getAssetList();
                foreach ($asset_list as $assetid => $type_code) {
                    $amount = 0;
                    if (isset($quantity[$assetid])) {
                        $amount = $quantity[$assetid];
                    }
                    if ($cart->updateItem($assetid, $this->_validateItemUpdate(SQ_CART_PRESET_QUANTITY, $amount, $assetid))) {
                        $this->_tmp['cart_updated'] = TRUE;
                    }
                }
            } else {
                // radio
                if ($cart->updateItem($quantity, $this->_validateItemUpdate(SQ_CART_PRESET_QUANTITY, 1, $assetid))) {
                    $this->_tmp['cart_updated'] = TRUE;
                }
            }
        }

        // delete
        if (isset($_REQUEST[SQ_CART_PRESET_REMOVE])) {
            $remove = $_REQUEST[SQ_CART_PRESET_REMOVE];
            if (is_array($remove)) {
                // checkbox, textbox, or drop-down
                foreach ($remove as $assetid => $amount) {
                    if ($cart->removeItem($assetid)) {
                        $this->_tmp['cart_updated'] = TRUE;
                    }
                }
            } else {
                // radio
                if ($cart->removeItem($remove)) {
                    $this->_tmp['cart_updated'] = TRUE;
                }
            }
        }

        return TRUE;

    }//end processAssetSelections()


    function _validateItemUpdate($selection_name, $quantity, $assetid)
    {
        $asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($assetid);
        if ($asset instanceof Donation) {
            return $quantity;
        }
        
        $selections     = $this->attr('asset_selections');
        $final_quantity = $quantity;

        // ensure we have enough items to add to the cart
        $checkout_id = $this->attr('ecommerce_checkout_id');
        if (!empty($checkout_id)) {
            if (!$GLOBALS['SQ_SYSTEM']->am->assetExists($checkout_id)) {
                trigger_localised_error('ECOM003', E_USER_WARNING, $checkout_id);
            } else {
                $checkout_asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($checkout_id);
                if ($checkout_asset->attr('enforce_quantities')) {
                    // determine which to use: metadata field or attribute name
                    $source = $checkout_asset->attr('quantity_selector');
                    switch ($source) {
                        case 'metadata':
                        $quantity_field = $checkout_asset->attr('quantity_field');
                        if (!empty($quantity_field)) {
                            $mm =& $GLOBALS['SQ_SYSTEM']->getMetadataManager();
                            $available_quantity = $mm->getMetadataValueByAssetid($assetid, $quantity_field);
                            if ($quantity > $available_quantity) {
                                $this->insufficient_quantities = TRUE;
                                // add name of asset to error list for displaying on frontend
                                $this->insufficient_quantity_assets[] = $asset->name;
                                $final_quantity = $available_quantity;
                            } else {
                                $this->insufficient_quantities = FALSE;
                            }
                        }
                        break;

                        case 'attribute':
                        $quantity_attribute = $checkout_asset->attr('quantity_attribute');
                        if (!empty($quantity_attribute)) {
                            $available_quantity = $asset->attr($quantity_attribute);
                            if ($quantity > $available_quantity) {
                                $this->insufficient_quantities = TRUE;
                                // add name of asset to error list for displaying on frontend
                                $this->insufficient_quantity_assets[] = $asset->name;
                                $final_quantity = $available_quantity;
                            } else {
                                $this->insufficient_quantities = FALSE;
                            }
                        }
                        break;
                    }
                    if (is_array($this->insufficient_quantity_assets)) {
                        $this->insufficient_quantity_assets = array_unique($this->insufficient_quantity_assets);
                    }
                }
            }//end else
        }//end if

        if (empty($selections[$selection_name]['options'])) {
            return $final_quantity;
        }
        $options = $selections[$selection_name]['options'];
        $restrict_range = FALSE;

        // allow_negative?
        if (isset($options['allow_negative']) && !$options['allow_negative']) {
            $restrict_range = TRUE;
            $min            = 0;

            // will always succeed
            $max            = NULL;
        }

        // if restrict_range is turned on
        if (isset($options['restrict_range']) && !empty($options['restrict_range']['enable'])) {
            $restrict_range = TRUE;

            $defaults = $this->getAssetSelectionDefaults();
            $min      = array_get_index($options['restrict_range'], 'min', $defaults['options']['restrict_range']['min']);
            $max      = array_get_index($options['restrict_range'], 'max', $defaults['options']['restrict_range']['max']);
        }

        // if this is a radio button or checkbox
        if ($selections[$selection_name]['type'] == 'radio') {
            $restrict_range = TRUE;
            $min = 0;
            $max = 1;
        }

        if ($restrict_range) {
            if ($quantity < $min) {
                $final_quantity = $min;
            } else if (!is_null($max) && $quantity > $max) {
                $final_quantity = $max;
            }
        }

        return $final_quantity;

    }//end _validateItemUpdate()


    function getAvailableKeywords()
    {
        $keywords = parent::getAvailableKeywords();

        $keywords['product_count'] = translate('ecom_cart_keyword_product_count');
        $keywords['total_value'] = translate('ecom_cart_keyword_total_value');
        
        return $keywords;

    }//end getAvailableKeywords()
    
    
    function onRequestKeywords(&$broadcaster, $vars=Array())
    {
        if (!isset($vars['keywords'])) return;
        if (!($broadcaster instanceof Content_Type)) return;
        $parents = $GLOBALS['SQ_SYSTEM']->am->getParents($broadcaster->id, 'bodycopy', TRUE);

        // the broadcaster could be our page contents bodycopy, in which case
        // we want to supply our own keyword replacements
        $page_contents_link = $GLOBALS['SQ_SYSTEM']->am->getLink($this->id, SQ_LINK_TYPE_2, 'bodycopy', TRUE, 'page_contents');
        if (!empty($page_contents_link)) {
            if (isset($parents[$page_contents_link['minorid']])) {
                $vars['keywords'] += $this->getContentsKeywords();
                return;
            }
        }

        // type folder links
        $folder =& $this->getFolder();
        $type_formats   = Array();
        if (!is_null($folder)) {
            $type_links = $GLOBALS['SQ_SYSTEM']->am->getLinks($folder->id, SQ_LINK_TYPE_2, 'bodycopy');
            foreach ($type_links as $link_info) {
                if (isset($parents[$link_info['minorid']])) {
                    $type_formats[] = $link_info['value'];
                }
            }
        }

        $keywords   = Array();
        if (count($type_formats) > 0) {
            $keywords['product_quantity'] = translate('ecom_cart_keyword_product_quantity');
            $keywords['product_total'] = translate('ecom_cart_keyword_product_total');
        }

        $vars['keywords'] = array_merge($vars['keywords'], $keywords);

        // if it's not the page contents bodycopy, it's something that we've
        // inherited from the listing engine, so pass it on
        parent::onRequestKeywords($broadcaster, $vars);

    }//end onRequestKeywords()


    function getContentsKeywords()
    {
        $keywords = parent::_getContentsKeywords();
        $GLOBALS['SQ_SYSTEM']->lm->includeAssetStrings('page_asset_listing');

        $keywords += Array(
                        'cart_updated'                  => translate('ecom_cart_keyword_cart_updated'),
                        'product_count'                 => translate('ecom_cart_keyword_product_count'),
                        'total_value'                   => translate('ecom_cart_keyword_total_value'),
                        'cart_update_button'            => translate('ecom_cart_keyword_cart_update_button'),
                        'checkout_cart_button'          => translate('ecom_cart_keyword_checkout_cart_button'),
                        'checkout_cart_href'            => translate('ecom_cart_keyword_checkout_cart_href'),
                        'insufficient_quantity_message' => translate('ecom_cart_keyword_insufficient_quantity_message'),
                        'asset_listing'                 => translate('cms_listing_asset_listing'),
                        'previous_page'                 => translate('cms_listing_previous_page_link'),
                        'next_page'                     => translate('cms_listing_next_page_link'),
                        'page_list'                     => translate('cms_listing_page_list'),
                        'page_number'                   => translate('cms_listing_page_number'),
                        'asset_count'                   => translate('cms_listing_asset_count'),
                        'page_asset_count'              => translate('cms_listing_page_asset_count'),
                        'first_asset_position'          => translate('cms_listing_first_asset_position'),
                        'last_asset_position'           => translate('cms_listing_last_asset_position'),
                     );

        return $keywords;

    }//end getContentsKeywords()


    function getInsufficientQuantityMessageKeywordReplacement()
    {
        if ($this->insufficient_quantities) {
            $checkout_id = $this->attr('ecommerce_checkout_id');
            if (!empty($checkout_id)) {
                if (!$GLOBALS['SQ_SYSTEM']->am->assetExists($checkout_id)) {
                    trigger_localised_error('ECOM003', E_USER_WARNING, $checkout_id);
                } else {
                    $checkout_asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($checkout_id);
                    ob_start();
                    echo $checkout_asset->attr('quantity_message_cart');
                    echo '<ul>';
                    foreach ($this->insufficient_quantity_assets as $asset_name) {
                        echo '<li>';
                        echo $asset_name;
                        echo '</li>';
                    }
                    echo '</ul>';
                    return ob_get_clean();
                }
            }
        }

    }//end getInsufficientQuantityMessageKeywordReplacement()


    function getProductCountKeywordReplacement()
    {
        $cart =& $this->_getCart();
        
        return (string)$cart->getCount();

    }//end getProductCountKeywordReplacement()
    

    function getTotalValueKeywordReplacement()
    {
        $cart =& $this->_getCart();
        
        return sprintf("%.{$this->attr('float_precision')}f", $cart->getTotal());

    }//end getTotalValueKeywordReplacement()
    
    
    function _getFormSubmitMethod()
    {
        return 'post';

    }//end _getFormSubmitMethod()


}//end class

?>