Return size_upload,upload_content,speed_upload,time_request

@return array
@throws Exception\TransportException
495766
public function info_upload()
    {
        $this->check();
        return [
            'size_upload'    => $this->response()->size_upload(),
            'upload_content' => $this->response()->upload_content_length(),
            'speed_upload'   => $this->response()->speed_upload(),
            'time_request'   => $this->response()->total_time()
        ];
    }
1150907
public function info()
    {
        $resp=$this->_transport->send(HttpRequest::GET, $this->_baseURL);
        $ret = array();
        $ret["hub"] = $this->_hub;
        $ret["key"] = $this->_key;
        $ret["disabledTill"] = $resp["disabledTill"];
        $ret["converts"] = $resp["converts"];
        return $ret;
    }
1296816
public function actionFilesUpload()
    {
        $this->checkRouteAccess(self::PERMISSION_ROUTE);
        
        foreach ($_FILES as $k => $file) {
            if ($file['error'] !== UPLOAD_ERR_OK) {
                Yii::$app->response->setStatusCode(422, 'Data Validation Failed.');
                return ['upload' => false, 'message' => Storage::getUploadErrorMessage($file['error']), 'file' => null];
            }
            try {
                $response = Yii::$app->storage->addFile($file['tmp_name'], $file['name'], Yii::$app->request->post('folderId', 0), Yii::$app->request->post('isHidden', false));
                if ($response) {
                    return ['upload' => true, 'message' => Module::t('api_storage_file_upload_succes'), 'file' => $response];
                } else {
                    Yii::$app->response->setStatusCode(422, 'Data Validation Failed.');
                    return ['upload' => false, 'message' => Module::t('api_storage_file_upload_folder_error'), 'file' => null];
                }
            } catch (Exception $err) {
                Yii::$app->response->setStatusCode(422, 'Data Validation Failed.');
                return ['upload' => false, 'message' => Module::t('api_sotrage_file_upload_error', ['error' => $err->getMessage()]), 'file' => null];
            }
        }
    
        // If the files array is empty, this is an indicator for exceeding the upload_max_filesize from php ini or a wrong upload defintion.
        Yii::$app->response->setStatusCode(422, 'Data Validation Failed.');
        return ['upload' => false, 'message' => Storage::getUploadErrorMessage(UPLOAD_ERR_NO_FILE), 'file' => null];
    }
181224
public function toData()
    {
        if ($this->action === self::TYPE_READ) {
            return [
                'fields' => 'home_url',
            ];
        }

        if ($this->action === self::TYPE_DELETE) {
            return [
                'fields' => [
                    'home_url',
                ],
            ];
        }

        return [
            'home_url' => array_merge([
                'webview_height_ratio' => 'tall',
            ], $this->config),
        ];
    }
498117
public function send() {
        if (is_null($this->Transport)) {
            throw new TransportException();
        }
        $this->Transport->setRequest($this);
        return $this->Transport->makeHttpRequest($this);
    }
1248139
protected function getData()
    {
        if ( ! $this->fileOptions) {
            return $this->request->all();
        }

        $excepts = collect($this->fileOptions)->keyBy(function ($item) {
            $columns = explode('.', $item['column']);
            return count($columns) === 1 ? $columns[0] : $columns[1];
        })->keys()->all();
        return $this->request->except($excepts);
    }
455895
protected function getConfigs()
    {
    	$session = $this->container->get('session');
    	if (!$configs = $session->get($this->getRequest()->get('thrace_media_id', false))){
            $configs = [
                'max_upload_size' => '200000000',
                'extensions' => 'application/*'
            ];
    	}
    	
    	return $configs;
    }
732654
public function getContentItemArray()
    {
        return [
            'content' => $this->content,
            'id' => $this->id,
            'created' => $this->created,
            'updated' => $this->updated,
            'contenttype' => $this->contenttype,
            'language' => $this->language,
            'parentid' => $this->parentid,
            'reply' => $this->reply,
            'forward' => $this->forward,
        ];
    }
1305442
public static function getFiles()
    {
        if (self::$_files === null) {
            self::$_files = [];
            if (isset($_FILES) && is_array($_FILES)) {
                foreach ($_FILES as $class => $info) {
                    self::getUploadFilesRecursive($class, $info['name'], $info['error']);
                }
            }
        }
        return self::$_files;
    }
150340
public function toMultipart()
    {
        $data = [];
        foreach ($this->payload as $key => $value) {
            if($key!='file')
            {
                $data[] = ['name' => $key, 'contents' => $value];
            }
            else
            {
                $data[] = $value;
            }
        }
        return $data;
    }
