oxvarianthandler.php

Go to the documentation of this file.

<?php

class oxVariantHandler extends oxSuperCfg
{
    protected $_oArticles = null;

    protected $_sMdSeparator = " | ";

    protected $_oMdVariants = null;

    public function init( $oArticles )
    {
        $this->_oArticles = $oArticles;
    }

    public function buildMdVariants( $oVariants, $sParentId )
    {
        $oMdVariants = oxNew( "OxMdVariant" );
        $oMdVariants->setParentId( $sParentId );
        $oMdVariants->setName( "_parent_product_" );
        foreach ( $oVariants as $sKey => $oVariant ) {
            $aNames = explode( trim( $this->_sMdSeparator ), $oVariant->oxarticles__oxvarselect->value );
            foreach ( $aNames as $sNameKey => $sName ) {
                $aNames[$sNameKey] = trim($sName);
            }
            $oMdVariants->addNames( $sKey,
                                    $aNames,
                                    ( $this->getConfig()->getConfigParam( 'bl_perfLoadPrice' ) ) ? $oVariant->getPrice()->getBruttoPrice() : null,
                                    $oVariant->getLink() );
        }

        return $oMdVariants;
    }

    public function genVariantFromSell( $aSels, $oArticle )
    {
        $oVariants = $oArticle->getAdminVariants();
        $myConfig  = $this->getConfig();
        $myUtils   = oxRegistry::getUtils();
        $myLang    = oxRegistry::getLang();
        $aConfLanguages = $myLang->getLanguageIds();

        foreach ($aSels as $sSelId) {
            $oSel = oxNew("oxi18n");
            $oSel->setEnableMultilang( false );
            $oSel->init( 'oxselectlist' );
            $oSel->load( $sSelId );
            $sVarNameUpdate = "";
            foreach ($aConfLanguages as $sKey => $sLang) {
                $sPrefix = $myLang->getLanguageTag($sKey);
                $aSelValues = $myUtils->assignValuesFromText($oSel->{"oxselectlist__oxvaldesc".$sPrefix}->value );
                foreach ($aSelValues as $sI => $oValue ) {
                    $aValues[$sI][$sKey] = $oValue;
                }
                $aSelTitle[$sKey] = $oSel->{"oxselectlist__oxtitle".$sPrefix}->value;
                $sMdSeparator = ($oArticle->oxarticles__oxvarname->value) ? $this->_sMdSeparator: '';
                if ( $sVarNameUpdate ) {
                    $sVarNameUpdate .= ", ";
                }
                $sVarName = oxDb::getDb()->quote($sMdSeparator.$aSelTitle[$sKey]);
                $sVarNameUpdate .= "oxvarname".$sPrefix." = CONCAT(oxvarname".$sPrefix.", ".$sVarName.")";
            }
            $oMDVariants = $this->_assignValues( $aValues, $oVariants, $oArticle, $aConfLanguages);
            if ( $myConfig->getConfigParam( 'blUseMultidimensionVariants' ) ) {
                $oAttribute = oxNew("oxattribute");
                $oAttribute->assignVarToAttribute( $oMDVariants, $aSelTitle );
            }
            $this->_updateArticleVarName( $sVarNameUpdate, $oArticle->oxarticles__oxid->value );
        }
    }

