oxarticle.php

Go to the documentation of this file.

<?php

// defining supported link types
define( 'OXARTICLE_LINKTYPE_CATEGORY', 0 );
define( 'OXARTICLE_LINKTYPE_VENDOR', 1 );
define( 'OXARTICLE_LINKTYPE_MANUFACTURER', 2 );
define( 'OXARTICLE_LINKTYPE_PRICECATEGORY', 3 );
define( 'OXARTICLE_LINKTYPE_TAG', 4 );
define( 'OXARTICLE_LINKTYPE_RECOMM', 5 );

class oxArticle extends oxI18n implements oxIArticle, oxIUrl
{
    protected $_sCoreTbl = 'oxarticles';

    protected $_sClassName = 'oxarticle';

    protected $_blUseLazyLoading = true;

    protected $_sItemKey;

    protected $_blCalcPrice    = true;

    protected $_oPrice      = null;

    protected $_dArticleVat = null;

    protected $_aPersistParam  = null;

    protected $_blNotBuyable   = false;

    protected $_blLoadVariants = true;

    protected $_aVariants = null;

    protected $_aVariantsWithNotOrderables = null;

    protected $_blNotBuyableParent  = false;

    protected $_blHasVariants = false;

    protected $_blHasMdVariants = false;

    protected $_blIsOnComparisonList = false;

    protected $_oUser = null;

    protected $_blLoadPrice = true;

    protected $_blSkipAbPrice = false;

    protected $_fPricePerUnit = null;

    protected $_blLoadParentData = false;

    protected $_blSkipAssign = false;

    protected $_blSkipDiscounts = null;

    protected $_oAttributeList = null;


    protected $_blIsRangePrice = false;

    protected $_aMediaUrls = null;

    static protected $_aLoadedParents;

    static protected $_aSelList;

    protected $_aDispSelList;

    protected $_blIsSeoObject = true;

    protected $_oAmountPriceList = null;

    protected $_iLinkType = 0;

    protected $_aStdUrls = array();

    protected $_aSeoUrls = array();

    protected $_aSeoAddParams = array();

    protected $_aStdAddParams = array();

    protected $_sDynImageDir = null;

    protected $_sMoreDetailLink = null;

    protected $_sToBasketLink = null;

    protected $_iStockStatus = null;

    protected $_oTPrice = null;

    protected $_oAmountPriceInfo = null;

    protected $_dAmountPrice = null;

    protected static $_aArticleManufacturers = array();

    protected static $_aArticleVendors = array();

    protected static $_aArticleCats = array();

    protected $_aNonCopyParentFields = array('oxarticles__oxinsert',
                                             'oxarticles__oxtimestamp',
                                             'oxarticles__oxnid',
                                             'oxarticles__oxid',
                                             'oxarticles__oxparentid');

    protected $_aCopyParentField = array('oxarticles__oxnonmaterial',
                                         'oxarticles__oxfreeshipping',
                                         'oxarticles__oxremindactive');

    protected $_oMdVariants = null;

    public function __construct($aParams = null)
    {
        if ( $aParams && is_array($aParams)) {
            foreach ( $aParams as $sParam => $mValue) {
                $this->$sParam = $mValue;
            }
        }
        parent::__construct();
        $this->init( 'oxarticles' );

        $this->_blIsRangePrice = false;
    }

    public function __isset( $sName )
    {
        if ( $sName == 'oxarticles__oxlongdesc' ) {
            //get empty oxlongdesc field
            $this->getArticleLongDesc();
            return true;
        }
        return isset( $this->$sName );
    }

    public function __get($sName)
    {
        $myUtils = oxUtils::getInstance();
        switch ($sName) {
            // NOT using caching here, because of these params should be used in templates ONLY
            // and in template files they are used not very much [once most of the time]

            // price related
            case 'netprice':
            case 'netPrice':
                $mVal = $myUtils->fRound($this->getPrice()->getNettoPrice());
                break;
            case 'brutPrice':
                return $myUtils->fRound($this->getPrice()->getBruttoPrice());
                break;
            case 'vatPercent':
                return $this->getPrice()->getVAT();
                break;
            case 'vat':
                return $this->getPrice()->getVATValue();
                break;
            case 'fnetprice':
                return oxLang::getInstance()->formatCurrency( $myUtils->fRound($this->getPrice()->getNettoPrice()));
                break;
            case 'fprice':
                return $this->getFPrice();
                break;

            // t price related
            case 'dtprice':
                if ( $oPrice = $this->getTPrice() ) {
                    return $myUtils->fRound($oPrice->getBruttoPrice());
                    break;
                } else {
                    return null;
                    break;
                }
            case 'tvat':
                if ( $oPrice = $this->getTPrice() ) {
                    return $oPrice->getVATValue();
                    break;
                } else {
                    return null;
                    break;
                }
            case 'ftprice':
                if ( $oPrice = $this->getTPrice() ) {
                    return oxLang::getInstance()->formatCurrency( $myUtils->fRound($oPrice->getBruttoPrice()) );
                    break;
                } else {
                    return null;
                    break;
                }
            case 'oxarticles__oxlongdesc':
                return $this->getArticleLongDesc($this->getId());
                break;
            case 'foxdelivery':
                return $this->getDeliveryDate();
                break;
            case 'sItemKey':
                return $this->getItemKey();
                break;
            case 'selectlist':
                return $this->_aDispSelList = $this->getDispSelList();
                break;
            case 'blNotBuyable':
                return $this->isNotBuyable();
                break;
            case 'blNotBuyableParent':
                return $this->isParentNotBuyable();
                break;
            case 'blIsOnComparisonList':
                return $this->isOnComparisonList();
                break;
            case 'oVariantlist' :
                return $this->getVariants();
                break;
            case 'fPricePerUnit' :
                return $this->getPricePerUnit();
                break;
            case 'dimagedir' :
                return $this->_sDynImageDir = $this->getDynImageDir();
                break;
            case 'oxmoredetaillink' :
                return $this->_sMoreDetailLink = $this->getMoreDetailLink();
                break;
            case 'amountpricelist' :
                return $this->loadAmountPriceInfo();
                break;
            case 'stockstatus' :
                return $this->getStockStatus();
                break;
            case 'tobasketlink' :
                return $this->getToBasketLink();
                break;
            case 'oxdetaillink' :
                return $this->getLink();
                break;
            case 'aSelectlist' :
                if ( $this->getConfig()->getConfigParam( 'bl_perfLoadSelectLists' ) ) {
                    return $this->aSelectlist = $this->getSelectLists();
                }
                return;
                break;
        }

        //checking for zoom picture
        if ( strpos($sName, "oxarticles__oxzoom") === 0 ) {
            $this->_assignZoomPictureValues( $sName );
            return $this->$sName;
        }

        $this->$sName = parent::__get($sName);
        if ( $this->$sName ) {
            $this->_assignParentFieldValue($sName);
        }

        //checking for picture information
        if ( $sName == "oxarticles__oxthumb" || $sName == "oxarticles__oxicon" || (strpos($sName, "oxarticles__oxpic") === 0 && $sName != "oxarticles__oxpicsgenerated") ) {
            $this->_assignPictureValues( $sName );
            return $this->$sName;
        }

        return $this->$sName;
    }

    public function setId( $sId = null )
    {
        $sId = parent::setId( $sId );

        // TODO: in oxbase::setId make it to check if exists and update, not recreate, then delete this overload
        $this->oxarticles__oxnid = $this->oxarticles__oxid;

        return $sId;
    }

    public function getTableNameForActiveSnippet( $blForceCoreTable = false )
    {
            $sTable = $this->getCoreTableName();

        return $sTable;
    }

    public function getActiveCheckQuery( $blForceCoreTable = false )
    {
        $sTable = $this->getTableNameForActiveSnippet( $blForceCoreTable );

        // check if article is still active
        $sQ = " $sTable.oxactive = 1 ";

        // enabled time range check ?
        if ( $this->getConfig()->getConfigParam( 'blUseTimeCheck' ) ) {
            $sDate = date( 'Y-m-d H:i:s', oxUtilsDate::getInstance()->getTime() );
            $sQ = "( $sQ or ( $sTable.oxactivefrom < '$sDate' and $sTable.oxactiveto > '$sDate' ) ) ";
        }

        return $sQ;
    }

    public function getStockCheckQuery( $blForceCoreTable = false )
    {
        $myConfig = $this->getConfig();
        $sTable = $this->getTableNameForActiveSnippet( $blForceCoreTable );

        $sQ = "";

        //do not check for variants
        if ( $myConfig->getConfigParam( 'blUseStock' ) ) {
            $sQ = " and ( $sTable.oxstockflag != 2 or ( $sTable.oxstock + $sTable.oxvarstock ) > 0  ) ";
            //V #M513: When Parent article is not purchaseble, it's visibility should be displayed in shop only if any of Variants is available.
            if ( !$myConfig->getConfigParam( 'blVariantParentBuyable' ) ) {
                $sTimeCheckQ = '';
                if ( $myConfig->getConfigParam( 'blUseTimeCheck' ) ) {
                     $sDate = date( 'Y-m-d H:i:s', oxUtilsDate::getInstance()->getTime() );
                     $sTimeCheckQ = " or ( art.oxactivefrom < '$sDate' and art.oxactiveto > '$sDate' )";
                }
                $sQ = " $sQ and IF( $sTable.oxvarcount = 0, 1, ( select 1 from $sTable as art where art.oxparentid=$sTable.oxid and ( art.oxactive = 1 $sTimeCheckQ ) and ( art.oxstockflag != 2 or art.oxstock > 0 ) limit 1 ) ) ";
            }
        }

        return $sQ;
    }

    public function getVariantsQuery( $blRemoveNotOrderables, $blForceCoreTable = false  )
    {
        $sTable = $this->getTableNameForActiveSnippet( $blForceCoreTable );
        $sQ = " and $sTable.oxparentid = '".$this->getId()."' ";

        //checking if variant is active and stock status
        if ( $this->getConfig()->getConfigParam( 'blUseStock' ) ) {
            $sQ .= " and ( $sTable.oxstock > 0 or ( $sTable.oxstock <= 0 and $sTable.oxstockflag != 2 ";
            if ( $blRemoveNotOrderables ) {
                $sQ .= " and $sTable.oxstockflag != 3 ";
            }
            $sQ .= " ) ) ";
        }

        return $sQ;
    }

    public function getSqlActiveSnippet( $blForceCoreTable = false )
    {
        $myConfig = $this->getConfig();

        // check if article is still active
        $sQ = $this->getActiveCheckQuery( $blForceCoreTable );

        // stock and variants check
        $sQ .= $this->getStockCheckQuery( $blForceCoreTable );


        return "( $sQ ) ";
    }

    public function setSkipAssign($blSkipAssign)
    {
        $this->_blSkipAssign = $blSkipAssign;
    }

    public function disablePriceLoad( $oArticle )
    {
        $oArticle->_blLoadPrice = false;
    }

    public function getItemKey()
    {
        return $this->_sItemKey;
    }

    public function setItemKey($sItemKey)
    {
        $this->_sItemKey = $sItemKey;
    }

    public function setNoVariantLoading( $blLoadVariants )
    {
        $this->_blLoadVariants = !$blLoadVariants;
    }

    public function isBuyable()
    {
        if ($this->_blNotBuyableParent) {
            return false;
        }

        return !$this->_blNotBuyable;
    }

    public function getPersParams()
    {
        return $this->_aPersistParam;
    }

    public function isOnComparisonList()
    {
        return $this->_blIsOnComparisonList;
    }

    public function setOnComparisonList( $blOnList )
    {
        $this->_blIsOnComparisonList = $blOnList;
    }

    public function setLoadParentData($blLoadParentData)
    {
        $this->_blLoadParentData = $blLoadParentData;
    }

    public function setSkipAbPrice( $blSkipAbPrice = null )
    {
        $this->_blSkipAbPrice = $blSkipAbPrice;
    }

    public function getSearchableFields()
    {
        $aSkipFields = array("oxblfixedprice", "oxicon", "oxvarselect", "oxamitemid", "oxamtaskid", "oxpixiexport", "oxpixiexported") ;
        $aFields = array_diff( array_keys($this->_aFieldNames), $aSkipFields );

        return $aFields;
    }


    public function isMultilingualField($sFieldName)
    {
        switch ($sFieldName) {
            case "oxlongdesc":
            case "oxtags":
                return true;
        }

        return parent::isMultilingualField($sFieldName);
    }

    public function isVisible()
    {

        // admin preview mode
        if ( ( $blCanPreview = oxUtils::getInstance()->canPreview() ) !== null ) {
            return $blCanPreview;
        }

        // active ?
        $sNow = date('Y-m-d H:i:s');
        if ( !$this->oxarticles__oxactive->value &&
             (  $this->oxarticles__oxactivefrom->value > $sNow ||
                $this->oxarticles__oxactiveto->value < $sNow
             )) {
            return false;
        }

        // stock flags
        if ( $this->getConfig()->getConfigParam( 'blUseStock' ) && $this->oxarticles__oxstockflag->value == 2) {
            $iOnStock = $this->oxarticles__oxstock->value + $this->oxarticles__oxvarstock->value;
            if ($this->getConfig()->getConfigParam( 'blPsBasketReservationEnabled' )) {
                $iOnStock += $this->getSession()->getBasketReservations()->getReservedAmount($this->getId());
            }
            if ( $iOnStock <= 0 ) {
                return false;
            }
        }

        return true;
    }

    public function assign( $aRecord)
    {
        startProfile('articleAssign');


        // load object from database
        parent::assign( $aRecord);

        $this->oxarticles__oxnid = $this->oxarticles__oxid;

        // check for simple article.
        if ($this->_blSkipAssign) {
            return;
        }

        $this->_assignParentFieldValues();
        $this->_assignNotBuyableParent();

        $this->_assignAllPictureValues();

        $this->_assignStock();
        startProfile('articleAssignPrices');
        $this->_assignPrices();
        stopProfile('articleAssignPrices');
        $this->_assignPersistentParam();
        $this->_assignDynImageDir();
        $this->_assignComparisonListFlag();
        $this->_assignAttributes();


        //$this->_seoAssign();

        stopProfile('articleAssign');
    }

