Obtain a set of ResourceThumbnail objects representing the thumbnails for several reports,
these ResourceThumbnail objects will contain the image data as a Base64 String only

@param array $uris
@param bool $defaultAllowed
@return array
500216
public function getResourceThumbnails(array $uris, $defaultAllowed = false)
    {
        $result = array();
        $url = self::makeUrl();
        $postString = Util::query_suffix(array("uri" => $uris, "defaultAllowed" => $defaultAllowed));

        $response = $this->service->makeRequest($url, array(200), 'POST', $postString, true, 'application/x-www-form-urlencoded');
        $data = json_decode($response['body']);
        if (isset($data)) {
            foreach ($data as $thumbnail) {
                $result[] = ResourceThumbnail::createFromJSON($thumbnail);
            }
        }
        return $result;
    }
62417
public static function getDatas() {
		$method = \strtolower ( $_SERVER ['REQUEST_METHOD'] );
		switch ($method) {
			case 'post' :
				if (self::getContentType () == 'application/x-www-form-urlencoded') {
					return $_POST;
				}
				break;
			case 'get' :
				return $_GET;
			default :
				return self::getInput ();
		}
		return self::getInput ();
	}
1331918
public function getThumbnailEncoded()
    {
        if ($data = base64_decode($this->getThumbnail(), $strict = true)) {
            // In case we don't have the file info extension enabled,
            // we'll set the jpeg mime type as default.
            $mime = 'image/jpeg';

            $image = base64_encode($data);

            if (function_exists('finfo_open')) {
                $finfo = finfo_open();

                $mime = finfo_buffer($finfo, $data, FILEINFO_MIME_TYPE);

                return "data:$mime;base64,$image";
            }

            return "data:$mime;base64,$image";
        }
    }
839553
function load_base64($base64string) {
        if (!extension_loaded('gd')) {
            throw new Exception('Required extension GD is not loaded.');
        }
        //remove data URI scheme and spaces from base64 string then decode it
        $this->imagestring = base64_decode(str_replace(' ', '+', preg_replace('#^data:image/[^;]+;base64,#', '', $base64string)));
        $this->image = imagecreatefromstring($this->imagestring);
        return $this->get_meta_data();
    }
1026933
public function getSupportedReportSet($uri)
    {
        $node = $this->server->tree->getNodeForPath($uri);
        if ($node instanceof IAddressBook || $node instanceof ICard) {
            return [
                 '{'.self::NS_CARDDAV.'}addressbook-multiget',
                 '{'.self::NS_CARDDAV.'}addressbook-query',
            ];
        }

        return [];
    }
61515
protected function _getUrlFromRequest(UriInterface $uri, $getFullUrl = false)
    {
        if (property_exists($uri, 'base')) {
            $uri = $uri->withPath($uri->base . $uri->getPath());
        }

        if ($getFullUrl) {
            return (string)$uri;
        }

        return $uri->getPath();
    }
1245274
protected function getRequestParamValue(string $defaultValue = null, string $defaultName = 'id'): ?string
    {
        $paramName = $this->getRequestParamName($defaultName);

        return $this->request->get($paramName, $defaultValue);
    }
1160909
public function getLinks($all = false)
    {
        $links = [];

        $this->getLinksByTagAttribute("link", "href", $links);
        $this->getLinksByTagAttribute("a", "href", $links);
        $this->getLinksByTagAttribute("script", "src", $links);
        $this->getLinksByTagAttribute("iframe", "src", $links);
        $this->getLinksByTagAttribute("img", "src", $links);

        //get all string started with http
        $regexUrl = '/[">\s]+((http|https|ftp|ftps)\:\/\/(.*?))["<\s]+/';
        $urls     = null;
        if (preg_match_all($regexUrl, $this->html, $urls) > 0) {
            $matches = $urls[1];
            foreach ($matches as $url) {
                if (filter_var($url, FILTER_VALIDATE_URL)) {
                    $links[$url] = $url;
                }
            }
        }

        if ($all) {
            //get all params which can be a url
            $regexParam = '/["](.*?)["]/';
            $params     = [];
            if (preg_match_all($regexParam, $this->html, $params) > 0) {
                $urls = $params[1];
                foreach ($urls as $url) {
                    $url = trim($url);
                    if ((strpbrk($url, "/.") !== false) && (strpbrk($url, " ") === false)) {
                        $links[$url] = $url;
                    }
                }
            }
        }

        foreach ($links as $link) {
            $url = parse_url($link);
            if (!((isset($url['host']) && isset($url['scheme'])) || (isset($url['path'])))) {
                unset($links[$link]);
            }
        }

        return $links;
    }
