nextcloud /
server
Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
Complex classes like Database often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use Database, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 69 | class Database extends Backend implements IUserBackend { |
||
| 70 | /** @var CappedMemoryCache */ |
||
| 71 | private $cache; |
||
| 72 | |||
| 73 | /** @var EventDispatcher */ |
||
| 74 | private $eventDispatcher; |
||
| 75 | |||
| 76 | /** |
||
| 77 | * \OC\User\Database constructor. |
||
| 78 | * |
||
| 79 | * @param EventDispatcher $eventDispatcher |
||
| 80 | */ |
||
| 81 | public function __construct($eventDispatcher = null) { |
||
| 82 | $this->cache = new CappedMemoryCache(); |
||
| 83 | $this->eventDispatcher = $eventDispatcher ? $eventDispatcher : \OC::$server->getEventDispatcher(); |
||
|
|
|||
| 84 | } |
||
| 85 | |||
| 86 | /** |
||
| 87 | * Create a new user |
||
| 88 | * |
||
| 89 | * @param string $uid The username of the user to create |
||
| 90 | * @param string $password The password of the new user |
||
| 91 | * @return bool |
||
| 92 | * |
||
| 93 | * Creates a new user. Basic checking of username is done in OC_User |
||
| 94 | * itself, not in its subclasses. |
||
| 95 | */ |
||
| 96 | public function createUser($uid, $password) { |
||
| 97 | if (!$this->userExists($uid)) { |
||
| 98 | $event = new GenericEvent($password); |
||
| 99 | $this->eventDispatcher->dispatch('OCP\PasswordPolicy::validate', $event); |
||
| 100 | $query = \OC_DB::prepare('INSERT INTO `*PREFIX*users` ( `uid`, `password` ) VALUES( ?, ? )'); |
||
| 101 | try { |
||
| 102 | $result = $query->execute(array($uid, \OC::$server->getHasher()->hash($password))); |
||
| 103 | } catch (\Exception $e) { |
||
| 104 | $result = false; |
||
| 105 | } |
||
| 106 | |||
| 107 | // Clear cache |
||
| 108 | unset($this->cache[$uid]); |
||
| 109 | |||
| 110 | return $result ? true : false; |
||
| 111 | } |
||
| 112 | |||
| 113 | return false; |
||
| 114 | } |
||
| 115 | |||
| 116 | /** |
||
| 117 | * delete a user |
||
| 118 | * |
||
| 119 | * @param string $uid The username of the user to delete |
||
| 120 | * @return bool |
||
| 121 | * |
||
| 122 | * Deletes a user |
||
| 123 | */ |
||
| 124 | View Code Duplication | public function deleteUser($uid) { |
|
| 125 | // Delete user-group-relation |
||
| 126 | $query = \OC_DB::prepare('DELETE FROM `*PREFIX*users` WHERE `uid` = ?'); |
||
| 127 | $result = $query->execute(array($uid)); |
||
| 128 | |||
| 129 | if (isset($this->cache[$uid])) { |
||
| 130 | unset($this->cache[$uid]); |
||
| 131 | } |
||
| 132 | |||
| 133 | return $result ? true : false; |
||
| 134 | } |
||
| 135 | |||
| 136 | /** |
||
| 137 | * Set password |
||
| 138 | * |
||
| 139 | * @param string $uid The username |
||
| 140 | * @param string $password The new password |
||
| 141 | * @return bool |
||
| 142 | * |
||
| 143 | * Change the password of a user |
||
| 144 | */ |
||
| 145 | public function setPassword($uid, $password) { |
||
| 146 | if ($this->userExists($uid)) { |
||
| 147 | $event = new GenericEvent($password); |
||
| 148 | $this->eventDispatcher->dispatch('OCP\PasswordPolicy::validate', $event); |
||
| 149 | $query = \OC_DB::prepare('UPDATE `*PREFIX*users` SET `password` = ? WHERE `uid` = ?'); |
||
| 150 | $result = $query->execute(array(\OC::$server->getHasher()->hash($password), $uid)); |
||
| 151 | |||
| 152 | return $result ? true : false; |
||
| 153 | } |
||
| 154 | |||
| 155 | return false; |
||
| 156 | } |
||
| 157 | |||
| 158 | /** |
||
| 159 | * Set display name |
||
| 160 | * |
||
| 161 | * @param string $uid The username |
||
| 162 | * @param string $displayName The new display name |
||
| 163 | * @return bool |
||
| 164 | * |
||
| 165 | * Change the display name of a user |
||
| 166 | */ |
||
| 167 | View Code Duplication | public function setDisplayName($uid, $displayName) { |
|
| 168 | if ($this->userExists($uid)) { |
||
| 169 | $query = \OC_DB::prepare('UPDATE `*PREFIX*users` SET `displayname` = ? WHERE LOWER(`uid`) = LOWER(?)'); |
||
| 170 | $query->execute(array($displayName, $uid)); |
||
| 171 | $this->cache[$uid]['displayname'] = $displayName; |
||
| 172 | |||
| 173 | return true; |
||
| 174 | } |
||
| 175 | |||
| 176 | return false; |
||
| 177 | } |
||
| 178 | |||
| 179 | /** |
||
| 180 | * get display name of the user |
||
| 181 | * |
||
| 182 | * @param string $uid user ID of the user |
||
| 183 | * @return string display name |
||
| 184 | */ |
||
| 185 | public function getDisplayName($uid) { |
||
| 186 | $this->loadUser($uid); |
||
| 187 | return empty($this->cache[$uid]['displayname']) ? $uid : $this->cache[$uid]['displayname']; |
||
| 188 | } |
||
| 189 | |||
| 190 | /** |
||
| 191 | * Get a list of all display names and user ids. |
||
| 192 | * |
||
| 193 | * @param string $search |
||
| 194 | * @param string|null $limit |
||
| 195 | * @param string|null $offset |
||
| 196 | * @return array an array of all displayNames (value) and the corresponding uids (key) |
||
| 197 | */ |
||
| 198 | public function getDisplayNames($search = '', $limit = null, $offset = null) { |
||
| 199 | $connection = \OC::$server->getDatabaseConnection(); |
||
| 200 | |||
| 201 | $query = $connection->getQueryBuilder(); |
||
| 202 | |||
| 203 | $query->select('uid', 'displayname') |
||
| 204 | ->from('users', 'u') |
||
| 205 | ->leftJoin('u', 'preferences', 'p', $query->expr()->andX( |
||
| 206 | $query->expr()->eq('userid', 'uid')), |
||
| 207 | $query->expr()->eq('appid', new Literal('settings')), |
||
| 208 | $query->expr()->eq('configkey', new Literal('email')) |
||
| 209 | ) |
||
| 210 | // sqlite doesn't like re-using a single named parameter here |
||
| 211 | ->where($query->expr()->iLike('uid', $query->createPositionalParameter('%' . $connection->escapeLikeParameter($search) . '%'))) |
||
| 212 | ->orWhere($query->expr()->iLike('displayname', $query->createPositionalParameter('%' . $connection->escapeLikeParameter($search) . '%'))) |
||
| 213 | ->orWhere($query->expr()->iLike('configvalue', $query->createPositionalParameter('%' . $connection->escapeLikeParameter($search) . '%'))) |
||
| 214 | ->orderBy($query->func()->lower('displayname'), 'ASC') |
||
| 215 | ->orderBy($query->func()->lower('uid'), 'ASC') |
||
| 216 | ->setMaxResults($limit) |
||
| 217 | ->setFirstResult($offset); |
||
| 218 | |||
| 219 | $result = $query->execute(); |
||
| 220 | $displayNames = []; |
||
| 221 | while ($row = $result->fetch()) { |
||
| 222 | $displayNames[$row['uid']] = $row['displayname']; |
||
| 223 | } |
||
| 224 | |||
| 225 | return $displayNames; |
||
| 226 | } |
||
| 227 | |||
| 228 | /** |
||
| 229 | * Check if the password is correct |
||
| 230 | * |
||
| 231 | * @param string $uid The username |
||
| 232 | * @param string $password The password |
||
| 233 | * @return string |
||
| 234 | * |
||
| 235 | * Check if the password is correct without logging in the user |
||
| 236 | * returns the user id or false |
||
| 237 | */ |
||
| 238 | public function checkPassword($uid, $password) { |
||
| 239 | $query = \OC_DB::prepare('SELECT `uid`, `password` FROM `*PREFIX*users` WHERE LOWER(`uid`) = LOWER(?)'); |
||
| 240 | $result = $query->execute(array($uid)); |
||
| 241 | |||
| 242 | $row = $result->fetchRow(); |
||
| 243 | if ($row) { |
||
| 244 | $storedHash = $row['password']; |
||
| 245 | $newHash = ''; |
||
| 246 | if (\OC::$server->getHasher()->verify($password, $storedHash, $newHash)) { |
||
| 247 | if (!empty($newHash)) { |
||
| 248 | $this->setPassword($uid, $password); |
||
| 249 | } |
||
| 250 | return $row['uid']; |
||
| 251 | } |
||
| 252 | |||
| 253 | } |
||
| 254 | |||
| 255 | return false; |
||
| 256 | } |
||
| 257 | |||
| 258 | /** |
||
| 259 | * Load an user in the cache |
||
| 260 | * |
||
| 261 | * @param string $uid the username |
||
| 262 | * @return boolean true if user was found, false otherwise |
||
| 263 | */ |
||
| 264 | private function loadUser($uid) { |
||
| 265 | $uid = (string)$uid; |
||
| 266 | if (!isset($this->cache[$uid])) { |
||
| 267 | //guests $uid could be NULL or '' |
||
| 268 | if ($uid === '') { |
||
| 269 | $this->cache[$uid] = false; |
||
| 270 | return true; |
||
| 271 | } |
||
| 272 | |||
| 273 | $query = \OC_DB::prepare('SELECT `uid`, `displayname` FROM `*PREFIX*users` WHERE LOWER(`uid`) = LOWER(?)'); |
||
| 274 | $result = $query->execute(array($uid)); |
||
| 275 | |||
| 276 | if ($result === false) { |
||
| 277 | Util::writeLog('core', \OC_DB::getErrorMessage(), Util::ERROR); |
||
| 278 | return false; |
||
| 279 | } |
||
| 280 | |||
| 281 | $this->cache[$uid] = false; |
||
| 282 | |||
| 283 | // "uid" is primary key, so there can only be a single result |
||
| 284 | if ($row = $result->fetchRow()) { |
||
| 285 | $this->cache[$uid]['uid'] = $row['uid']; |
||
| 286 | $this->cache[$uid]['displayname'] = $row['displayname']; |
||
| 287 | $result->closeCursor(); |
||
| 288 | } else { |
||
| 289 | $result->closeCursor(); |
||
| 290 | return false; |
||
| 291 | } |
||
| 292 | } |
||
| 293 | |||
| 294 | return true; |
||
| 295 | } |
||
| 296 | |||
| 297 | /** |
||
| 298 | * Get a list of all users |
||
| 299 | * |
||
| 300 | * @param string $search |
||
| 301 | * @param null|int $limit |
||
| 302 | * @param null|int $offset |
||
| 303 | * @return string[] an array of all uids |
||
| 304 | */ |
||
| 305 | public function getUsers($search = '', $limit = null, $offset = null) { |
||
| 306 | $users = $this->getDisplayNames($search, $limit, $offset); |
||
| 307 | $userIds = array_keys($users); |
||
| 308 | sort($userIds, SORT_STRING | SORT_FLAG_CASE); |
||
| 309 | return $userIds; |
||
| 310 | } |
||
| 311 | |||
| 312 | /** |
||
| 313 | * check if a user exists |
||
| 314 | * |
||
| 315 | * @param string $uid the username |
||
| 316 | * @return boolean |
||
| 317 | */ |
||
| 318 | public function userExists($uid) { |
||
| 319 | $this->loadUser($uid); |
||
| 320 | return $this->cache[$uid] !== false; |
||
| 321 | } |
||
| 322 | |||
| 323 | /** |
||
| 324 | * get the user's home directory |
||
| 325 | * |
||
| 326 | * @param string $uid the username |
||
| 327 | * @return string|false |
||
| 328 | */ |
||
| 329 | public function getHome($uid) { |
||
| 330 | View Code Duplication | if ($this->userExists($uid)) { |
|
| 331 | return \OC::$server->getConfig()->getSystemValue("datadirectory", \OC::$SERVERROOT . "/data") . '/' . $uid; |
||
| 332 | } |
||
| 333 | |||
| 334 | return false; |
||
| 335 | } |
||
| 336 | |||
| 337 | /** |
||
| 338 | * @return bool |
||
| 339 | */ |
||
| 340 | public function hasUserListings() { |
||
| 341 | return true; |
||
| 342 | } |
||
| 343 | |||
| 344 | /** |
||
| 345 | * counts the users in the database |
||
| 346 | * |
||
| 347 | * @return int|bool |
||
| 348 | */ |
||
| 349 | public function countUsers() { |
||
| 350 | $query = \OC_DB::prepare('SELECT COUNT(*) FROM `*PREFIX*users`'); |
||
| 351 | $result = $query->execute(); |
||
| 352 | if ($result === false) { |
||
| 353 | Util::writeLog('core', \OC_DB::getErrorMessage(), Util::ERROR); |
||
| 354 | return false; |
||
| 355 | } |
||
| 356 | return $result->fetchOne(); |
||
| 357 | } |
||
| 358 | |||
| 359 | /** |
||
| 360 | * returns the username for the given login name in the correct casing |
||
| 361 | * |
||
| 362 | * @param string $loginName |
||
| 363 | * @return string|false |
||
| 364 | */ |
||
| 365 | public function loginName2UserName($loginName) { |
||
| 366 | if ($this->userExists($loginName)) { |
||
| 367 | return $this->cache[$loginName]['uid']; |
||
| 368 | } |
||
| 369 | |||
| 370 | return false; |
||
| 371 | } |
||
| 372 | |||
| 373 | /** |
||
| 374 | * Backend name to be shown in user management |
||
| 375 | * |
||
| 376 | * @return string the name of the backend to be shown |
||
| 377 | */ |
||
| 378 | public function getBackendName() { |
||
| 381 | |||
| 382 | public static function preLoginNameUsedAsUserName($param) { |
||
| 400 | } |
||
| 401 |
Loading history...
Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a mixed type is assigned to a property that is type hinted more strictly.
For example, imagine you have a variable
$accountIdthat can either hold an Id object or false (if there is no account id yet). Your code now assigns that value to theidproperty of an instance of theAccountclass. This class holds a proper account, so the id value must no longer be false.Either this assignment is in error or a type check should be added for that assignment.