PHP UploadBase::fetchFile方法代码示例

 /**
  * Do the upload.
  * Checks are made in SpecialUpload::execute()
  */
 protected function processUpload()
 {
     // Fetch the file if required
     $status = $this->mUpload->fetchFile();
     if (!$status->isOK()) {
         $this->showUploadError($this->getOutput()->parse($status->getWikiText()));
         return;
     }
     if (!Hooks::run('UploadForm:BeforeProcessing', array(&$this))) {
         wfDebug("Hook 'UploadForm:BeforeProcessing' broke processing the file.\n");
         // This code path is deprecated. If you want to break upload processing
         // do so by hooking into the appropriate hooks in UploadBase::verifyUpload
         // and UploadBase::verifyFile.
         // If you use this hook to break uploading, the user will be returned
         // an empty form with no error message whatsoever.
         return;
     }
     // Upload verification
     $details = $this->mUpload->verifyUpload();
     if ($details['status'] != UploadBase::OK) {
         $this->processVerificationError($details);
         return;
     }
     // Verify permissions for this title
     $permErrors = $this->mUpload->verifyTitlePermissions($this->getUser());
     if ($permErrors !== true) {
         $code = array_shift($permErrors[0]);
         $this->showRecoverableUploadError($this->msg($code, $permErrors[0])->parse());
         return;
     }
     $this->mLocalFile = $this->mUpload->getLocalFile();
     // Check warnings if necessary
     if (!$this->mIgnoreWarning) {
         $warnings = $this->mUpload->checkWarnings();
         if ($this->showUploadWarning($warnings)) {
             return;
         }
     }
     // This is as late as we can throttle, after expected issues have been handled
     if (UploadBase::isThrottled($this->getUser())) {
         $this->showRecoverableUploadError($this->msg('actionthrottledtext')->escaped());
         return;
     }
     // Get the page text if this is not a reupload
     if (!$this->mForReUpload) {
         $pageText = self::getInitialPageText($this->mComment, $this->mLicense, $this->mCopyrightStatus, $this->mCopyrightSource, $this->getConfig());
     } else {
         $pageText = false;
     }
     $status = $this->mUpload->performUpload($this->mComment, $pageText, $this->mWatchthis, $this->getUser());
     if (!$status->isGood()) {
         $this->showUploadError($this->getOutput()->parse($status->getWikiText()));
         return;
     }
     // Success, redirect to description page
     $this->mUploadSuccessful = true;
     Hooks::run('SpecialUploadComplete', array(&$this));
     $this->getOutput()->redirect($this->mLocalFile->getTitle()->getFullURL());
 }

 public function execute()
 {
     // Check whether upload is enabled
     if (!UploadBase::isEnabled()) {
         $this->dieUsageMsg('uploaddisabled');
     }
     $user = $this->getUser();
     // Parameter handling
     $this->mParams = $this->extractRequestParams();
     $request = $this->getMain()->getRequest();
     // Check if async mode is actually supported (jobs done in cli mode)
     $this->mParams['async'] = $this->mParams['async'] && $this->getConfig()->get('EnableAsyncUploads');
     // Add the uploaded file to the params array
     $this->mParams['file'] = $request->getFileName('file');
     $this->mParams['chunk'] = $request->getFileName('chunk');
     // Copy the session key to the file key, for backward compatibility.
     if (!$this->mParams['filekey'] && $this->mParams['sessionkey']) {
         $this->mParams['filekey'] = $this->mParams['sessionkey'];
     }
     // Select an upload module
     try {
         if (!$this->selectUploadModule()) {
             return;
             // not a true upload, but a status request or similar
         } elseif (!isset($this->mUpload)) {
             $this->dieUsage('No upload module set', 'nomodule');
         }
     } catch (UploadStashException $e) {
         // XXX: don't spam exception log
         $this->handleStashException($e);
     }
     // First check permission to upload
     $this->checkPermissions($user);
     // Fetch the file (usually a no-op)
     /** @var $status Status */
     $status = $this->mUpload->fetchFile();
     if (!$status->isGood()) {
         $errors = $status->getErrorsArray();
         $error = array_shift($errors[0]);
         $this->dieUsage('Error fetching file from remote source', $error, 0, $errors[0]);
     }
     // Check if the uploaded file is sane
     if ($this->mParams['chunk']) {
         $maxSize = UploadBase::getMaxUploadSize();
         if ($this->mParams['filesize'] > $maxSize) {
             $this->dieUsage('The file you submitted was too large', 'file-too-large');
         }
         if (!$this->mUpload->getTitle()) {
             $this->dieUsage('Invalid file title supplied', 'internal-error');
         }
     } elseif ($this->mParams['async'] && $this->mParams['filekey']) {
         // defer verification to background process
     } else {
         wfDebug(__METHOD__ . " about to verify\n");
         $this->verifyUpload();
     }
     // Check if the user has the rights to modify or overwrite the requested title
     // (This check is irrelevant if stashing is already requested, since the errors
     //  can always be fixed by changing the title)
     if (!$this->mParams['stash']) {
         $permErrors = $this->mUpload->verifyTitlePermissions($user);
         if ($permErrors !== true) {
             $this->dieRecoverableError($permErrors[0], 'filename');
         }
     }
     // Get the result based on the current upload context:
     try {
         $result = $this->getContextResult();
         if ($result['result'] === 'Success') {
             $result['imageinfo'] = $this->mUpload->getImageInfo($this->getResult());
         }
     } catch (UploadStashException $e) {
         // XXX: don't spam exception log
         $this->handleStashException($e);
     }
     $this->getResult()->addValue(null, $this->getModuleName(), $result);
     // Cleanup any temporary mess
     $this->mUpload->cleanupTempFile();
 }

 public function execute()
 {
     // Check whether upload is enabled
     if (!UploadBase::isEnabled()) {
         $this->dieUsageMsg('uploaddisabled');
     }
     $user = $this->getUser();
     // Parameter handling
     $this->mParams = $this->extractRequestParams();
     $request = $this->getMain()->getRequest();
     // Add the uploaded file to the params array
     $this->mParams['file'] = $request->getFileName('file');
     $this->mParams['chunk'] = $request->getFileName('chunk');
     // Copy the session key to the file key, for backward compatibility.
     if (!$this->mParams['filekey'] && $this->mParams['sessionkey']) {
         $this->mParams['filekey'] = $this->mParams['sessionkey'];
     }
     // Select an upload module
     if (!$this->selectUploadModule()) {
         // This is not a true upload, but a status request or similar
         return;
     }
     if (!isset($this->mUpload)) {
         $this->dieUsage('No upload module set', 'nomodule');
     }
     // First check permission to upload
     $this->checkPermissions($user);
     // Fetch the file
     $status = $this->mUpload->fetchFile();
     if (!$status->isGood()) {
         $errors = $status->getErrorsArray();
         $error = array_shift($errors[0]);
         $this->dieUsage('Error fetching file from remote source', $error, 0, $errors[0]);
     }
     // Check if the uploaded file is sane
     if ($this->mParams['chunk']) {
         $maxSize = $this->mUpload->getMaxUploadSize();
         if ($this->mParams['filesize'] > $maxSize) {
             $this->dieUsage('The file you submitted was too large', 'file-too-large');
         }
     } else {
         $this->verifyUpload();
     }
     // Check if the user has the rights to modify or overwrite the requested title
     // (This check is irrelevant if stashing is already requested, since the errors
     //  can always be fixed by changing the title)
     if (!$this->mParams['stash']) {
         $permErrors = $this->mUpload->verifyTitlePermissions($user);
         if ($permErrors !== true) {
             $this->dieRecoverableError($permErrors[0], 'filename');
         }
     }
     // Get the result based on the current upload context:
     $result = $this->getContextResult();
     if ($result['result'] === 'Success') {
         $result['imageinfo'] = $this->mUpload->getImageInfo($this->getResult());
     }
     $this->getResult()->addValue(null, $this->getModuleName(), $result);
     // Cleanup any temporary mess
     $this->mUpload->cleanupTempFile();
 }

 public function execute()
 {
     global $wgUser;
     // Check whether upload is enabled
     if (!UploadBase::isEnabled()) {
         $this->dieUsageMsg('uploaddisabled');
     }
     // Parameter handling
     $this->mParams = $this->extractRequestParams();
     $request = $this->getMain()->getRequest();
     // Add the uploaded file to the params array
     $this->mParams['file'] = $request->getFileName('file');
     // Copy the session key to the file key, for backward compatibility.
     if (!$this->mParams['filekey'] && $this->mParams['sessionkey']) {
         $this->mParams['filekey'] = $this->mParams['sessionkey'];
     }
     // Select an upload module
     if (!$this->selectUploadModule()) {
         // This is not a true upload, but a status request or similar
         return;
     }
     if (!isset($this->mUpload)) {
         $this->dieUsage('No upload module set', 'nomodule');
     }
     // First check permission to upload
     $this->checkPermissions($wgUser);
     // Fetch the file
     $status = $this->mUpload->fetchFile();
     if (!$status->isGood()) {
         $errors = $status->getErrorsArray();
         $error = array_shift($errors[0]);
         $this->dieUsage('Error fetching file from remote source', $error, 0, $errors[0]);
     }
     // Check if the uploaded file is sane
     $this->verifyUpload();
     // Check if the user has the rights to modify or overwrite the requested title
     // (This check is irrelevant if stashing is already requested, since the errors
     //  can always be fixed by changing the title)
     if (!$this->mParams['stash']) {
         $permErrors = $this->mUpload->verifyTitlePermissions($wgUser);
         if ($permErrors !== true) {
             $this->dieRecoverableError($permErrors[0], 'filename');
         }
     }
     // Prepare the API result
     $result = array();
     $warnings = $this->getApiWarnings();
     if ($warnings) {
         $result['result'] = 'Warning';
         $result['warnings'] = $warnings;
         // in case the warnings can be fixed with some further user action, let's stash this upload
         // and return a key they can use to restart it
         try {
             $result['filekey'] = $this->performStash();
             $result['sessionkey'] = $result['filekey'];
             // backwards compatibility
         } catch (MWException $e) {
             $result['warnings']['stashfailed'] = $e->getMessage();
         }
     } elseif ($this->mParams['stash']) {
         // Some uploads can request they be stashed, so as not to publish them immediately.
         // In this case, a failure to stash ought to be fatal
         try {
             $result['result'] = 'Success';
             $result['filekey'] = $this->performStash();
             $result['sessionkey'] = $result['filekey'];
             // backwards compatibility
         } catch (MWException $e) {
             $this->dieUsage($e->getMessage(), 'stashfailed');
         }
     } else {
         // This is the most common case -- a normal upload with no warnings
         // $result will be formatted properly for the API already, with a status
         $result = $this->performUpload();
     }
     if ($result['result'] === 'Success') {
         $result['imageinfo'] = $this->mUpload->getImageInfo($this->getResult());
     }
     $this->getResult()->addValue(null, $this->getModuleName(), $result);
     // Cleanup any temporary mess
     $this->mUpload->cleanupTempFile();
 }