476364
public function imageAsBase64($path, array $params = [], $skipValidation = false)
    {
        $this->validateRequest($path, $params, $skipValidation);

        return $this->getLeagueGlideServer()->getImageAsBase64($path, $params);
    }
445988
public static function getAllowedFunctions()
    {
        $properties = array(
            static::PROPERTY_DRAG,
            static::PROPERTY_DROP,
            static::PROPERTY_EDIT,
            static::PROPERTY_DELETE,
        );

        $class = get_called_class();

        if ( is_a( $class, __NAMESPACE__ . '\RepresentsTextContentInterface', true ) )
        {
            $properties[] = static::PROPERTY_REPRESENTS_TEXT;
        }

        if ( is_a( $class, __NAMESPACE__ . '\RepresentsImageContentsInterface', true ) )
        {
            $properties[] = static::PROPERTY_REPRESENTS_IMAGES;
        }

        return $properties;
    }
1017717
public function retrieve($uri)
    {
        $errorMessage = null;
        set_error_handler(function ($errno, $errstr) use (&$errorMessage) {
            $errorMessage = $errstr;
        });
        $response = file_get_contents($uri);
        restore_error_handler();

        if ($errorMessage) {
            throw new ResourceNotFoundException($errorMessage);
        }

        if (false === $response) {
            throw new ResourceNotFoundException('JSON schema not found at ' . $uri);
        }

        if ($response == ''
            && substr($uri, 0, 7) == 'file://' && substr($uri, -1) == '/'
        ) {
            throw new ResourceNotFoundException('JSON schema not found at ' . $uri);
        }

        $this->messageBody = $response;
        if (!empty($http_response_header)) {
            // $http_response_header cannot be tested, because it's defined in the method's local scope
            // See http://php.net/manual/en/reserved.variables.httpresponseheader.php for more info.
            $this->fetchContentType($http_response_header); // @codeCoverageIgnore
        } else {                                            // @codeCoverageIgnore
            // Could be a "file://" url or something else - fake up the response
            $this->contentType = null;
        }

        return $this->messageBody;
    }
1226975
function loadURIRoot( $uri, $displayErrors = true, &$extraParameters )
    {
        $res = "";
        $template = "";
        $resobj = $this->resourceFor( $uri, $res, $template );

        if ( !is_object( $resobj ) )
        {
            if ( $displayErrors )
                $this->warning( "", "No resource handler for \"$res\" and no default resource handler, aborting." );
            return null;
        }

        $canCache = true;
        if ( !$resobj->servesStaticData() )
            $canCache = false;
        if ( !$this->isCachingAllowed() )
            $canCache = false;

        $resourceData = $this->loadURIData( $resobj, $uri, $res, $template, $extraParameters, $displayErrors );

        if ( $resourceData )
        {
            eZTemplate::appendTemplateToStatisticsIfNeeded( $resourceData['template-name'], $resourceData['template-filename'] );
            $this->appendTemplateFetch( $resourceData['template-filename'] );

            if ( !$resourceData['compiled-template'] and
                 $resourceData['root-node'] === null )
            {
                $resourceData['root-node'] = array( eZTemplate::NODE_ROOT, false );
                $templateText = $resourceData["text"];
                $keyData = $resourceData['key-data'];
                $this->setIncludeText( $uri, $templateText );
                $rootNamespace = '';
                $this->parse( $templateText, $resourceData['root-node'], $rootNamespace, $resourceData );

                if ( eZTemplate::isDebugEnabled() )
                {
                    $this->appendDebugNodes( $resourceData['root-node'], $resourceData );
                }

                if ( $canCache )
                    $resobj->setCachedTemplateTree( $keyData, $uri, $res, $template, $extraParameters, $resourceData['root-node'] );
            }
            if ( !$resourceData['compiled-template'] and
                 $canCache and
                 $this->canCompileTemplate( $resourceData, $extraParameters ) )
            {
                $generateStatus = $this->compileTemplate( $resourceData, $extraParameters );
                if ( $generateStatus )
                    $resourceData['compiled-template'] = true;
            }
        }

        return $resourceData;
    }
