return the active entrys

@return null
176333
public function getActiveRecommList()
    {
        if (!$this->getViewConfig()->getShowListmania()) {
            return false;
        }

        if ($this->_oActRecommList === null) {
            $this->_oActRecommList = false;

            if (($oUser = $this->getUser()) &&
                ($sRecommId = \OxidEsales\Eshop\Core\Registry::getConfig()->getRequestParameter('recommid'))
            ) {
                $oRecommList = oxNew(\OxidEsales\Eshop\Application\Model\RecommendationList::class);
                $sUserIdField = 'oxrecommlists__oxuserid';
                if (($oRecommList->load($sRecommId)) && $oUser->getId() === $oRecommList->$sUserIdField->value) {
                    $this->_oActRecommList = $oRecommList;
                }
            }
        }

        return $this->_oActRecommList;
    }
1042264
public function inactiveMigrations()
    {
        $inactiveMigrations = [];
        $migration_arr = [];

        // Package Migrations
        $tables = $this->migrations_tables;

        // Application active migrations
        $migrations = DB::select('select * from '.DB::getTablePrefix().'migrations');

        foreach ($migrations as $migration_parent) { // Count active package migrations
            $migration_arr[] = $migration_parent->migration;
        }

        foreach ($tables as $table) {
            if (!in_array($table, $migration_arr)) {
                $inactiveMigrations[] = $table;
            }
        }

        return $inactiveMigrations;
    }
480370
public function get_active()
    {
        if ($this->active !== null) {
            return $this->active;
        }

        if (!$this->sieve) {
            return $this->_set_error(self::ERROR_INTERNAL);
        }

        return $this->active = $this->sieve->getActive();
    }
337541
public function &GetActiveSearchObject()
    {
        if (is_null($this->oActiveSearchCache) && array_key_exists(self::SESSION_ACTIVE_SEARCH_CACHE_ID, $_SESSION)) {
            $this->oActiveSearchCache = unserialize(base64_decode($_SESSION[self::SESSION_ACTIVE_SEARCH_CACHE_ID]));
            //        $this->oActiveSearchCache = TdbShopSearchCache::GetNewInstance();
            //        if (!$this->oActiveSearchCache->Load($_SESSION[self::SESSION_ACTIVE_SEARCH_CACHE_ID])) $this->oActiveSearchCache = null;
        }

        return $this->oActiveSearchCache;
    }
1029433
protected function _active()
    {
        $dir = new SplFileInfo($this->_config['path']);
        $path = $dir->getPathname();
        $success = true;
        if (!is_dir($path)) {
            //@codingStandardsIgnoreStart
            $success = @mkdir($path, 0775, true);
            //@codingStandardsIgnoreEnd
        }

        $isWritableDir = ($dir->isDir() && $dir->isWritable());
        if (!$success || ($this->_init && !$isWritableDir)) {
            $this->_init = false;
            trigger_error(sprintf(
                '%s is not writable',
                $this->_config['path']
            ), E_USER_WARNING);
        }

        return $success;
    }
602732
public function active()
    {
        $classes = $this->getAdaptee()->classes;

        foreach ($classes as $class) {
            if (strpos($class, 'current') !== false) {
                return true;
            }
        }

        return false;
    }
816483
public function current()
    {
        return array_key_exists($this->currentKey, $this->items)
            ? $this->items[$this->currentKey]
            : null;
    }
958599
public function getActiveClients()
    {
        $result = $this->getClients();
        if ( $result->isSuccess() ) {
            $clients = array();
            foreach ($result->data as $client) {
                if ($client->active == "true") {
                    $clients[$client->id] = $client;
                }
            }
            $result->data = $clients;
        }

        return $result;
    }
159967
public function getActiveExperiments()
    {
        if ($this->cache->contains($this->activeExperimentsSettingName)) {
            return $this->cache->fetch($this->activeExperimentsSettingName)['value'];
        }

        if ($this->has($this->activeExperimentsSettingName)) {
            $experiments = $this->get($this->activeExperimentsSettingName)->getValue();
        } else {
            $this->create(
                [
                    'name' => $this->activeExperimentsSettingName,
                    'value' => [],
                    'type' => 'hidden',
                ]
            );
            $experiments = [];
        }

        $this->cache->save($this->activeExperimentsSettingName, ['value' => $experiments]);

        return $experiments;
    }
