Return connection array ResourceMethod => RequestPathFormat.

@see \Zibios\WrikePhpLibrary\Enum\Api\ResourceMethodEnum
@see \Zibios\WrikePhpLibrary\Enum\Api\RequestPathFormatEnum

@return array
511295
protected function getResourceMethodConfiguration(): array
    {
        return [
            ResourceMethodEnum::GET_ALL_FOR_TASK => RequestPathFormatEnum::DEPENDENCIES_FOR_TASK,
            ResourceMethodEnum::GET_BY_ID => RequestPathFormatEnum::DEPENDENCIES_BY_ID,
            ResourceMethodEnum::GET_BY_IDS => RequestPathFormatEnum::DEPENDENCIES_BY_IDS,
            ResourceMethodEnum::CREATE_FOR_TASK => RequestPathFormatEnum::DEPENDENCIES_FOR_TASK,
            ResourceMethodEnum::UPDATE => RequestPathFormatEnum::DEPENDENCIES_BY_ID,
            ResourceMethodEnum::DELETE => RequestPathFormatEnum::DEPENDENCIES_BY_ID,
        ];
    }
518091
protected function mapResourceAbilities(): array
    {
        // Reflect calling controller
        $controller = new ReflectionClass(static::class);

        // Get public methods and filter magic methods
        $methods = array_filter($controller->getMethods(ReflectionMethod::IS_PUBLIC), function ($item) use ($controller) {
            return $item->class === $controller->name && mb_substr($item->name, 0, 2) !== '__' && ! in_array($item->name, $this->resourceActionWhitelist);
        });

        // Get controller actions
        $actions = array_combine($items = array_map(function ($action) {
            return $action->name;
        }, $methods), $items);

        // Map resource actions to resourse abilities
        array_walk($actions, function ($value, $key) use (&$actions) {
            $actions[$key] = array_get($this->resourceAbilityMap(), $key, $value);
        });

        return $actions;
    }
138960
public function get_resources() {

        if (empty($this->resources)) {
            $this->resources = array();
            $this->resources[] = new \ltiservice_toolsettings\local\resources\systemsettings($this);
            $this->resources[] = new \ltiservice_toolsettings\local\resources\contextsettings($this);
            $this->resources[] = new \ltiservice_toolsettings\local\resources\linksettings($this);
        }

        return $this->resources;

    }
519687
public function getParamsAsCode(): array
    {
        $paramsAsCode = [];

        foreach ($this->getParamNames() as $paramName) {
            $paramsAsCode[$paramName] = RequestPropertyUtility::getStringValueAsCode($this->$paramName);
        }

        return $paramsAsCode;
    }
775063
public function getUrlPatternsAsArray()
    {

        // initialize the array for the URL patterns
        $urlPatterns = array();

        // prepare the URL patterns
        /** @var \AppserverIo\Appserver\Core\Api\Node\UrlPatternNode $urlPatternNode */
        foreach ($this->getUrlPatterns() as $urlPatternNode) {
            $urlPatterns[] = $urlPatternNode->__toString();
        }

        // return the array with the URL patterns
        return $urlPatterns;
    }
31164
protected function getConnectionOptions(): array
	{
		return $this->options +
		[
			PDO::ATTR_PERSISTENT         => $this->usePersistentConnection,
			PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
			PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_OBJ,
			PDO::ATTR_STRINGIFY_FETCHES  => false,
			PDO::ATTR_EMULATE_PREPARES   => false,
		];
	}
1339554
public function getConnectionsCredentials()
    {
        $connectionName = null;
        if ($this->connections) {
            $this->presentConnections($this->connections);
            if ($this->command->confirm('Do you want to add a connection to this?', false)) {
                $connectionName = $this->command->ask('What do you want to name it?');
            }
        } else {
            $connectionName = $this->command->ask('No connections have been set, let\'s create one, what do you want to name it?', 'production');
        }

        // If the user does not want to add any more connection
        // then we can quit
        if (!$connectionName) {
            return $this->connections;
        }

        $this->getConnectionCredentials($connectionName);

        return $this->getConnectionsCredentials();
    }
1070562
public function getConnections()
    {
        $connections = [];
        foreach ($this->getConnectionNames() as $name) {
            $connections[$name] = $this->getConnection($name);
        }

        return $connections;
    }
1362302
public function GetList() {
        $namespacePrefix = "\\Applications\\" .
                "APP_NAME" .
                "\\Resources\\Controller\\";
        $resourceNamespace = $this->GetResourceNamespace($namespacePrefix, $this->ModuleValue);
        $resourceFile = new $resourceNamespace();
        return $resourceFile->GetList();
    }
