PHP ISession::get方法代码示例

 /**
  * check if private key is set
  *
  * @return boolean
  */
 public function isPrivateKeySet()
 {
     $key = $this->session->get('privateKey');
     if (is_null($key)) {
         return false;
     }
     return true;
 }

 /**
  * Returns the current token or throws an exception if none is found.
  *
  * @return string
  * @throws \Exception
  */
 public function getToken()
 {
     $token = $this->session->get('requesttoken');
     if (empty($token)) {
         throw new \Exception('Session does not contain a requesttoken');
     }
     return $token;
 }

 protected function initializeSession()
 {
     $encryptedSessionData = $this->session->get(self::encryptedSessionName);
     try {
         $this->sessionValues = json_decode($this->crypto->decrypt($encryptedSessionData, $this->passphrase), true);
     } catch (\Exception $e) {
         $this->sessionValues = [];
     }
 }

 public function testUnwrappingGet()
 {
     $unencryptedValue = 'foobar';
     $encryptedValue = $this->crypto->encrypt($unencryptedValue);
     $this->wrappedSession->expects($this->once())->method('get')->with('encrypted_session_data')->willReturnCallback(function () use($encryptedValue) {
         return $encryptedValue;
     });
     $this->assertSame($unencryptedValue, $this->wrappedSession->get('encrypted_session_data'));
 }

 public function manipulateStorageConfig(StorageConfig &$storage)
 {
     $encrypted = $this->session->get('password::sessioncredentials/credentials');
     if (!isset($encrypted)) {
         throw new InsufficientDataForMeaningfulAnswerException('No session credentials saved');
     }
     $credentials = json_decode($this->crypto->decrypt($encrypted), true);
     $storage->setBackendOption('user', $this->session->get('loginname'));
     $storage->setBackendOption('password', $credentials['password']);
 }

 /**
  * Get a value from the session
  *
  * @param string $key
  * @return string|null Either the value or null
  */
 public function get($key)
 {
     $encryptedValue = $this->session->get($key);
     if ($encryptedValue === null) {
         return null;
     }
     try {
         $value = $this->crypto->decrypt($encryptedValue, $this->passphrase);
         return json_decode($value);
     } catch (\Exception $e) {
         return null;
     }
 }

 /**
  * Get the timezone of the current user, based on his session information and config data
  *
  * @param bool|int $timestamp
  * @return \DateTimeZone
  */
 public function getTimeZone($timestamp = false)
 {
     $timeZone = $this->config->getUserValue($this->session->get('user_id'), 'core', 'timezone', null);
     if ($timeZone === null) {
         if ($this->session->exists('timezone')) {
             return $this->guessTimeZoneFromOffset($this->session->get('timezone'), $timestamp);
         }
         $timeZone = $this->getDefaultTimeZone();
     }
     try {
         return new \DateTimeZone($timeZone);
     } catch (\Exception $e) {
         \OCP\Util::writeLog('datetimezone', 'Failed to created DateTimeZone "' . $timeZone . "'", \OCP\Util::DEBUG);
         return new \DateTimeZone($this->getDefaultTimeZone());
     }
 }

 /**
  * Makes sure the user is already properly authenticated when a password is required and none
  * was provided
  *
  * @param array|bool $linkItem
  *
  * @throws CheckException
  */
 private function checkSession($linkItem)
 {
     // Not authenticated ?
     if (!$this->session->exists('public_link_authenticated') || $this->session->get('public_link_authenticated') !== $linkItem['id']) {
         throw new CheckException("Missing password", Http::STATUS_UNAUTHORIZED);
     }
 }

 /**
  * Makes sure the user is already properly authenticated when a password is required and none
  * was provided
  *
  * @param IShare $share
  *
  * @throws CheckException
  */
 private function checkSession($share)
 {
     // Not authenticated ?
     if (!$this->session->exists('public_link_authenticated') || $this->session->get('public_link_authenticated') !== (string) $share->getId()) {
         throw new CheckException("Missing password", Http::STATUS_UNAUTHORIZED);
     }
 }

 /**
  * get private key for decrypt all operation
  *
  * @return string
  * @throws PrivateKeyMissingException
  */
 public function getDecryptAllKey()
 {
     $privateKey = $this->session->get('decryptAllKey');
     if (is_null($privateKey) && $this->decryptAllModeActivated()) {
         throw new PrivateKeyMissingException('No private key found while in decrypt all mode');
     } elseif (is_null($privateKey)) {
         throw new PrivateKeyMissingException('Please activate decrypt all mode first');
     }
     return $privateKey;
 }

 /**
  * @param IToken $token
  */
 private function updateToken(IToken $token)
 {
     // To save unnecessary DB queries, this is only done once a minute
     $lastTokenUpdate = $this->session->get('last_token_update') ?: 0;
     $now = $this->timeFacory->getTime();
     if ($lastTokenUpdate < $now - 60) {
         $this->tokenProvider->updateToken($token);
         $this->session->set('last_token_update', $now);
     }
 }

 /**
  * Get the timezone of the current user, based on his session information and config data
  *
  * @return \DateTimeZone
  */
 public function getTimeZone()
 {
     $timeZone = $this->config->getUserValue($this->session->get('user_id'), 'core', 'timezone', null);
     if ($timeZone === null) {
         if ($this->session->exists('timezone')) {
             $offsetHours = $this->session->get('timezone');
             // Note: the timeZone name is the inverse to the offset,
             // so a positive offset means negative timeZone
             // and the other way around.
             if ($offsetHours > 0) {
                 return new \DateTimeZone('Etc/GMT-' . $offsetHours);
             } else {
                 return new \DateTimeZone('Etc/GMT+' . abs($offsetHours));
             }
         } else {
             return new \DateTimeZone('UTC');
         }
     }
     return new \DateTimeZone($timeZone);
 }

 /**
  * @param \Sabre\DAV\Server $server
  * @param $realm
  * @return bool
  */
 private function auth(\Sabre\DAV\Server $server, $realm)
 {
     if (\OC_User::handleApacheAuth() || $this->userSession->isLoggedIn() && is_null($this->session->get(self::DAV_AUTHENTICATED))) {
         $user = $this->userSession->getUser()->getUID();
         \OC_Util::setupFS($user);
         $this->currentUser = $user;
         $this->session->close();
         return true;
     }
     return parent::authenticate($server, $realm);
 }

 /**
  * Validates a username and password
  *
  * This method should return true or false depending on if login
  * succeeded.
  *
  * @param string $username
  * @param string $password
  *
  * @return bool
  * @throws \Sabre\DAV\Exception\NotAuthenticated
  */
 protected function validateUserPass($username, $password)
 {
     try {
         $share = $this->shareManager->getShareByToken($username);
     } catch (ShareNotFound $e) {
         return false;
     }
     $this->share = $share;
     \OC_User::setIncognitoMode(true);
     // check if the share is password protected
     if ($share->getPassword() !== null) {
         if ($share->getShareType() === \OCP\Share::SHARE_TYPE_LINK) {
             if ($this->shareManager->checkPassword($share, $password)) {
                 return true;
             } else {
                 if ($this->session->exists('public_link_authenticated') && $this->session->get('public_link_authenticated') === $share->getId()) {
                     return true;
                 } else {
                     if (in_array('XMLHttpRequest', explode(',', $this->request->getHeader('X-Requested-With')))) {
                         // do not re-authenticate over ajax, use dummy auth name to prevent browser popup
                         http_response_code(401);
                         header('WWW-Authenticate', 'DummyBasic real="ownCloud"');
                         throw new \Sabre\DAV\Exception\NotAuthenticated('Cannot authenticate over ajax calls');
                     }
                     return false;
                 }
             }
         } else {
             if ($share->getShareType() === \OCP\Share::SHARE_TYPE_REMOTE) {
                 return true;
             } else {
                 return false;
             }
         }
     } else {
         return true;
     }
 }

 /**
  * get the login name of the current user
  *
  * @return string
  */
 public function getLoginName()
 {
     if ($this->activeUser) {
         return $this->session->get('loginname');
     } else {
         $uid = $this->session->get('user_id');
         if ($uid) {
             $this->activeUser = $this->manager->get($uid);
             return $this->session->get('loginname');
         } else {
             return null;
         }
     }
 }