    public function load( $oxID)
    {
        // A. #1325 resetting to avoid problems when reloading (details etc)
        $this->_blNotBuyableParent = false;

        $blRet = parent::load( $oxID);

        // convert date's to international format
        $this->oxarticles__oxinsert    = new oxField(oxUtilsDate::getInstance()->formatDBDate( $this->oxarticles__oxinsert->value));
        $this->oxarticles__oxtimestamp = new oxField(oxUtilsDate::getInstance()->formatDBDate( $this->oxarticles__oxtimestamp->value));

        return $blRet;
    }

    public function addToRatingAverage( $iRating)
    {
        $dOldRating = $this->oxarticles__oxrating->value;
        $dOldCnt    = $this->oxarticles__oxratingcnt->value;
        $this->oxarticles__oxrating->setValue(( $dOldRating * $dOldCnt + $iRating ) / ($dOldCnt + 1));
        $this->oxarticles__oxratingcnt->setValue($dOldCnt + 1);
        $dRating = ( $dOldRating * $dOldCnt + $iRating ) / ($dOldCnt + 1);
        $dRatingCnt = (int) ($dOldCnt + 1);
        // oxarticles.oxtimestamp = oxarticles.oxtimestamp to keep old timestamp value
        oxDb::getDb()->execute( 'update oxarticles set oxarticles.oxrating = '.$dRating.',oxarticles.oxratingcnt = '.$dRatingCnt.', oxarticles.oxtimestamp = oxarticles.oxtimestamp where oxarticles.oxid = "'.$this->getId().'" ' );
    }

    public function getArticleRatingAverage()
    {
        return round( $this->oxarticles__oxrating->value, 1);
    }

    public function getReviews()
    {
        $myConfig  = $this->getConfig();

        $aIds = array($this->getId());

        if ( $this->oxarticles__oxparentid->value ) {
                $aIds[] = $this->oxarticles__oxparentid->value;
        }

        // showing variant reviews ..
        if ( $myConfig->getConfigParam( 'blShowVariantReviews' ) ) {
            $aAdd = $this->_getVariantsIds();
            if (is_array($aAdd)) {
                $aIds = array_merge($aIds, $aAdd);
            }
        }

        $oReview = oxNew('oxreview');
        $oRevs = $oReview->loadList('oxarticle', $aIds);

        //if no review found, return null
        if ( $oRevs->count() < 1 ) {
            return null;
        }

        return $oRevs;
    }

    public function getCrossSelling()
    {
        $oCrosslist = oxNew( "oxarticlelist");
        $oCrosslist->loadArticleCrossSell($this->oxarticles__oxid->value);
        if ( $oCrosslist->count() ) {
            return $oCrosslist;
        }
    }

    public function getAccessoires()
    {
        $myConfig = $this->getConfig();

        // Performance
        if ( !$myConfig->getConfigParam( 'bl_perfLoadAccessoires' ) ) {
            return;
        }

        $oAcclist = oxNew( "oxarticlelist");
        $oAcclist->setSqlLimit( 0, $myConfig->getConfigParam( 'iNrofCrossellArticles' ));
        $oAcclist->loadArticleAccessoires($this->oxarticles__oxid->value);

        if ( $oAcclist->count()) {
            return $oAcclist;
        }
    }

    public function getSimilarProducts()
    {
        // Performance
        $myConfig = $this->getConfig();
        if ( !$myConfig->getConfigParam( 'bl_perfLoadSimilar' ) ) {
            return;
        }

        $sArticleTable = $this->_getObjectViewName('oxarticles');

        $sAttribs = '';
        $iCnt = 0;
        $this->_getAttribsString($sAttribs, $iCnt);

        if ( !$sAttribs) {
            return null;
        }

        $aList = $this->_getSimList($sAttribs, $iCnt);

        if ( count( $aList ) ) {
            uasort( $aList, 'cmpart');

            $sSearch = $this->_generateSimListSearchStr($sArticleTable, $aList);

            $oSimilarlist = oxNew( 'oxarticlelist' );
            $oSimilarlist->setSqlLimit( 0, $myConfig->getConfigParam( 'iNrofSimilarArticles' ));
            $oSimilarlist->selectString( $sSearch);

            return $oSimilarlist;
        }
    }

    public function getCustomerAlsoBoughtThisProducts()
    {
        // Performance
        $myConfig = $this->getConfig();
        if ( !$myConfig->getConfigParam( 'bl_perfLoadCustomerWhoBoughtThis' ) ) {
            return;
        }

        // selecting products that fits
        $sQ = $this->_generateSearchStrForCustomerBought();

        $oArticles = oxNew( 'oxarticlelist' );
        $oArticles->setSqlLimit( 0, $myConfig->getConfigParam( 'iNrofCustomerWhoArticles' ));
        $oArticles->selectString( $sQ );
        if ( $oArticles->count() ) {
            return $oArticles;
        }
    }

    public function loadAmountPriceInfo()
    {
        $myConfig = $this->getConfig();
        if ( !$myConfig->getConfigParam( 'bl_perfLoadPrice' ) || !$this->_blLoadPrice || !$this->_blCalcPrice) {
            return array();
        }

        if ( $this->_oAmountPriceInfo === null ) {
            $this->_oAmountPriceInfo = array();
            if ( count( ( $oAmPriceList = $this->_getAmountPriceList() ) ) ) {
                $this->_oAmountPriceInfo = $this->_fillAmountPriceList( $oAmPriceList );

            }
        }
        return $this->_oAmountPriceInfo;
    }

    public function getSelectLists($sKeyPrefix = null)
    {
        //#1468C - more then one article in basket with different selectlist...
        //optionall function parameter $sKeyPrefix added, used only in basket.php
        $sKey = $this->getId();
        if ( isset( $sKeyPrefix ) ) {
            $sKey = $sKeyPrefix.'__'.$this->getId();
        }

        if ( !isset( self::$_aSelList[$sKey] ) ) {
            $oDb = oxDb::getDb();
            $sSLViewName = getViewName( 'oxselectlist' );

            $sQ = "select {$sSLViewName}.* from oxobject2selectlist join {$sSLViewName} on $sSLViewName.oxid=oxobject2selectlist.oxselnid
                   where oxobject2selectlist.oxobjectid=%s order by oxobject2selectlist.oxsort";

            // all selectlists this article has
            $oLists = oxNew( 'oxlist' );
            $oLists->init( 'oxselectlist' );
            $oLists->selectString( sprintf( $sQ, $oDb->quote( $this->getId() ) ) );

            //#1104S if this is variant ant it has no selectlists, trying with parent
            if ( $oLists->count() == 0 && $this->oxarticles__oxparentid->value ) {
                $oLists->selectString( sprintf( $sQ, $oDb->quote( $this->oxarticles__oxparentid->value ) ) );
            }

            $dVat = 0;
            if ( $this->getPrice() != null ) {
                $dVat = $this->getPrice()->getVat();
            }

            $iCnt = 0;
            self::$_aSelList[$sKey] = array();
            foreach ( $oLists as $oSelectlist ) {
                self::$_aSelList[$sKey][$iCnt] = $oSelectlist->getFieldList( $dVat );
                self::$_aSelList[$sKey][$iCnt]['name'] = $oSelectlist->oxselectlist__oxtitle->value;
                $iCnt++;
            }
        }
        return self::$_aSelList[$sKey];
    }

    protected function _hasAnyVariant( $blForceCoreTable = false )
    {
        $sArticleTable = $this->getTableNameForActiveSnippet( $blForceCoreTable );
        return (bool) oxDb::getDb()->getOne( "select 1 from $sArticleTable where oxparentid='".$this->getId()."'" );
    }

    public function hasMdVariants()
    {
        return $this->_blHasMdVariants;
    }

    public function getVariants( $blRemoveNotOrderables = true, $blForceCoreTable = false  )
    {
        if ( $blRemoveNotOrderables && $this->_aVariants ) {
            return $this->_aVariants;
        } elseif ( !$blRemoveNotOrderables && $this->_aVariantsWithNotOrderables ) {
            return $this->_aVariantsWithNotOrderables;
        }

        $myConfig = $this->getConfig();
        if ( !$this->_blLoadVariants ||
            ( !$this->isAdmin() && !$myConfig->getConfigParam( 'blLoadVariants') ) ||
            ( !$this->isAdmin() && !$this->oxarticles__oxvarcount->value ) ) {
            return array();
        }

        //do not load me as a parent later
        self::$_aLoadedParents[$this->getId()] = $this;

        //load simple variants for lists
        if ( $this->_isInList() ) {
            $oVariants = oxNew( 'oxsimplevariantlist' );
            $oVariants->setParent( $this );
        } else {
            //loading variants
            $oVariants = oxNew( 'oxarticlelist' );
            $oVariants->getBaseObject()->modifyCacheKey( '_variants' );
        }

        if ( $this->_blHasVariants = $this->_hasAnyVariant( $blForceCoreTable ) ) {

            startProfile("selectVariants");
            $blUseCoreTable = $blForceCoreTable;
            $oBaseObject = $oVariants->getBaseObject();
            $sArticleTable = $this->getTableNameForActiveSnippet( $blUseCoreTable );

            $sSelect = "select ".$oBaseObject->getSelectFields()." from $sArticleTable where " .
                       $this->getActiveCheckQuery( $blUseCoreTable ) .
                       $this->getVariantsQuery( $blRemoveNotOrderables, $blUseCoreTable ) .
                       " order by $sArticleTable.oxsort";

            $oVariants->selectString( $sSelect );

            //if this is multidimensional variants, make additional processing
            if ( $myConfig->getConfigParam( 'blUseMultidimensionVariants' ) ) {
                $oMdVariants = oxNew( "oxVariantHandler" );
                $this->_blHasMdVariants = $oMdVariants->isMdVariant( $oVariants->current() );
            }
            stopProfile("selectVariants");
        }

        //if we have variants then depending on config option the parent may be non buyable
        if ( !$myConfig->getConfigParam( 'blVariantParentBuyable' ) && $this->_blHasVariants ) {
            $this->_blNotBuyableParent = true;
        }

        //if we have variants, but all variants are incative means article may be non buyable (depends on config option)
        if ( !$myConfig->getConfigParam( 'blVariantParentBuyable' ) && $oVariants->count() == 0 && $this->_blHasVariants ) {
            $this->_blNotBuyable = true;
        }

        // cache
        if ( $blRemoveNotOrderables ) {
            $this->_aVariants = $oVariants;
        } else {
            $this->_aVariantsWithNotOrderables = $oVariants;
        }

        return $oVariants;
    }

    public function getSimpleVariants()
    {
        if ( $this->oxarticles__oxvarcount->value) {
            return $this->getVariants();
        }
    }

    public function getAdminVariants( $sLanguage = null )
    {
        $myConfig = $this->getConfig();

        $oVariants = oxNew( 'oxarticlelist');

        if ( is_null($sLanguage) ) {
            $oVariants->getBaseObject()->setLanguage(oxLang::getInstance()->getBaseLanguage());
        } else {
            $oVariants->getBaseObject()->setLanguage($sLanguage);
        }

        $sSql = 'select * from oxarticles where oxparentid = "'.$this->getId().'" order by oxsort ';

        $oVariants->selectString( $sSql);

        //if we have variants then depending on config option the parent may be non buyable
        if (!$myConfig->getConfigParam( 'blVariantParentBuyable' ) && ($oVariants->count() > 0)) {
            //$this->blNotBuyable = true;
            $this->_blNotBuyableParent = true;
        }

        return $oVariants;
    }

    public function getCategory()
    {
        startPRofile( 'getCategory' );

        $oCategory = oxNew( 'oxcategory' );
        $oCategory->setLanguage( $this->getLanguage() );

        // variant handling
        $sOXID = $this->getId();
        if ( isset( $this->oxarticles__oxparentid->value ) && $this->oxarticles__oxparentid->value ) {
            $sOXID = $this->oxarticles__oxparentid->value;
        }

        $oStr = getStr();
        $sWhere   = $oCategory->getSqlActiveSnippet();
        $sSelect  = $this->_generateSearchStr( $sOXID );
        $sSelect .= ( $oStr->strstr( $sSelect, 'where' )?' and ':' where ') . $sWhere . " order by oxobject2category.oxtime limit 1";

        // category not found ?
        if ( !$oCategory->assignRecord( $sSelect ) ) {

            $sSelect  = $this->_generateSearchStr( $sOXID, true );
            $sSelect .= ( $oStr->strstr( $sSelect, 'where' )?' and ':' where ') . $sWhere . " limit 1";

            // looking for price category
            if ( !$oCategory->assignRecord( $sSelect ) ) {
                $oCategory = null;
            }
        }

        stopPRofile( 'getCategory' );
        return $oCategory;
    }

    public function getCategoryIds( $blActCats = false, $blSkipCache = false )
    {
        $myConfig = $this->getConfig();
        if ( isset( self::$_aArticleCats[$this->getId()] ) && !$blSkipCache ) {
            return self::$_aArticleCats[$this->getId()];
        }

        // variant handling
        $sOXID = $this->getId();
        if (isset( $this->oxarticles__oxparentid->value) && $this->oxarticles__oxparentid->value) {
            $sOXID = $this->oxarticles__oxparentid->value;
        }

        // we do not use lists here as we dont need this overhead right now
        $sSql = $this->_getSelectCatIds( $sOXID, $blActCats );
        $oDB = oxDb::getDb(true);
        $rs = $oDB->execute( $sSql );


        $aRet = array();

        if ($rs != false && $rs->recordCount() > 0) {
            while (!$rs->EOF) {
                $aRet[] = $rs->fields['oxcatnid'];
                $rs->moveNext();
            }
        }

        // adding price categories if such exists
        $sSql = $this->getSqlForPriceCategories();

        $oDB = oxDb::getDb( true );
        $rs = $oDB->execute( $sSql );

        if ($rs != false && $rs->recordCount() > 0) {
            while (!$rs->EOF) {

                if ( is_array( $rs->fields ) ) {
                   $rs->fields = array_change_key_case( $rs->fields, CASE_LOWER );
                }


                if ( !$aRet[$rs->fields['oxid']] ) {
                    $aRet[] = $rs->fields['oxid'];
                }
                $rs->moveNext();
            }
        }

        return self::$_aArticleCats[$this->getId()] = $aRet;
    }

