PHP MOXMAN_Util_PathUtils::getExtension方法代码示例

 /**
  * Executes the command logic with the specified RPC parameters.
  *
  * @param Object $params Command parameters sent from client.
  * @return Object Result object to be passed back to client.
  */
 public function execute($params)
 {
     $toPath = $params->to;
     $ext = MOXMAN_Util_PathUtils::getExtension($toPath);
     if ($ext !== 'zip') {
         $toPath .= '.zip';
     }
     $toFile = MOXMAN::getFile($toPath);
     $config = $toFile->getConfig();
     if ($config->get('general.demo')) {
         throw new MOXMAN_Exception("This action is restricted in demo mode.", MOXMAN_Exception::DEMO_MODE);
     }
     if (!$toFile->canWrite()) {
         throw new MOXMAN_Exception("No write access to file: " . $toFile->getPublicPath(), MOXMAN_Exception::NO_WRITE_ACCESS);
     }
     $zipWriter = new MOXMAN_Zip_ZipWriter(array("compressionLevel" => 5));
     $filter = MOXMAN_Vfs_BasicFileFilter::createFromConfig($config);
     $path = $params->path;
     foreach ($params->names as $name) {
         $fromFile = MOXMAN::getFile(MOXMAN_Util_PathUtils::combine($path, $name));
         $this->addZipFiles($fromFile, $fromFile->getParent(), $filter, $zipWriter);
     }
     $stream = $toFile->open(MOXMAN_Vfs_IFileStream::WRITE);
     if ($stream) {
         $stream->write($zipWriter->toString());
         $stream->close();
     }
     $this->fireFileAction(MOXMAN_Core_FileActionEventArgs::ADD, $toFile);
     return $this->fileToJson($toFile);
 }

 private function addVideoMeta(MOXMAN_Vfs_IFile $file, $metaData)
 {
     $fileName = $file->getName();
     $ext = strtolower(MOXMAN_Util_PathUtils::getExtension($fileName));
     if (preg_match('/^(mp4|ogv|webm)$/', $ext)) {
         $metaData->url_type = MOXMAN_Util_Mime::get($fileName);
         $name = substr($fileName, 0, strlen($fileName) - strlen($ext));
         // Alternative video formats
         $altExt = array("mp4", "ogv", "webm");
         foreach ($altExt as $altExt) {
             if ($ext != $altExt) {
                 $altFile = MOXMAN::getFile($file->getParent(), $name . $altExt);
                 if ($altFile->exists()) {
                     $metaData->alt_url = $altFile->getUrl();
                     break;
                 }
             }
         }
         // Alternative image format
         $altFile = MOXMAN::getFile($file->getParent(), $name . "jpg");
         if ($altFile->exists()) {
             $metaData->alt_img = $altFile->getUrl();
         }
     }
 }

 /**
  * Get an unique file
  *
  * @param MOXMAN_Vfs_IFile $file File object to check against
  * @return MOXMAN_Vfs_IFile Unique file object.
  */
 public static function uniqueFile(MOXMAN_Vfs_IFile $file)
 {
     $fileName = $file->getName();
     $ext = MOXMAN_Util_PathUtils::getExtension($fileName);
     for ($i = 2; $file->exists(); $i++) {
         if ($file->isFile() && $ext) {
             $file = MOXMAN::getFile($file->getParent(), basename($fileName, '.' . $ext) . '_' . $i . '.' . $ext);
         } else {
             $file = MOXMAN::getFile($file->getParent(), $fileName . '_' . $i);
         }
     }
     return $file;
 }

 /**
  * Sends the specified file with the correct mime type back to the browser.
  * This method gets called from the client side using the stream file.
  *
  * @param MOXMAN_Http_Context $httpContext Context instance to pass to use for the handler.
  */
 public function processRequest(MOXMAN_Http_Context $httpContext)
 {
     $request = $httpContext->getRequest();
     $response = $httpContext->getResponse();
     try {
         $file = MOXMAN::getFile($request->get("path"));
     } catch (Exception $e) {
         $response->setStatus("500", "Could not resolve path: " . $request->get("path"));
         if (MOXMAN::getLogger()) {
             MOXMAN::getLogger()->debug("Could not resolve path: " . $request->get("path"));
         }
         return;
     }
     // Create thumbnail
     if ($request->get("thumb")) {
         try {
             $file = $this->plugin->createThumbnail($file);
         } catch (Exception $e) {
             $response->setStatus("500", "Could not generate thumbnail.");
             $response->sendContent("Could not generate thumbnail.");
             return;
         }
     }
     // Fire before stream event
     $args = new MOXMAN_Vfs_StreamEventArgs($httpContext, $file);
     $this->plugin->fire("BeforeStream", $args);
     $file = $args->getFile();
     // Stream temp file if it exists
     if ($tempName = $request->get("tempname")) {
         $ext = MOXMAN_Util_PathUtils::getExtension($file->getName());
         $tempName = "mcic_" . md5(session_id() . $file->getName()) . "." . $ext;
         $tempFilePath = MOXMAN_Util_PathUtils::combine(MOXMAN_Util_PathUtils::getTempDir(), $tempName);
         if (file_exists($tempFilePath)) {
             $response->sendLocalFile($tempFilePath);
             return;
         }
     }
     $url = $file->getUrl();
     if ($url && !$request->get("stream", false)) {
         $response->redirect($url);
     } else {
         // Force 48h cache time
         $offset = 48 * 60 * 60;
         $response->setHeader("Cache-Control", "max-age=" . $offset);
         $response->setHeader("Date", gmdate("D, d M Y H:i:s", time() + $offset) . " GMT");
         $response->setHeader("Expires", gmdate("D, d M Y H:i:s", time() + $offset) . " GMT");
         $response->setHeader("Pragma", "public");
         $response->sendFile($file);
     }
 }

 /**
  * Executes the command logic with the specified RPC parameters.
  *
  * @param Object $params Command parameters sent from client.
  * @return Object Result object to be passed back to client.
  */
 public function execute($params)
 {
     if (isset($params->action) && $params->action == "save") {
         return $this->save($params);
     }
     $file = MOXMAN::getFile($params->path);
     $config = $file->getConfig();
     if (!$file->exists()) {
         throw new MOXMAN_Exception("File doesn't exist: " . $file->getPublicPath(), MOXMAN_Exception::FILE_DOESNT_EXIST);
     }
     $filter = MOXMAN_Vfs_CombinedFileFilter::createFromConfig($config, "edit");
     if ($filter->accept($file, true) !== MOXMAN_Vfs_CombinedFileFilter::ACCEPTED) {
         throw new MOXMAN_Exception("Invalid file name for: " . $file->getPublicPath(), MOXMAN_Exception::INVALID_FILE_NAME);
     }
     // Create temp name if not specified
     $tempname = isset($params->tempname) ? $params->tempname : "";
     if (!$tempname) {
         $ext = MOXMAN_Util_PathUtils::getExtension($file->getName());
         $tempname = "mcic_" . md5(session_id() . $file->getName()) . "." . $ext;
         $tempFilePath = MOXMAN_Util_PathUtils::combine(MOXMAN_Util_PathUtils::getTempDir(), $tempname);
         if (file_exists($tempFilePath)) {
             unlink($tempFilePath);
         }
         $file->exportTo($tempFilePath);
     } else {
         $tempFilePath = MOXMAN_Util_PathUtils::combine(MOXMAN_Util_PathUtils::getTempDir(), $tempname);
     }
     $imageAlter = new MOXMAN_Media_ImageAlter();
     $imageAlter->load($tempFilePath);
     // Rotate
     if (isset($params->rotate)) {
         $imageAlter->rotate($params->rotate);
     }
     // Flip
     if (isset($params->flip)) {
         $imageAlter->flip($params->flip == "h");
     }
     // Crop
     if (isset($params->crop)) {
         $imageAlter->crop($params->crop->x, $params->crop->y, $params->crop->w, $params->crop->h);
     }
     // Resize
     if (isset($params->resize)) {
         $imageAlter->resize($params->resize->w, $params->resize->h);
     }
     $imageAlter->save($tempFilePath, $config->get("edit.jpeg_quality"));
     return (object) array("path" => $file->getPublicPath(), "tempname" => $tempname);
 }

 /**
  * Fixes filenames
  *
  * @param MOXMAN_Vfs_IFile $file File to fix name on.
  */
 public function renameFile(MOXMAN_Vfs_IFile $file)
 {
     $config = $file->getConfig();
     $autorename = $config->get("autorename.enabled", "");
     $spacechar = $config->get("autorename.space", "_");
     $custom = $config->get("autorename.pattern", "/[^0-9a-z\\-_]/i");
     $overwrite = $config->get("upload.overwrite", false);
     $lowercase = $config->get("autorename.lowercase", false);
     $prefix = $lowercase = $config->get("autorename.prefix", '');
     // @codeCoverageIgnoreStart
     if (!$autorename) {
         return $file;
     }
     // @codeCoverageIgnoreEnd
     $path = $file->getPath();
     $name = $file->getName();
     $orgname = $name;
     $ext = MOXMAN_Util_PathUtils::getExtension($path);
     $name = preg_replace("/\\." . $ext . "\$/i", "", $name);
     $name = str_replace(array('\'', '"'), '', $name);
     $name = htmlentities($name, ENT_QUOTES, 'UTF-8');
     $name = preg_replace('~&([a-z]{1,2})(acute|cedil|circ|grave|lig|orn|ring|slash|th|tilde|uml);~i', '$1', $name);
     $name = preg_replace($custom, $spacechar, $name);
     $name = str_replace(" ", $spacechar, $name);
     $name = trim($name);
     if ($lowercase) {
         $ext = strtolower($ext);
         $name = strtolower($name);
     }
     if ($ext) {
         $name = $name . "." . $ext;
     }
     //add prefix
     if ($prefix != '') {
         $aa = explode("-", $name);
         if (count($aa) == 1) {
             $name = $prefix . $name;
         }
     }
     // If no change to name after all this, return original file.
     if ($name === $orgname) {
         return $file;
     }
     // Return new file
     $toFile = MOXMAN::getFile($file->getParent() . "/" . $name);
     return $toFile;
 }

 /**
  * Returns an array with media info.
  *
  * @param MOXMAN_Vfs_IFile $file File to get the media info for.
  * @return Array Name/value array with media info.
  */
 public static function getInfo(MOXMAN_Vfs_IFile $file)
 {
     if (!$file->exists()) {
         return null;
     }
     $ext = strtolower(MOXMAN_Util_PathUtils::getExtension($file->getName()));
     switch ($ext) {
         case "png":
             return self::getPngInfo($file);
         default:
             if ($file instanceof MOXMAN_Vfs_Local_File) {
                 $size = @getimagesize($file->getPath());
                 if ($size) {
                     return array("width" => $size[0], "height" => $size[1]);
                 }
             }
     }
 }

 /**
  * Executes the command logic with the specified RPC parameters.
  *
  * @param Object $params Command parameters sent from client.
  * @return Object Result object to be passed back to client.
  */
 public function execute($params)
 {
     if (!isset($params->template)) {
         throw new MOXMAN_Exception("You must specify a path to a template file to be used when creating documents");
     }
     $templateFile = MOXMAN::getFile($params->template);
     $file = MOXMAN::getFile($params->path, $params->name . '.' . MOXMAN_Util_PathUtils::getExtension($templateFile->getName()));
     $config = $file->getConfig();
     if ($config->get('general.demo')) {
         throw new MOXMAN_Exception("This action is restricted in demo mode.", MOXMAN_Exception::DEMO_MODE);
     }
     if (!$file->canWrite()) {
         throw new MOXMAN_Exception("No write access to file: " . $file->getPublicPath(), MOXMAN_Exception::NO_WRITE_ACCESS);
     }
     if ($file->exists()) {
         throw new MOXMAN_Exception("File already exist: " . $file->getPublicPath(), MOXMAN_Exception::FILE_EXISTS);
     }
     $filter = MOXMAN_Vfs_CombinedFileFilter::createFromConfig($config, "createdoc");
     if (!$filter->accept($file, true)) {
         throw new MOXMAN_Exception("Invalid file name for: " . $file->getPublicPath(), MOXMAN_Exception::INVALID_FILE_NAME);
     }
     // TODO: Security audit this
     $stream = $templateFile->open(MOXMAN_Vfs_IFileStream::READ);
     if ($stream) {
         $content = $stream->readToEnd();
         $stream->close();
     }
     // Replace fields
     if (isset($params->fields)) {
         foreach ($params->fields as $key => $value) {
             $content = str_replace('${' . $key . '}', htmlentities($value), $content);
         }
     }
     $args = $this->fireBeforeFileAction("add", $file, strlen($content));
     $file = $args->getFile();
     // Write contents to file
     $stream = $file->open(MOXMAN_Vfs_IFileStream::WRITE);
     if ($stream) {
         $stream->write($content);
         $stream->close();
     }
     $this->fireFileAction(MOXMAN_Vfs_FileActionEventArgs::ADD, $file);
     return $this->fileToJson($file, true);
 }

 /** @ignore */
 private function copyFile($fromFile, $toFile)
 {
     $config = $toFile->getConfig();
     if ($config->get('general.demo')) {
         throw new MOXMAN_Exception("This action is restricted in demo mode.", MOXMAN_Exception::DEMO_MODE);
     }
     if (!$fromFile->exists()) {
         throw new MOXMAN_Exception("From file doesn't exist: " . $fromFile->getPublicPath(), MOXMAN_Exception::FILE_DOESNT_EXIST);
     }
     if (!$toFile->canWrite()) {
         throw new MOXMAN_Exception("No write access to file: " . $toFile->getPublicPath(), MOXMAN_Exception::NO_WRITE_ACCESS);
     }
     $filter = MOXMAN_Vfs_BasicFileFilter::createFromConfig($config);
     if ($filter->accept($fromFile, $fromFile->isFile()) !== MOXMAN_Vfs_BasicFileFilter::ACCEPTED) {
         throw new MOXMAN_Exception("Invalid file name for: " . $fromFile->getPublicPath(), MOXMAN_Exception::INVALID_FILE_NAME);
     }
     // Fire before file action event
     $args = new MOXMAN_Core_FileActionEventArgs(MOXMAN_Core_FileActionEventArgs::COPY, $fromFile);
     $args->setTargetFile($toFile);
     $args->getData()->fileSize = $fromFile->getSize();
     MOXMAN::getPluginManager()->get("core")->fire("BeforeFileAction", $args);
     $fromFile = $args->getFile();
     $toFile = $args->getTargetFile();
     // To file exists generate unique name
     $fileName = $toFile->getName();
     $ext = MOXMAN_Util_PathUtils::getExtension($fileName);
     for ($i = 2; $toFile->exists(); $i++) {
         if ($toFile->isFile() && $ext) {
             $toFile = MOXMAN::getFile($toFile->getParent(), basename($fileName, '.' . $ext) . '_' . $i . '.' . $ext);
         } else {
             $toFile = MOXMAN::getFile($toFile->getParent(), $fileName . '_' . $i);
         }
     }
     $fromFile->copyTo($toFile);
     $this->fireTargetFileAction(MOXMAN_Core_FileActionEventArgs::COPY, $fromFile, $toFile);
     return $toFile;
 }

 /**
  * Removes the local temp file for a specific file instance.
  *
  * @param MOXMAN_Vfs_IFile File instance used to create a local temp file.
  */
 public function removeLocalTempFile(MOXMAN_Vfs_IFile $file)
 {
     if ($file->exists()) {
         $tempDir = MOXMAN_Util_PathUtils::combine(MOXMAN_Util_PathUtils::getTempDir($this->config), "moxman_blob_cache");
         $tempFile = MOXMAN_Util_PathUtils::combine($tempDir, md5($file->getPath() . $file->getLastModified()) . "." . MOXMAN_Util_PathUtils::getExtension($file->getName()));
         if (file_exists($tempFile)) {
             unlink($tempFile);
         }
     }
 }

 /**
  * Creates a thumbnail for the specified file and returns that file object
  * or the input file if thumbnails are disabled or not supported.
  *
  * @param MOXMAN_Vfs_IFile $file File to generate thumbnail for.
  * @return MOXMAN_Vfs_IFile File instance that got generated or input file.
  */
 public function createThumbnail(MOXMAN_Vfs_IFile $file, $localTempFile = null)
 {
     $config = $file->getConfig();
     // Thumbnails disabled in config
     if (!$config->get('thumbnail.enabled')) {
         return $file;
     }
     // File is not an image
     if (!MOXMAN_Media_ImageAlter::canEdit($file)) {
         return $file;
     }
     // No write access to parent path
     $dirFile = $file->getParentFile();
     if (!$dirFile->canWrite()) {
         return $file;
     }
     $thumbnailFolderPath = MOXMAN_Util_PathUtils::combine($file->getParent(), $config->get('thumbnail.folder'));
     $thumbnailFile = MOXMAN::getFile($thumbnailFolderPath, $config->get('thumbnail.prefix') . $file->getName());
     // Never generate thumbs in thumbs dirs
     if (basename($file->getParent()) == $config->get('thumbnail.folder')) {
         return $file;
     }
     $thumbnailFolderFile = $thumbnailFile->getParentFile();
     if ($thumbnailFile->exists()) {
         if ($file->isDirectory()) {
             return $file;
         }
         return $thumbnailFile;
     }
     if (!$thumbnailFolderFile->exists()) {
         $thumbnailFolderFile->mkdir();
         $this->fireThumbnailFileAction(MOXMAN_Vfs_FileActionEventArgs::ADD, $thumbnailFolderFile);
     }
     // TODO: Maybe implement this inside MOXMAN_Media_ImageAlter
     if ($file instanceof MOXMAN_Vfs_Local_File) {
         if ($config->get('thumbnail.use_exif') && function_exists("exif_thumbnail") && preg_match('/jpe?g/i', MOXMAN_Util_PathUtils::getExtension($file->getName()))) {
             $imageType = null;
             $width = 0;
             $height = 0;
             try {
                 // Silently fail this, hence the @, some exif data can be corrupt.
                 $exifImage = @exif_thumbnail($localTempFile ? $localTempFile : $file->getInternalPath(), $width, $height, $imageType);
                 if ($exifImage) {
                     $stream = $thumbnailFile->open(MOXMAN_Vfs_IFileStream::WRITE);
                     $stream->write($exifImage);
                     $stream->close();
                     $this->fireThumbnailFileAction(MOXMAN_Vfs_FileActionEventArgs::ADD, $thumbnailFile);
                     return $thumbnailFile;
                 }
             } catch (Exception $e) {
                 // Ignore exif failure
             }
         }
     }
     $imageAlter = new MOXMAN_Media_ImageAlter();
     if ($localTempFile) {
         $imageAlter->load($localTempFile);
     } else {
         $imageAlter->loadFromFile($file);
     }
     $imageAlter->createThumbnail($config->get('thumbnail.width'), $config->get('thumbnail.height'), $config->get('thumbnail.mode', "resize"));
     $imageAlter->saveToFile($thumbnailFile, $config->get('thumbnail.jpeg_quality'));
     $this->fireThumbnailFileAction(MOXMAN_Vfs_FileActionEventArgs::ADD, $thumbnailFile);
     return $thumbnailFile;
 }

 /**
  * Returns true or false if the file is accepted or not.
  *
  * @param MOXMAN_Vfs_IFile $file File to grant or deny.
  * @param Boolean $isFile Default state if the filter is on an non existing file.
  * @return int Accepted or the reson why it failed.
  */
 public function accept(MOXMAN_Vfs_IFile $file, $isFile = true)
 {
     $name = $file->getName();
     $absPath = $file->getPath();
     $isFile = $file->exists() ? $file->isFile() : $isFile;
     // Handle file patterns
     if ($isFile) {
         if ($this->dirsOnly) {
             if ($this->logFunction) {
                 $this->log("File denied \"" . $absPath . "\" by \"dirsOnly\".");
             }
             return self::INVALID_TYPE;
         }
         // Handle exclude files
         if (is_array($this->excludeFiles) && $isFile) {
             foreach ($this->excludeFiles as $fileName) {
                 if ($name == $fileName) {
                     if ($this->logFunction) {
                         $this->log("File \"" . $absPath . "\" denied by \"excludeFiles\".");
                     }
                     return self::INVALID_NAME;
                 }
             }
         }
         // Handle include files
         if (is_array($this->includeFiles) && $isFile) {
             $state = false;
             foreach ($this->includeFiles as $fileName) {
                 if ($name == $fileName) {
                     $state = true;
                     break;
                 }
             }
             if (!$state) {
                 if ($this->logFunction) {
                     $this->log("File \"" . $absPath . "\" denied by \"includeFiles\".");
                 }
                 return self::INVALID_NAME;
             }
         }
         // Handle exclude pattern
         if ($this->excludeFilePattern && preg_match($this->excludeFilePattern, $name)) {
             if ($this->logFunction) {
                 $this->log("File \"" . $absPath . "\" denied by \"excludeFilePattern\".");
             }
             return self::INVALID_NAME;
         }
         // Handle include pattern
         if ($this->includeFilePattern && !preg_match($this->includeFilePattern, $name)) {
             if ($this->logFunction) {
                 $this->log("File \"" . $absPath . "\" denied by \"includeFilePattern\".");
             }
             return self::INVALID_NAME;
         }
         // Handle file extension pattern
         if (is_array($this->extensions)) {
             $ext = MOXMAN_Util_PathUtils::getExtension($absPath);
             $valid = false;
             foreach ($this->extensions as $extension) {
                 if ($extension == $ext) {
                     $valid = true;
                     break;
                 }
             }
             if (!$valid) {
                 if ($this->logFunction) {
                     $this->log("File \"" . $absPath . "\" denied by \"extensions\".");
                 }
                 return self::INVALID_EXTENSION;
             }
         }
     } else {
         if ($this->filesOnly) {
             if ($this->logFunction) {
                 $this->log("Dir denied \"" . $absPath . "\" by \"filesOnly\".");
             }
             return self::INVALID_TYPE;
         }
         // Handle exclude folders
         if (is_array($this->excludeFolders)) {
             foreach ($this->excludeFolders as $folder) {
                 if (strpos($absPath, $folder) !== false) {
                     if ($this->logFunction) {
                         $this->log('File denied "' . $absPath . '" by "excludeFolders".');
                     }
                     return self::INVALID_NAME;
                 }
             }
         }
         // Handle include folders
         if (is_array($this->includeFolders)) {
             $state = false;
             foreach ($this->includeFolders as $folder) {
//.........这里部分代码省略.........

 /**
  * Process a request using the specified context.
  *
  * @param MOXMAN_Http_Context $httpContext Context instance to pass to use for the handler.
  */
 public function processRequest(MOXMAN_Http_Context $httpContext)
 {
     $tempFilePath = null;
     $chunkFilePath = null;
     $request = $httpContext->getRequest();
     $response = $httpContext->getResponse();
     try {
         // Check if the user is authenticated or not
         if (!MOXMAN::getAuthManager()->isAuthenticated()) {
             if (!isset($json->method) || !preg_match('/^(login|logout)$/', $json->method)) {
                 $exception = new MOXMAN_Exception("Access denied by authenticator(s).", 10);
                 $exception->setData(array("login_url" => MOXMAN::getConfig()->get("authenticator.login_page")));
                 throw $exception;
             }
         }
         $file = MOXMAN::getFile($request->get("path"));
         $config = $file->getConfig();
         if ($config->get('general.demo')) {
             throw new MOXMAN_Exception("This action is restricted in demo mode.", MOXMAN_Exception::DEMO_MODE);
         }
         $maxSizeBytes = preg_replace("/[^0-9.]/", "", $config->get("upload.maxsize"));
         if (strpos(strtolower($config->get("upload.maxsize")), "k") > 0) {
             $maxSizeBytes = round(floatval($maxSizeBytes) * 1024);
         }
         if (strpos(strtolower($config->get("upload.maxsize")), "m") > 0) {
             $maxSizeBytes = round(floatval($maxSizeBytes) * 1024 * 1024);
         }
         function generateRandomString($length = 10)
         {
             $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
             $charactersLength = strlen($characters);
             $randomString = '';
             for ($i = 0; $i < $length; $i++) {
                 $randomString .= $characters[rand(0, $charactersLength - 1)];
             }
             return $randomString;
         }
         $filename = generateRandomString() . '.' . MOXMAN_Util_PathUtils::getExtension($request->get("name"));
         $id = $request->get("id");
         $loaded = intval($request->get("loaded", "0"));
         $total = intval($request->get("total", "-1"));
         $file = MOXMAN::getFile($file->getPath(), $filename);
         // Generate unique id for first chunk
         // TODO: We should cleanup orphan ID:s if upload fails etc
         if ($loaded == 0) {
             $id = uniqid();
         }
         // Setup path to temp file based on id
         $tempFilePath = MOXMAN_Util_PathUtils::combine(MOXMAN_Util_PathUtils::getTempDir(), "mcupload_" . $id . "." . MOXMAN_Util_PathUtils::getExtension($file->getName()));
         $chunkFilePath = MOXMAN_Util_PathUtils::combine(MOXMAN_Util_PathUtils::getTempDir(), "mcupload_chunk_" . $id . "." . MOXMAN_Util_PathUtils::getExtension($file->getName()));
         if (!$file->canWrite()) {
             throw new MOXMAN_Exception("No write access to path: " . $file->getPublicPath(), MOXMAN_Exception::NO_WRITE_ACCESS);
         }
         if ($total > $maxSizeBytes) {
             throw new MOXMAN_Exception("File size to large: " . $file->getPublicPath(), MOXMAN_Exception::FILE_SIZE_TO_LARGE);
         }
         // Operations on first chunk
         if ($loaded == 0) {
             // Fire before file action add event
             $args = new MOXMAN_Core_FileActionEventArgs("add", $file);
             $args->getData()->fileSize = $total;
             MOXMAN::getPluginManager()->get("core")->fire("BeforeFileAction", $args);
             $file = $args->getFile();
             if ($file->exists()) {
                 if (!$config->get("upload.overwrite") && !$request->get("overwrite")) {
                     throw new MOXMAN_Exception("Target file exists: " . $file->getPublicPath(), MOXMAN_Exception::FILE_EXISTS);
                 } else {
                     MOXMAN::getPluginManager()->get("core")->deleteThumbnail($file);
                     $file->delete();
                 }
             }
             $filter = MOXMAN_Vfs_CombinedFileFilter::createFromConfig($config, "upload");
             if ($filter->accept($file) !== MOXMAN_Vfs_CombinedFileFilter::ACCEPTED) {
                 throw new MOXMAN_Exception("Invalid file name for: " . $file->getPublicPath(), MOXMAN_Exception::INVALID_FILE_NAME);
             }
         }
         $blobSize = 0;
         $inputFile = $request->getFile("file");
         if (!$inputFile) {
             throw new MOXMAN_Exception("No input file specified.");
         }
         if ($loaded === 0) {
             // Check if we should mock or not
             if (defined('PHPUNIT')) {
                 if (!copy($inputFile['tmp_name'], $tempFilePath)) {
                     throw new MOXMAN_Exception("Could not move the uploaded temp file.");
                 }
             } else {
                 if (!move_uploaded_file($inputFile['tmp_name'], $tempFilePath)) {
                     throw new MOXMAN_Exception("Could not move the uploaded temp file.");
                 }
             }
             $blobSize = filesize($tempFilePath);
         } else {
             // Check if we should mock or not
//.........这里部分代码省略.........

 /**
  * Returns true or false if the file is accepted or not.
  *
  * @param MOXMAN_Vfs_IFile $file File to grant or deny.
  * @param Boolean $isFile Default state if the filter is on an non existing file.
  * @return Boolean True/false if the file is accepted or not.
  */
 public function accept(MOXMAN_Vfs_IFile $file, $isFile = true)
 {
     if ($this->isEmpty()) {
         return true;
     }
     $name = $file->getName();
     $isFile = $file->exists() ? $file->isFile() : $isFile;
     // Handle file patterns
     if ($isFile) {
         if ($this->dirsOnly) {
             return false;
         }
         // Handle exclude files
         if ($this->excludeFiles) {
             foreach ($this->excludeFiles as $fileName) {
                 if ($name == $fileName) {
                     return false;
                 }
             }
         }
         // Handle exclude pattern
         if ($this->excludeFilePattern && preg_match($this->excludeFilePattern, $name)) {
             return false;
         }
         // Handle include pattern
         if ($this->includeFilePattern && !preg_match($this->includeFilePattern, $name)) {
             return false;
         }
         // Handle file extension pattern
         if ($this->extensions) {
             $ext = MOXMAN_Util_PathUtils::getExtension($name);
             $valid = false;
             foreach ($this->extensions as $extension) {
                 if ($extension == $ext) {
                     $valid = true;
                     break;
                 }
             }
             if (!$valid) {
                 return false;
             }
         }
     } else {
         if ($this->filesOnly) {
             return false;
         }
         // Handle exclude pattern
         if ($this->excludeDirectoryPattern && preg_match($this->excludeDirectoryPattern, $name)) {
             return false;
         }
         // Handle include pattern
         if ($this->includeDirectoryPattern && !preg_match($this->includeDirectoryPattern, $name)) {
             return false;
         }
     }
     // Handle include wildcard pattern
     if ($this->includeWildcardPatternRegExp && !preg_match($this->includeWildcardPatternRegExp, $name)) {
         return false;
     }
     // Handle exclude wildcard pattern
     if ($this->excludeWildcardPatternRegExp && preg_match($this->excludeWildcardPatternRegExp, $name)) {
         return false;
     }
     return true;
 }

 /**
  * Returns true/false if the specified file can be altered or not.
  *
  * @param MOXMAN_Vfs_IFile $file File to check if can be altered.
  * @return Boolean True/false if the image can be edited or not.
  */
 public static function canEdit(MOXMAN_Vfs_IFile $file)
 {
     $ext = MOXMAN_Util_PathUtils::getExtension($file->getName());
     return preg_match('/gif|jpe?g|png|bmp/', $ext) === 1;
 }