    protected function _assignValues( $aValues, $oVariants, $oArticle, $aConfLanguages)
    {
        $myConfig = $this->getConfig();
        $myLang    = oxRegistry::getLang();
        $iCounter = 0;
        $aVarselect = array(); //multilanguage names of existing variants
        //iterating through all select list values (eg. $oValue->name = S, M, X, XL)
        for ( $i=0; $i<count($aValues); $i++ ) {
            $oValue = $aValues[$i][0];
            $dPriceMod = $this->_getValuePrice( $oValue, $oArticle->oxarticles__oxprice->value);
            if ( $oVariants->count() > 0 ) {
                //if we have any existing variants then copying each variant with $oValue->name
                foreach ( $oVariants as $oSimpleVariant ) {
                    if ( !$iCounter ) {
                        //we just update the first variant
                        $oVariant = oxNew("oxarticle");
                        $oVariant->setEnableMultilang(false);
                        $oVariant->load($oSimpleVariant->oxarticles__oxid->value);
                        $oVariant->oxarticles__oxprice->setValue( $oVariant->oxarticles__oxprice->value + $dPriceMod );
                        //assign for all languages
                        foreach ( $aConfLanguages as $sKey => $sLang ) {
                            $oValue = $aValues[$i][$sKey];
                            $sPrefix = $myLang->getLanguageTag($sKey);
                            $aVarselect[$oSimpleVariant->oxarticles__oxid->value][$sKey] = $oVariant->{"oxarticles__oxvarselect".$sPrefix}->value;
                            $oVariant->{'oxarticles__oxvarselect'.$sPrefix}->setValue($oVariant->{"oxarticles__oxvarselect".$sPrefix}->value.$this->_sMdSeparator.$oValue->name);
                        }
                        $oVariant->oxarticles__oxsort->setValue($oVariant->oxarticles__oxsort->value * 10);
                        $oVariant->save();
                        $sVarId = $oSimpleVariant->oxarticles__oxid->value;
                    } else {
                        //we create new variants
                        foreach ($aVarselect[$oSimpleVariant->oxarticles__oxid->value] as $sKey => $sVarselect) {
                            $oValue = $aValues[$i][$sKey];
                            $sPrefix = $myLang->getLanguageTag($sKey);
                            $aParams['oxarticles__oxvarselect'.$sPrefix] = $sVarselect.$this->_sMdSeparator.$oValue->name;
                        }
                        $aParams['oxarticles__oxartnum'] = $oSimpleVariant->oxarticles__oxartnum->value . "-" . $iCounter;
                        $aParams['oxarticles__oxprice'] = $oSimpleVariant->oxarticles__oxprice->value + $dPriceMod;
                        $aParams['oxarticles__oxsort'] = $oSimpleVariant->oxarticles__oxsort->value*10 + 10*$iCounter;
                        $aParams['oxarticles__oxstock'] = 0;
                        $aParams['oxarticles__oxstockflag'] = $oSimpleVariant->oxarticles__oxstockflag->value;
                        $aParams['oxarticles__oxisconfigurable'] = $oSimpleVariant->oxarticles__oxisconfigurable->value;
                        $sVarId = $this->_createNewVariant( $aParams, $oArticle->oxarticles__oxid->value );
                        if ( $myConfig->getConfigParam( 'blUseMultidimensionVariants' ) ) {
                            $oAttrList = oxNew('oxattribute');
                            $aIds = $oAttrList->getAttributeAssigns( $oSimpleVariant->oxarticles__oxid->value);
                            $aMDVariants["mdvar_".$sVarId] = $aIds;
                        }
                    }
                    if ( $myConfig->getConfigParam( 'blUseMultidimensionVariants' ) ) {
                        $aMDVariants[$sVarId] = $aValues[$i];
                    }
                }
                $iCounter++;
            } else {
                //in case we don't have any variants then we just create variant(s) with $oValue->name
                $iCounter++;
                foreach ($aConfLanguages as $sKey => $sLang) {
                    $oValue = $aValues[$i][$sKey];
                    $sPrefix = $myLang->getLanguageTag($sKey);
                    $aParams['oxarticles__oxvarselect'.$sPrefix] = $oValue->name;
                }
                $aParams['oxarticles__oxartnum'] = $oArticle->oxarticles__oxartnum->value . "-" . $iCounter ;
                $aParams['oxarticles__oxprice'] = $oArticle->oxarticles__oxprice->value + $dPriceMod;
                $aParams['oxarticles__oxsort'] = $iCounter * 100; // reduction
                $aParams['oxarticles__oxstock'] = 0;
                $aParams['oxarticles__oxstockflag'] = $oArticle->oxarticles__oxstockflag->value;
                $aParams['oxarticles__oxisconfigurable'] = $oArticle->oxarticles__oxisconfigurable->value;
                $sVarId = $this->_createNewVariant( $aParams, $oArticle->oxarticles__oxid->value );
                if ( $myConfig->getConfigParam( 'blUseMultidimensionVariants' ) ) {
                    $aMDVariants[$sVarId] = $aValues[$i];
                }
            }
        }
        return $aMDVariants;
    }

