Returns TRUE if product is variant, and false if not

@return bool
320745
public function isVariant(): bool
    {
        $isVariant = false;
        if (isset($this->oxarticles__oxparentid) && false !== $this->oxarticles__oxparentid) {
            $isVariant = (bool) $this->oxarticles__oxparentid->value;
        }

        return $isVariant;
    }
447188
public function chooseVariant($variants)
    {
        $count = count($variants);
        if (0 === $count) {
            return null;
        }

        $chosenCount = mt_rand(0, $count - 1);
        $keys = array_keys($variants);

        return $variants[$keys[$chosenCount]];
    }
472099
public function isDemoVersion()
    {
        if ($this->_blDemoVersion == null) {
            $this->_blDemoVersion = \OxidEsales\Eshop\Core\Registry::getConfig()->detectVersion() == 1;
        }

        return $this->_blDemoVersion;
    }
1271655
public function variantContentType($variant)
    {
        if (    ! array_key_exists($variant, $this->variants)
            ||  ! is_array($this->variants[ $variant ])
            ||  ! array_key_exists('content_type', $this->variants[ $variant ])
        ) {
            return false;
        }

        return $this->variants[ $variant ]['content_type'];
    }
7109
public function chooseVariant($variants)
    {
        if (array_key_exists($this->choice, $variants)) {
            return $variants[$this->choice];
        }

        return null;
    }
667715
protected function validateProduct()
    {
        $id = $this->getUpdatingId();

        if ($id === false) {
            return null;
        }

        $data = $this->product->get($id);

        if (empty($data)) {
            $this->setErrorUnavailable('update', $this->translation->text('Product'));
            return false;
        }

        $this->setUpdating($data);
        return true;
    }
484470
public function variants($withOriginal = false)
    {
        $variants = array_keys($this->config->variantConfigs());

        if ($withOriginal && ! in_array(FileHandler::ORIGINAL, $variants)) {
            array_unshift($variants, FileHandler::ORIGINAL);
        }

        return $variants;
    }
1165829
protected function checkBrowseriPod()
    {
        if (stripos($this->_agent, 'iPod') !== false) {
            $aresult = explode('/', stristr($this->_agent, 'Version'));
            if (isset($aresult[1])) {
                $aversion = explode(' ', $aresult[1]);
                $this->setVersion($aversion[0]);
            } else {
                $this->setVersion(self::VERSION_UNKNOWN);
            }
            $this->setMobile(true);
            $this->setBrowser(self::BROWSER_IPOD);

            return true;
        }

        return false;
    }
1231994
public function getDefaultItemType()
    {
        if ($this->hasOption(self::OPTION_DEFAULT_ITEM_TYPE)) {
            return $this->getOption(self::OPTION_DEFAULT_ITEM_TYPE);
        }
        return false;
    }
333303
private function checkProduct(){
		$product =  explode('/',trim($this->data[0]));
		if (count($product) !== 2) {
			return false;	
		}
		list($this->report['product'], $this->report['productVersion']) =$product;
		unset($this->data[0]);
		$this->data = $this->reindex($this->data);
		return true;
	}
26323
protected function validateItemsProductBundle()
    {
        $field = 'bundle';
        $value = $this->getSubmitted($field);

        if (empty($value)) {
            return null;
        }

        if (!is_array($value)) {
            $this->setErrorInvalid($field, $this->translation->text('Product bundle'));
            return false;
        }

        $main_product = $this->getSubmitted('product');

        $loaded = array();

        foreach ($value as $product_id) {

            if (isset($loaded[$product_id])) {
                $this->setError($field, $this->translation->text('All bundled products must be unique'));
                return false;
            }

            $product = $this->product->get($product_id);

            $loaded[$product_id] = $product;

            if (empty($product['status'])) {
                $this->setError($field, $this->translation->text('Some of bundled products are unavailable'));
                return false;
            }

            if ($main_product['product_id'] == $product['product_id']) {
                $this->setError($field, $this->translation->text('Bundled products cannot be the same as the main product'));
                return false;
            }

            if ($main_product['store_id'] != $product['store_id']) {
                $this->setError($field, $this->translation->text('All bundled products must belong to the same store'));
                return false;
            }
        }

        $this->setSubmitted('products', $loaded);
        return true;
    }
117709
public function participates($test, $variant = null)
    {
        $test = $test instanceof TestInterface ? $test->getIdentifier() : $test;
        $variant = $variant instanceof VariantInterface ? $variant->getIdentifier() : $variant;

        if (!$this->storage->has($test)) {
            return false;
        }

        $storedValue = $this->storage->get($test);

        // It was asked explicitly for the variant and it matches
        if (null !== $variant) {
            return $storedValue === $variant;
        }

        return true;
    }
48331
public function isSpecific()
    {
        foreach ($this->modelDevices as $modelDevice) {
            if ($modelDevice->specific === true || $modelDevice->actualDeviceRoot === true) {
                return true;
            }
        }

        return false;
    }
839133
public function deleteAction($parentId, $variantId)
    {
        $variant = $this->getProductVariantManager()->deleteVariant($variantId);

        if ($variant->getParent()->getId() !== (int) $parentId) {
            throw new ProductException('Variant does not exists for given product.');
        }
        $this->getEntityManager()->flush();

        $view = $this->view(null, 204);

        return $this->handleView($view);
    }
1083628
public function isProductNew($product)
    {
        $newsFromDate = $product->getNewsFromDate();
        $newsToDate = $product->getNewsToDate();
        if (!$newsFromDate && !$newsToDate) {
            return false;
        }

        return $this->localeDate->isScopeDateInInterval(
            $product->getStore(),
            $newsFromDate,
            $newsToDate
        );
    }
499593
public function getSimilarProducts()
    {
        if ($this->_oSimilarProducts === null) {
            $this->_oSimilarProducts = false;
            if ($oProduct = $this->getProduct()) {
                $this->_oSimilarProducts = $oProduct->getSimilarProducts();
            }
        }

        return $this->_oSimilarProducts;
    }
635080
public function getProduct()
    {
        $config = \OxidEsales\Eshop\Core\Registry::getConfig();
        $utils = \OxidEsales\Eshop\Core\Registry::getUtils();

        if ($this->_oProduct === null) {
            //this option is only for lists and we must reset value
            //as blLoadVariants = false affect "ab price" functionality
            $config->setConfigParam('blLoadVariants', true);

            $articleId = \OxidEsales\Eshop\Core\Registry::getConfig()->getRequestParameter('anid');

            // object is not yet loaded
            $this->_oProduct = oxNew(\OxidEsales\Eshop\Application\Model\Article::class);

            if (!$this->_oProduct->load($articleId)) {
                $utils->redirect($config->getShopHomeUrl());
                $utils->showMessageAndExit('');
            }

            $variantSelectionId = \OxidEsales\Eshop\Core\Registry::getConfig()->getRequestParameter("varselid");
            $variantSelections = $this->_oProduct->getVariantSelections($variantSelectionId);
            if ($variantSelections && $variantSelections['oActiveVariant'] && $variantSelections['blPerfectFit']) {
                $this->_oProduct = $variantSelections['oActiveVariant'];
            }
        }

        // additional checks
        if (!$this->_blIsInitialized) {
            $this->_additionalChecksForArticle();
        }

        return $this->_oProduct;
    }