    protected function _getSelectCatIds( $sOXID, $blActCats = false )
    {
        $sO2CView = $this->_getObjectViewName('oxobject2category');
        $sCatView = $this->_getObjectViewName('oxcategories');
        $sSelect =  "select oxobject2category.oxcatnid as oxcatnid from $sO2CView as oxobject2category left join $sCatView as oxcategories on oxcategories.oxid = oxobject2category.oxcatnid ";
        $sSelect .= 'where oxobject2category.oxobjectid='.oxDb::getDb()->quote($sOXID).' and oxcategories.oxid is not null and oxcategories.oxactive'.(($this->getLanguage())?'_'.$this->getLanguage():'').' = 1 ';
        if ( $blActCats ) {
            $sSelect .= "and oxcategories.oxhidden = 0 and (select count(cats.oxid) from $sCatView as cats where cats.oxrootid = oxcategories.oxrootid and cats.oxleft < oxcategories.oxleft and cats.oxright > oxcategories.oxright and ( cats.oxhidden = 1 or cats.oxactive".(($this->getLanguage())?"_".$this->getLanguage():"")." = 0 ) ) = 0 ";
        }
        $sSelect .= 'order by oxobject2category.oxtime ';
        return $sSelect;
    }

    public function getVendor( $blShopCheck = true )
    {
        if ( ( $sVendorId = $this->getVendorId() ) ) {
            $oVendor = oxNew( 'oxvendor' );
        } elseif ( !$blShopCheck && $this->oxarticles__oxvendorid->value ) {
            $oVendor = oxNew( 'oxi18n' );
            $oVendor->init('oxvendor');
            $oVendor->setReadOnly( true );
            $sVendorId = $this->oxarticles__oxvendorid->value;
        }
        if ( $sVendorId && $oVendor->load( $sVendorId ) && $oVendor->oxvendor__oxactive->value ) {
            if ( !$this->getConfig()->getConfigParam( 'bl_perfLoadVendorTree' ) ) {
                $oVendor->setReadOnly( true );
            }
            return $oVendor;
        }
        return null;
    }

    public function getVendorId( $blForceReload = false )
    {
        $sVendorId = false;
        if ( $this->oxarticles__oxvendorid->value ) {
            if ( !$blForceReload && isset( self::$_aArticleVendors[$this->getId()] ) ) {
                return self::$_aArticleVendors[$this->getId()];
            }
            $oDb = oxDb::getDb();
            $sVendorIdQuoted = $oDb->quote($this->oxarticles__oxvendorid->value);
            $sQ = "select oxid from ".getViewName('oxvendor')." where oxid=$sVendorIdQuoted";
            self::$_aArticleVendors[$this->getId()] = $sVendorId = $oDb->getOne( $sQ );
        }
        return $sVendorId;
    }

    public function getManufacturerId( $blForceReload = false )
    {
        $sManufacturerId = false;
        if ( $this->oxarticles__oxmanufacturerid->value ) {
            if ( !$blForceReload && isset( self::$_aArticleManufacturers[$this->getId()])) {
                return self::$_aArticleManufacturers[$this->getId()];
            }
            $oDb = oxDb::getDb();
            $sQ = "select oxid from ".getViewName('oxmanufacturers')." where oxid=".$oDb->quote($this->oxarticles__oxmanufacturerid->value);
            self::$_aArticleManufacturers[$this->getId()] = $sManufacturerId = $oDb->getOne( $sQ );
        }
        return $sManufacturerId;
    }

    public function getManufacturer( $blShopCheck = true )
    {
        $oManufacturer = oxNew( 'oxmanufacturer' );;
        if ( !( $sManufacturerId = $this->getManufacturerId() ) &&
             !$blShopCheck && $this->oxarticles__oxmanufacturerid->value ) {
            $oManufacturer->setReadOnly( true );
            $sManufacturerId = $this->oxarticles__oxmanufacturerid->value;
        }

        if ( $sManufacturerId && $oManufacturer->load( $sManufacturerId ) ) {
            if ( !$this->getConfig()->getConfigParam( 'bl_perfLoadManufacturerTree' ) ) {
                $oManufacturer->setReadOnly( true );
            }
            $oManufacturer = $oManufacturer->oxmanufacturers__oxactive->value ? $oManufacturer : null;
        } else {
            $oManufacturer = null;
        }

        return $oManufacturer;
    }

    public function inCategory( $sCatNid)
    {
        return in_array( $sCatNid, $this->getCategoryIds());
    }

    public function isAssignedToCategory( $sCatId )
    {
        // variant handling
        $sOXID = $this->getId();
        if ( isset( $this->oxarticles__oxparentid->value) && $this->oxarticles__oxparentid->value) {
            $sOXID = $this->oxarticles__oxparentid->value;
        }

        $oDB = oxDb::getDb();
        $sSelect = $this->_generateSelectCatStr( $sOXID, $sCatId);
        $sOXID = $oDB->getOne( $sSelect);
        // article is assigned to passed category!
        if ( isset( $sOXID) && $sOXID) {
            return true;
        }

        // maybe this category is price category ?
        if ( $this->getConfig()->getConfigParam( 'bl_perfLoadPrice' ) && $this->_blLoadPrice ) {
            $dPriceFromTo = $this->getPrice()->getBruttoPrice();
            if ( $dPriceFromTo > 0) {
                $sSelect = $this->_generateSelectCatStr( $sOXID, $sCatId, $dPriceFromTo);
                $sOXID = $oDB->getOne( $sSelect);
                // article is assigned to passed category!
                if ( isset( $sOXID) && $sOXID) {
                    return true;
                }
            }
        }
        return false;
    }

    public function getTPrice()
    {
        if ( !$this->getConfig()->getConfigParam( 'bl_perfLoadPrice' ) || !$this->_blLoadPrice ) {
            return;
        }
        // return cached result, since oPrice is created ONLY in this function [or function of EQUAL level]
        if ( $this->_oTPrice !== null ) {
            return $this->_oTPrice;
        }

        $this->_oTPrice = oxNew( 'oxPrice' );
        $this->_oTPrice->setPrice( $this->oxarticles__oxtprice->value );

        $this->_applyVat( $this->_oTPrice, $this->getArticleVat() );
        $this->_applyCurrency( $this->_oTPrice );

        return $this->_oTPrice;
    }

    public function skipDiscounts()
    {
        // allready loaded skip discounts config
        if ( $this->_blSkipDiscounts !== null )
            return $this->_blSkipDiscounts;

        if ( $this->oxarticles__oxskipdiscounts->value )
            return true;

        $sO2CView = getViewName('oxobject2category');
        $sSelect =  "select 1 from $sO2CView as oxobject2category left join oxcategories on oxcategories.oxid = oxobject2category.oxcatnid ";
        $sSelect .= 'where oxobject2category.oxobjectid="'.$this->getId().'" and oxcategories.oxactive'.(($this->getLanguage())?'_'.$this->getLanguage():'').' = 1 and oxcategories.oxskipdiscounts = "1" ';

        return $this->_blSkipDiscounts = ( oxDb::getDb()->getOne($sSelect) == 1 );
    }

    public function setPrice(oxPrice $oPrice)
    {
        $this->_oPrice = $oPrice;
    }

    public function getBasePrice( $dAmount = 1 )
    {
        // override this function if you want e.g. different prices
        // for diff. usergroups.

        // Performance
        $myConfig = $this->getConfig();
        if( !$myConfig->getConfigParam( 'bl_perfLoadPrice' ) || !$this->_blLoadPrice )
            return;

        // GroupPrice or DB price ajusted by AmountPrice
        $dPrice = $this->_getAmountPrice( $dAmount );


        return $dPrice;
    }

    public function getPrice( $dAmount = 1 )
    {
        $myConfig = $this->getConfig();
        // Performance
        if ( !$myConfig->getConfigParam( 'bl_perfLoadPrice' ) || !$this->_blLoadPrice ) {
            return;
        }

        // return cached result, since oPrice is created ONLY in this function [or function of EQUAL level]
        if ( $dAmount != 1 || $this->_oPrice === null ) {
            $oPrice = oxNew( 'oxPrice' );

            // get base
            $oPrice->setPrice( $this->getBasePrice( $dAmount ) );

            // price handling
            if ( !$this->_blCalcPrice && $dAmount == 1 ) {
                return $this->_oPrice = $oPrice;
            }

            $this->_calculatePrice( $oPrice );
            if ( $dAmount != 1 ) {
                return $oPrice;
            }

            $this->_oPrice = $oPrice;
        }
        return $this->_oPrice;
    }

    protected function _calculatePrice( $oPrice )
    {
        // apply VAT only if configuration requires it
        if ( !$this->getConfig()->getConfigParam( 'bl_perfCalcVatOnlyForBasketOrder' ) ) {
            $this->_applyVAT( $oPrice, $this->getArticleVat() );
        }

        // apply currency
        $this->_applyCurrency( $oPrice );
        // apply discounts
        if ( !$this->skipDiscounts() ) {
            $oDiscountList = oxDiscountList::getInstance();
            $oDiscountList->applyDiscounts( $oPrice, $oDiscountList->getArticleDiscounts($this, $this->getArticleUser() ) );
        }

        return $oPrice;
    }

    public function setArticleUser($oUser)
    {
        $this->_oUser = $oUser;
    }

    public function getArticleUser()
    {
        if ($this->_oUser) {
            return $this->_oUser;
        }
        return $this->getUser();
    }

    public function getBasketPrice( $dAmount, $aSelList, $oBasket )
    {
        $oUser = $oBasket->getBasketUser();
        $this->setArticleUser($oUser);

        $oBasketPrice = oxNew( 'oxPrice' );

        // get base price
        $dBasePrice = $this->getBasePrice( $dAmount );

        // applying select list price
        $dBasePrice = $this->_modifySelectListPrice( $dBasePrice, $aSelList );

        // setting price
        $oBasketPrice->setPrice( $dBasePrice );

        // apply VAT
        $this->_applyVat( $oBasketPrice, oxVatSelector::getInstance()->getBasketItemVat( $this, $oBasket ) );

        // apply currency
        $this->_applyCurrency( $oBasketPrice );

        // apply discounts
        if ( !$this->skipDiscounts() ) {
            // apply general discounts
            $oDiscountList = oxDiscountList::getInstance();
            $oDiscountList->applyDiscounts( $oBasketPrice, $oDiscountList->getArticleDiscounts( $this, $oUser ) );
        }

        // returning final price object
        return $oBasketPrice;
    }

    public function applyBasketDiscounts(oxPrice $oPrice, $aDiscounts, $dAmount = 1)
    {
        $oDiscountList = oxDiscountList::getInstance();
        return $oDiscountList->applyBasketDiscounts( $oPrice, $aDiscounts, $dAmount );
    }

    public function delete( $sOXID = null )
    {
        if ( !$sOXID ) {
            $sOXID = $this->getId();
        }
        if ( !$sOXID ) {
            return false;
        }


        $this->load( $sOXID );
        $this->_deletePics();
        $this->_onChangeResetCounts( $sOXID, $this->oxarticles__oxvendorid->value, $this->oxarticles__oxmanufacturerid->value );
        $this->_deleteVariantRecords( $sOXID );
        $rs = $this->_deleteRecords( $sOXID );

        oxSeoEncoderArticle::getInstance()->onDeleteArticle($this);

        $this->onChange( ACTION_DELETE, $sOXID, $this->oxarticles__oxparentid->value );

        return $rs->EOF;
    }

    public function reduceStock($dAmount, $blAllowNegativeStock = false)
    {
        $this->beforeUpdate();

        $iStockCount = $this->oxarticles__oxstock->value - $dAmount;
        if (!$blAllowNegativeStock && ($iStockCount < 0)) {
            $dAmount += $iStockCount;
            $iStockCount = 0;
        }
        $this->oxarticles__oxstock = new oxField($iStockCount);

        $oDb = oxDb::getDb();
        $oDb->execute( 'update oxarticles set oxarticles.oxstock = '.$oDb->quote( $iStockCount ).' where oxarticles.oxid = '.$oDb->quote( $this->getId() ) );
        $this->onChange( ACTION_UPDATE_STOCK );
        return $dAmount;
    }

    public function updateSoldAmount( $dAmount = 0 )
    {
        if ( !$dAmount ) {
            return;
        }

        $this->beforeUpdate();

        // article is not variant - should be updated current amount
        if ( !$this->oxarticles__oxparentid->value ) {
            //updating by SQL query, due to wrong behaviour if saving article using not admin mode
            $dAmount = (double) $dAmount;
            $oDb = oxDb::getDb();
            $rs = $oDb->execute( "update oxarticles set oxarticles.oxsoldamount = oxarticles.oxsoldamount + $dAmount where oxarticles.oxid = ".$oDb->quote($this->oxarticles__oxid->value));
        } elseif ( $this->oxarticles__oxparentid->value) {
            // article is variant - should be updated this article parent amount
            $oUpdateArticle = oxNewArticle( $this->oxarticles__oxparentid->value );
            $oUpdateArticle->updateSoldAmount( $dAmount );
        }

        $this->onChange( ACTION_UPDATE );

        return $rs;
    }

    public function disableReminder()
    {
        $oDB = oxDb::getDb(true);
        return $oDB->execute( "update oxarticles set oxarticles.oxremindactive = 2 where oxarticles.oxid = ".$oDB->quote($this->oxarticles__oxid->value));
    }

    public function save()
    {
        $myConfig = $this->getConfig();

        $this->oxarticles__oxthumb = new oxField(basename($this->oxarticles__oxthumb->value), oxField::T_RAW);
        $this->oxarticles__oxicon  = new oxField(basename($this->oxarticles__oxicon->value), oxField::T_RAW);
        $iPicCount = $myConfig->getConfigParam( 'iPicCount');
        for ($i=1; $i <= $iPicCount; $i++) {
            if ( isset($this->{'oxarticles__oxpic'.$i}) ) {
                $this->{'oxarticles__oxpic'.$i}->setValue(basename($this->{'oxarticles__oxpic'.$i}->value));
            }
        }

        $blRet = parent::save();

        // save article long description
        $this->setArticleLongDesc();

        // load article images after save
        $this->_assignAllPictureValues();

        return $blRet;
    }