    protected function _getValuePrice( $oValue, $dParentPrice)
    {
        $myConfig = $this->getConfig();
        $dPriceMod = 0;
        if ( $myConfig->getConfigParam( 'bl_perfLoadSelectLists' ) && $myConfig->getConfigParam( 'bl_perfUseSelectlistPrice' ) ) {
            if ($oValue->priceUnit == 'abs') {
                $dPriceMod = $oValue->price;
            } elseif ($oValue->priceUnit == '%') {
                $dPriceModPerc = abs($oValue->price)*$dParentPrice/100.0;
                if (($oValue->price) >= 0.0) {
                    $dPriceMod = $dPriceModPerc;
                } else {
                    $dPriceMod = -$dPriceModPerc;
                }
            }
        }
        return $dPriceMod;
    }

    protected function _createNewVariant( $aParams = null, $sParentId = null)
    {
        // checkbox handling
        $aParams['oxarticles__oxactive'] = 0;

            // shopid
            $sShopID = oxSession::getVar( "actshop");
            $aParams['oxarticles__oxshopid'] = $sShopID;

        // varianthandling
        $aParams['oxarticles__oxparentid'] = $sParentId;

        $oArticle = oxNew("oxi18n");
        $oArticle->setEnableMultilang(false);
        $oArticle->init( 'oxarticles' );
        $oArticle->assign( $aParams);

            //echo $aParams['oxarticles__oxartnum']."---";
            $oArticle->save();

        return $oArticle->getId();
    }

    protected function _updateArticleVarName( $sUpdate, $sArtId )
    {
        $oDb = oxDb::getDb();
        $sUpdate = "update oxarticles set " . $sUpdate . " where oxid = " . $oDb->quote( $sArtId );
        $oDb->Execute( $sUpdate );
    }

    public function isMdVariant( $oArticle )
    {
        if ( $this->getConfig()->getConfigParam( 'blUseMultidimensionVariants' ) ) {
            if ( strpos( $oArticle->oxarticles__oxvarselect->value, trim($this->_sMdSeparator) ) !== false ) {
                return true;
            }
        }

        return false;
    }

    protected function _fillVariantSelections( $oVariantList, $iVarSelCnt, &$aFilter, $sActVariantId )
    {
        $aSelections = array();

        // filling selections
        foreach ( $oVariantList as $oVariant ) {

            $aNames = $this->_getSelections( $oVariant->oxarticles__oxvarselect->getRawValue() );
            $blActive = ( $sActVariantId === $oVariant->getId() ) ? true : false;
            for ( $i = 0; $i < $iVarSelCnt; $i++ ) {
                $sName = isset( $aNames[$i] ) ? trim($aNames[$i]) : false;
                if ($sName) {
                    $sHash = md5($sName );

                    // filling up filter
                    if ( $blActive ) {
                        $aFilter[$i] = $sHash;
                    }

                    $aSelections[$oVariant->getId()][$i] = array( 'name' => $sName, 'disabled' => null, 'active' => false, 'hash' => $sHash );
                }
            }
        }
        return $aSelections;
    }

    protected function _cleanFilter( $aFilter )
    {
        $aCleanFilter = false;
        if ( is_array( $aFilter ) && count( $aFilter ) ) {
            foreach ( $aFilter as $iKey => $sFilter ) {
                if ( $sFilter ) {
                    $aCleanFilter[$iKey] = $sFilter;
                }
            }
        }

        return $aCleanFilter;
    }