794416
protected function _getUploadInfoString() {
        $maxFileSize = $this->getUploadMaxFilesize();
        $allowedExtensions = $this->getAllowedExtensions();
        $lastExtension = array_pop($allowedExtensions);

        $translator = $this->getTranslator();
        $uploadInfoStr = $translator->translate('Only %1$s and %2$s files with a maximum of %3$s MB are allowed');
        $uploadInfoStr = sprintf($uploadInfoStr, implode(', ', $allowedExtensions), $lastExtension, $maxFileSize);

        return $uploadInfoStr;
    }
164620
public function getFileInfo()
    {
        $upload = new eZContentUpload();
        $errors = array();
        $mimeData = $file = '';
        $result = $upload->fetchHTTPFile( 'UploadFile', $errors, $file, $mimeData );

        if ( $result === false )
        {
            throw new RuntimeException(
                ezpI18n::tr(
                    'extension/ezjscore/ajaxuploader',
                    'Unable to retrieve the uploaded file: %message',
                    null, array( '%message' => $errors[0]['description'] )
                )
            );
        }
        return array(
            'file' => $file,
            'mime' => $mimeData
        );
    }
982706
public function toData()
    {
        if ($this->type === self::TYPE_LOCATION) {
            return ['content_type' => 'location'];
        }

        return array_merge([
            'content_type' => 'text',
            'title' => $this->title,
            'payload' => $this->payload,
        ], $this->imageUrl ? ['image_url' => $this->imageUrl] : []);
    }
776749
public function getData(): array
    {
        $uploads = [];
        //if the user is trying to upload a image
        if ($this->request->hasFiles()) {
            foreach ($this->request->getUploadedFiles() as $file) {
                $uploads[] = [
                    'name' => $file->getKey(),
                    'filename' => $file->getName(),
                    'contents' => file_get_contents($file->getTempName()),
                ];
            }

            $parseUpload = function ($request) use (&$uploads) {
                foreach ($request as $key => $value) {
                    if (is_array($value)) {
                        foreach ($value as $f => $v) {
                            $uploads[] = ['name' => $key . '[' . $f . ']', 'contents' => $v];
                        }
                    } else {
                        $uploads[] = ['name' => $key, 'contents' => $value];
                    }
                }
            };
        }

        switch ($this->request->getMethod()) {
            case 'GET':
                $queryParams = $this->request->getQuery();
                unset($queryParams['_url']);
                return ['query' => $queryParams];
                break;

            case 'POST':
                if (!$uploads) {
                    //if we dont get post send the raw
                    if (count($this->request->getPost()) > 0) {
                        return ['form_params' => $this->request->getPost()];
                    } elseif ($this->request->getJsonRawBody()) {
                        return ['json' => json_decode($this->request->getRawBody(), true)];
                    }
                    //why did we get here?
                    return ['form_params' => $this->request->getPost()];
                } else {
                    $parseUpload($this->request->getPost());
                    return ['multipart' => $uploads];
                }
                break;

            case 'PUT':
                if (!$uploads) {
                    //if we get put send it with the normal put, else send json
                    if (count($this->request->getPut()) > 0) {
                        return ['form_params' => $this->request->getPut()];
                    } elseif ($this->request->getJsonRawBody()) {
                        return ['json' => json_decode($this->request->getRawBody(), true)];
                    }
                    //why did we get here?
                    return ['form_params' => $this->request->getPut()];
                } else {
                    $parseUpload($this->request->getPut());
                    return ['multipart' => $uploads];
                }

                break;
            default:
                return [];
                break;
        }
    }
423187
public function getExportData()
    {
        $snippets = $this->getSnippets();
        $snippetsData = [];

        $progress = new ProgressBar($this->output, count($snippets));
        $progress->start();

        /*
         * @var SnippetDocument
         */
        foreach ($snippets as $snippet) {
            $contentData = $this->getContentData($snippet, $this->exportLocale);

            $snippetsData[] = [
                'uuid' => $snippet->getUuid(),
                'locale' => $snippet->getLocale(),
                'content' => $contentData,
            ];

            $progress->advance();
        }

        $progress->finish();

        return [
            'locale' => $this->exportLocale,
            'format' => $this->format,
            'snippetData' => $snippetsData,
        ];
    }
31439
public function getContentLength()
    {
        if (null !== $this->requestStack && null !== $request = $this->requestStack->getCurrentRequest()) {
            return $request->server->get('CONTENT_LENGTH');
        }

        return isset($_SERVER['CONTENT_LENGTH'])
            ? (int) $_SERVER['CONTENT_LENGTH']
            : null;
    }
656678
public function getRequestData() {
        $data = $this->Controller->request->data;

        if ($data) {
            foreach ($data as $model => $fields) {
                foreach ($fields as $key => $value) {
                    if (
                        (mb_substr($key, -5) === '_null') ||
                        (mb_substr($key, -11) === '_type_ahead') ||
                        in_array($key, array('redirect_to', 'log_comment', 'report_action'))
                    ) {
                        unset($data[$model][$key]);
                    }
                }
            }
        }

        return $data;
    }