    public function getPictureGallery()
    {
        $myConfig = $this->getConfig();

        //initialize
        $blMorePic = false;
        $aArtPics  = array();
        $aArtIcons = array();
        $iActPicId = 1;
        $sActPic = $this->getPictureUrl( $iActPicId );

        if ( oxConfig::getParameter( 'actpicid' ) ) {
            $iActPicId = oxConfig::getParameter('actpicid');
        }

        $oStr = getStr();
        $iCntr = 0;
        $iPicCount = $myConfig->getConfigParam( 'iPicCount' );
        $blCheckActivePicId = true;

        for ( $i = 1; $i <= $iPicCount; $i++) {
            $sPicVal = $this->getPictureUrl( $i );
            $sIcoVal = $this->getIconUrl( $i );
            if ( !$oStr->strstr($sIcoVal, 'nopic_ico.jpg') && !$oStr->strstr($sIcoVal, 'nopic.jpg') ) {
                if ($iCntr) {
                    $blMorePic = true;
                }
                $aArtIcons[$i]= $sIcoVal;
                $aArtPics[$i]= $sPicVal;
                $iCntr++;

                if ($iActPicId == $i) {
                    $sActPic = $sPicVal;
                    $blCheckActivePicId = false;
                }

            } else if ( $blCheckActivePicId && $iActPicId <= $i) {
                // if picture is empty, setting active pic id to next
                // picture
                $iActPicId++;
            }
        }

        $blZoomPic  = false;
        $aZoomPics = array();
        $iZoomPicCount = $myConfig->getConfigParam( 'iPicCount' );

        for ( $j = 1,$c = 1; $j <= $iZoomPicCount; $j++) {
            $sVal = $this->getZoomPictureUrl($j);

            if ( !$oStr->strstr($sVal, 'nopic.jpg')) {
                if ($this->getConfig()->getConfigParam('blFormerTplSupport')) {
                    $sVal = $this->_sDynImageDir."/".$sVal;
                }
                $blZoomPic = true;
                $aZoomPics[$c]['id'] = $c;
                $aZoomPics[$c]['file'] = $sVal;
                //anything is better than empty name, because <img src=""> calls shop once more = x2 SLOW.
                if (!$sVal) {
                    $aZoomPics[$c]['file'] = "nopic.jpg";
                }
                $c++;
            }
        }

        $aPicGallery = array('ActPicID' => $iActPicId,
                             'ActPic' => $sActPic,
                             'MorePics' => $blMorePic,
                             'Pics' => $aArtPics,
                             'Icons' => $aArtIcons,
                             'ZoomPic' => $blZoomPic,
                             'ZoomPics' => $aZoomPics);

        return $aPicGallery;
    }

    public function onChange($sAction = null, $sOXID = null, $sParentID = null)
    {
        $myConfig = $this->getConfig();

        if (!isset($sOXID)) {
            if ( $this->getId()) {
                $sOXID = $this->getId();
            }
            if (!isset ($sOXID)) {
                $sOXID = $this->oxarticles__oxid->value;
            }
            if ($this->oxarticles__oxparentid->value) {
                $sParentID = $this->oxarticles__oxparentid->value;
            }
        }
        if (!isset($sOXID)) {
            return;
        }

        //if (isset($sOXID) && !$myConfig->blVariantParentBuyable && $myConfig->blUseStock)
        if ( $myConfig->getConfigParam( 'blUseStock' ) ) {
            //if article has variants then updating oxvarstock field
            //getting parent id
            if (!isset($sParentID)) {
                $oDb = oxDb::getDb();
                $sQ = 'select oxparentid from oxarticles where oxid = '.$oDb->quote($sOXID);
                $sParentID = $oDb->getOne($sQ);
            }
            //if we have parent id then update stock
            if ($sParentID) {
                $this->_onChangeUpdateStock($sParentID);
            }
        }
        //if we have parent id then update count
        //update count even if blUseStock is not active
        if ($sParentID) {
            $this->_onChangeUpdateVarCount($sParentID);
        }

        $sId = ( $sParentID ) ? $sParentID : $sOXID;
        $this->_onChangeUpdateMinVarPrice( $sId );

            // reseting articles count cache if stock has changed and some
            // articles goes offline (M:1448)
            if ( $sAction === ACTION_UPDATE_STOCK ) {
                $this->_onChangeStockResetCount( $sOXID );
            }

    }

    public function getCustomVAT()
    {
        if ( isset($this->oxarticles__oxvat->value) ) {
            return $this->oxarticles__oxvat->value;
        }
    }

    public function checkForStock( $dAmount, $dArtStockAmount = 0 )
    {
        $myConfig = $this->getConfig();
        if ( !$myConfig->getConfigParam( 'blUseStock' ) ) {
            return true;
        }

        // fetching DB info as its up-to-date
        $sQ = 'select oxstock, oxstockflag from oxarticles where oxid = "'.$this->getId().'" ';
        $rs = oxDb::getDb(true)->Execute( $sQ );

        $iOnStock   = 0;
        $iStockFlag = 0;
        if ( $rs !== false && $rs->recordCount() > 0 ) {
            $iOnStock   = $rs->fields['oxstock'] - $dArtStockAmount;
            $iStockFlag = $rs->fields['oxstockflag'];

            // dodger : fremdlager is also always considered as on stock
            if ( $iStockFlag == 1 || $iStockFlag == 4) {
                return true;
            }
            if ( !$myConfig->getConfigParam( 'blAllowUnevenAmounts' ) ) {
                $iOnStock = floor( $iOnStock );
            }
        }
        if ($this->getConfig()->getConfigParam( 'blPsBasketReservationEnabled' )) {
            $iOnStock += $this->getSession()->getBasketReservations()->getReservedAmount($this->getId());
        }
        if ( $iOnStock >= $dAmount ) {
            return true;
        } else {
            if ( $iOnStock > 0 ) {
                return $iOnStock;
            } else {
                $oEx = oxNew( 'oxArticleInputException' );
                $oEx->setMessage( 'EXCEPTION_ARTICLE_ARTICELNOTBUYABLE' );
                oxUtilsView::getInstance()->addErrorToDisplay( $oEx );
                return false;
            }
        }
    }


    public function getArticleLongDesc($sOXID = null)
    {

        if ( !$sOXID ) {
            $sOXID = $this->oxarticles__oxid->value;
        }

        if ($sOXID == $this->oxarticles__oxid->value) {
            if (isset($this->oxarticles__oxlongdesc) && ($this->oxarticles__oxlongdesc instanceof oxField) && $this->oxarticles__oxlongdesc->value) {
                return $this->oxarticles__oxlongdesc;
            }
        }

        $myConfig = $this->getConfig();

        if ( $sOXID ) {
            $sLangField = oxLang::getInstance()->getLanguageTag($this->getLanguage());
            $oDb = oxDb::getDb();
            $this->_setLongDesc($oDb->getOne( "select oxlongdesc{$sLangField} from oxartextends where oxid = ".$oDb->quote($sOXID) ));
        } else {
            // TODO: check if keeping fldname is needed in non-admin mode
            $this->oxarticles__oxlongdesc = new oxField();
            $this->oxarticles__oxlongdesc->fldname = 'oxlongdesc';
            $this->oxarticles__oxlongdesc->table   = 'oxarticles';
            $this->oxarticles__oxlongdesc->fldtype = 'text';
        }

        return $this->oxarticles__oxlongdesc;
    }

    protected function _setLongDesc($sDbValue)
    {
        // TODO: the code below is redundant, optimize it, assignments should go smooth without conversions
        // hack, if editor screws up text, htmledit tends to do so
        $sDbValue = str_replace( '&amp;nbsp;', '&nbsp;', $sDbValue );
        $sDbValue = str_replace( '&amp;', '&', $sDbValue );
        $sDbValue = str_replace( '&quot;', '"', $sDbValue );
        $sDbValue = str_replace( '&lang=', '&amp;lang=', $sDbValue);
        //

        $oStr = getStr();
        $blHasSmarty = $oStr->strstr( $sDbValue, '[{' );
        $blHasPhp = $oStr->strstr( $sDbValue, '<?' );
        $myConfig = oxConfig::getInstance();
        if ( ( $blHasSmarty || $blHasPhp ) && ($myConfig->getConfigParam( 'blExport' ) || !$this->isAdmin() ) && $myConfig->getConfigParam( 'bl_perfParseLongDescinSmarty' ) ) {
            $sDbValue = oxUtilsView::getInstance()->parseThroughSmarty( $sDbValue, $this->getId() );
        }
        $this->oxarticles__oxlongdesc = new oxField($sDbValue, oxField::T_RAW);
        // TODO: check if keeping fldname is needed in non-admin mode
        $this->oxarticles__oxlongdesc->fldname = 'oxlongdesc';
        $this->oxarticles__oxlongdesc->table   = 'oxarticles';
        $this->oxarticles__oxlongdesc->fldtype = 'text';
    }

    public function setArticleLongDesc()
    {

        if ( $this->_blEmployMultilanguage ) {
            // update or insert article long description
            if ($this->oxarticles__oxlongdesc instanceof oxField) {
                $sLongDesc = $this->oxarticles__oxlongdesc->getRawValue();
            } else {
                $sLongDesc = $this->oxarticles__oxlongdesc->value;
            }
            $this->_saveArtLongDesc($this->getLanguage(), $sLongDesc);
        } else {
            $oArtExt = oxNew('oxi18n');
            $oArtExt->init('oxartextends');
            $aObjFields = $oArtExt->_getAllFields(true);
            foreach ($aObjFields as $sKey => $sValue ) {
                if ( preg_match('/^oxlongdesc(_(\d{1,2}))?$/', $sKey) ) {
                    $sField = $this->_getFieldLongName($sKey);
                    if (isset($this->$sField)) {
                        $iLang = $oArtExt->_getFieldLang($sKey);
                        $sLongDesc = null;
                        if ($this->$sField instanceof oxField) {
                            $sLongDesc = $this->$sField->getRawValue();
                        } elseif (is_object($this->$sField)) {
                            $sLongDesc = $this->$sField->value;
                        }
                        if (isset($sLongDesc)) {
                            $this->_saveArtLongDesc($iLang, $sLongDesc);
                        }
                    }
                }
            }
        }
    }

    public function getAttributes()
    {
        if ( $this->_oAttributeList === null ) {
            $this->_oAttributeList = oxNew( 'oxattributelist' );
            $this->_oAttributeList->loadAttributes( $this->getId() );
        }

        return $this->_oAttributeList;
    }

    public function appendLink( $sAddParams, $iLang = null )
    {
        if ( $sAddParams ) {
            if ( $iLang === null ) {
                $iLang = $this->getLanguage();
            }

            $this->_aSeoAddParams[$iLang]  = isset( $this->_aSeoAddParams[$iLang] ) ? $this->_aSeoAddParams[$iLang] . "&amp;" : "";
            $this->_aSeoAddParams[$iLang] .= $sAddParams;
        }
    }

    public function getBaseSeoLink( $iLang, $blMain = false )
    {
        $oEncoder = oxSeoEncoderArticle::getInstance();
        if ( !$blMain ) {
            return $oEncoder->getArticleUrl( $this, $iLang, $this->getLinkType() );
        }
        return $oEncoder->getArticleMainUrl( $this, $iLang );
    }

    public function getLink( $iLang = null, $blMain = false  )
    {
        if ( !oxUtils::getInstance()->seoIsActive() ) {
            return $this->getStdLink( $iLang );
        }

        if ( $iLang === null ) {
            $iLang = $this->getLanguage();
        }

        $iLinkType = $this->getLinkType();
        if ( !isset( $this->_aSeoUrls[$iLang][$iLinkType] ) ) {
            $this->_aSeoUrls[$iLang][$iLinkType] = $this->getBaseSeoLink( $iLang, $blMain );
        }

        $sUrl = $this->_aSeoUrls[$iLang][$iLinkType];
        if ( isset($this->_aSeoAddParams[$iLang])) {
            $sUrl .= ( ( strpos( $sUrl.$this->_aSeoAddParams[$iLang], '?' ) === false ) ? '?' : '&amp;' ).$this->_aSeoAddParams[$iLang];
        }

        return $sUrl;
    }

    public function getMainLink( $iLang = null )
    {
        return $this->getLink( $iLang, true );
    }

    public function setLinkType( $iType )
    {
        // resetting detaisl link, to force new
        $this->_sDetailLink = null;

        // setting link type
        $this->_iLinkType = (int) $iType;
    }

    public function getLinkType()
    {
        return $this->_iLinkType;
    }

    public function appendStdLink( $sAddParams, $iLang = null )
    {
        if ( $sAddParams ) {
            if ( $iLang === null ) {
                $iLang = $this->getLanguage();
            }

            $this->_aStdAddParams[$iLang]  = isset( $this->_aStdAddParams[$iLang] ) ? $this->_aStdAddParams[$iLang] . "&amp;" : "";
            $this->_aStdAddParams[$iLang] .= $sAddParams;
        }
    }

    public function getBaseStdLink( $iLang, $blAddId = true, $blFull = true )
    {
        $sUrl = '';
        if ( $blFull ) {
            //always returns shop url, not admin
            $sUrl = $this->getConfig()->getShopUrl( $iLang, false );
        }

        $sUrl .= "index.php?cl=details" . ( $blAddId ? "&amp;anid=".$this->getId() : "" );
        return $sUrl . ( isset( $this->_aStdAddParams[$iLang] ) ? "&amp;". $this->_aStdAddParams[$iLang] : "" );
    }

    public function getStdLink( $iLang = null, $aParams = array() )
    {
        if ( $iLang === null ) {
            $iLang = $this->getLanguage();
        }

        if ( !isset( $this->_aStdUrls[$iLang] ) ) {
            $this->_aStdUrls[$iLang] = $this->getBaseStdLink( $iLang );
        }

        return oxUtilsUrl::getInstance()->processStdUrl( $this->_aStdUrls[$iLang], $aParams, $iLang, $iLang != $this->getLanguage() );
    }

    public function getStdTagLink( $sTag )
    {
        $sStdTagLink = $this->getConfig()->getShopHomeURL( $this->getLanguage(), false );
        return $sStdTagLink . "cl=details&amp;anid=".$this->getId()."&amp;listtype=tag&amp;searchtag=".rawurlencode( $sTag );
    }

    public function getTags()
    {
        $sTagField = "oxtags".oxLang::getInstance()->getLanguageTag($this->getLanguage());
        $sQ = "select $sTagField from oxartextends where oxid = '".$this->getId()."'";
        $sTags = oxDb::getDb(true)->getOne($sQ);
        $oTagCloud = oxNew('oxtagcloud');
        $sTags = $oTagCloud->trimTags($sTags);
        return $sTags;
    }