20709
protected function active()
    {
        if( empty($activeDatabaseList = $this->getActiveDatabaseList()) )
        {
            return false;
        }

        $this->setActiveDatabaseEncoding($encoding);

        $status = false;

        $tableKeyColumnDesignData = $this->getTableKeyColumnDesignData();
        
        foreach( $activeDatabaseList as $database )
        {
            $this->forge->createDatabase($database, $encoding);

            if( ! empty($activeTableList = $this->getTableListByActiveDatabase($database)) )
            {
                $dbForge = $this->getDBForgeDifferentConnectionByDatabaseName($database);
                $db      = $this->getDBDifferentConnectionByDatabaseName($database);

                foreach( $activeTableList as $table )
                {
                    $activeTableColumnSchema = $this->getActiveTableColumnSchema($database, $table);

                    $this->addIdColumnToActiveTableIfNotExists($activeTableColumnSchema);

                    $activeTableColumns = $this->getActiveTableColumns($table = $this->getTableNameWithoutExtension($table), $db);

                    $this->getActiveTableKeyAndColumns($activeTableColumns, $activeTableKey, $activeTableColumns);

                    $currentTableKey = $this->getCurrentTableKey($table, $activeTableColumnSchema);

                    if( ! empty($activeTableColumns) )
                    {
                        $columnsMerge = array_merge(array_flip($activeTableColumns), $activeTableColumnSchema);

                        foreach( $columnsMerge as $key => $val )
                        {
                            if( is_numeric($val) )
                            {
                                $this->dropColumnFromActiveTable($table, $key, $dbForge, $status);
                            }
                            elseif( in_array($key, $activeTableColumns) )
                            {
                                $this->modifyColumnFromActiveTable($table, $key, $val, $dbForge, $status, $activeTableKey, $currentTableKey);
                            }
                            else
                            {
                                $this->addColumnFromActiveTable($table, $key, $val, $dbForge, $status);
                            }
                        }

                        if( $status === true )
                        {
                            $this->addTableToArchive($database, $table);
                        }
                    }
                    else
                    {
                        $activeTableColumnSchema[$currentTableKey] = $tableKeyColumnDesignData;

                        $dbForge->createTable($table, $activeTableColumnSchema);
                    }
                }
            }
        }
    }
106688
public function entries()
    {
        $page = $this->page();
        $cat = $this->category();
        if (isset($this->entries[$cat])) {
            if (isset($this->entries[$cat][$page])) {
                return $this->entries[$cat][$page];
            }
        }

        $loader = $this->entriesLoader();

        $this->entries[$cat][$page] = $loader->load();

        return $this->entries[$cat][$page];
    }
641313
public function all()
    {
        $entries = [];
        while ($keys = $this->redis->scan($it, self::KEY_PREFIX.'*')) {
            foreach ($keys as $key) {
                $entries[substr($key, strlen(self::KEY_PREFIX))] = Collection::make($this->redis->get($key));
            }
        }

        return $entries;
    }
725053
public function getActiveLocales()
	{
		$activeLocales = array();
		
		$locales = $this->getLocales();

		foreach ($locales as $id => $locale) {
			if ($locale->isActive()) {
				$activeLocales[$id] = $locale;
			}
		}

		return $activeLocales;
	}
1343611
public function getActive()
    {
        if (count($this->active) < 1) {
            return null;
        }
        while (time() > current($this->active)) {
            $key = key($this->active);
            $this->expired[$key] = current($this->active);
            $this->increment($this->active);
            unset($this->active[$key]);
            if (count($this->active) < 1) {
                return null;
            }
        }
        $active = key($this->active);
        $this->increment($this->active);
        return $active;
    }
897883
public function getActiveCategory()
    {
        if ($this->_oActCategory === null) {
            $this->_oActCategory = false;
            if (($this->_getVendorId() && $oVendorTree = $this->getVendorTree())) {
                if ($oVendor = $this->getActVendor()) {
                    $this->_oActCategory = $oVendor;
                }
            }
        }

        return $this->_oActCategory;
    }
9371
public function findActiveItem()
    {
        foreach ($this->items as $index => $item) {
            $index++;

            if ($item->number == $this->currentPage) {
                $item->active = true;
            }
        }
    }
749889
public function getAllActive()
    {
        $dto = new DTO();

        $dto->setParameter("Status", "enabled");
        $dto->setParameter("Installed", "1");
        $dto->setOrderBy("Priority");

        $dto = $this->findAll($dto);

        return $dto->getResults();
    }