    protected function _applyVariantSelectionsFilter( $aSelections, $aFilter )
    {
        $iMaxActiveCount = 0;
        $sMostSuitableVariantId = null;
        $blPerfectFit = false;
        // applying filters, disabling/activating items
        if ( ( $aFilter = $this->_cleanFilter( $aFilter ) ) ) {
            $aFilterKeys = array_keys( $aFilter );
            $iFilterKeysCount = count( $aFilter );
            foreach ( $aSelections as $sVariantId => &$aLineSelections ) {
                $iActive = 0;
                foreach ( $aFilter as $iKey => $sVal ) {
                    if ( strcmp( $aLineSelections[$iKey]['hash'], $sVal ) === 0 ) {
                        $aLineSelections[$iKey]['active'] = true;
                        $iActive++;
                    } else {
                        foreach ($aLineSelections as $iOtherKey => &$aLineOtherVariant) {
                            if ( $iKey != $iOtherKey ) {
                                $aLineOtherVariant['disabled'] = true;
                            }
                        }
                    }
                }
                foreach ($aLineSelections as $iOtherKey => &$aLineOtherVariant) {
                    if ( !in_array( $iOtherKey, $aFilterKeys ) ) {
                        $aLineOtherVariant['disabled'] = !($iFilterKeysCount == $iActive);
                    }
                }

                $blFitsAll = $iActive && (count($aLineSelections) == $iActive) && ($iFilterKeysCount == $iActive);
                if (($iActive > $iMaxActiveCount) || (!$blPerfectFit && $blFitsAll)) {
                    $blPerfectFit = $blFitsAll;
                    $sMostSuitableVariantId = $sVariantId;
                    $iMaxActiveCount = $iActive;
                }

                unset( $aLineSelections );
            }
        }
        return array($aSelections, $sMostSuitableVariantId, $blPerfectFit);
    }

    protected function _buildVariantSelectionsList( $aVarSelects, $aSelections )
    {
        // creating selection lists
        foreach ( $aVarSelects as $iKey => $sLabel ) {
            $aVariantSelections[$iKey] = oxNew( "oxVariantSelectList", $sLabel, $iKey );
        }

        // building variant selections
        foreach ( $aSelections as $aLineSelections ) {
            foreach ( $aLineSelections as $oPos => $aLine ) {
                $aVariantSelections[$oPos]->addVariant( $aLine['name'], $aLine['hash'], $aLine['disabled'], $aLine['active'] );
            }
        }

        return $aVariantSelections;
    }

    protected function _getSelections( $sTitle )
    {

        if ( $this->getConfig()->getConfigParam( 'blUseMultidimensionVariants' ) ) {
            $aSelections = explode( $this->_sMdSeparator, $sTitle );
        } else {
            $aSelections = array( $sTitle );
        }

        return $aSelections;
    }

    public function buildVariantSelections( $sVarName, $oVariantList, $aFilter, $sActVariantId, $iLimit = 0 )
    {
        $aReturn = false;


        // assigning variants
        $aVarSelects = $this->_getSelections( $sVarName );

        if ($iLimit) {
            $aVarSelects = array_slice($aVarSelects, 0, $iLimit);
        }
        if ( ( $iVarSelCnt = count( $aVarSelects ) ) ) {

            // filling selections
            $aRawVariantSelections = $this->_fillVariantSelections( $oVariantList, $iVarSelCnt, $aFilter, $sActVariantId );

            // applying filters, disabling/activating items
            list($aRawVariantSelections, $sActVariantId, $blPerfectFit) = $this->_applyVariantSelectionsFilter( $aRawVariantSelections, $aFilter );
            // creating selection lists
            $aVariantSelections = $this->_buildVariantSelectionsList( $aVarSelects, $aRawVariantSelections );

            $oCurrentVariant = null;
            if ($sActVariantId) {
                $oCurrentVariant = $oVariantList[$sActVariantId];
            }



            return array(
                'selections' => $aVariantSelections,
                'rawselections' => $aRawVariantSelections,
                'oActiveVariant' => $oCurrentVariant,
                'blPerfectFit' => $blPerfectFit
            );
        }
        return false;
    }
}