    public function saveTags($sTags)
    {
        //do not allow derived update
        if ( !$this->allowDerivedUpdate() ) {
            return false;
        }


        $oTagCloud = oxNew('oxtagcloud');
        $oTagCloud->resetTagCache();
        $sTags = $oTagCloud->prepareTags($sTags);

        $sTags = mysql_real_escape_string($sTags);

        $sTagField = "oxtags".oxLang::getInstance()->getLanguageTag($this->getLanguage());
        $sQ = "update oxartextends set $sTagField = '$sTags'  where oxid = '".$this->getId()."'";
        return oxDb::getDb()->execute($sQ);
    }

    public function addTag($sTag)
    {
        $oDb = oxDb::getDb();

        $oTagCloud = oxNew('oxtagcloud');
        $oTagCloud->resetTagCache();
        $sTag = $oTagCloud->prepareTags($sTag);
        $sTagSeparator = $this->getConfig()->getConfigParam('sTagSeparator');

        $sField = "oxartextends.OXTAGS" . oxLang::getInstance()->getLanguageTag();

        if ( $oDb->getOne( "select $sField from oxartextends where oxartextends.OXID = '{$this->getId()}'" ) ) {
            $sTailTag = $sTagSeparator . $sTag;
        } else {
            $sTailTag = $sTag;
        }

        $sTag = mysql_real_escape_string($sTag);
        $sTailTag = mysql_real_escape_string($sTailTag);

        $sQ = "insert into oxartextends (oxartextends.OXID, $sField) values ('".$this->getId()."', '{$sTag}')
                       ON DUPLICATE KEY update $sField = CONCAT(TRIM($sField), '$sTailTag') ";

        return $oDb->Execute($sQ);
    }

    public function getMediaUrls()
    {
        if ( $this->_aMediaUrls === null ) {
            $this->_aMediaUrls = oxNew("oxlist");
            $this->_aMediaUrls->init("oxmediaurl");
            $this->_aMediaUrls->getBaseObject()->setLanguage( $this->getLanguage() );

            $sQ = "select * from oxmediaurls where oxobjectid = '".$this->getId()."'";
            $this->_aMediaUrls->selectString($sQ);
        }
        return $this->_aMediaUrls;
    }

    public function getDynImageDir()
    {
        return $this->_sDynImageDir;
    }

    public function getDispSelList()
    {
        if ($this->_aDispSelList === null) {
            if ( $this->getConfig()->getConfigParam( 'bl_perfLoadSelectLists' ) && $this->getConfig()->getConfigParam( 'bl_perfLoadSelectListsInAList' ) ) {
                $this->_aDispSelList = $this->getSelectLists();
            }
        }
        return $this->_aDispSelList;
    }

    public function getMoreDetailLink()
    {
        if ( $this->_sMoreDetailLink == null ) {

            // and assign special article values
            $this->_sMoreDetailLink = $this->getConfig()->getShopHomeURL() . 'cl=moredetails';

            // not always it is okey, as not all the time active category is the same as primary article cat.
            if ( $sActCat = oxConfig::getParameter( 'cnid' ) ) {
                $this->_sMoreDetailLink .= '&amp;cnid='.$sActCat;
            }
            $this->_sMoreDetailLink .= '&amp;anid='.$this->getId();
            $this->_sMoreDetailLink = $this->_sMoreDetailLink;
        }

        return $this->_sMoreDetailLink;
    }

    public function getToBasketLink()
    {
        if ( $this->_sToBasketLink == null ) {
            $myConfig = $this->getConfig();

            if ( oxUtils::getInstance()->isSearchEngine() ) {
                $this->_sToBasketLink = $this->getLink();
            } else {
                // and assign special article values
                $this->_sToBasketLink = $myConfig->getShopHomeURL();

                // override some classes as these should never showup
                $sActClass = oxConfig::getParameter( 'cl' );
                if ( $sActClass == 'thankyou') {
                    $sActClass = 'basket';
                }
                $this->_sToBasketLink .= 'cl='.$sActClass;

                // this is not very correct
                if ( $sActCat = oxConfig::getParameter( 'cnid' ) ) {
                    $this->_sToBasketLink .= '&amp;cnid='.$sActCat;
                }

                $this->_sToBasketLink .= '&amp;fnc=tobasket&amp;aid='.$this->getId().'&amp;anid='.$this->getId();

                if ( $sTpl = basename( oxConfig::getParameter( 'tpl' ) ) ) {
                    $this->_sToBasketLink .= '&amp;tpl='.$sTpl;
                }
            }
        }

        return $this->_sToBasketLink;
    }

    public function getStockStatus()
    {
        return $this->_iStockStatus;
    }

    public function getDeliveryDate()
    {
        if ( $this->oxarticles__oxdelivery->value != '0000-00-00') {
            return oxUtilsDate::getInstance()->formatDBDate( $this->oxarticles__oxdelivery->value);
        }
        return false;
    }

    public function getFTPrice()
    {
        if ( $oPrice = $this->getTPrice() ) {
            if ( $oPrice->getBruttoPrice() ) {
                return oxLang::getInstance()->formatCurrency( oxUtils::getInstance()->fRound($oPrice->getBruttoPrice()));
            }
        }
    }

    public function getFPrice()
    {
        if ( $oPrice = $this->getPrice() ) {
            return $this->getPriceFromPrefix().oxLang::getInstance()->formatCurrency( $oPrice->getBruttoPrice() );
        }
    }

    public function getPricePerUnit()
    {
        return $this->_fPricePerUnit;
    }

    public function isParentNotBuyable()
    {
        return $this->_blNotBuyableParent;
    }

    public function isNotBuyable()
    {
        return $this->_blNotBuyable;
    }

    public function setBuyableState( $blBuyable = false )
    {
        $this->_blNotBuyable = !$blBuyable;
    }

    public function getVariantList()
    {
        return $this->getVariants();
    }

    public function setSelectlist( $aSelList )
    {
        $this->_aDispSelList = $aSelList;
    }

    public function getPictureUrl( $iIndex = '' )
    {
        if ( $iIndex ) {

            if ( !$this->_hasGeneratedImage( $iIndex ) ) {
                $this->_generateImages( $iIndex );
            }

            $sPic = $iIndex . "/" . $this->_getPictureName( $iIndex );

            return $this->getConfig()->getPictureUrl( $sPic, $this->isAdmin() );
        }
    }

    protected function _getPictureName( $iIndex = '' )
    {
        if ( !$this->_isFieldEmpty( "oxarticles__oxpic".$iIndex ) ) {
            $sPicName = basename($this->{"oxarticles__oxpic".$iIndex}->value);
        } else {
            $sPicName = "nopic.jpg";
        }

        return $sPicName;
    }

    public function getIconUrl( $iIndex = '')
    {
        if ( $this->_isFieldEmpty( "oxarticles__oxicon" ) ) {

            $iIconIndex = ( $iIndex ) ? $iIndex : 1;
            //generating new images if needed
            if ( !$this->_hasGeneratedImage( $iIconIndex ) ) {
                $this->_generateImages( $iIconIndex );
            }
        }

        $sIconName = $this->_getIconName( $iIndex );

        if ( !$iIndex ) {
            $sPic = "icon/" . basename( $sIconName );
        } else {
            $sPic = $iIndex . "/" . basename( $sIconName );
        }

        return $this->getConfig()->getIconUrl( $sPic, $this->isAdmin() );
    }

    protected function _getIconName( $iIndex = '' )
    {
        $oPictureHandler = oxPictureHandler::getInstance();
        $sIconName = "nopic_ico.jpg";

        if ( !$iIndex ) {
            if ( !$this->_isFieldEmpty( "oxarticles__oxicon" ) ) {
                $sIconName = basename( $this->oxarticles__oxicon->value );
            } elseif ( $this->_hasGeneratedImage( 1 ) && $this->_hasMasterImage( 1 )  && $this->oxarticles__oxpic1->value ) {
                $sIconName = $oPictureHandler->getMainIconName( $this->oxarticles__oxpic1->value );
            }
        } else {
            if ( $this->_hasGeneratedImage( $iIndex ) && $this->{"oxarticles__oxpic".$iIndex}->value ) {
                $sIconName = $oPictureHandler->getIconName( $this->{"oxarticles__oxpic".$iIndex}->value );
            }
        }

        return $sIconName;
    }

    public function getThumbnailUrl()
    {
        if ( $this->_isFieldEmpty( "oxarticles__oxthumb" ) ) {
            //generating new images if needed
            if ( !$this->_hasGeneratedImage( 1 ) ) {
                $this->_generateImages( 1 );
            }
        }

        $sPic = "0/" . $this->_getThumbnailName();

        return $this->getConfig()->getPictureUrl( $sPic, $this->isAdmin() );
    }

    protected function _getThumbnailName()
    {
        if ( !$this->_isFieldEmpty( "oxarticles__oxthumb" ) ) {
            $sThumbName = basename($this->oxarticles__oxthumb->value);
        } else {
            if ( $this->_hasGeneratedImage( 1 ) && $this->_hasMasterImage( 1 ) && $this->oxarticles__oxpic1->value ) {
                $oPictureHandler = oxPictureHandler::getInstance();
                $sThumbName = $oPictureHandler->getThumbName( $this->oxarticles__oxpic1->value );
            } else {
                $sThumbName = "nopic.jpg";
            }
        }

        return $sThumbName;
    }

    public function getZoomPictureUrl( $iIndex = '' )
    {
        $iIndex = (int) $iIndex;
        if ( $iIndex > 0) {
            //generating new images if needed
            if ( $this->_isFieldEmpty( "oxarticles__oxzoom" . $iIndex ) ) {
                //generating new images if needed
                if ( !$this->_hasGeneratedImage( $iIndex ) ) {
                    $this->_generateImages( $iIndex );
                }
            }

            $sPic = "z{$iIndex}/" . $this->_getZoomPictureName( $iIndex );

            return $this->getConfig()->getPictureUrl( $sPic, $this->isAdmin() );
        }
    }

    protected function _getZoomPictureName( $iIndex = '' )
    {
        $sZoomField = "oxarticles__oxzoom" . $iIndex;

        if ( !$this->_isFieldEmpty( $sZoomField ) ) {
            $sZoomName = basename( $this->$sZoomField->value );
        } else {
            if ( $this->_hasGeneratedImage( $iIndex ) && $this->_hasMasterImage( $iIndex ) && $this->{"oxarticles__oxpic".$iIndex}->value ) {
                $oPictureHandler = oxPictureHandler::getInstance();
                $sZoomName = $oPictureHandler->getZoomName( $this->{"oxarticles__oxpic".$iIndex}->value, $iIndex );
            } else {
                $sZoomName = "nopic.jpg";
            }
        }

        return $sZoomName;
    }

    public function getFileUrl()
    {
        return $this->getConfig()->getPictureUrl( '0/' );
    }

    public function getPriceFromPrefix()
    {
        $sPricePrefics = '';
        if ( $this->_blIsRangePrice) {
            $sPricePrefics = oxLang::getInstance()->translateString('priceFrom').' ';
        }

        return $sPricePrefics;
    }

    protected function _saveArtLongDesc($iLang, $sValue)
    {
        $oDB = oxDb::getDb();
        $iLang = (int) $iLang;
        $sLangField = ($iLang > '0') ? '_'.$iLang : '';
        $sLongDesc = $oDB->quote($sValue);
        $sLongDescSQL = "insert into oxartextends (oxartextends.OXID, oxartextends.OXLONGDESC{$sLangField})
                       VALUES ('".$this->getId()."', {$sLongDesc})
                       ON DUPLICATE KEY update oxartextends.OXLONGDESC{$sLangField} = {$sLongDesc} ";

        $oDB->execute($sLongDescSQL);
    }

    protected function _skipSaveFields()
    {
        $myConfig = $this->getConfig();

        $this->_aSkipSaveFields = array();

        $this->_aSkipSaveFields[] = 'oxtimestamp';
        $this->_aSkipSaveFields[] = 'oxlongdesc';
        $this->_aSkipSaveFields[] = 'oxinsert';

        if ( !isset( $this->oxarticles__oxparentid->value) || $this->oxarticles__oxparentid->value == '') {
            $this->_aSkipSaveFields[] = 'oxparentid';
        }

    }

    protected function _mergeDiscounts( $aDiscounts, $aItemDiscounts)
    {
        foreach ( $aItemDiscounts as $sKey => $oDiscount ) {
            // add prices of the same discounts
            if ( array_key_exists ($sKey, $aDiscounts) ) {
                $aDiscounts[$sKey]->dDiscount += $oDiscount->dDiscount;
            } else {
                $aDiscounts[$sKey] = $oDiscount;
            }
        }
        return $aDiscounts;
    }

    protected function _getGroupPrice()
    {
        $dPrice = $this->oxarticles__oxprice->value;

        $oUser = $this->getArticleUser();
        if ( $oUser ) {
            if ( $oUser->inGroup( 'oxidpricea' ) ) {
                $dPrice = $this->oxarticles__oxpricea->value;
            } elseif ( $oUser->inGroup( 'oxidpriceb' ) ) {
                $dPrice = $this->oxarticles__oxpriceb->value;
            } elseif ( $oUser->inGroup( 'oxidpricec' ) ) {
                $dPrice = $this->oxarticles__oxpricec->value;
            }
        }

        // #1437/1436C - added config option, and check for zero A,B,C price values
        if ( $this->getConfig()->getConfigParam( 'blOverrideZeroABCPrices' ) && (double) $dPrice == 0 ) {
            $dPrice = $this->oxarticles__oxprice->value;
        }

        return $dPrice;
    }

    protected function _getAmountPrice($dAmount = 1)
    {
        $myConfig = $this->getConfig();

        startProfile( "_getAmountPrice" );

        $dPrice = $this->_getGroupPrice();
        $oAmtPrices = $this->_getAmountPriceList();
        foreach ($oAmtPrices as $oAmPrice) {
            if ($oAmPrice->oxprice2article__oxamount->value <= $dAmount
                    && $dAmount <= $oAmPrice->oxprice2article__oxamountto->value
                    && $dPrice > $oAmPrice->oxprice2article__oxaddabs->value ) {
                $dPrice = $oAmPrice->oxprice2article__oxaddabs->value;
            }
        }

        stopProfile( "_getAmountPrice" );
        return $dPrice;
    }

