HomePhorge
Diffusion Phorge (HEAD -> master) Code

phorge/src/applications/people/storage/PhabricatorExternalAccount.php
e81eff68e581HEAD -> master

Last Change
Raw File

PhabricatorExternalAccount.php
View Options

<?php
final class PhabricatorExternalAccount
extends PhabricatorUserDAO
implements
PhabricatorPolicyInterface,
PhabricatorDestructibleInterface {
protected $userPHID;
protected $accountSecret;
protected $displayName;
protected $username;
protected $realName;
protected $email;
protected $emailVerified = 0;
protected $accountURI;
protected $profileImagePHID;
protected $properties = array();
protected $providerConfigPHID;
// TODO: Remove these (see T13493). These columns are obsolete and have
// no readers and only trivial writers.
protected $accountType;
protected $accountDomain;
protected $accountID;
private $profileImageFile = self::ATTACHABLE;
private $providerConfig = self::ATTACHABLE;
private $accountIdentifiers = self::ATTACHABLE;
public function getProfileImageFile() {
return $this->assertAttached($this->profileImageFile);
}
public function attachProfileImageFile(PhabricatorFile $file) {
$this->profileImageFile = $file;
return $this;
}
public function generatePHID() {
return PhabricatorPHID::generateNewPHID(
PhabricatorPeopleExternalPHIDType::TYPECONST);
}
protected function getConfiguration() {
return array(
self::CONFIG_AUX_PHID => true,
self::CONFIG_SERIALIZATION => array(
'properties' => self::SERIALIZATION_JSON,
),
self::CONFIG_COLUMN_SCHEMA => array(
'userPHID' => 'phid?',
'accountType' => 'text16',
'accountDomain' => 'text64',
'accountSecret' => 'text?',
'accountID' => 'text64',
'displayName' => 'text255?',
'username' => 'text255?',
'realName' => 'text255?',
'email' => 'text255?',
'emailVerified' => 'bool',
'profileImagePHID' => 'phid?',
'accountURI' => 'text255?',
),
self::CONFIG_KEY_SCHEMA => array(
'key_user' => array(
'columns' => array('userPHID'),
),
'key_provider' => array(
'columns' => array('providerConfigPHID', 'userPHID'),
),
),
) + parent::getConfiguration();
}
public function save() {
if (!$this->getAccountSecret()) {
$this->setAccountSecret(Filesystem::readRandomCharacters(32));
}
$this->openTransaction();
$result = parent::save();
$account_phid = $this->getPHID();
$config_phid = $this->getProviderConfigPHID();
if ($this->accountIdentifiers !== self::ATTACHABLE) {
foreach ($this->getAccountIdentifiers() as $identifier) {
$identifier
->setExternalAccountPHID($account_phid)
->setProviderConfigPHID($config_phid)
->save();
}
}
$this->saveTransaction();
return $result;
}
public function unlinkAccount() {
// When unlinking an account, we disassociate it from the user and
// remove all the identifying information. We retain the PHID, the
// object itself, and the "ExternalAccountIdentifier" objects in the
// external table.
// TODO: This unlinks (but does not destroy) any profile image.
return $this
->setUserPHID(null)
->setDisplayName(null)
->setUsername(null)
->setRealName(null)
->setEmail(null)
->setEmailVerified(0)
->setProfileImagePHID(null)
->setAccountURI(null)
->setProperties(array())
->save();
}
public function setProperty($key, $value) {
$this->properties[$key] = $value;
return $this;
}
public function getProperty($key, $default = null) {
return idx($this->properties, $key, $default);
}
public function isUsableForLogin() {
$config = $this->getProviderConfig();
if (!$config->getIsEnabled()) {
return false;
}
$provider = $config->getProvider();
if (!$provider->shouldAllowLogin()) {
return false;
}
return true;
}
public function attachProviderConfig(PhabricatorAuthProviderConfig $config) {
$this->providerConfig = $config;
return $this;
}
public function getProviderConfig() {
return $this->assertAttached($this->providerConfig);
}
public function getAccountIdentifiers() {
$raw = $this->assertAttached($this->accountIdentifiers);
return array_values($raw);
}
public function attachAccountIdentifiers(array $identifiers) {
assert_instances_of($identifiers, 'PhabricatorExternalAccountIdentifier');
$this->accountIdentifiers = mpull($identifiers, null, 'getIdentifierRaw');
return $this;
}
public function appendIdentifier(
PhabricatorExternalAccountIdentifier $identifier) {
$this->assertAttached($this->accountIdentifiers);
$map = $this->accountIdentifiers;
$raw = $identifier->getIdentifierRaw();
$old = idx($map, $raw);
$new = $identifier;
if ($old === null) {
$result = $new;
} else {
// Here, we already know about an identifier and have rediscovered it.
// We could copy properties from the new version of the identifier here,
// or merge them in some other way (for example, update a "last seen
// from the provider" timestamp), but no such properties currently exist.
$result = $old;
}
$this->accountIdentifiers[$raw] = $result;
return $this;
}
/* -( PhabricatorPolicyInterface )----------------------------------------- */
public function getCapabilities() {
return array(
PhabricatorPolicyCapability::CAN_VIEW,
PhabricatorPolicyCapability::CAN_EDIT,
);
}
public function getPolicy($capability) {
switch ($capability) {
case PhabricatorPolicyCapability::CAN_VIEW:
return PhabricatorPolicies::getMostOpenPolicy();
case PhabricatorPolicyCapability::CAN_EDIT:
return PhabricatorPolicies::POLICY_NOONE;
}
}
public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
return ($viewer->getPHID() == $this->getUserPHID());
}
public function describeAutomaticCapability($capability) {
switch ($capability) {
case PhabricatorPolicyCapability::CAN_VIEW:
return null;
case PhabricatorPolicyCapability::CAN_EDIT:
return pht(
'External accounts can only be edited by the account owner.');
}
}
/* -( PhabricatorDestructibleInterface )----------------------------------- */
public function destroyObjectPermanently(
PhabricatorDestructionEngine $engine) {
$viewer = $engine->getViewer();
$identifiers = id(new PhabricatorExternalAccountIdentifierQuery())
->setViewer($viewer)
->withExternalAccountPHIDs(array($this->getPHID()))
->newIterator();
foreach ($identifiers as $identifier) {
$engine->destroyObject($identifier);
}
// TODO: This may leave a profile image behind.
$this->delete();
}
}

Owner Packages

  • No Owners