PHP FileRepo类代码示例

 /**
  * Store a file or virtual URL source into a media file name.
  *
  * @param $originalName string The title of the image
  * @param $srcPath string The filepath or virtual URL
  * @param $flags integer Flags to pass into repo::store().
  * @return FileRepoStatus
  */
 private function storeit($originalName, $srcPath, $flags)
 {
     $hashPath = $this->repo->getHashPath($originalName);
     $dstRel = "{$hashPath}{$this->date}!{$originalName}";
     $dstUrlRel = $hashPath . $this->date . '!' . rawurlencode($originalName);
     $result = $this->repo->store($srcPath, 'temp', $dstRel, $flags);
     $result->value = $this->repo->getVirtualUrl('temp') . '/' . $dstUrlRel;
     $this->createdFiles[] = $result->value;
     return $result;
 }

 /**
  * Per docs in FileRepo, this needs to return false if we don't support versioned
  * files. Well, we don't.
  */
 function newFile($title, $time = false)
 {
     if ($time) {
         return false;
     }
     return parent::newFile($title, $time);
 }

 /**
  * Create an UnregisteredLocalFile based on a path or a (title,repo) pair.
  * A FileRepo object is not required here, unlike most other File classes.
  *
  * @throws MWException
  * @param Title|bool $title
  * @param FileRepo|bool $repo
  * @param string|bool $path
  * @param string|bool $mime
  */
 function __construct($title = false, $repo = false, $path = false, $mime = false)
 {
     if (!($title && $repo) && !$path) {
         throw new MWException(__METHOD__ . ': not enough parameters, must specify title and repo, or a full path');
     }
     if ($title instanceof Title) {
         $this->title = File::normalizeTitle($title, 'exception');
         $this->name = $repo->getNameFromTitle($title);
     } else {
         $this->name = basename($path);
         $this->title = File::normalizeTitle($this->name, 'exception');
     }
     $this->repo = $repo;
     if ($path) {
         $this->path = $path;
     } else {
         $this->assertRepoDefined();
         $this->path = $repo->getRootDirectory() . '/' . $repo->getHashPath($this->name) . $this->name;
     }
     if ($mime) {
         $this->mime = $mime;
     }
     $this->dims = array();
 }

 function getFileProps($fileName)
 {
     if (FileRepo::isVirtualUrl($fileName)) {
         list($repoName, , ) = $this->splitVirtualUrl($fileName);
         if ($repoName === '') {
             $repoName = 'local';
         }
         $repo = $this->getRepo($repoName);
         return $repo->getFileProps($fileName);
     } else {
         return File::getPropsFromPath($fileName);
     }
 }

 /**
  * Return information about the repository.
  *
  * @return array
  * @since 1.22
  */
 function getInfo()
 {
     return FileRepo::getInfo();
 }

 protected function doOperations(FileRepo $tempRepo, array $ops)
 {
     $status = $tempRepo->getBackend()->doQuickOperations($ops);
     if (!$status->isOK()) {
         $this->error(print_r($status->getErrorsArray(), true));
     }
 }

 /**
  * @param Masthead $masthead
  * @param int $width
  * @param $timestamp
  * @return \Wikia\Vignette\UrlGenerator
  */
 public static function getVignetteUrl(Masthead $masthead, $width, $timestamp)
 {
     $relativePath = $masthead->mUser->getGlobalAttribute(AVATAR_USER_OPTION_NAME);
     if ($relativePath) {
         if (strpos($relativePath, '/') !== false) {
             // custom avatar
             $url = self::vignetteCustomUrl($width, $relativePath, $timestamp);
         } else {
             // wikia-provided avatars
             $hash = FileRepo::getHashPathForLevel($relativePath, 2);
             $bucket = VignetteRequest::parseBucket($masthead->mDefaultPath);
             $relativePath = $hash . $relativePath;
             $url = self::buildVignetteUrl($width, $bucket, $relativePath, $timestamp, false);
         }
     } else {
         // default avatar
         $legacyDefaultUrl = $masthead->getDefaultAvatars('thumb/')[0];
         $bucket = VignetteRequest::parseBucket($legacyDefaultUrl);
         $relativePath = VignetteRequest::parseRelativePath($legacyDefaultUrl);
         $url = self::buildVignetteUrl($width, $bucket, $relativePath, $timestamp, false);
     }
     return $url;
 }

 /**
  * @param string $fileName
  * @return array
  */
 function getFileProps($fileName)
 {
     if (FileRepo::isVirtualUrl($fileName)) {
         list($repoName, , ) = $this->splitVirtualUrl($fileName);
         if ($repoName === '') {
             $repoName = 'local';
         }
         $repo = $this->getRepo($repoName);
         return $repo->getFileProps($fileName);
     } else {
         $mwProps = new MWFileProps(MimeMagic::singleton());
         return $mwProps->getPropsFromPath($fileName, true);
     }
 }

	function __construct( $info ) {
		// We don't call parent::_construct because it requires $this->directory,
		// which doesn't exist in Swift.
		FileRepo::__construct( $info );

		// Required settings
		$this->url = $info['url'];

		// Optional settings
		$this->hashLevels = isset( $info['hashLevels'] ) ? $info['hashLevels'] : 2;
		$this->deletedHashLevels = isset( $info['deletedHashLevels'] ) ?
			$info['deletedHashLevels'] : $this->hashLevels;

		// This relationship is also hard-coded in rewrite.py, another part of this
		// extension. If you want to change this here, you might have to change it
		// there, too.
		$this->thumbUrl = "{$this->url}/thumb";

		// we don't have directories
		$this->deletedDir = false;

		// Required settings
		$this->swiftuser = $info['user'];
		$this->swiftkey = $info['key'];
		$this->authurl = $info['authurl'];
		$this->container = $info['container'];
	}

 /**
  * A LocalFile wrapper around a file that has been temporarily stashed,
  * so we can do things like create thumbnails for it. Arguably
  * UnregisteredLocalFile should be handling its own file repo but that
  * class is a bit retarded currently.
  *
  * @param FileRepo $repo Repository where we should find the path
  * @param string $path Path to file
  * @param string $key Key to store the path and any stashed data under
  * @throws UploadStashBadPathException
  * @throws UploadStashFileNotFoundException
  */
 public function __construct($repo, $path, $key)
 {
     $this->fileKey = $key;
     // resolve mwrepo:// urls
     if ($repo->isVirtualUrl($path)) {
         $path = $repo->resolveVirtualUrl($path);
     } else {
         // check if path appears to be sane, no parent traversals,
         // and is in this repo's temp zone.
         $repoTempPath = $repo->getZonePath('temp');
         if (!$repo->validateFilename($path) || strpos($path, $repoTempPath) !== 0) {
             wfDebug("UploadStash: tried to construct an UploadStashFile " . "from a file that should already exist at '{$path}', but path is not valid\n");
             throw new UploadStashBadPathException('path is not valid');
         }
         // check if path exists! and is a plain file.
         if (!$repo->fileExists($path)) {
             wfDebug("UploadStash: tried to construct an UploadStashFile from " . "a file that should already exist at '{$path}', but path is not found\n");
             throw new UploadStashFileNotFoundException('cannot find path, or not a plain file');
         }
     }
     parent::__construct(false, $repo, $path, false);
     $this->name = basename($this->path);
 }

 /**
  * @param bool|FileRepo $repo
  */
 function __construct($repo = false)
 {
     if ($repo) {
         $this->cleanCallback = $repo->getErrorCleanupFunction();
     }
 }

 static function getHashPath($name)
 {
     return FileRepo::getHashPathForLevel($name, 2);
 }

 /**
  * @brief Gets an array of sample avatars
  *
  * @desc Method based on Masthead::getDefaultAvatars()
  *
  * @param string $thumb a thumb
  *
  * @return array multidimensional array with default avatars defined on messaging.wikia.com
  *
  * @author Andrzej 'nAndy' Łukaszewski
  */
 private function getDefaultAvatars($thumb = '')
 {
     wfProfileIn(__METHOD__);
     // parse message only once per request
     if (empty($thumb) && is_array($this->defaultAvatars) && count($this->defaultAvatars) > 0) {
         wfProfileOut(__METHOD__);
         return $this->defaultAvatars;
     }
     $this->defaultAvatars = array();
     $images = getMessageForContentAsArray('blog-avatar-defaults');
     if (is_array($images)) {
         foreach ($images as $image) {
             $hash = FileRepo::getHashPathForLevel($image, 2);
             $this->defaultAvatars[] = array('name' => $image, 'url' => $this->defaultAvatarPath . $thumb . $hash . $image);
         }
     }
     wfProfileOut(__METHOD__);
     return $this->defaultAvatars;
 }