562809
private function resolveResourceThumbnail($defaultImage)
    {
        $baseFolder = $this->getBaseFolder();
        $iconUrl = $baseFolder.DIRECTORY_SEPARATOR.'default_thumbnail.png';
        foreach ($this->getThumbnailBaseFolderPaths() as $path) {
            $imageFilePath = $path.DIRECTORY_SEPARATOR.$defaultImage;

            if (file_exists($imageFilePath) && is_readable($imageFilePath)) {
                $iconUrl = $baseFolder.DIRECTORY_SEPARATOR.$defaultImage;
                break;
            }
        }

        return $iconUrl;
    }
626419
protected static function getPagingLinks(UriInterface $originalUri, PaginatedDataInterface $data): array
    {
        $links = [
            DocumentInterface::KEYWORD_PREV => null,
            DocumentInterface::KEYWORD_NEXT => null,
        ];

        if ($data->isCollection() === true && (0 < $data->getOffset() || $data->hasMoreItems() === true)) {
            parse_str($originalUri->getQuery(), $queryParams);

            $pageSize    = $data->getLimit();
            $linkClosure = function (int $offset) use ($originalUri, $pageSize, $queryParams): UriInterface {
                $paramsWithPaging = array_merge($queryParams, [
                    BaseQueryParserInterface::PARAM_PAGE => [
                        JsonApiQueryValidatingParserInterface::PARAM_PAGING_OFFSET => $offset,
                        JsonApiQueryValidatingParserInterface::PARAM_PAGING_LIMIT  => $pageSize,
                    ],
                ]);

                $paginatedUri = $originalUri->withQuery(http_build_query($paramsWithPaging));

                return $paginatedUri;
            };

            if ($data->getOffset() > 0) {
                $prevOffset                             = max(0, $data->getOffset() - $data->getLimit());
                $links[DocumentInterface::KEYWORD_PREV] = $linkClosure($prevOffset);
            }
            if ($data->hasMoreItems() === true) {
                $nextOffset                             = $data->getOffset() + $data->getLimit();
                $links[DocumentInterface::KEYWORD_NEXT] = $linkClosure($nextOffset);
            }
        }

        return $links;
    }
380734
public function getJsActionsAllowed($profile, $resource, $actions)
    {
        $actionsAllowed = '[';
        $flag = false;
        foreach ($actions as $action)
        {
            if(parent::isAllowed($profile, $resource, $action->id_008))
            {
                if($flag) $actionsAllowed .= ',';
                $actionsAllowed .= '"' . $action->id_008 . '"';
                $flag =true;
            }
        }
        
        $actionsAllowed .= ']';
        return $actionsAllowed;    
    }
462080
public function getSuggestForceHttps($defaultIfEmpty = false)
    {
        $isHttpsForced = $this->getValueByPathOrDefaultValue('plugin.tx_solr.suggest.forceHttps', $defaultIfEmpty);
        return $this->getBool($isHttpsForced);
    }
951750
public static function handles($uri)
	{
		$uri = rtrim($uri, '/').'/';

		foreach (static::$bundles as $key => $value)
		{
			if (isset($value['handles']) and starts_with($uri, $value['handles'].'/') or $value['handles'] == '/')
			{
				return $key;
			}
		}

		return DEFAULT_BUNDLE;
	}