PHP OC_Filesystem::getRoot方法代码示例

 /**
  * get all files and folders in a folder
  * @param string path
  * @param string root (optional)
  * @return array
  *
  * returns an array of assiciative arrays with the following keys:
  * - path
  * - name
  * - size
  * - mtime
  * - ctime
  * - mimetype
  * - encrypted
  * - versioned
  */
 public static function getFolderContent($path, $root = false, $mimetype_filter = '')
 {
     if ($root === false) {
         $root = OC_Filesystem::getRoot();
     }
     $parent = OC_FileCache::getId($path, $root);
     if ($parent == -1) {
         return array();
     }
     $query = OC_DB::prepare('SELECT `id`,`path`,`name`,`ctime`,`mtime`,`mimetype`,`size`,`encrypted`,`versioned`,`writable` FROM `*PREFIX*fscache` WHERE `parent`=? AND (`mimetype` LIKE ? OR `mimetype` = ?)');
     $result = $query->execute(array($parent, $mimetype_filter . '%', 'httpd/unix-directory'))->fetchAll();
     if (is_array($result)) {
         return $result;
     } else {
         OC_Log::write('files', 'getFolderContent(): file not found in cache (' . $path . ')', OC_Log::DEBUG);
         return false;
     }
 }

 /**
  * abstraction for running most basic operations
  * @param string $operation
  * @param string #path
  * @param array (optional) hooks
  * @param mixed (optional) $extraParam
  * @return mixed
  */
 private function basicOperation($operation, $path, $hooks = array(), $extraParam = null)
 {
     $absolutePath = $this->getAbsolutePath($path);
     if (OC_FileProxy::runPreProxies($operation, $absolutePath, $extraParam) and OC_Filesystem::isValidPath($path)) {
         $path = $this->getRelativePath($absolutePath);
         if ($path == null) {
             return false;
         }
         $internalPath = $this->getInternalPath($path);
         $run = true;
         if (OC_Filesystem::$loaded and $this->fakeRoot == OC_Filesystem::getRoot()) {
             foreach ($hooks as $hook) {
                 if ($hook != 'read') {
                     OC_Hook::emit(OC_Filesystem::CLASSNAME, $hook, array(OC_Filesystem::signal_param_path => $path, OC_Filesystem::signal_param_run => &$run));
                 } else {
                     OC_Hook::emit(OC_Filesystem::CLASSNAME, $hook, array(OC_Filesystem::signal_param_path => $path));
                 }
             }
         }
         if ($run and $storage = $this->getStorage($path)) {
             if (!is_null($extraParam)) {
                 $result = $storage->{$operation}($internalPath, $extraParam);
             } else {
                 $result = $storage->{$operation}($internalPath);
             }
             $result = OC_FileProxy::runPostProxies($operation, $this->getAbsolutePath($path), $result);
             if (OC_Filesystem::$loaded and $this->fakeRoot == OC_Filesystem::getRoot()) {
                 if ($operation != 'fopen') {
                     //no post hooks for fopen, the file stream is still open
                     foreach ($hooks as $hook) {
                         if ($hook != 'read') {
                             OC_Hook::emit(OC_Filesystem::CLASSNAME, 'post_' . $hook, array(OC_Filesystem::signal_param_path => $path));
                         }
                     }
                 }
             }
             return $result;
         }
     }
     return null;
 }

 /**
  * @brief Get shared items from the database
  * @param string Item type
  * @param string Item source or target (optional)
  * @param int SHARE_TYPE_USER, SHARE_TYPE_GROUP, SHARE_TYPE_LINK, $shareTypeUserAndGroups, or $shareTypeGroupUserUnique
  * @param string User or group the item is being shared with
  * @param string User that is the owner of shared items (optional)
  * @param int Format to convert items to with formatItems()
  * @param mixed Parameters to pass to formatItems()
  * @param int Number of items to return, -1 to return all matches (optional)
  * @param bool Include collection item types (optional)
  * @return mixed
  *
  * See public functions getItem(s)... for parameter usage
  *
  */
 private static function getItems($itemType, $item = null, $shareType = null, $shareWith = null, $uidOwner = null, $format = self::FORMAT_NONE, $parameters = null, $limit = -1, $includeCollections = false, $itemShareWithBySource = false)
 {
     if (!self::isEnabled()) {
         if ($limit == 1 || isset($uidOwner) && isset($item)) {
             return false;
         } else {
             return array();
         }
     }
     $backend = self::getBackend($itemType);
     // Get filesystem root to add it to the file target and remove from the file source, match file_source with the file cache
     if ($itemType == 'file' || $itemType == 'folder') {
         $root = \OC_Filesystem::getRoot();
         $where = 'INNER JOIN `*PREFIX*fscache` ON `file_source` = `*PREFIX*fscache`.`id`';
         if (!isset($item)) {
             $where .= ' WHERE `file_target` IS NOT NULL';
         }
         $fileDependent = true;
         $queryArgs = array();
     } else {
         $fileDependent = false;
         $root = '';
         if ($includeCollections && !isset($item) && ($collectionTypes = self::getCollectionItemTypes($itemType))) {
             // If includeCollections is true, find collections of this item type, e.g. a music album contains songs
             if (!in_array($itemType, $collectionTypes)) {
                 $itemTypes = array_merge(array($itemType), $collectionTypes);
             } else {
                 $itemTypes = $collectionTypes;
             }
             $placeholders = join(',', array_fill(0, count($itemTypes), '?'));
             $where .= ' WHERE item_type IN (' . $placeholders . '))';
             $queryArgs = $itemTypes;
         } else {
             $where = ' WHERE `item_type` = ?';
             $queryArgs = array($itemType);
         }
     }
     if (isset($shareType)) {
         // Include all user and group items
         if ($shareType == self::$shareTypeUserAndGroups && isset($shareWith)) {
             $where .= ' AND `share_type` IN (?,?,?)';
             $queryArgs[] = self::SHARE_TYPE_USER;
             $queryArgs[] = self::SHARE_TYPE_GROUP;
             $queryArgs[] = self::$shareTypeGroupUserUnique;
             $userAndGroups = array_merge(array($shareWith), \OC_Group::getUserGroups($shareWith));
             $placeholders = join(',', array_fill(0, count($userAndGroups), '?'));
             $where .= ' AND `share_with` IN (' . $placeholders . ')';
             $queryArgs = array_merge($queryArgs, $userAndGroups);
             // Don't include own group shares
             $where .= ' AND `uid_owner` != ?';
             $queryArgs[] = $shareWith;
         } else {
             $where .= ' AND `share_type` = ?';
             $queryArgs[] = $shareType;
             if (isset($shareWith)) {
                 $where .= ' AND `share_with` = ?';
                 $queryArgs[] = $shareWith;
             }
         }
     }
     if (isset($uidOwner)) {
         $where .= ' AND `uid_owner` = ?';
         $queryArgs[] = $uidOwner;
         if (!isset($shareType)) {
             // Prevent unique user targets for group shares from being selected
             $where .= ' AND `share_type` != ?';
             $queryArgs[] = self::$shareTypeGroupUserUnique;
         }
         if ($itemType == 'file' || $itemType == 'folder') {
             $column = 'file_source';
         } else {
             $column = 'item_source';
         }
     } else {
         if ($itemType == 'file' || $itemType == 'folder') {
             $column = 'file_target';
         } else {
             $column = 'item_target';
         }
     }
     if (isset($item)) {
         if ($includeCollections && ($collectionTypes = self::getCollectionItemTypes($itemType))) {
             $where .= ' AND (';
         } else {
//.........这里部分代码省略.........

 /**
  * find files by mimetype
  * @param string $part1
  * @param string $part2 (optional)
  * @param string root (optional)
  * @return array of file paths
  *
  * $part1 and $part2 together form the complete mimetype.
  * e.g. searchByMime('text','plain')
  *
  * seccond mimetype part can be ommited
  * e.g. searchByMime('audio')
  */
 public static function searchByMime($part1, $part2 = null, $root = false)
 {
     if ($root === false) {
         $root = OC_Filesystem::getRoot();
     }
     $rootLen = strlen($root);
     $root .= '%';
     $user = OC_User::getUser();
     if (!$part2) {
         $query = OC_DB::prepare('SELECT `path` FROM `*PREFIX*fscache` WHERE `mimepart`=? AND `user`=? AND `path` LIKE ?');
         $result = $query->execute(array($part1, $user, $root));
     } else {
         $query = OC_DB::prepare('SELECT `path` FROM `*PREFIX*fscache` WHERE `mimetype`=? AND `user`=? AND `path` LIKE ? ');
         $result = $query->execute(array($part1 . '/' . $part2, $user, $root));
     }
     $names = array();
     while ($row = $result->fetchRow()) {
         $names[] = substr($row['path'], $rootLen);
     }
     return $names;
 }

 public static function findFiles($path)
 {
     $images = OC_FileCache::searchByMime('image', '', OC_Filesystem::getRoot() . $path);
     $new = array();
     foreach ($images as $i) {
         if (strpos($i, '/', 1) === FALSE) {
             $new[] = $path . $i;
         }
     }
     return $new;
 }

 /**
  * check if a file or folder is updated outside owncloud
  * @param string path
  * @param string root (optional)
  * @return bool
  */
 public static function isUpdated($path, $root = '')
 {
     if (!$root) {
         $root = OC_Filesystem::getRoot();
         $view = OC_Filesystem::getView();
     } else {
         if ($root == '/') {
             $root = '';
         }
         $view = new OC_FilesystemView($root);
     }
     if (!$view->file_exists($path)) {
         return false;
     }
     $mtime = $view->filemtime($path);
     $isDir = $view->is_dir($path);
     $fullPath = $root . $path;
     $query = OC_DB::prepare('SELECT mtime FROM *PREFIX*fscache WHERE path_hash=?');
     $result = $query->execute(array(md5($fullPath)));
     if ($row = $result->fetchRow()) {
         $cachedMTime = $row['mtime'];
         return $mtime > $cachedMTime;
     } else {
         //file not in cache, so it has to be updated
         if ($path == '/' or $path == '') {
             //dont auto update the root folder, it will be scanned
             return false;
         }
         return true;
     }
 }

 private function runHooks($hooks, $path, $post = false)
 {
     $prefix = $post ? 'post_' : '';
     $run = true;
     if (OC_Filesystem::$loaded and $this->fakeRoot == OC_Filesystem::getRoot()) {
         foreach ($hooks as $hook) {
             if ($hook != 'read') {
                 OC_Hook::emit(OC_Filesystem::CLASSNAME, $prefix . $hook, array(OC_Filesystem::signal_param_run => &$run, OC_Filesystem::signal_param_path => $path));
             } elseif (!$post) {
                 OC_Hook::emit(OC_Filesystem::CLASSNAME, $prefix . $hook, array(OC_Filesystem::signal_param_path => $path));
             }
         }
     }
     return $run;
 }

function get_absolute_path($path)
{
    return OC_Config::getValue("datadirectory") . OC_Filesystem::getRoot() . "/" . $path;
}