275371
protected function getConnectionDescription() {
        $options = $this->options;

        if (is_resource($this->hConnection)) {
            $host        = pg_host($this->hConnection);
            $port        = pg_port($this->hConnection);
            $db          = pg_dbname($this->hConnection);
            $path        = $this->getSchemaSearchPath();
            $description = $host.':'.$port.'/'.$db.' (schema search path: '.$path.')';
        }
        else {
            if      (isset($options['hostaddr'])) $host = $options['hostaddr'];
            else if (isset($options['host'    ])) $host = $options['host'    ];
            else                                  $host = '';

            if (isset($options['port'])) $port = ':'.$options['port'];
            else                         $port = '';

            if      (isset($options['dbname'])) $db = $options['dbname'];
            else if (isset($options['user'  ])) $db = $options['user'  ];
            else                                $db = '';

            $description = $host.$port.'/'.$db;
        }
        return $description;
    }
1137206
public function getConnectionString(){
        $connection_string = array();

        $type = $this->getType();
        array_push($connection_string, $type);

        if($type == self::SQLite){
        	$filename = 'db.sqlite';
        	if(isset($this->properties['filename']))
        		$filename = $this->properties['filename'];
        	array_push($connection_string, ":$filename");
        }
        else {
	        array_push($connection_string, ':host=');
	        array_push($connection_string,
	            (isset($this->properties['host']))?
	            $this->properties['host']:'localhost'
	        );
	        array_push($connection_string, ';dbname=');
	        array_push($connection_string,
	            (isset($this->properties['name']))?
	            $this->properties['name']:null
	        );
        }
        
        array_push($connection_string, ';charset=');
        array_push($connection_string, $this->getCharset());
        return implode($connection_string);
    }
461271
public final function getResourceStats(): ?array
    {
        $return = null;

        $resourceType = $this->resource->getType();
        $resourceObject = $this->resource->getObject();
        if ($resourceType == Resource::TYPE_MYSQL_LINK) {
            $result = $resourceObject->query('SHOW SESSION STATUS');
            while ($row = $result->fetch_assoc()) {
                $return[strtolower($row['Variable_name'])] = $row['Value'];
            }
            $result->free();
        } elseif ($resourceType == Resource::TYPE_PGSQL_LINK) {
            $result = pg_query($resourceObject, sprintf(
                "SELECT * FROM pg_stat_activity WHERE usename = '%s'",
                    pg_escape_string($resourceObject, $this->config['username'])
            ));
            $resultArray = pg_fetch_all($result);
            if (isset($resultArray[0])) {
                $return = $resultArray[0];
            }
            pg_free_result($result);
        }

        return $return;
    }
270508
protected function _getServicePath()
    {
        if (isset($this->_options['server'])) {
            return $this->_options['server']->getDirectory();
        }

        if (isset($this->_options['directories'])) {
            return $this->_options['directories'];
        }

        return array();
    }
4074
protected function connection()
	{
		// If no a protocol in URL, assume its a local link
		! preg_match('!^\w+://! i', $this->resource) and $this->resource = Uri::create($this->resource);

		return curl_init($this->resource);
	}
302254
private function getLaravelPaths()
    {
        $is54 = version_compare(\Illuminate\Foundation\Application::VERSION, '5.4.0', '>');
        $paths = [
            'app' => $this->app[ 'path' ],
            'envFile' => $this->app->environmentFilePath(),
            'env' => $this->app->environmentPath(),
            'cached' => [
                'compile' => $is54 ? null : $this->app->getCachedCompilePath(),
                'config' => $this->app->getCachedConfigPath(),
                'routes' => $this->app->getCachedRoutesPath(),
                'services' => $this->app->getCachedServicesPath(),
            ],
        ];
        foreach (['base', 'lang', 'config', 'public', 'storage', 'database', 'bootstrap'] as $key) {
            $paths[ $key ] = $this->app[ 'path.'.$key ];
        }
        $paths[ 'resource' ] = resource_path();

        return $paths;
    }
1338019
public function getMethods()
    {
        $requestMethod = $this->request->getAccessControlRequestMethod();
        if (in_array('*', $this->methods) && $requestMethod) {
            return $requestMethod;
        }

        return $this->methods;
    }
89646
protected function getRequestData()
    {
        return [
            'request'  => $this->request->toArray(),
            'response' => [
                'content'      => null,
                'content_type' => null,
                'status_code'  => ServiceResponseInterface::HTTP_OK
            ],
            'resource' => $this->resourcePath
        ];
    }