PHP Helper::getUser方法代码示例

 /**
  * @param string $path
  * @param int $size
  * @return int|bool
  */
 public function postFileSize($path, $size, $fileInfo = null)
 {
     $view = new \OC\Files\View('/');
     $userId = Helper::getUser($path);
     $util = new Util($view, $userId);
     // if encryption is no longer enabled or if the files aren't migrated yet
     // we return the default file size
     if (!\OCP\App::isEnabled('files_encryption') || $util->getMigrationStatus() !== Util::MIGRATION_COMPLETED) {
         return $size;
     }
     // if path is a folder do nothing
     if ($view->is_dir($path)) {
         $proxyState = \OC_FileProxy::$enabled;
         \OC_FileProxy::$enabled = false;
         $fileInfo = $view->getFileInfo($path);
         \OC_FileProxy::$enabled = $proxyState;
         if (isset($fileInfo['unencrypted_size']) && $fileInfo['unencrypted_size'] > 0) {
             return $fileInfo['unencrypted_size'];
         }
         return $size;
     }
     // get relative path
     $relativePath = \OCA\Encryption\Helper::stripUserFilesPath($path);
     // if path is empty we cannot resolve anything
     if (empty($relativePath)) {
         return $size;
     }
     // get file info from database/cache if not .part file
     if (empty($fileInfo) && !Helper::isPartialFilePath($path)) {
         $proxyState = \OC_FileProxy::$enabled;
         \OC_FileProxy::$enabled = false;
         $fileInfo = $view->getFileInfo($path);
         \OC_FileProxy::$enabled = $proxyState;
     }
     // if file is encrypted return real file size
     if (isset($fileInfo['encrypted']) && $fileInfo['encrypted'] === true) {
         // try to fix unencrypted file size if it doesn't look plausible
         if ((int) $fileInfo['size'] > 0 && (int) $fileInfo['unencrypted_size'] === 0) {
             $fixSize = $util->getFileSize($path);
             $fileInfo['unencrypted_size'] = $fixSize;
             // put file info if not .part file
             if (!Helper::isPartialFilePath($relativePath)) {
                 $view->putFileInfo($path, array('unencrypted_size' => $fixSize));
             }
         }
         $size = $fileInfo['unencrypted_size'];
     } else {
         $fileInfoUpdates = array();
         $fixSize = $util->getFileSize($path);
         if ($fixSize > 0) {
             $size = $fixSize;
             $fileInfoUpdates['encrypted'] = true;
             $fileInfoUpdates['unencrypted_size'] = $size;
             // put file info if not .part file
             if (!Helper::isPartialFilePath($relativePath)) {
                 $view->putFileInfo($path, $fileInfoUpdates);
             }
         }
     }
     return $size;
 }

 /**
  * @param $path
  */
 public function handleFile($path)
 {
     // Disable encryption proxy to prevent recursive calls
     $proxyStatus = \OC_FileProxy::$enabled;
     \OC_FileProxy::$enabled = false;
     $view = new \OC_FilesystemView('/');
     $session = new \OCA\Encryption\Session($view);
     $userId = Helper::getUser($path);
     $util = new Util($view, $userId);
     // split the path parts
     $pathParts = explode('/', $path);
     // get relative path
     $relativePath = \OCA\Encryption\Helper::stripUserFilesPath($path);
     // only if file is on 'files' folder fix file size and sharing
     if (isset($pathParts[2]) && $pathParts[2] === 'files' && $util->fixFileSize($path)) {
         // get sharing app state
         $sharingEnabled = \OCP\Share::isEnabled();
         // get users
         $usersSharing = $util->getSharingUsersArray($sharingEnabled, $relativePath);
         // update sharing-keys
         $util->setSharedFileKeyfiles($session, $usersSharing, $relativePath);
     }
     \OC_FileProxy::$enabled = $proxyStatus;
 }

 public function actionIndex()
 {
     $user = Helper::getUser();
     Helper::renderJSON(["id" => $user->id, "username" => $user->username]);
 }

 /**
  * Delete a keyfile
  *
  * @param \OC\Files\View $view
  * @param string $path path of the file the key belongs to
  * @param string $userId the user to whom the file belongs
  * @return bool Outcome of unlink operation
  * @note $path must be relative to data/user/files. e.g. mydoc.txt NOT
  *       /data/admin/files/mydoc.txt
  */
 public static function deleteFileKey($view, $path, $userId = null)
 {
     $trimmed = ltrim($path, '/');
     if ($trimmed === '') {
         \OCP\Util::writeLog('Encryption library', 'Can\'t delete file-key empty path given!', \OCP\Util::ERROR);
         return false;
     }
     if ($userId === null) {
         $userId = Helper::getUser($path);
     }
     $util = new Util($view, $userId);
     if ($util->isSystemWideMountPoint($path)) {
         $keyPath = '/files_encryption/keyfiles/' . $trimmed;
     } else {
         $keyPath = '/' . $userId . '/files_encryption/keyfiles/' . $trimmed;
     }
     $result = false;
     $fileExists = $view->file_exists('/' . $userId . '/files/' . $trimmed);
     if ($view->is_dir($keyPath) && !$fileExists) {
         \OCP\Util::writeLog('files_encryption', 'deleteFileKey: delete file key: ' . $keyPath, \OCP\Util::DEBUG);
         $result = $view->unlink($keyPath);
     } elseif ($view->file_exists($keyPath . '.key') && !$fileExists) {
         \OCP\Util::writeLog('files_encryption', 'deleteFileKey: delete file key: ' . $keyPath, \OCP\Util::DEBUG);
         $result = $view->unlink($keyPath . '.key');
     }
     if ($fileExists) {
         \OCP\Util::writeLog('Encryption library', 'Did not delete the file key, file still exists: ' . '/' . $userId . '/files/' . $trimmed, \OCP\Util::ERROR);
     } elseif (!$result) {
         \OCP\Util::writeLog('Encryption library', 'Could not delete keyfile; does not exist: "' . $keyPath, \OCP\Util::ERROR);
     }
     return $result;
 }

 /**
  * @param string $path raw path relative to data/
  * @param string $mode
  * @param int $options
  * @param string $opened_path
  * @return bool
  */
 public function stream_open($path, $mode, $options, &$opened_path)
 {
     // assume that the file already exist before we decide it finally in getKey()
     $this->newFile = false;
     if (!isset($this->rootView)) {
         $this->rootView = new \OC\Files\View('/');
     }
     $this->session = new \OCA\Encryption\Session($this->rootView);
     $this->privateKey = $this->session->getPrivateKey();
     $normalizedPath = \OC\Files\Filesystem::normalizePath(str_replace('crypt://', '', $path));
     if ($originalFile = Helper::getPathFromTmpFile($normalizedPath)) {
         $this->rawPath = $originalFile;
         $this->isLocalTmpFile = true;
         $this->localTmpFile = $normalizedPath;
     } else {
         $this->rawPath = $normalizedPath;
     }
     $this->userId = Helper::getUser($this->rawPath);
     $util = new Util($this->rootView, $this->userId);
     // get the key ID which we want to use, can be the users key or the
     // public share key
     $this->keyId = $util->getKeyId();
     // Strip identifier text from path, this gives us the path relative to data/<user>/files
     $this->relPath = Helper::stripUserFilesPath($this->rawPath);
     // if raw path doesn't point to a real file, check if it is a version or a file in the trash bin
     if ($this->relPath === false) {
         $this->relPath = Helper::getPathToRealFile($this->rawPath);
     }
     if ($this->relPath === false) {
         \OCP\Util::writeLog('Encryption library', 'failed to open file "' . $this->rawPath . '" expecting a path to "files", "files_versions" or "cache"', \OCP\Util::ERROR);
         return false;
     }
     // Disable fileproxies so we can get the file size and open the source file without recursive encryption
     $proxyStatus = \OC_FileProxy::$enabled;
     \OC_FileProxy::$enabled = false;
     if ($mode === 'w' or $mode === 'w+' or $mode === 'wb' or $mode === 'wb+') {
         // We're writing a new file so start write counter with 0 bytes
         $this->size = 0;
         $this->unencryptedSize = 0;
     } else {
         if ($this->privateKey === false) {
             // if private key is not valid redirect user to a error page
             \OCA\Encryption\Helper::redirectToErrorPage($this->session);
         }
         $this->size = $this->rootView->filesize($this->rawPath);
     }
     if ($this->isLocalTmpFile) {
         $this->handle = fopen($this->localTmpFile, $mode);
     } else {
         $this->handle = $this->rootView->fopen($this->rawPath, $mode);
     }
     \OC_FileProxy::$enabled = $proxyStatus;
     if (!is_resource($this->handle)) {
         \OCP\Util::writeLog('Encryption library', 'failed to open file "' . $this->rawPath . '"', \OCP\Util::ERROR);
     } else {
         $this->meta = stream_get_meta_data($this->handle);
         // sometimes fopen changes the mode, e.g. for a url "r" convert to "r+"
         // but we need to remember the original access type
         $this->meta['mode'] = $mode;
     }
     return is_resource($this->handle);
 }

 /**
  * @brief Delete a single user's shareKey for a single file
  */
 public static function delShareKey(\OC_FilesystemView $view, $userIds, $filePath)
 {
     $proxyStatus = \OC_FileProxy::$enabled;
     \OC_FileProxy::$enabled = false;
     $userId = Helper::getUser($filePath);
     $util = new Util($view, $userId);
     list($owner, $filename) = $util->getUidAndFilename($filePath);
     if ($util->isSystemWideMountPoint($filename)) {
         $shareKeyPath = \OC\Files\Filesystem::normalizePath('/files_encryption/share-keys/' . $filename);
     } else {
         $shareKeyPath = \OC\Files\Filesystem::normalizePath('/' . $owner . '/files_encryption/share-keys/' . $filename);
     }
     if ($view->is_dir($shareKeyPath)) {
         $localPath = \OC\Files\Filesystem::normalizePath($view->getLocalFolder($shareKeyPath));
         self::recursiveDelShareKeys($localPath, $userIds);
     } else {
         foreach ($userIds as $userId) {
             if (!$view->unlink($shareKeyPath . '.' . $userId . '.shareKey')) {
                 \OCP\Util::writeLog('Encryption library', 'Could not delete shareKey; does not exist: "' . $shareKeyPath . '.' . $userId . '.shareKey"', \OCP\Util::ERROR);
             }
         }
     }
     \OC_FileProxy::$enabled = $proxyStatus;
 }

 /**
  * @brief Delete a single user's shareKey for a single file
  */
 public static function delShareKey(\OC_FilesystemView $view, $userIds, $filePath)
 {
     $proxyStatus = \OC_FileProxy::$enabled;
     \OC_FileProxy::$enabled = false;
     $userId = Helper::getUser($filePath);
     $util = new Util($view, $userId);
     list($owner, $filename) = $util->getUidAndFilename($filePath);
     if ($util->isSystemWideMountPoint($filename)) {
         $shareKeyPath = \OC\Files\Filesystem::normalizePath('/files_encryption/share-keys/' . $filename);
     } else {
         $shareKeyPath = \OC\Files\Filesystem::normalizePath('/' . $owner . '/files_encryption/share-keys/' . $filename);
     }
     if ($view->is_dir($shareKeyPath)) {
         self::recursiveDelShareKeys($shareKeyPath, $userIds, $owner, $view);
     } else {
         foreach ($userIds as $userId) {
             if ($userId === $owner && $view->file_exists('/' . $owner . '/files/' . $filename)) {
                 \OCP\Util::writeLog('files_encryption', 'Tried to delete owner key, but the file still exists!', \OCP\Util::FATAL);
                 continue;
             }
             $result = $view->unlink($shareKeyPath . '.' . $userId . '.shareKey');
             \OCP\Util::writeLog('files_encryption', 'delShareKey: delete share key: ' . $shareKeyPath . '.' . $userId . '.shareKey', \OCP\Util::DEBUG);
             if (!$result) {
                 \OCP\Util::writeLog('Encryption library', 'Could not delete shareKey; does not exist: "' . $shareKeyPath . '.' . $userId . '.shareKey"', \OCP\Util::ERROR);
             }
         }
     }
     \OC_FileProxy::$enabled = $proxyStatus;
 }

 public function sms(Request $request)
 {
     $validator = \Validator::make($request->all(), ['phone' => 'required|digits:11|unique:customers,phone']);
     if ($validator->fails()) {
         return response()->json(['success' => false, 'error_message' => $validator->errors()->getMessages()]);
     }
     $phone = $request->input(['phone']);
     $code = \MessageSender::generateMessageVerify();
     \MessageSender::sendMessageVerify($phone, $code);
     $user = \Helper::getUser();
     try {
         $customer = \Helper::getCustomerOrFail();
     } catch (\Exception $e) {
         $customer = Customer::create(['openid' => $user['openid'], 'type_id' => 1, 'phone' => $phone]);
     }
     $customer->update(['auth_code' => $code, 'auth_code_expired' => Carbon::now()->addMinute(AppConstant::AUTH_CODE_EXPIRE_INTERVAL)]);
     return response()->json(['success' => true]);
 }

 private function _checkAuth()
 {
     $user = Helper::getUser();
     if (!$user) {
         Helper::renderJSONErorr("Internal user error");
     }
     return $user;
 }