Returns only currently connected providers

@return mixed
966517
public function getConnectedProviders() {
		$hybridAuthProviders = $this->hybridAuth->getConnectedProviders();

		$providers = $this->makeProviders($hybridAuthProviders);

		return $providers;
	}
1070335
public function getReservations(){
        $rest = $this->getService( self::API_VPN_IPPOOL);
        $rest->GET();

        return $rest->getResult();
    }
1203967
public function ping() {

		$canConnect = false;

		foreach ( $this->httpRequests as $httpRequest ) {
			if ( !$httpRequest->ping() ) {
				return false;
			}

			$canConnect = true;
		}

		return $canConnect;
	}
554781
public function getDefaultConnection()
    {
        if (!$this->defaultConnection && empty($this->connections)) {
            throw new InvalidConnectionException('There are no connections configured');
        }

        if (!$this->defaultConnection) {
            reset($this->connections);

            return current($this->connections);
        }

        return $this->getConnection($this->defaultConnection);
    }
1152889
public function getSocialAccounts()
    {
        $connected = [];
        /** @var UserSocialAccount[] $accounts */
        $accounts = $this->hasMany(UserSocialAccount::class, ['user_id' => 'id'])->all();
        /**
         * @var UserSocialAccount $account
         */
        foreach ($accounts as $account) {
            $connected[$account->provider] = $account;
        }

        return $connected;
    }
607540
public function getProviderService()
    {
        if ($this->providerService == null) {
            $this->setProviderService($this->getServiceLocator()->get('playgrounduser_provider_service'));
        }

        return $this->providerService;
    }
1217365
public static function getAvailableProviders()
    {
        $result = array();
        foreach (self::getAllProviders() as $provider) {
            if ($provider->isAvailable()) {
                $result[] = $provider;
            }
        }
        return $result;
    }
1198402
public function getStatus()
    {
        $reports = [];
        $this->connectionManager = GeneralUtility::makeInstance(ConnectionManager::class);

        $solrConnections = $this->connectionManager->getAllConfigurations();

        foreach ($solrConnections as $solrConnection) {
            $reports[] = $this->getConnectionStatus($solrConnection);
        }

        return $reports;
    }
1319843
public function current()
    {
        if (!$this->valid()) {
            return null;
        }

        $ob = $this->_data[$this->_ptr['idx']];

        return is_null($this->_ptr['subidx'])
            ? $ob
            : $ob->addresses[$this->_ptr['subidx']];
    }
462141
public function getConnectionStatus()
    {
        if (!$this->hasHandler()) {
            if ($this->is_closed) {
                return static::CONNECTION_STATUS_CLOSED;
            } else {
                return static::CONNECTION_STATUS_NONE;
            }
        }

        if (@pg_connection_status($this->handler) === \PGSQL_CONNECTION_OK) {
            return static::CONNECTION_STATUS_GOOD;
        }

        return static::CONNECTION_STATUS_BAD;
    }
32172
public static function getCurrentIP()
    {
        $ip = '';

        foreach (['HTTP_CLIENT_IP', 'HTTP_X_FORWARDED_FOR', 'HTTP_X_FORWARDED', 'HTTP_X_CLUSTER_CLIENT_IP', 'HTTP_FORWARDED_FOR', 'HTTP_FORWARDED', 'REMOTE_ADDR'] as $headerKey) {
            if ($item = getenv($headerKey)) {
                foreach (array_filter(explode(',', $item), 'trim') as $ipAddress) {
                    if ($ip = filter_var($ipAddress, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE)) {
                        break 2;
                    }
                }
            }
        }

        return (string) $ip;
    }
838229
private function getProvider()
	{
		$providerData = null;

		if (isset($_SERVER['HTTP_AUTHORIZATION'])) {
			$authBasicHeader = trim($_SERVER['HTTP_AUTHORIZATION']);

			preg_match('/^Basic (.+)$/', $authBasicHeader, $matches);
			@list($login, $password) = explode(':', base64_decode($matches[1]));
			$providerData = array(
				'login'    => $login,
				'password' => $password,
			);
		}

		if (isset($_SERVER['PHP_AUTH_USER']) && isset($_SERVER['PHP_AUTH_PW'])) {
			$providerData = array(
				'login'    => (int)trim($_SERVER['PHP_AUTH_USER']),
				'password' => trim($_SERVER['PHP_AUTH_PW']),
			);
		}

		return $providerData;
	}
707351
public function getAvailableConnections()
    {
        // Fetch stored credentials
        $storage = $this->localStorage->get('connections');
        $storage = $this->unifyMultiserversDeclarations($storage);

        // Merge with defaults from config file
        $configuration = $this->config->get('connections');
        $configuration = $this->unifyMultiserversDeclarations($configuration);

        // Merge configurations
        $connections = array_replace_recursive($configuration, $storage);

        return $connections;
    }
763659
public static function getCurrent()
    {
        $class = get_called_class();
        if (Session::get('user')) {
            return $class::search()->where('user_id', Session::get('user')->user_id)->execOne();
        }
        return false;
    }
252152
protected function findAvailableConnection()
    {
        $servers = $this->credentials;
        shuffle($servers);
        $previous = null;

        foreach ($servers as $server) {
            try {
                $node = $this->getNodeConnection($server);
            } catch (ConnectionException $e) {
                $previous = $e;
                continue;
            }

            if ($node->isConnected()) {
                return $node;
            }
        }

        throw new ConnectionException('No servers available', 0, $previous);
    }
1354833
public function getAll() {
        $rest = $this->getService( self::API_WIFI_BSS);
        $rest->GET();

        return $rest->getResultAsArray( models\WiFi\Bss\Bss::class);
    }
784844
public function getAll(){
        $rest = $this->getService( self::API_VPN_CONNECTION);
        $rest->GET();

        return $rest->getResultAsArray( models\VPN\Server\Connection::class);
    }