    protected function _modifySelectListPrice( $dPrice, $aChosenList = null )
    {
        $myConfig = $this->getConfig();
        // #690
        if ( $myConfig->getConfigParam( 'bl_perfLoadSelectLists' ) && $myConfig->getConfigParam( 'bl_perfUseSelectlistPrice' ) ) {

            $aSelLists = $this->getSelectLists();
            foreach ( $aSelLists as $key => $aSel) {
                if ( isset( $aChosenList[$key]) && isset($aSel[$aChosenList[$key]] ) ) {
                    $oSel = $aSel[$aChosenList[$key]];
                    if ( $oSel->priceUnit =='abs' ) {
                        $dPrice += $oSel->price;
                    } elseif ( $oSel->priceUnit =='%' ) {
                        $dPrice += oxPrice::percent( $dPrice, $oSel->price );
                    }
                }
            }
        }
        return $dPrice;
    }


    protected function _fillAmountPriceList($oAmPriceList)
    {
        $myConfig = $this->getConfig();
        $myUtils  = oxUtils::getInstance();

        //modifying price
        $oCur = $myConfig->getActShopCurrencyObject();

        $oUser = $this->getArticleUser();

        $oDiscountList = oxDiscountList::getInstance();
        $aDiscountList = $oDiscountList->getArticleDiscounts( $this, $oUser );

        $oLowestPrice = null;

        $dBasePrice = $this->_getGroupPrice();
        $oLang = oxLang::getInstance();

        $dArticleVat = null;
        if ( !$myConfig->getConfigParam( 'bl_perfCalcVatOnlyForBasketOrder' ) ) {
            $dArticleVat = $this->getArticleVat();
        }

        // trying to find lowest price value
        foreach ($oAmPriceList as $sId => $oItem) {
            $oItemPrice = oxNew( 'oxprice' );
            if ( $oItem->oxprice2article__oxaddabs->value) {
                $oItemPrice->setPrice( $oItem->oxprice2article__oxaddabs->value );
                $oDiscountList->applyDiscounts( $oItemPrice, $aDiscountList );
                $this->_applyCurrency( $oItemPrice, $oCur );
            } else {
                $oItemPrice->setPrice( $dBasePrice );
                $oItemPrice->subtractPercent( $oItem->oxprice2article__oxaddperc->value );
            }

            if (isset($dArticleVat)) {
                $this->_applyVAT($oItemPrice, $dArticleVat);
            }

            if (!$oLowestPrice) {
                $oLowestPrice = $oItemPrice;
            } elseif ($oLowestPrice->getBruttoPrice() > $oItemPrice->getBruttoPrice()) {
                $oLowestPrice = $oItemPrice;
            }

            $oAmPriceList[$sId]->oxprice2article__oxaddabs = new oxField( $oLang->formatCurrency( $myUtils->fRound( $oItemPrice->getBruttoPrice(), $oCur ) ) );
            $oAmPriceList[$sId]->fnetprice  = $oLang->formatCurrency( $myUtils->fRound($oItemPrice->getNettoPrice(), $oCur ) );
            $oAmPriceList[$sId]->fbrutprice = $oLang->formatCurrency( $myUtils->fRound($oItemPrice->getBruttoPrice(), $oCur ) );
        }

        $this->_dAmountPrice = $myUtils->fRound( $oLowestPrice->getBruttoPrice() );
        return $oAmPriceList;
    }

    protected function _getVariantsIds()
    {
        $aSelect = array();
        $oRs = oxDb::getDb(true)->execute( "select oxid from oxarticles where oxparentid = '".$this->getId()."' " );
        if ( $oRs != false && $oRs->recordCount() > 0 ) {
            while (!$oRs->EOF) {
                $aSelect[] = $oRs->fields['oxid'];
                $oRs->moveNext();
            }
        }
        return $aSelect;
    }

    public function getArticleVat()
    {
        if (!isset($this->_dArticleVat)) {
            $this->_dArticleVat = oxVatSelector::getInstance()->getArticleVat( $this );
        }
        return $this->_dArticleVat;
    }

    protected function _applyVAT( oxPrice $oPrice, $dVat )
    {
        startProfile(__FUNCTION__);
        $oPrice->setVAT( $dVat );
        if ( ($dVat = oxVatSelector::getInstance()->getArticleUserVat($this)) !== false ) {
            $oPrice->setUserVat( $dVat );
        }
        stopProfile(__FUNCTION__);
    }

    public function applyVats( oxPrice $oPrice )
    {
        $this->_applyVAT($oPrice, $this->getArticleVat() );
    }

    protected function _applyDiscounts( $oPrice, $aDiscounts )
    {
        $oDiscountList = oxDiscountList::getInstance();
        $oDiscountList->applyDiscounts( $oPrice, $aDiscounts );
    }

    public function applyDiscountsForVariant( $oPrice )
    {
        // apply discounts
        if ( !$this->skipDiscounts() ) {
            $oDiscountList = oxDiscountList::getInstance();
            $oDiscountList->applyDiscounts( $oPrice, $oDiscountList->getArticleDiscounts( $this, $this->getArticleUser() ) );
        }
    }

    protected function _applyCurrency(oxPrice $oPrice, $oCur = null )
    {
        if ( !$oCur ) {
            $oCur = $this->getConfig()->getActShopCurrencyObject();
        }

        $oPrice->multiply($oCur->rate);
    }


    protected function _getAttribsString(&$sAttribs, &$iCnt)
    {
        // we do not use lists here as we dont need this overhead right now
        $oDB = oxDb::getDb(true);
        $sSelect =  'select oxattrid from oxobject2attribute where oxobject2attribute.oxobjectid="'.$this->getId().'" ';
        $sAttribs = '';
        $blSep = false;
        $rs = $oDB->execute( $sSelect);
        $iCnt = 0;
        if ($rs != false && $rs->recordCount() > 0) {
            while (!$rs->EOF) {
                if ( $blSep) {
                    $sAttribs .= ' or ';
                }
                $sAttribs .= 't1.oxattrid = '.$oDB->quote($rs->fields['oxattrid']).' ';
                $blSep = true;
                $iCnt++;
                $rs->moveNext();
            }
        }
    }

    protected function _getSimList($sAttribs, $iCnt)
    {
        $myConfig = $this->getConfig();
        $oDB      = oxDb::getDb(true);

        // #523A
        $iAttrPercent = $myConfig->getConfigParam( 'iAttributesPercent' )/100;
        // 70% same attributes
        if ( !$iAttrPercent || $iAttrPercent < 0 || $iAttrPercent > 1) {
            $iAttrPercent = 0.70;
        }
        // #1137V iAttributesPercent = 100 doesnt work
        $iHitMin = ceil( $iCnt * $iAttrPercent );

        // we do not use lists here as we dont need this overhead right now
        $aList= array();
        $sSelect =  "select oxobjectid, count(*) as cnt from oxobject2attribute as t1 where
                    ( $sAttribs )
                    and t1.oxobjectid != '".$this->oxarticles__oxid->value."'
                    group by t1.oxobjectid having count(*) >= $iHitMin ";

        $rs = $oDB->selectLimit( $sSelect, 20, 0);
        if ($rs != false && $rs->recordCount() > 0) {
            while (!$rs->EOF) {
                $oTemp = new stdClass();    // #663
                $oTemp->cnt = $rs->fields['cnt'];
                $oTemp->id  = $rs->fields['oxobjectid'];
                $aList[] = $oTemp;
                $rs->moveNext();
            }
        }
        return $aList;
    }

    protected function _generateSimListSearchStr($sArticleTable, $aList)
    {
        $myConfig = $this->getConfig();
        $sFieldList = $this->getSelectFields();
        $sSearch = "select $sFieldList from $sArticleTable where ".$this->getSqlActiveSnippet()."  and $sArticleTable.oxissearch = 1 and $sArticleTable.oxid in ( ";
        $blSep = false;
        $iCnt = 0;
        $oDb = oxDb::getDb();
        foreach ( $aList as $oTemp) {
            if ( $blSep) {
                $sSearch .= ',';
            }
            $sSearch .= $oDb->quote($oTemp->id);
            $blSep = true;
            if ( $iCnt >= $myConfig->getConfigParam( 'iNrofSimilarArticles' ) ) {
                break;
            }
            $iCnt++;
        }

        //#1741T
        //$sSearch .= ") and $sArticleTable.oxparentid = '' ";
        $sSearch .= ') ';

        // #524A -- randomizing articles in attribute list
        $sSearch .= ' order by rand() ';

        return $sSearch;
    }

    protected function _generateSearchStr($sOXID, $blSearchPriceCat = false )
    {
        $sCatView = getViewName( 'oxcategories' );
        $sO2CView = getViewName( 'oxobject2category' );

        // we do not use lists here as we dont need this overhead right now
        if ( !$blSearchPriceCat ) {
            $sSelect  = "select {$sCatView}.* from {$sO2CView} as oxobject2category left join {$sCatView} on
                         {$sCatView}.oxid = oxobject2category.oxcatnid
                         where oxobject2category.oxobjectid=".oxDb::getDb()->quote($sOXID)." and {$sCatView}.oxid is not null ";
        } else {
            $sSelect  = "select {$sCatView}.* from {$sCatView} where
                         '{$this->oxarticles__oxprice->value}' >= {$sCatView}.oxpricefrom and
                         '{$this->oxarticles__oxprice->value}' <= {$sCatView}.oxpriceto ";
        }
        return $sSelect;
    }

    protected function _generateSearchStrForCustomerBought()
    {
        $sArtTable = $this->_getObjectViewName( 'oxarticles' );
        $sOrderArtTable = getViewName( 'oxorderarticles' );

        // fetching filter params
        $sIn = " '{$this->oxarticles__oxid->value}' ";
        if ( $this->oxarticles__oxparentid->value ) {

            // adding article parent
            $sIn .= ", '{$this->oxarticles__oxparentid->value}' ";
            $sParentIdForVariants = $this->oxarticles__oxparentid->value;

        } else {
            $sParentIdForVariants = $this->getId();
        }

        // adding variants
        $oDb = oxDb::getDb(true);
        $oRs = $oDb->execute( "select oxid from {$sArtTable} where oxparentid = ".$oDb->quote($sParentIdForVariants)." and oxid != ".$oDb->quote($this->oxarticles__oxid->value)." " );
        if ( $oRs != false && $oRs->recordCount() > 0) {
            while ( !$oRs->EOF ) {
                $sIn .= ", ".$oDb->quote(current( $oRs->fields ))." ";
                $oRs->moveNext();
            }
        }

        $iLimit = (int) $this->getConfig()->getConfigParam( 'iNrofCustomerWhoArticles' );
        $iLimit = $iLimit?( $iLimit * 10 ): 50;

        // building sql (optimized)
        $sQ = "select distinct {$sArtTable}.* from (
                   select d.oxorderid as suborderid from {$sOrderArtTable} as d use index ( oxartid ) where d.oxartid in ( {$sIn} ) limit {$iLimit}
               ) as suborder
               left join {$sOrderArtTable} force index ( oxorderid ) on suborder.suborderid = {$sOrderArtTable}.oxorderid
               left join {$sArtTable} on {$sArtTable}.oxid = {$sOrderArtTable}.oxartid
               where {$sArtTable}.oxid not in ( {$sIn} )
               and ( {$sArtTable}.oxissearch = 1 or {$sArtTable}.oxparentid <> '' ) and ".$this->getSqlActiveSnippet();

        /* non optimized, but could be used if index forcing is not supported
        // building sql
        $sQ = "select distinct {$sArtTable}.* from {$sOrderArtTable}, {$sArtTable} where {$sOrderArtTable}.oxorderid in (
                   select {$sOrderArtTable}.oxorderid from {$sOrderArtTable} where {$sOrderArtTable}.oxartid in ( {$sIn} )
               ) and {$sArtTable}.oxid = {$sOrderArtTable}.oxartid and {$sArtTable}.oxid not in ( {$sIn} )
               and ( {$sArtTable}.oxissearch = 1 or {$sArtTable}.oxparentid <> '' )
               and ".$this->getSqlActiveSnippet();
        */

