Returns the extension model that can be used to retrieve payment methods.

@return \ModelSettingExtension|\ModelExtensionExtension

@throws \Exception
776069
public function getExtensionModel()
    {
        if ($this->extensionModel === null) {
            $this->load->model('setting/extension');
            /** @noinspection PhpUndefinedFieldInspection */
            $this->extensionModel = $this->model_setting_extension;
        }
        return $this->extensionModel;
    }
347432
protected function fileExtension()
    {
        if (!$this->fileExtension) {
            $mimeType = $this->serializer->mimeType();
            $this->fileExtension = $this->mimetypes->fileExtensions($mimeType)[0];
        };
        return $this->fileExtension;
    }
1261804
public function getModel()
    {
        if (empty($this->model)) {
            throw new LogicException(
                sprintf(self::ERROR_MISSING_ATTRIBUTE_FORMAT, 'model')
            );
        }
        return $this->model;
    }
951523
public function getExecOptionsResolver()
    {
        if (null === $this->execOptionsResolver) {
            if (null !== $this->parent) {
                $this->execOptionsResolver = clone $this->parent->getExecOptionsResolver();
            } else {
                $this->execOptionsResolver = new OptionsResolver();
            }

            $this->innerType->setExecOptions($this->execOptionsResolver);

            foreach ($this->typeExtensions as $extension) {
                $extension->setExecOptions($this->execOptionsResolver);
            }
        }

        return $this->execOptionsResolver;
    }
587938
protected function getExtensions() {
        if (!$this->_extensions) {
            $this->_extensions = new AssignedAddOnExtensionList(
                $this->version,
                $this->solution['accountSid'],
                $this->solution['resourceSid'],
                $this->solution['sid']
            );
        }

        return $this->_extensions;
    }
228084
protected function findExtension()
    {
        $manifest = $this->getManifest();

        $this->extensionEntity = $this->getEntityManager()->getRepository('Extension')->where(array(
            'name' => $manifest['name'],
            'isInstalled' => true,
        ))->findOne();

        return $this->extensionEntity;
    }
844069
protected function getAdditionAdapterOptions()
    {
        /** @var \common_ext_ExtensionsManager $extManager */
        $extManager = ServiceManager::getServiceManager()->get(\common_ext_ExtensionsManager::SERVICE_ID);
        $taoTestTaker = $extManager->getExtensionById('taoTestTaker');
        $config = $taoTestTaker->getConfig('csvImporterCallbacks');

        if (empty($config['callbacks'])){
            $returnValue = array(
                'callbacks' => array(
                    '*' => array('trim'),
                    GenerisRdf::PROPERTY_USER_PASSWORD => array('oat\taoTestTaker\models\CsvImporter::taoSubjectsPasswordEncode')
                )
            );
        } else {
            $returnValue = array(
                'callbacks' => $config['callbacks']
            );
        }

        return $returnValue;
    }
225955
protected function getExtensionConfiguration()
    {
        $cacheInstance = CacheService::get()->getCacheInstance();
        $hash = $this->getContextHash();

        if ($cacheInstance->has($hash)) {
            $result = $cacheInstance->get($hash);
        } else {
            $result = $this->getFullConfiguration();
            $result = (ArrayUtility::isValidPath($result, self::EXTENSION_CONFIGURATION_PATH, '.'))
                ? ArrayUtility::getValueByPath($result, self::EXTENSION_CONFIGURATION_PATH, '.')
                : [];

            if (ArrayUtility::isValidPath($result, 'settings.typoScriptIncluded', '.')) {
                $cacheInstance->set($hash, $result);
            }
        }

        return $result;
    }
37243
public function getExpanded()
    {
        if (!isset($this->_blExpanded)) {
            $this->_blExpanded = ($this->getId() == \OxidEsales\Eshop\Core\Registry::getConfig()->getRequestParameter('oxcid'));
        }

        return $this->_blExpanded;
    }
1200903
protected function getExportModel()
    {
        $model = parent::getExportModel();
        $model->del('parents', 'formatFunction');
        $model->del('allowed', 'formatFunction');
        $model->del('inherited', 'formatFunction');

        return $model;
    }
89207
public function getExtension()
    {
        if (is_null($this->extension) === true) {
            $filename = parent::getFilename();
            $str = new StringWrapper($filename);
            $this->extension = $str->getFirstEndMatch($this->predefinedExtensions);
            $this->hasPredefinedExt = true;

            if ($this->extension === '') {
                $this->hasPredefinedExt = false;
                $this->extension = parent::getExtension();
            }
        }

        return $this->extension;
    }
188902
public function getContainerExtension()
    {
        if (null === $this->extension || false === $this->extension) {
            $this->extension = new GendoriaCommandQueueExtension();
        }

        return $this->extension;
    }
860556
public function getAdapter()
    {
        if ($this->adapter instanceof Compress\CompressionAlgorithmInterface) {
            return $this->adapter;
        }

        $adapter = $this->adapter;
        $options = $this->getAdapterOptions();
        if (!class_exists($adapter)) {
            $adapter = 'Zend\\Filter\\Compress\\' . ucfirst($adapter);
            if (!class_exists($adapter)) {
                throw new Exception\RuntimeException(sprintf(
                    '%s unable to load adapter; class "%s" not found',
                    __METHOD__,
                    $this->adapter
                ));
            }
        }

        $this->adapter = new $adapter($options);
        if (!$this->adapter instanceof Compress\CompressionAlgorithmInterface) {
            throw new Exception\InvalidArgumentException("Compression adapter '" . $adapter . "' does not implement Zend\\Filter\\Compress\\CompressionAlgorithmInterface");
        }
        return $this->adapter;
    }
1234034
public function getModel()
    {
        if(!is_null($this->modelAttr)){
            return $this->modelAttr;
        }

        $model = AchievementDetails::where('class_name', $this->getClassName())->first();

        if (is_null($model)) {
            $model = new AchievementDetails();
            $model->class_name = $this->getClassName();
        }

        if(config('achievements.auto_sync') || is_null($model->name)) {
            $model->name = $this->name;
            $model->description = $this->description;
            $model->points = $this->points;
            $model->secret = $this->secret;

            // Syncs
            $model->save();
        }

        $this->modelAttr = $model;
        return $model;
    }
304312
public function getPaymentMethod()
    {
        $session = $this
            ->getRequest()
            ->getSession();

        $payment_methods = GatewayInfo::getSupportedGateways();
        $payment_session = $session->get('Checkout.PaymentMethodID');
        $method = null;

        if (!empty($payment_session) && array_key_exists($payment_session, $payment_methods)) {
            $method = $payment_session;
        } else {
            $default = key($payment_methods);
            $method = $default;
            $session->set('Checkout.PaymentMethodID', $default);
        }

        return $method;
    }
1163332
public function extension($sExtension = null)
    {
        if (null === $sExtension) {
            return $this->getExtension();
        }

        return $this->setExtension($sExtension);
    }
885037
public function getExtension()
    {
        $basename = $this->getBasename();
        if (false !== $pos = strrpos($basename, '.')) {
            $ext = substr($basename, $pos + 1);
        } else {
            $ext = '';
        }
        return $ext;
    }