PHP StorageConfig::setBackendOption方法代码示例

 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']);
 }

 public function manipulateStorageConfig(StorageConfig &$storage, IUser $user = null)
 {
     if (!isset($user)) {
         throw new InsufficientDataForMeaningfulAnswerException('No login credentials saved');
     }
     $uid = $user->getUID();
     $credentials = $this->credentialsManager->retrieve($uid, self::CREDENTIALS_IDENTIFIER);
     if (!isset($credentials)) {
         throw new InsufficientDataForMeaningfulAnswerException('No login credentials saved');
     }
     $storage->setBackendOption('user', $credentials['user']);
     $storage->setBackendOption('password', $credentials['password']);
 }

 /**
  * Process storage ready for mounting
  *
  * @param StorageConfig $storage
  * @param IUser $user
  */
 private function prepareStorageConfig(StorageConfig &$storage, IUser $user)
 {
     foreach ($storage->getBackendOptions() as $option => $value) {
         $storage->setBackendOption($option, \OC_Mount_Config::setUserVars($user->getUID(), $value));
     }
     $objectStore = $storage->getBackendOption('objectstore');
     if ($objectStore) {
         $objectClass = $objectStore['class'];
         $storage->setBackendOption('objectstore', new $objectClass($objectStore));
     }
     $storage->getAuthMechanism()->manipulateStorageConfig($storage);
     $storage->getBackend()->manipulateStorageConfig($storage);
 }

 public function manipulateStorageConfig(StorageConfig &$storage, IUser $user = null)
 {
     if ($storage->getType() === StorageConfig::MOUNT_TYPE_ADMIN) {
         $uid = '';
     } else {
         $uid = $user->getUID();
     }
     $credentials = $this->credentialsManager->retrieve($uid, self::CREDENTIALS_IDENTIFIER);
     if (is_array($credentials)) {
         $storage->setBackendOption('user', $credentials['user']);
         $storage->setBackendOption('password', $credentials['password']);
     }
 }

 public function manipulateStorageConfig(StorageConfig &$storage, IUser $user = null)
 {
     if ($storage->getType() === StorageConfig::MOUNT_TYPE_ADMIN) {
         $uid = '';
     } elseif (is_null($user)) {
         throw new InsufficientDataForMeaningfulAnswerException('No credentials saved');
     } else {
         $uid = $user->getUID();
     }
     $credentials = $this->credentialsManager->retrieve($uid, self::CREDENTIALS_IDENTIFIER);
     if (is_array($credentials)) {
         $storage->setBackendOption('user', $credentials['user']);
         $storage->setBackendOption('password', $credentials['password']);
     }
 }

 /**
  * @param StorageConfig $storage
  * @param IUser $user
  */
 public function manipulateStorageConfig(StorageConfig &$storage, IUser $user = null)
 {
     $user = $storage->getBackendOption('user');
     if ($domain = $storage->getBackendOption('domain')) {
         $storage->setBackendOption('user', $domain . '\\' . $user);
     }
 }

 /**
  * Process storage ready for mounting
  *
  * @param StorageConfig $storage
  * @param IUser $user
  */
 private function prepareStorageConfig(StorageConfig &$storage, IUser $user)
 {
     foreach ($storage->getBackendOptions() as $option => $value) {
         $storage->setBackendOption($option, \OC_Mount_Config::setUserVars($user->getUID(), $value));
     }
     $objectStore = $storage->getBackendOption('objectstore');
     if ($objectStore) {
         $objectClass = $objectStore['class'];
         if (!is_subclass_of($objectClass, '\\OCP\\Files\\ObjectStore\\IObjectStore')) {
             throw new \InvalidArgumentException('Invalid object store');
         }
         $storage->setBackendOption('objectstore', new $objectClass($objectStore));
     }
     $storage->getAuthMechanism()->manipulateStorageConfig($storage);
     $storage->getBackend()->manipulateStorageConfig($storage);
 }

 public function manipulateStorageConfig(StorageConfig &$storage)
 {
     $username_as_share = $storage->getBackendOption('username_as_share') === true;
     if ($username_as_share) {
         $share = '/' . $storage->getBackendOption('user');
         $storage->setBackendOption('share', $share);
     }
 }

 public function manipulateStorageConfig(StorageConfig &$storage, IUser $user = null)
 {
     $auth = new RSACrypt();
     $auth->setPassword($this->config->getSystemValue('secret', ''));
     if (!$auth->loadKey($storage->getBackendOption('private_key'))) {
         throw new \RuntimeException('unable to load private key');
     }
     $storage->setBackendOption('public_key_auth', $auth);
 }

 /**
  * Update storage to the configuration
  *
  * @param StorageConfig $updatedStorage storage attributes
  *
  * @return StorageConfig storage config
  * @throws NotFoundException if the given storage does not exist in the config
  */
 public function updateStorage(StorageConfig $updatedStorage)
 {
     $allStorages = $this->readConfig();
     $id = $updatedStorage->getId();
     if (!isset($allStorages[$id])) {
         throw new NotFoundException('Storage with id "' . $id . '" not found');
     }
     $oldStorage = $allStorages[$id];
     // ensure objectstore is persistent
     if ($objectstore = $oldStorage->getBackendOption('objectstore')) {
         $updatedStorage->setBackendOption('objectstore', $objectstore);
     }
     $allStorages[$id] = $updatedStorage;
     $this->writeConfig($allStorages);
     $this->triggerChangeHooks($oldStorage, $updatedStorage);
     return $this->getStorage($id);
 }

 /**
  * Check if parameters are satisfied in a StorageConfig
  *
  * @param StorageConfig $storage
  * @return bool
  */
 public function validateStorageDefinition(StorageConfig $storage)
 {
     foreach ($this->getParameters() as $name => $parameter) {
         $value = $storage->getBackendOption($name);
         if (!is_null($value) || !$parameter->isOptional()) {
             if (!$parameter->validateValue($value)) {
                 return false;
             }
             $storage->setBackendOption($name, $value);
         }
     }
     return true;
 }

 /**
  * @param StorageConfig $mount
  * @param string $key
  * @param string $value
  * @param OutputInterface $output
  */
 protected function setOption(StorageConfig $mount, $key, $value, OutputInterface $output)
 {
     $decoded = json_decode($value, true);
     if (!is_null($decoded)) {
         $value = $decoded;
     }
     if ($key === 'mountpoint' || $key === 'mount_point') {
         $mount->setMountPoint($value);
     } else {
         $mount->setBackendOption($key, $value);
     }
     $this->globalService->updateStorage($mount);
 }