src/applications/settings/storage/PhabricatorUserPreferences.php

   1 <?php
   2
   3 final class PhabricatorUserPreferences
   4   extends PhabricatorUserDAO
   5   implements
   6     PhabricatorPolicyInterface,
   7     PhabricatorDestructibleInterface,
   8     PhabricatorApplicationTransactionInterface {
   9
  10   const BUILTIN_GLOBAL_DEFAULT = 'global';
  11
  12   protected $userPHID;
  13   protected $preferences = array();
  14   protected $builtinKey;
  15
  16   private $user = self::ATTACHABLE;
  17   private $defaultSettings;
  18
  19   protected function getConfiguration() {
  20     return array(
  21       self::CONFIG_AUX_PHID => true,
  22       self::CONFIG_SERIALIZATION => array(
  23         'preferences' => self::SERIALIZATION_JSON,
  24       ),
  25       self::CONFIG_COLUMN_SCHEMA => array(
  26         'userPHID' => 'phid?',
  27         'builtinKey' => 'text32?',
  28       ),
  29       self::CONFIG_KEY_SCHEMA => array(
  30         'key_user' => array(
  31           'columns' => array('userPHID'),
  32           'unique' => true,
  33         ),
  34         'key_builtin' => array(
  35           'columns' => array('builtinKey'),
  36           'unique' => true,
  37         ),
  38       ),
  39     ) + parent::getConfiguration();
  40   }
  41
  42   public function generatePHID() {
  43     return PhabricatorPHID::generateNewPHID(
  44       PhabricatorUserPreferencesPHIDType::TYPECONST);
  45   }
  46
  47   public function getPreference($key, $default = null) {
  48     return idx($this->preferences, $key, $default);
  49   }
  50
  51   public function setPreference($key, $value) {
  52     $this->preferences[$key] = $value;
  53     return $this;
  54   }
  55
  56   public function unsetPreference($key) {
  57     unset($this->preferences[$key]);
  58     return $this;
  59   }
  60
  61   public function getDefaultValue($key) {
  62     if ($this->defaultSettings) {
  63       return $this->defaultSettings->getSettingValue($key);
  64     }
  65
  66     $setting = self::getSettingObject($key);
  67
  68     if (!$setting) {
  69       return null;
  70     }
  71
  72     $setting = id(clone $setting)
  73       ->setViewer($this->getUser());
  74
  75     return $setting->getSettingDefaultValue();
  76   }
  77
  78   public function getSettingValue($key) {
  79     if (array_key_exists($key, $this->preferences)) {
  80       return $this->preferences[$key];
  81     }
  82
  83     return $this->getDefaultValue($key);
  84   }
  85
  86   private static function getSettingObject($key) {
  87     $settings = PhabricatorSetting::getAllSettings();
  88     return idx($settings, $key);
  89   }
  90
  91   public function attachDefaultSettings(PhabricatorUserPreferences $settings) {
  92     $this->defaultSettings = $settings;
  93     return $this;
  94   }
  95
  96   public function attachUser(PhabricatorUser $user = null) {
  97     $this->user = $user;
  98     return $this;
  99   }
 100
 101   public function getUser() {
 102     return $this->assertAttached($this->user);
 103   }
 104
 105   public function hasManagedUser() {
 106     $user_phid = $this->getUserPHID();
 107     if (!$user_phid) {
 108       return false;
 109     }
 110
 111     $user = $this->getUser();
 112     if ($user->getIsSystemAgent() || $user->getIsMailingList()) {
 113       return true;
 114     }
 115
 116     return false;
 117   }
 118
 119   /**
 120    * Load or create a preferences object for the given user.
 121    *
 122    * @param PhabricatorUser User to load or create preferences for.
 123    */
 124   public static function loadUserPreferences(PhabricatorUser $user) {
 125     return id(new PhabricatorUserPreferencesQuery())
 126       ->setViewer($user)
 127       ->withUsers(array($user))
 128       ->needSyntheticPreferences(true)
 129       ->executeOne();
 130   }
 131
 132   /**
 133    * Load or create a global preferences object.
 134    *
 135    * If no global preferences exist, an empty preferences object is returned.
 136    *
 137    * @param PhabricatorUser Viewing user.
 138    */
 139   public static function loadGlobalPreferences(PhabricatorUser $viewer) {
 140     $global = id(new PhabricatorUserPreferencesQuery())
 141       ->setViewer($viewer)
 142       ->withBuiltinKeys(
 143         array(
 144           self::BUILTIN_GLOBAL_DEFAULT,
 145         ))
 146       ->executeOne();
 147
 148     if (!$global) {
 149       $global = id(new self())
 150         ->attachUser(new PhabricatorUser());
 151     }
 152
 153     return $global;
 154   }
 155
 156   public function newTransaction($key, $value) {
 157     $setting_property = PhabricatorUserPreferencesTransaction::PROPERTY_SETTING;
 158     $xaction_type = PhabricatorUserPreferencesTransaction::TYPE_SETTING;
 159
 160     return id(clone $this->getApplicationTransactionTemplate())
 161       ->setTransactionType($xaction_type)
 162       ->setMetadataValue($setting_property, $key)
 163       ->setNewValue($value);
 164   }
 165
 166   public function getEditURI() {
 167     if ($this->getUser()) {
 168       return '/settings/user/'.$this->getUser()->getUsername().'/';
 169     } else {
 170       return '/settings/builtin/'.$this->getBuiltinKey().'/';
 171     }
 172   }
 173
 174   public function getDisplayName() {
 175     if ($this->getBuiltinKey()) {
 176       return pht('Global Default Settings');
 177     }
 178
 179     return pht('Personal Settings');
 180   }
 181
 182 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 183
 184
 185   public function getCapabilities() {
 186     return array(
 187       PhabricatorPolicyCapability::CAN_VIEW,
 188       PhabricatorPolicyCapability::CAN_EDIT,
 189     );
 190   }
 191
 192   public function getPolicy($capability) {
 193     switch ($capability) {
 194       case PhabricatorPolicyCapability::CAN_VIEW:
 195         $user_phid = $this->getUserPHID();
 196         if ($user_phid) {
 197           return $user_phid;
 198         }
 199
 200         return PhabricatorPolicies::getMostOpenPolicy();
 201       case PhabricatorPolicyCapability::CAN_EDIT:
 202         if ($this->hasManagedUser()) {
 203           return PhabricatorPolicies::POLICY_ADMIN;
 204         }
 205
 206         $user_phid = $this->getUserPHID();
 207         if ($user_phid) {
 208           return $user_phid;
 209         }
 210
 211         return PhabricatorPolicies::POLICY_ADMIN;
 212     }
 213   }
 214
 215   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
 216     if ($this->hasManagedUser()) {
 217       if ($viewer->getIsAdmin()) {
 218         return true;
 219       }
 220     }
 221
 222     $builtin_key = $this->getBuiltinKey();
 223
 224     $is_global = ($builtin_key === self::BUILTIN_GLOBAL_DEFAULT);
 225     $is_view = ($capability === PhabricatorPolicyCapability::CAN_VIEW);
 226
 227     if ($is_global && $is_view) {
 228       // NOTE: Without this policy exception, the logged-out viewer can not
 229       // see global preferences.
 230       return true;
 231     }
 232
 233     return false;
 234   }
 235
 236 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 237
 238
 239   public function destroyObjectPermanently(
 240     PhabricatorDestructionEngine $engine) {
 241     $this->delete();
 242   }
 243
 244
 245 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 246
 247
 248   public function getApplicationTransactionEditor() {
 249     return new PhabricatorUserPreferencesEditor();
 250   }
 251
 252   public function getApplicationTransactionTemplate() {
 253     return new PhabricatorUserPreferencesTransaction();
 254   }
 255
 256 }