/**
 * Diese Hook-Funktion aktualisiert die Index-Sektion, sollte es sich um einen FileUpload handeln
 * und ein neuer Inhalt fuer diese Sektion vorbereitet worden sein.
 * In jedem Fall wird die global abgelegte Index-Sektions-Inhalts-Variable wieder geleert.
 *
 * @param $oArticle OBJECT Der Artikel
 * @param $oUser OBJECT Der Benutzer
 * @param $sContent STRING Inhalt des Artikels
 * @param $sSummary STRING Zusammenfassung fuer das Update
 * @param $minor SIEHE WIKIDOKU
 * @param $watch SIEHE WIKIDOKU
 * @param $sectionanchor SIEHE WIKIDOKU
 * @param $flags SIEHE WIKIDOKU
 * @return BOOL TRUE
 */
function wfFiArticleSave(&$oArticle, &$oUser, &$sContent, &$sSummary, $minor, $watch, $sectionanchor, &$flags)
{
    global $wgFiPrefix, $wgFiPostfix, $wgUploadDirectory, $wgHashedUploadDirectory, $wgRequest, $wgFiCreateIndexThisTime;
    // Spezialseite und UploadFormular setzen $wgFiCreateIndexThisTime auf true zur Indexerstellung
    if ($wgFiCreateIndexThisTime === true || !is_null($wgRequest->getVal('wpProcessIndex')) && $wgRequest->getVal('wpProcessIndex') == "true") {
        // Datei holen und Index erstellen
        $sFilepath = $wgUploadDirectory . "/" . FileRepo::getHashPathForLevel($oArticle->mTitle->mDbkeyform, $wgHashedUploadDirectory ? 2 : 0) . $oArticle->mTitle->mDbkeyform;
        $sIndex = wfFiGetIndex($sFilepath);
        if (is_numeric($sIndex)) {
            // kein Index aus Datei erzeugt
            switch ($sIndex) {
                case WC_FI_ERR_MISSING_SYSTEMCOMMAND:
                    $sReason = wfMsg('fileindexer_index_creation_failed_comment_missing_systemcommand');
                    break;
                case WC_FI_ERR_UNKNOWN_FILETYPE:
                    $sReason = wfMsg('fileindexer_index_creation_failed_comment_unknown_filetype');
                    break;
                default:
                    $sReason = wfMsg('fileindexer_index_creation_failed_comment_unknown_reason');
            }
            $sSummary .= (substr($sSummary, strlen($sSummary) - 1, 1) == "\n" ? "" : "\n") . wfMsg('fileindexer_index_creation_failed_comment') . $sReason;
            return true;
        }
        // Index suchen und Text in Fragmente splitten
        $aFragments = wfFiGetIndexFragments($sContent);
        if ($aFragments === false) {
            // kein Index gefunden
            if (substr($sContent, strlen($sContent) - 1, 1) != "\n") {
                $sContent .= "\n";
            }
            $sContent .= $sIndex;
            $sSummary .= (substr($sSummary, strlen($sSummary) - 1, 1) == "\n" ? "" : "\n") . wfMsg('fileindexer_index_creation_complete_comment');
            return true;
        } else {
            // Index gefunden
            $sContent = $aFragments['pre'] . $sIndex . $aFragments['post'];
            $sSummary .= (substr($sSummary, strlen($sSummary) - 1, 1) == "\n" ? "" : "\n") . wfMsg('fileindexer_index_update_complete_comment');
            return true;
        }
    }
    return true;
}

 function __construct($info)
 {
     parent::__construct($info);
     $this->mApiBase = $info['apibase'];
     // http://commons.wikimedia.org/w/api.php
     if (!$this->scriptDirUrl) {
         // hack for description fetches
         $this->scriptDirUrl = dirname($this->mApiBase);
     }
 }