        return $sQ;
    }

    protected function _generateSelectCatStr($sOXID, $sCatId, $dPriceFromTo = false)
    {
        $sCategoryView = getViewName('oxcategories');
        $sO2CView = getViewName('oxobject2category');
        $sLangPrefix = (($this->getLanguage())?'_'.$this->getLanguage():'');

        $oDb    = oxDb::getDb();
        $sOXID  = $oDb->quote($sOXID);
        $sCatId = $oDb->quote($sCatId);

        if (!$dPriceFromTo) {
            $sSelect  = "select oxobject2category.oxcatnid from $sO2CView as oxobject2category ";
            $sSelect .= "left join $sCategoryView as oxcategories on oxcategories.oxid = oxobject2category.oxcatnid ";
            $sSelect .= "where oxobject2category.oxcatnid=$sCatId and oxobject2category.oxobjectid=$sOXID ";
            $sSelect .= "and oxcategories.oxactive$sLangPrefix = 1 order by oxobject2category.oxtime ";
        } else {
            $dPriceFromTo = $oDb->quote($dPriceFromTo);
            $sSelect  = "select oxcategories.oxid from $sCategoryView as oxcategories where ";
            $sSelect .= "oxcategories.oxid=$sCatId and $dPriceFromTo >= oxcategories.oxpricefrom and ";
            $sSelect .= "$dPriceFromTo <= oxcategories.oxpriceto ";
        }
        return $sSelect;
    }

    protected function _getAmountPriceList()
    {
        if ($this->_oAmountPriceList) {
            return $this->_oAmountPriceList;
        }

        $myConfig = $this->getConfig();

        $sArtID  = $this->getId();

        // #1690C - Scale prices and variants
        if ( !$this->isAdmin() && $myConfig->getConfigParam( 'blVariantInheritAmountPrice' ) && $this->oxarticles__oxparentid->value ) {
            $sArtID = $this->oxarticles__oxparentid->value;
        }

        $sArtID = mysql_real_escape_string($sArtID);

        //collecting assigned to article amount-price list
        $oAmPriceList = oxNew( 'oxlist');
        $oAmPriceList->init('oxbase', 'oxprice2article');

        $sShopID = $myConfig->getShopID();
        if ( $myConfig->getConfigParam( 'blMallInterchangeArticles' ) ) {
            $sShopSelect = '1';
        } else {
            $sShopSelect = " oxshopid =  '$sShopID' ";
        }

        $oAmPriceList->selectString( "select * from oxprice2article where oxartid = '$sArtID' and $sShopSelect order by oxamount ");

        // prepare abs prices if currently having percentages
        $oBasePrice = $this->_getGroupPrice();
        foreach ($oAmPriceList as $oAmPrice) {
            if ($oAmPrice->oxprice2article__oxaddperc->value) {
                $oAmPrice->oxprice2article__oxaddabs = new oxField(oxPrice::percent( $oBasePrice, 100 - $oAmPrice->oxprice2article__oxaddperc->value ), oxField::T_RAW);
            }
        }

        $this->_oAmountPriceList = $oAmPriceList;
        return $oAmPriceList;
    }

    protected function _isFieldEmpty($sFieldName)
    {
        $mValue = $this->$sFieldName->value;

        if (is_null($mValue)) {
            return true;
        }

        if ($mValue === '') {
            return true;
        }

        $aDoubleCopyFields = array('oxarticles__oxprice',
                                       'oxarticles__oxvat');

        if (!$mValue && in_array($sFieldName, $aDoubleCopyFields)) {
            return true;
        }


        if (!strcmp($mValue, '0000-00-00 00:00:00') || !strcmp($mValue, '0000-00-00')) {
            return true;
        }

        $sFieldName = strtolower($sFieldName);

        if ( $sFieldName == 'oxarticles__oxicon' && strpos($mValue, "nopic_ico.jpg") !== false ) {
            return true;
        }

        if ( strpos($mValue, "nopic.jpg") !== false && ($sFieldName == 'oxarticles__oxthumb' || substr($sFieldName, 0, 17) == 'oxarticles__oxpic' || substr($sFieldName, 0, 18) == 'oxarticles__oxzoom') ) {
            return true;
        }

        return false;
    }

    protected function _assignParentFieldValue($sFieldName)
    {
        if (!($oParentArticle = $this->getParentArticle())) {
            return;
        }

        $sCopyFieldName = $this->_getFieldLongName($sFieldName);

        // assigning only theese which parent article has
        if ( $oParentArticle->$sCopyFieldName != null ) {

            // only overwrite database values
            if ( substr( $sCopyFieldName, 0, 12) != 'oxarticles__') {
                continue;
            }

            //do not copy certain fields
            if (in_array($sCopyFieldName, $this->_aNonCopyParentFields)) {
                return;
            }

            //COPY THE VALUE
            // assigning images from parent only if variant has no master image (#1807)
            if ( stristr($sCopyFieldName, '_oxthumb') || stristr($sCopyFieldName, '_oxicon') ) {
                if ( $this->_isFieldEmpty( $sCopyFieldName ) && !$this->_hasMasterImage( 1 ) ) {
                    $this->$sCopyFieldName = clone $oParentArticle->$sCopyFieldName;
                }
            } elseif ( stristr($sCopyFieldName, '_oxzoom') ) {
                // for zoom images checking master image with specified index
                // assign from parent only if no pictures to variant are added
                $iIndex = (int) str_ireplace( "oxarticles__oxzoom", "", $sFieldName );
                if ( $this->_isFieldEmpty( $sCopyFieldName ) && !$this->_hasMasterImage( $iIndex ) && !$this->_hasMasterImage( 1 ) ) {
                    $this->$sCopyFieldName = clone $oParentArticle->$sCopyFieldName;
                }
            } elseif ( stristr($sCopyFieldName, '_oxpicsgenerated') && $this->{$sCopyFieldName}->value == 0 ) {
                // if no pics generated for variants, load all from
                $this->$sCopyFieldName = clone $oParentArticle->$sCopyFieldName;
            } elseif ($this->_isFieldEmpty($sCopyFieldName) || in_array( $sCopyFieldName, $this->_aCopyParentField ) ) {
                $this->$sCopyFieldName = clone $oParentArticle->$sCopyFieldName;
            }
        }
    }

    public function getParentArticle()
    {
        if ( ( $sParentId = $this->oxarticles__oxparentid->value ) ) {
            if ( !isset( self::$_aLoadedParents[$sParentId] ) ) {
                self::$_aLoadedParents[$sParentId] = oxNew( 'oxarticle' );
                self::$_aLoadedParents[$sParentId]->_blSkipAbPrice  = true;
                self::$_aLoadedParents[$sParentId]->_blLoadPrice    = false;
                self::$_aLoadedParents[$sParentId]->_blLoadVariants = false;
                self::$_aLoadedParents[$sParentId]->load( $sParentId );
            }
            return self::$_aLoadedParents[$sParentId];
        }
    }

    protected function _getParentAricle()
    {
        return $this->getParentArticle();
    }

    protected function _assignParentFieldValues()
    {   startProfile('articleAssignParentInternal');
        if ( $this->oxarticles__oxparentid->value) {
            // yes, we are in fact a variant
            if ( !$this->isAdmin() || ($this->_blLoadParentData && $this->isAdmin() ) ) {
                foreach ($this->_aFieldNames as $sFieldName => $sVal) {
                    $this->_assignParentFieldValue($sFieldName);
                }

                //assing long description
                $oParentArticle = $this->getParentArticle();
                if ( !$this->oxarticles__oxlongdesc->value ) {
                    $this->oxarticles__oxlongdesc = $oParentArticle->oxarticles__oxlongdesc;
                }

            }
        }
        stopProfile('articleAssignParentInternal');

    }

    protected function _assignNotBuyableParent()
    {
        if ( !$this->getConfig()->getConfigParam( 'blVariantParentBuyable' ) &&
             ($this->_blHasVariants || $this->oxarticles__oxvarstock->value || $this->oxarticles__oxvarcount->value )) {
            $this->_blNotBuyableParent = true;

        }
    }

    protected function _assignAllPictureValues()
    {
        $myConfig = $this->getConfig();

        $this->_assignPictureValues( "oxarticles__oxicon" );
        $this->_assignPictureValues( "oxarticles__oxthumb" );

        $iPicCount = $myConfig->getConfigParam( 'iPicCount' );

        for ( $i=1; $i<= $iPicCount; $i++ ) {
            $this->_assignPictureValues( "oxarticles__oxpic".$i );
        }

        if ( $iZoomPicCount = $myConfig->getConfigParam( 'iZoomPicCount' ) ) {
            for ( $i=1; $i<= $iZoomPicCount; $i++ ) {
                $this->_assignZoomPictureValues( "oxarticles__oxzoom".$i );
            }
        }
    }

    protected function _assignZoomPictureValues( $sName='' )
    {
        if ( $this->isAdmin() ) {
            return;
        }

        $sFieldName = substr_replace( $sName, "", 0, 12);

        $aAllFields = $this->_getAllFields( true );

        if ( isset( $aAllFields[$sFieldName] ) ) {
            $this->$sName = parent::__get( $sName );
            $this->$sName->value;
        }

        $this->_assignParentFieldValue( $sName );

        $iIndex = (int) str_ireplace( "oxzoom", "", $sFieldName );

        if ( isset($this->_aFieldNames[$sFieldName]) || isset($this->_aFieldNames["oxpic".$iIndex]) ) {
            if ( $iIndex > 0 ) {
                $this->$sName = new oxField( 'z' . $iIndex.'/'.$this->_getZoomPictureName($iIndex) );
            }
        }
    }

    protected function _assignPictureValues( $sName='' )
    {
        if ( $this->isAdmin() || !$sName ) {
            return;
        }

        $sFieldName = substr_replace( $sName, "", 0, 12);
        $myConfig = $this->getConfig();

        // add directories
        if ( $sFieldName == 'oxicon' && isset($this->_aFieldNames["oxicon"]) ) {
            $this->oxarticles__oxicon = new oxField('icon/'.$this->_getIconName());
            return;
        }

        if ( $sFieldName == 'oxthumb' && isset($this->_aFieldNames["oxthumb"]) ) {
            $this->oxarticles__oxthumb = new oxField('0/'.$this->_getThumbnailName());
            return;
        }

        $iPicCount = $myConfig->getConfigParam( 'iPicCount' );
        if ( strpos($sFieldName, "oxpic") === 0 && isset($this->_aFieldNames[$sFieldName] ) ) {

            $iIndex = (int) str_ireplace( "oxpic", "", $sFieldName );

            if ( $iIndex > 0 && $iIndex < $iPicCount ) {
                $this->$sName = new oxField( $iIndex . '/'.$this->_getPictureName($iIndex) );
                $this->{$sName.'_ico'} = new oxField( $iIndex . '/'.$this->_getIconName($iIndex) );
                return;
            }
        }
    }

    protected function _assignStock()
    {
        $myConfig = $this->getConfig();
        // -----------------------------------
        // stock
        // -----------------------------------

        // #1125 A. must round (using floor()) value taken from database and cast to int
        if (!$myConfig->getConfigParam( 'blAllowUnevenAmounts' ) && !$this->isAdmin() ) {
            $this->oxarticles__oxstock = new oxField((int) floor($this->oxarticles__oxstock->value));
        }
        //GREEN light
        $this->_iStockStatus = 0;

        // if we have flag /*1 or*/ 4 - we show always green light
        if ( $myConfig->getConfigParam( 'blUseStock' ) && /*$this->oxarticles__oxstockflag->value != 1 && */ $this->oxarticles__oxstockflag->value != 4) {
            //ORANGE light
            $iStock = $this->oxarticles__oxstock->value;

            if ($this->_blNotBuyableParent) {
                $iStock = $this->oxarticles__oxvarstock->value;
            }


            if ( $iStock <= $myConfig->getConfigParam( 'sStockWarningLimit' ) && $iStock > 0) {
                $this->_iStockStatus = 1;
            }

            //RED light
            if ($iStock <= 0) {
                $this->_iStockStatus = -1;
            }
        }


        // stock
        if ( $myConfig->getConfigParam( 'blUseStock' ) && ($this->oxarticles__oxstockflag->value == 3 || $this->oxarticles__oxstockflag->value == 2)) {
            $iOnStock = $this->oxarticles__oxstock->value;
            if ($this->getConfig()->getConfigParam( 'blPsBasketReservationEnabled' )) {
                $iOnStock += $this->getSession()->getBasketReservations()->getReservedAmount($this->getId());
            }
            if ($iOnStock <= 0) {
                $this->_blNotBuyable = true;
            }
        }

        //exceptional handling for variant parent stock:
        if ($this->_blNotBuyable && $this->oxarticles__oxvarstock->value ) {
            $this->_blNotBuyable = false;
            //but then at least setting notBuaybleParent to true
            $this->_blNotBuyableParent = true;
        }

        //special treatment for lists when blVariantParentBuyable config option is set to false
        //then we just hide "to basket" button.
        //if variants are not loaded in the list and this article has variants and parent is not buyable then this article is not buyable
        if ( !$myConfig->getConfigParam( 'blVariantParentBuyable' ) && !$myConfig->getConfigParam( 'blLoadVariants' ) && $this->oxarticles__oxvarstock->value) {
            $this->_blNotBuyable = true;
        }

        //setting to non buyable when variant list is empty (for example not loaded or inactive) and $this is non buyable parent
        if ($this->_blNotBuyableParent && count($this->getVariants()) == 0) {
            $this->_blNotBuyable = true;
        }
    }

    protected function _assignPrices()
    {
        $myConfig = $this->getConfig();

        // Performance
        if ( !$myConfig->getConfigParam( 'bl_perfLoadPrice' ) || !$this->_blLoadPrice ) {
            return;
        }

        // compute price
        $dPrice = $this->getPrice()->getBruttoPrice();

        $oCur = $myConfig->getActShopCurrencyObject();
        //price per unit handling
        if ((double) $this->oxarticles__oxunitquantity->value && $this->oxarticles__oxunitname->value) {
            $this->_fPricePerUnit = oxLang::getInstance()->formatCurrency($dPrice / (double) $this->oxarticles__oxunitquantity->value, $oCur);
        }


        //getting min and max prices of variants
        $this->_applyRangePrice();
    }

    protected function _assignPersistentParam()
    {
        // Persistent Parameter Handling
        $aPersParam     = oxSession::getVar( 'persparam');
        if ( isset( $aPersParam) && isset( $aPersParam[$this->getId()])) {
            $this->_aPersistParam = $aPersParam[$this->getId()];
        }
    }

    protected function _assignDynImageDir()
    {
        $myConfig = $this->getConfig();

        $sThisShop = $this->oxarticles__oxshopid->value;

        $this->_sDynImageDir   = $myConfig->getPictureUrl( null, false );
        $this->dabsimagedir    = $myConfig->getPictureDir( false ); //$sThisShop
        $this->nossl_dimagedir = $myConfig->getPictureUrl( null, false, false, null, $sThisShop ); //$sThisShop
        $this->ssl_dimagedir   = $myConfig->getPictureUrl( null, false, true, null, $sThisShop ); //$sThisShop
    }

    protected function _assignComparisonListFlag()
    {
        // #657 add a flag if article is on comparisonlist

        $aItems = oxConfig::getParameter('aFiltcompproducts');
        if ( isset( $aItems[$this->getId()])) {
            $this->_blIsOnComparisonList = true;
        }
    }

    protected function _assignAttributes()
    {
        //#1029T load attributes
        //#1078S removed check for module "Produktvergleich"
        if ( $this->getConfig()->getConfigParam( 'bl_perfLoadAttributes' ) ) {
            $this->getAttributes();
        }
    }


    protected function _insert()
    {
        // set oxinsert
        $iInsertTime = time();
        $now = date('Y-m-d H:i:s', $iInsertTime);
        $this->oxarticles__oxinsert    = new oxField( $now );
        $this->oxarticles__oxtimestamp = new oxField( $now );
        if ( !is_object($this->oxarticles__oxsubclass) || $this->oxarticles__oxsubclass->value == '') {
            $this->oxarticles__oxsubclass = new oxField('oxarticle');
        }

        return parent::_insert();
    }

    protected function _update()
    {

        $this->_skipSaveFields();

        $myConfig = $this->getConfig();


        return parent::_update();
    }

    protected function _deleteRecords($sOXID)
    {
        $oDB = oxDb::getDb();

        $sOXID = $oDB->quote($sOXID);

        //delete the record
        $sDelete = 'delete from '.$this->_sCoreTbl.' where oxid = '.$sOXID.' ';
        $oDB->execute( $sDelete);

        //remove other records
        $sDelete = 'delete from oxobject2article where oxarticlenid = '.$sOXID.' or oxobjectid = '.$sOXID.' ';
        $oDB->execute( $sDelete);

        $sDelete = 'delete from oxobject2attribute where oxobjectid = '.$sOXID.' ';
        $oDB->execute( $sDelete);

        $sDelete = 'delete from oxobject2category where oxobjectid = '.$sOXID.' ';
        $oDB->execute( $sDelete);

        $sDelete = 'delete from oxobject2selectlist where oxobjectid = '.$sOXID.' ';
        $oDB->execute( $sDelete);

        $sDelete = 'delete from oxprice2article where oxartid = '.$sOXID.' ';
        $oDB->execute( $sDelete);

        $sDelete = 'delete from oxreviews where oxtype="oxarticle" and oxobjectid = '.$sOXID.' ';
        $oDB->execute( $sDelete);

        $sDelete = 'delete from oxaccessoire2article where oxobjectid = '.$sOXID.' or oxarticlenid = '.$sOXID.' ';
        $oDB->execute( $sDelete);

        //#1508C - deleting oxobject2delivery entries added
        $sDelete = 'delete from oxobject2delivery where oxobjectid = '.$sOXID.' and oxtype=\'oxarticles\' ';
        $oDB->execute( $sDelete);

        $sDelete = 'delete from oxartextends where oxid = '.$sOXID.' ';
        $oDB->execute( $sDelete);

        $sDelete = 'delete from oxactions2article where oxartid = '.$sOXID.' ';
        $rs = $oDB->execute( $sDelete );

        $sDelete = 'delete from oxobject2list where oxobjectid = '.$sOXID.' ';
        $rs = $oDB->execute( $sDelete );


        return $rs;
    }

    protected function _deleteVariantRecords($sOXID)
    {
        $oDB = oxDb::getDb();
        //collect variants to remove recursively
        $sVariants = 'select oxid from '.$this->getViewName().' where oxparentid = '.$oDB->quote($sOXID);
        $rs = $oDB->execute( $sVariants);
        if ($rs != false && $rs->recordCount() > 0) {
            while (!$rs->EOF) {
                $this->delete( $rs->fields[0]);
                $rs->moveNext();
            }
        }
    }

    protected function _resetCacheAndArticleCount( $sOxid )
    {
        $this->_onChangeResetCounts( $sOxid, $this->oxarticles__oxvendorid->value, $this->oxarticles__oxmanufacturerid->value );
    }

    protected function _deletePics()
    {
        $myUtilsPic = oxUtilsPic::getInstance();
        $myConfig   = $this->getConfig();
        $oPictureHandler = oxPictureHandler::getInstance();

        //deleting custom main icon
        $oPictureHandler->deleteMainIcon( $this );

        //deleting custom thumbnail
        $oPictureHandler->deleteThumbnail( $this );

        $sAbsDynImageDir = $myConfig->getAbsDynImageDir();

        // deleting master image and all generated images
        $iPicCount = $myConfig->getConfigParam( 'iPicCount' );
        for ( $i = 1; $i <= $iPicCount; $i++ ) {
            $oPictureHandler->deleteArticleMasterPicture( $this, $i );
        }
    }

    protected function _onChangeResetCounts( $sOxid, $sVendorId = null, $sManufacturerId = null )
    {

        $myUtilsCount = oxUtilsCount::getInstance();

        if ( $sVendorId ) {
            $myUtilsCount->resetVendorArticleCount( $sVendorId );
        }

        if ( $sManufacturerId ) {
            $myUtilsCount->resetManufacturerArticleCount( $sManufacturerId );
        }

        //also reseting category counts
        $oDb = oxDb::getDb();
        $sQ = "select oxcatnid from oxobject2category where oxobjectid = ".$oDb->quote($sOxid);
        $oRs = $oDb->execute( $sQ );
        if ( $oRs !== false && $oRs->recordCount() > 0) {
            while ( !$oRs->EOF ) {
                $myUtilsCount->resetCatArticleCount( $oRs->fields[0] );
                $oRs->moveNext();
            }
        }
    }

    protected function _onChangeUpdateStock( $sParentID )
    {
        $oDb = oxDb::getDb();
        $sParentIdQuoted = $oDb->quote($sParentID);
        $sQ = 'select oxstock, oxvendorid, oxmanufacturerid from oxarticles where oxid = '.$sParentIdQuoted;
        $rs = $oDb->execute($sQ);
        $iOldStock = $rs->fields[0];
        $iVendorID = $rs->fields[1];
        $iManufacturerID = $rs->fields[2];

        $sQ = 'select sum(oxstock) from oxarticles where oxparentid = '.$sParentIdQuoted.' and '. $this->getSqlActiveSnippet( true ).' and oxstock > 0 ';
        $iStock = (float) $oDb->getOne( $sQ );

        $sQ = 'update oxarticles set oxvarstock = '.$iStock.' where oxid = '.$sParentIdQuoted;
        $oDb->execute( $sQ );

            //now lets update category counts
            //first detect stock status change for this article (to or from 0)
            if ( $iStock < 0 ) {
                $iStock = 0;
            }
            if ( $iOldStock < 0 ) {
                $iOldStock = 0;
            }
            if ( $this->oxarticles__oxstockflag->value == 2 && $iOldStock xor $iStock ) {
                //means the stock status could be changed (oxstock turns from 0 to 1 or from 1 to 0)
                // so far we leave it like this but later we could move all count resets to one or two functions
                $this->_onChangeResetCounts( $sParentID, $iVendorID, $iManufacturerID );
            }
    }

    protected function _onChangeStockResetCount( $sOxid )
    {
        $myConfig = $this->getConfig();

        if ( $myConfig->getConfigParam( 'blUseStock' ) && $this->oxarticles__oxstockflag->value == 2 &&
           ( $this->oxarticles__oxstock->value + $this->oxarticles__oxvarstock->value ) <= 0 ) {

               $this->_onChangeResetCounts( $sOxid, $this->oxarticles__oxvendorid->value, $this->oxarticles__oxmanufacturerid->value );
        }
    }

    protected function _onChangeUpdateVarCount( $sParentID )
    {
        $oDb = oxDb::getDb();
        $sParentIdQuoted = $oDb->quote($sParentID);
        $sQ = 'select count(*) as varcount from oxarticles where oxparentid = '.$sParentIdQuoted;
        $iVarCount = (int) $oDb->getOne($sQ);

        $sQ = 'update oxarticles set oxvarcount = '.$iVarCount.' where oxid = '.$sParentIdQuoted;
        $oDb->execute($sQ);
    }

    protected function _onChangeUpdateMinVarPrice( $sParentID )
    {
        $oDb = oxDb::getDb();
        $sParentIdQuoted = $oDb->quote($sParentID);
        //#M0000883 (Sarunas)
        $sQ = 'select min(oxprice) as varminprice from oxarticles where '.$this->getSqlActiveSnippet(true).' and (oxparentid = '.$sParentIdQuoted.')';
        $dVarMinPrice = $oDb->getOne($sQ);

        $dParentPrice = $oDb->getOne("select oxprice from oxarticles where oxid = $sParentIdQuoted ");

        $blParentBuyable =  $this->getConfig()->getConfigParam( 'blVariantParentBuyable' );

        if ($dVarMinPrice) {
            if ($blParentBuyable) {
                $dVarMinPrice = min($dVarMinPrice, $dParentPrice);
            }

        } else {
            $dVarMinPrice = $dParentPrice;
        }

        if ( $dVarMinPrice ) {
            $sQ = 'update oxarticles set oxvarminprice = '.$dVarMinPrice.' where oxid = '.$sParentIdQuoted;
            $oDb->execute($sQ);
        }
    }


    protected function _applyRangePrice()
    {
        //#buglist_413 if bl_perfLoadPriceForAddList variant price shouldn't be loaded too
        if ( !$this->getConfig()->getConfigParam( 'bl_perfLoadPrice' ) || !$this->_blLoadPrice ) {
            return;
        }

        $this->_blIsRangePrice = false;

        // if parent is buyable - do not apply range price calcculations
        if ($this->_blSkipAbPrice || !$this->_blNotBuyableParent) {
            return;
        }

        $aPrices = array();

        if (!$this->_blNotBuyableParent) {
            $aPrices[] = $this->getPrice()->getBruttoPrice();
        }

        $aVariants = $this->getVariants(false);

        if (count($aVariants)) {
            foreach ($aVariants as $sKey => $oVariant) {
                $aPrices[] = $oVariant->getPrice()->getBruttoPrice();
            }
        }

        /*  $oAmPrices = $this->loadAmountPriceInfo();
        foreach ($oAmPrices as $oAmPrice) {
            $aPrices[] = $oAmPrice->oxprice2article__oxaddabs->value;
        }*/

        if (count($aPrices)) {
            $dMinPrice = $aPrices[0];
            $dMaxPrice = $aPrices[0];
            foreach ($aPrices as $dPrice) {
                if ($dMinPrice > $dPrice) {
                    $dMinPrice = $dPrice;
                }

                if ($dMaxPrice < $dPrice) {
                    $dMaxPrice = $dPrice;
                }
            }
        }

        if ($this->_blNotBuyableParent && isset($dMinPrice) && $dMinPrice == $dMaxPrice) {
            $this->getPrice()->setBruttoPriceMode();
            $this->getPrice()->setPrice($dMinPrice);
        }

        if (isset($dMinPrice) && $dMinPrice != $dMaxPrice) {
            $this->getPrice()->setBruttoPriceMode();
            $this->getPrice()->setPrice($dMinPrice);
            $this->_blIsRangePrice = true;
        }

        if ( $this->isParentNotBuyable() && !$this->getConfig()->getConfigParam( 'blLoadVariants' )) {
            $this->getPrice()->setBruttoPriceMode();
            $this->getPrice()->setPrice($this->oxarticles__oxvarminprice->value);
            $this->_blIsRangePrice = true;
            $this->_calculatePrice( $this->getPrice() );
        }
    }

    public function getProductId()
    {
        return $this->getId();
    }

    public function getProductParentId()
    {
        return $this->oxarticles__oxparentid->value;
    }

    public function isOrderArticle()
    {
        return false;
    }

    public function isVariant()
    {
        return (bool) ( isset( $this->oxarticles__oxparentid ) ? $this->oxarticles__oxparentid->value : false );
    }

    public function isMdVariant()
    {
        $oMdVariant = oxNew( "oxVariantHandler" );

        return $oMdVariant->isMdVariant($this);
    }

    public function getSqlForPriceCategories($sFields = '')
    {
        if (!$sFields) {
            $sFields = 'oxid';
        }
        $sSelectWhere = "select $sFields from ".$this->_getObjectViewName('oxcategories')." where";
        $sQuotedPrice = oxDb::getDb()->quote( $this->oxarticles__oxprice->value );
        return  "$sSelectWhere oxpricefrom != 0 and oxpriceto != 0 and oxpricefrom <= $sQuotedPrice and oxpriceto >= $sQuotedPrice"
               ." union $sSelectWhere oxpricefrom != 0 and oxpriceto = 0 and oxpricefrom <= $sQuotedPrice"
               ." union $sSelectWhere oxpricefrom = 0 and oxpriceto != 0 and oxpriceto >= $sQuotedPrice";
    }

    public function inPriceCategory( $sCatNid )
    {
        $oDb = oxDb::getDb();

        $sQuotedPrice = oxDb::getDb()->quote( $this->oxarticles__oxprice->value );
        $sQuotedCnid = oxDb::getDb()->quote( $sCatNid );
        return (bool) $oDb->getOne(
            "select 1 from ".$this->_getObjectViewName('oxcategories')." where oxid=$sQuotedCnid and"
           ."(   (oxpricefrom != 0 and oxpriceto != 0 and oxpricefrom <= $sQuotedPrice and oxpriceto >= $sQuotedPrice)"
           ." or (oxpricefrom != 0 and oxpriceto = 0 and oxpricefrom <= $sQuotedPrice)"
           ." or (oxpricefrom = 0 and oxpriceto != 0 and oxpriceto >= $sQuotedPrice)"
           .")"
        );
    }

    public function getMdVariants()
    {
        if ( $this->_oMdVariants ) {
            return $this->_oMdVariants;
        }

        $oParentArticle = $this->getParentArticle();
        if ( $oParentArticle ) {
            $oVariants = $oParentArticle->getVariants();
        } else {
            $oVariants = $this->getVariants();
        }

        $oVariantHandler = oxNew( "oxVariantHandler" );
        $this->_oMdVariants = $oVariantHandler->buildMdVariants( $oVariants, $this->getId() );

        return $this->_oMdVariants;
    }

    public function getMdSubvariants()
    {
        return $this->getMdVariants()->getMdSubvariants();
    }


    protected function _generateImages( $iIndex )
    {
        if ( isset($this->_aFieldNames["oxpic".$iIndex]) && !$this->_hasGeneratedImage( $iIndex ) ) {
            if ( !$this->_isFieldEmpty( "oxarticles__oxpic".$iIndex ) && $this->_hasMasterImage( $iIndex ) ) {
                $oPictureHandler = oxPictureHandler::getInstance();
                $oPictureHandler->generateArticlePictures( $this, $iIndex );
            }
        }
    }

    public function updateAmountOfGeneratedPictures( $iTotalGenerated )
    {
        $this->oxarticles__oxpicsgenerated = new oxField( $iTotalGenerated );
        $oDb = oxDb::getDb();
        $sIdQuoted = $oDb->quote($this->getId());

        $sQ = 'update oxarticles set oxpicsgenerated = '.$iTotalGenerated.' where oxid = '.$sIdQuoted;
        $oDb->execute( $sQ );
    }

    protected function _hasGeneratedImage( $iIndex )
    {
        if ( $iIndex > (int) $this->oxarticles__oxpicsgenerated->value ) {
            return false;
        }

        return true;
    }

    protected function _hasMasterImage( $iIndex )
    {
        $sPicName = basename($this->{"oxarticles__oxpic" . $iIndex}->value);

        if ( $sPicName == "nopic.jpg" || $sPicName == "" ) {
            return false;
        }
        if ( $this->isVariant() && $this->getParentArticle()->{"oxarticles__oxpic".$iIndex}->value == $this->{"oxarticles__oxpic".$iIndex}->value ) {
            return false;
        }

        $sMasterPic = $iIndex . "/" . $sPicName;

        if ( $this->getConfig()->getMasterPicturePath( $sMasterPic ) ) {
            return true;
        }

        return false;
    }

    public function getPictureFieldValue( $sFieldName, $iIndex = null )
    {
        if ( $sFieldName ) {
            $sFieldName = "oxarticles__" . $sFieldName . $iIndex;
            return $this->$sFieldName->value;
        }
    }
}