/**
* Class Access
+ *
* @package OCA\User_LDAP
*/
class Access extends LDAPUtility {
/**
* protected $cookies = [];
+ *
* @var AbstractMapping $userMapper
*/
protected $userMapper;
/**
* sets the User Mapper
+ *
* @param AbstractMapping $mapper
*/
public function setUserMapper(AbstractMapping $mapper) {
/**
* returns the User Mapper
- * @throws \Exception
+ *
* @return AbstractMapping
+ * @throws \Exception
*/
public function getUserMapper() {
if (is_null($this->userMapper)) {
/**
* sets the Group Mapper
+ *
* @param AbstractMapping $mapper
*/
public function setGroupMapper(AbstractMapping $mapper) {
/**
* returns the Group Mapper
- * @throws \Exception
+ *
* @return AbstractMapping
+ * @throws \Exception
*/
public function getGroupMapper() {
if (is_null($this->groupMapper)) {
/**
* returns the Connection instance
+ *
* @return \OCA\User_LDAP\Connection
*/
public function getConnection() {
$result = $this->extractRangeData($result, $attr);
if (!empty($result)) {
$normalizedResult = $this->extractAttributeValuesFromResult(
- [ $attr => $result['values'] ],
+ [$attr => $result['values']],
$attr
);
$values = array_merge($values, $normalizedResult);
// no more results left
return $values;
} else {
- $low = $result['rangeHigh'] + 1;
+ $low = $result['rangeHigh'] + 1;
$attrToRead = $result['attributeName'] . ';range=' . $low . '-*';
$isRangeRequest = true;
}
}
} while ($isRangeRequest);
- \OCP\Util::writeLog('user_ldap', 'Requested attribute '.$attr.' not found for '.$dn, ILogger::DEBUG);
+ \OCP\Util::writeLog('user_ldap', 'Requested attribute ' . $attr . ' not found for ' . $dn, ILogger::DEBUG);
return false;
}
$values = [];
if (isset($result[$attribute]) && $result[$attribute]['count'] > 0) {
$lowercaseAttribute = strtolower($attribute);
- for ($i=0;$i<$result[$attribute]['count'];$i++) {
+ for ($i = 0; $i < $result[$attribute]['count']; $i++) {
if ($this->resemblesDN($attribute)) {
$values[] = $this->helper->sanitizeDN($result[$attribute][$i]);
} elseif ($lowercaseAttribute === 'objectguid' || $lowercaseAttribute === 'guid') {
try {
// try PASSWD extended operation first
return @$this->invokeLDAPMethod('exopPasswd', $cr, $userDN, '', $password) ||
- @$this->invokeLDAPMethod('modReplace', $cr, $userDN, $password);
+ @$this->invokeLDAPMethod('modReplace', $cr, $userDN, $password);
} catch (ConstraintViolationException $e) {
- throw new HintException('Password change rejected.', \OC::$server->getL10N('user_ldap')->t('Password change rejected. Hint: ').$e->getMessage(), $e->getCode());
+ throw new HintException('Password change rejected.', \OC::$server->getL10N('user_ldap')->t('Password change rejected. Hint: ') . $e->getMessage(), $e->getCode());
}
}
/**
* checks whether the given attributes value is probably a DN
+ *
* @param string $attr the attribute in question
* @return boolean if so true, otherwise false
*/
/**
* checks whether the given string is probably a DN
+ *
* @param string $string
* @return boolean
*/
* returns a DN-string that is cleaned from not domain parts, e.g.
* cn=foo,cn=bar,dc=foobar,dc=server,dc=org
* becomes dc=foobar,dc=server,dc=org
+ *
* @param string $dn
* @return string
*/
/**
* returns the LDAP DN for the given internal Nextcloud name of the group
+ *
* @param string $name the Nextcloud name in question
* @return string|false LDAP DN on success, otherwise false
*/
/**
* returns the LDAP DN for the given internal Nextcloud name of the user
+ *
* @param string $name the Nextcloud name in question
* @return string|false with the LDAP DN on success, otherwise false
*/
}
} else {
//If the UUID can't be detected something is foul.
- \OCP\Util::writeLog('user_ldap', 'Cannot determine UUID for '.$fdn.'. Skipping.', ILogger::INFO);
+ \OCP\Util::writeLog('user_ldap', 'Cannot determine UUID for ' . $fdn . '. Skipping.', ILogger::INFO);
return false;
}
if (is_null($ldapName)) {
$ldapName = $this->readAttribute($fdn, $nameAttribute, $filter);
if (!isset($ldapName[0]) && empty($ldapName[0])) {
- \OCP\Util::writeLog('user_ldap', 'No or empty name for '.$fdn.' with filter '.$filter.'.', ILogger::INFO);
+ \OCP\Util::writeLog('user_ldap', 'No or empty name for ' . $fdn . ' with filter ' . $filter . '.', ILogger::INFO);
return false;
}
$ldapName = $ldapName[0];
}
//if everything else did not help..
- \OCP\Util::writeLog('user_ldap', 'Could not create unique name for '.$fdn.'.', ILogger::INFO);
+ \OCP\Util::writeLog('user_ldap', 'Could not create unique name for ' . $fdn . '.', ILogger::INFO);
return false;
}
string $name,
string $uuid,
bool $isUser
- ) :bool {
+ ): bool {
if ($mapper->map($fdn, $name, $uuid)) {
if ($this->ncUserManager instanceof PublicEmitter && $isUser) {
$this->cacheUserExists($name);
private function ldap2NextcloudNames($ldapObjects, $isUsers) {
if ($isUsers) {
$nameAttribute = $this->connection->ldapUserDisplayName;
- $sndAttribute = $this->connection->ldapUserDisplayName2;
+ $sndAttribute = $this->connection->ldapUserDisplayName2;
} else {
$nameAttribute = $this->connection->ldapGroupDisplayName;
}
/**
* caches the user display name
+ *
* @param string $ocName the internal Nextcloud username
* @param string|false $home the home directory path
*/
public function cacheUserHome($ocName, $home) {
- $cacheKey = 'getHome'.$ocName;
+ $cacheKey = 'getHome' . $ocName;
$this->connection->writeToCache($cacheKey, $home);
}
/**
* caches a user as existing
+ *
* @param string $ocName the internal Nextcloud username
*/
public function cacheUserExists($ocName) {
- $this->connection->writeToCache('userExists'.$ocName, true);
+ $this->connection->writeToCache('userExists' . $ocName, true);
}
/**
* caches a group as existing
*/
public function cacheGroupExists(string $gid): void {
- $this->connection->writeToCache('groupExists'.$gid, true);
+ $this->connection->writeToCache('groupExists' . $gid, true);
}
/**
}
$displayName = $user->composeAndStoreDisplayName($displayName, $displayName2);
$cacheKeyTrunk = 'getDisplayName';
- $this->connection->writeToCache($cacheKeyTrunk.$ocName, $displayName);
+ $this->connection->writeToCache($cacheKeyTrunk . $ocName, $displayName);
}
public function cacheGroupDisplayName(string $ncName, string $displayName): void {
/**
* creates a unique name for internal Nextcloud use for users. Don't call it directly.
+ *
* @param string $name the display name of the object
* @return string|false with with the name to use in Nextcloud or false if unsuccessful
*
//while loop is just a precaution. If a name is not generated within
//20 attempts, something else is very wrong. Avoids infinite loop.
while ($attempts < 20) {
- $altName = $name . '_' . rand(1000,9999);
+ $altName = $name . '_' . rand(1000, 9999);
if (!$this->ncUserManager->userExists($altName)) {
return $altName;
}
/**
* creates a unique name for internal Nextcloud use for groups. Don't call it directly.
+ *
* @param string $name the display name of the object
* @return string|false with with the name to use in Nextcloud or false if unsuccessful.
*
$lastName = array_pop($usedNames);
$lastNo = (int)substr($lastName, strrpos($lastName, '_') + 1);
}
- $altName = $name.'_'. (string)($lastNo+1);
+ $altName = $name . '_' . (string)($lastNo + 1);
unset($usedNames);
$attempts = 1;
/**
* creates a unique name for internal Nextcloud use.
+ *
* @param string $name the display name of the object
* @param boolean $isUser whether name should be created for a user (true) or a group (false)
* @return string|false with with the name to use in Nextcloud or false if unsuccessful
return $listOfDNs;
}, []);
$idsByDn = $this->userMapper->getListOfIdsByDn($listOfDNs);
- $recordsToUpdate = array_filter($ldapRecords, function($record) use ($isBackgroundJobModeAjax, $idsByDn) {
+ $recordsToUpdate = array_filter($ldapRecords, function ($record) use ($isBackgroundJobModeAjax, $idsByDn) {
$newlyMapped = false;
$uid = $idsByDn[$record['dn'][0]] ?? null;
- if($uid === null) {
+ if ($uid === null) {
$uid = $this->dn2ocname($record['dn'][0], null, true, $newlyMapped, $record);
}
if (is_string($uid)) {
// displayName is obligatory
continue;
}
- $ocName = $this->dn2ocname($userRecord['dn'][0], null, true);
+ $ocName = $this->dn2ocname($userRecord['dn'][0], null, true);
if ($ocName === false) {
continue;
}
} else {
\OC::$server->getLogger()->debug(
"The ldap user manager returned null for $ocName",
- ['app'=>'user_ldap']
+ ['app' => 'user_ldap']
);
}
}
$listOfDNs = array_reduce($groupRecords, function ($listOfDNs, $entry) {
$listOfDNs[] = $entry['dn'][0];
- return$listOfDNs;
+ return $listOfDNs;
}, []);
$idsByDn = $this->groupMapper->getListOfIdsByDn($listOfDNs);
- array_walk($groupRecords, function($record) use ($idsByDn) {
+ array_walk($groupRecords, function ($record) use ($idsByDn) {
$newlyMapped = false;
$gid = $uidsByDn[$record['dn'][0]] ?? null;
- if($gid === null) {
+ if ($gid === null) {
$gid = $this->dn2ocname($record['dn'][0], null, false, $newlyMapped, $record);
}
if (!$newlyMapped && is_string($gid)) {
/**
* Returns the LDAP handler
+ *
* @throws \OC\ServerNotAvailableException
*/
// cannot use $cr anymore, might have changed in the previous call!
$error = $this->ldap->errno($this->connection->getConnectionResource());
if (!$this->ldap->isResource($sr) || $error !== 0) {
- \OCP\Util::writeLog('user_ldap', 'Attempt for Paging? '.print_r($pagedSearchOK, true), ILogger::ERROR);
+ \OCP\Util::writeLog('user_ldap', 'Attempt for Paging? ' . print_r($pagedSearchOK, true), ILogger::ERROR);
return false;
}
if (!is_null($limit) && (int)$this->connection->ldapPagingSize !== 0) {
\OC::$server->getLogger()->debug(
'Paged search was not available',
- [ 'app' => 'user_ldap' ]
+ ['app' => 'user_ldap']
);
}
}
//a) paged search unsuccessful, though attempted
//b) no paged search, but limit set
if ((!$this->getPagedSearchResultState()
- && $pagedSearchOK)
+ && $pagedSearchOK)
|| (
!$pagedSearchOK
&& !is_null($limit)
/**
* escapes (user provided) parts for LDAP filter
- * @param string $input, the provided value
+ *
+ * @param string $input , the provided value
* @param bool $allowAsterisk whether in * at the beginning should be preserved
* @return string the escaped string
*/
$asterisk = '*';
$input = mb_substr($input, 1, null, 'UTF-8');
}
- $search = ['*', '\\', '(', ')'];
+ $search = ['*', '\\', '(', ')'];
$replace = ['\\*', '\\\\', '\\(', '\\)'];
return $asterisk . str_replace($search, $replace, $input);
}
/**
* combines the input filters with AND
+ *
* @param string[] $filters the filters to connect
* @return string the combined filter
*/
/**
* combines the input filters with OR
+ *
* @param string[] $filters the filters to connect
* @return string the combined filter
* Combines Filter arguments with OR
/**
* combines the input filters with given operator
+ *
* @param string[] $filters the filters to connect
* @param string $operator either & or |
* @return string the combined filter
*/
private function combineFilter($filters, $operator) {
- $combinedFilter = '('.$operator;
+ $combinedFilter = '(' . $operator;
foreach ($filters as $filter) {
if ($filter !== '' && $filter[0] !== '(') {
- $filter = '('.$filter.')';
+ $filter = '(' . $filter . ')';
}
- $combinedFilter.=$filter;
+ $combinedFilter .= $filter;
}
- $combinedFilter.=')';
+ $combinedFilter .= ')';
return $combinedFilter;
}
/**
* creates a filter part for to perform search for users
+ *
* @param string $search the search term
* @return string the final filter part to use in LDAP searches
*/
/**
* creates a filter part for to perform search for groups
+ *
* @param string $search the search term
* @return string the final filter part to use in LDAP searches
*/
/**
* creates a filter part for searches by splitting up the given search
* string into single words
+ *
* @param string $search the search term
* @param string[] $searchAttributes needs to have at least two attributes,
* otherwise it does not make sense :)
/**
* creates a filter part for searches
+ *
* @param string $search the search term
* @param string[]|null $searchAttributes
* @param string $fallbackAttribute a fallback attribute in case the user
}
}
if (count($filter) === 1) {
- return '('.$filter[0].')';
+ return '(' . $filter[0] . ')';
}
return $this->combineFilterWithOr($filter);
}
* returns the search term depending on whether we are allowed
* list users found by ldap with the current input appended by
* a *
+ *
* @return string
*/
private function prepareSearchTerm($term) {
/**
* returns the filter used for counting users
+ *
* @return string
*/
public function getFilterForUserCount() {
*/
public function getUserDnByUuid($uuid) {
$uuidOverride = $this->connection->ldapExpertUUIDUserAttr;
- $filter = $this->connection->ldapUserFilter;
- $bases = $this->connection->ldapBaseUsers;
+ $filter = $this->connection->ldapUserFilter;
+ $bases = $this->connection->ldapBaseUsers;
if ($this->connection->ldapUuidUserAttribute === 'auto' && $uuidOverride === '') {
// Sacrebleu! The UUID attribute is unknown :( We need first an
*/
private function detectUuidAttribute($dn, $isUser = true, $force = false, array $ldapRecord = null) {
if ($isUser) {
- $uuidAttr = 'ldapUuidUserAttribute';
+ $uuidAttr = 'ldapUuidUserAttribute';
$uuidOverride = $this->connection->ldapExpertUUIDUserAttr;
} else {
- $uuidAttr = 'ldapUuidGroupAttribute';
+ $uuidAttr = 'ldapUuidGroupAttribute';
$uuidOverride = $this->connection->ldapExpertUUIDGroupAttr;
}
*/
public function getUUID($dn, $isUser = true, $ldapRecord = null) {
if ($isUser) {
- $uuidAttr = 'ldapUuidUserAttribute';
+ $uuidAttr = 'ldapUuidUserAttribute';
$uuidOverride = $this->connection->ldapExpertUUIDUserAttr;
} else {
- $uuidAttr = 'ldapUuidGroupAttribute';
+ $uuidAttr = 'ldapUuidGroupAttribute';
$uuidOverride = $this->connection->ldapExpertUUIDGroupAttr;
}
/**
* converts a binary ObjectGUID into a string representation
+ *
* @param string $oguid the ObjectGUID in it's binary form as retrieved from AD
* @return string
* @link http://www.php.net/manual/en/function.ldap-get-values-len.php#73198
\OC::$server->getLogger()->info(
'Passed string does not resemble a valid GUID. Known UUID ' .
'({uuid}) probably does not match UUID configuration.',
- [ 'app' => 'user_ldap', 'uuid' => $guid ]
+ ['app' => 'user_ldap', 'uuid' => $guid]
);
return $guid;
}
- for ($i=0; $i < 3; $i++) {
+ for ($i = 0; $i < 3; $i++) {
$pairs = str_split($blocks[$i], 2);
$pairs = array_reverse($pairs);
$blocks[$i] = implode('', $pairs);
}
- for ($i=0; $i < 5; $i++) {
+ for ($i = 0; $i < 5; $i++) {
$pairs = str_split($blocks[$i], 2);
$blocks[$i] = '\\' . implode('\\', $pairs);
}
*/
public function getSID($dn) {
$domainDN = $this->getDomainDNFromDN($dn);
- $cacheKey = 'getSID-'.$domainDN;
+ $cacheKey = 'getSID-' . $domainDN;
$sid = $this->connection->getFromCache($cacheKey);
if (!is_null($sid)) {
return $sid;
/**
* converts a binary SID into a string representation
+ *
* @param string $sid
* @return string
*/
/**
* checks if the given DN is part of the given base DN(s)
+ *
* @param string $dn the DN
* @param string[] $bases array containing the allowed base DN or DNs
* @return bool
foreach ($bases as $base) {
$belongsToBase = true;
- if (mb_strripos($dn, $base, 0, 'UTF-8') !== (mb_strlen($dn, 'UTF-8')-mb_strlen($base, 'UTF-8'))) {
+ if (mb_strripos($dn, $base, 0, 'UTF-8') !== (mb_strlen($dn, 'UTF-8') - mb_strlen($base, 'UTF-8'))) {
$belongsToBase = false;
}
if ($belongsToBase) {
* be reset by other operations. Best, call it immediately after a search(),
* searchUsers() or searchGroups() call. count-methods are probably safe as
* well. Don't rely on it with any fetchList-method.
+ *
* @return bool
*/
public function hasMoreResults() {
/**
* Check whether the most recent paged search was successful. It flushed the state var. Use it always after a possible paged search.
+ *
* @return boolean|null true on success, null or false otherwise
*/
public function getPagedSearchResultState() {
$this->abandonPagedSearch();
}
$pagedSearchOK = true === $this->invokeLDAPMethod(
- 'controlPagedResult', $this->connection->getConnectionResource(), $limit, false
- );
+ 'controlPagedResult', $this->connection->getConnectionResource(), $limit, false
+ );
if ($pagedSearchOK) {
- \OC::$server->getLogger()->debug('Ready for a paged search',['app' => 'user_ldap']);
+ \OC::$server->getLogger()->debug('Ready for a paged search', ['app' => 'user_ldap']);
}
/* ++ Fixing RHDS searches with pages with zero results ++
* We coudn't get paged searches working with our RHDS for login ($limit = 0),
/**
* is user in group?
+ *
* @param string $uid uid of the user
* @param string $gid gid of the group
* @return bool
if (!$this->enabled) {
return false;
}
- $cacheKey = 'inGroup'.$uid.':'.$gid;
+ $cacheKey = 'inGroup' . $uid . ':' . $gid;
$inGroup = $this->access->connection->getFromCache($cacheKey);
if (!is_null($inGroup)) {
return (bool)$inGroup;
return $isInGroup;
}
- $cacheKeyMembers = 'inGroup-members:'.$gid;
+ $cacheKeyMembers = 'inGroup-members:' . $gid;
$members = $this->access->connection->getFromCache($cacheKeyMembers);
if (!is_null($members)) {
$this->cachedGroupMembers[$gid] = $members;
$pos = strpos($memberURLs[0], '(');
if ($pos !== false) {
$memberUrlFilter = substr($memberURLs[0], $pos);
- $foundMembers = $this->access->searchUsers($memberUrlFilter,'dn');
+ $foundMembers = $this->access->searchUsers($memberUrlFilter, 'dn');
$dynamicMembers = [];
foreach ($foundMembers as $value) {
$dynamicMembers[$value['dn'][0]] = 1;
}
} else {
- \OCP\Util::writeLog('user_ldap', 'No search filter found on member url '.
+ \OCP\Util::writeLog('user_ldap', 'No search filter found on member url ' .
'of group ' . $dnGroup, ILogger::DEBUG);
}
}
return [];
}
// used extensively in cron job, caching makes sense for nested groups
- $cacheKey = '_groupMembers'.$dnGroup;
+ $cacheKey = '_groupMembers' . $dnGroup;
$groupMembers = $this->access->connection->getFromCache($cacheKey);
if ($groupMembers !== null) {
return $groupMembers;
* @return array
*/
private function walkNestedGroups(string $dn, \Closure $fetcher, array $list): array {
- $nesting = (int) $this->access->connection->ldapNestedGroups;
+ $nesting = (int)$this->access->connection->ldapNestedGroups;
// depending on the input, we either have a list of DNs or a list of LDAP records
// also, the output expects either DNs or records. Testing the first element should suffice.
$recordMode = is_array($list) && isset($list[0]) && is_array($list[0]) && isset($list[0]['dn'][0]);
/**
* translates a gidNumber into an ownCloud internal name
+ *
* @param string $gid as given by gidNumber on POSIX LDAP
* @param string $dn a DN that belongs to the same domain as the group
* @return string|bool
/**
* returns the entry's gidNumber
+ *
* @param string $dn
* @param string $attribute
* @return string|bool
/**
* returns the group's primary ID
+ *
* @param string $dn
* @return string|bool
*/
/**
* returns the user's gidNumber
+ *
* @param string $dn
* @return string|bool
*/
if ($search !== '') {
$filterParts[] = $this->access->getFilterPartForUserSearch($search);
}
- $filterParts[] = $this->access->connection->ldapGidNumber .'=' . $groupID;
+ $filterParts[] = $this->access->connection->ldapGidNumber . '=' . $groupID;
return $this->access->combineFilterWithAnd($filterParts);
}
/**
* gets the gidNumber of a user
+ *
* @param string $dn
* @return string
*/
/**
* translates a primary group ID into an Nextcloud internal name
+ *
* @param string $gid as given by primaryGroupID on AD
* @param string $dn a DN that belongs to the same domain as the group
* @return string|bool
/**
* returns the entry's primary group ID
+ *
* @param string $dn
* @param string $attribute
* @return string|bool
/**
* returns the group's primary ID
+ *
* @param string $dn
* @return string|bool
*/
/**
* returns the user's primary group ID
+ *
* @param string $dn
* @return string|bool
*/
/**
* gets the primary group of a user
+ *
* @param string $dn
* @return string
*/
/**
* Get all groups a user belongs to
+ *
* @param string $uid Name of the user
* @return array with group names
*
if (!$this->enabled) {
return [];
}
- $cacheKey = 'getUserGroups'.$uid;
+ $cacheKey = 'getUserGroups' . $uid;
$userGroups = $this->access->connection->getFromCache($cacheKey);
if (!is_null($userGroups)) {
return $userGroups;
if (!empty($dynamicGroupMemberURL)) {
// look through dynamic groups to add them to the result array if needed
$groupsToMatch = $this->access->fetchListOfGroups(
- $this->access->connection->ldapGroupFilter,['dn',$dynamicGroupMemberURL]);
+ $this->access->connection->ldapGroupFilter, ['dn', $dynamicGroupMemberURL]);
foreach ($groupsToMatch as $dynamicGroup) {
if (!array_key_exists($dynamicGroupMemberURL, $dynamicGroup)) {
continue;
}
$pos = strpos($dynamicGroup[$dynamicGroupMemberURL][0], '(');
if ($pos !== false) {
- $memberUrlFilter = substr($dynamicGroup[$dynamicGroupMemberURL][0],$pos);
+ $memberUrlFilter = substr($dynamicGroup[$dynamicGroupMemberURL][0], $pos);
// apply filter via ldap search to see if this user is in this
// dynamic group
$userMatch = $this->access->readAttribute(
}
}
} else {
- \OCP\Util::writeLog('user_ldap', 'No search filter found on member url '.
+ \OCP\Util::writeLog('user_ldap', 'No search filter found on member url ' .
'of group ' . print_r($dynamicGroup, true), ILogger::DEBUG);
}
}
if ((int)$this->access->connection->hasMemberOfFilterSupport === 1
&& (int)$this->access->connection->useMemberOfToDetectMembership === 1
&& strtolower($this->access->connection->ldapGroupMemberAssocAttr) !== 'memberuid'
- ) {
+ ) {
$groupDNs = $this->_getGroupDNsFromMemberOf($userDN);
if (is_array($groupDNs)) {
foreach ($groupDNs as $dn) {
} elseif (strtolower($this->access->connection->ldapGroupMemberAssocAttr) === 'memberuid') {
$result = $this->access->readAttribute($userDN, 'uid');
if ($result === false) {
- \OCP\Util::writeLog('user_ldap', 'No uid attribute found for DN ' . $userDN . ' on '.
+ \OCP\Util::writeLog('user_ldap', 'No uid attribute found for DN ' . $userDN . ' on ' .
$this->access->connection->ldapHost, ILogger::DEBUG);
$uid = false;
} else {
}
$allGroups = [];
$seen[$dn] = true;
- $filter = $this->access->connection->ldapGroupMemberAssocAttr.'='.$dn;
+ $filter = $this->access->connection->ldapGroupMemberAssocAttr . '=' . $dn;
$groups = $this->access->fetchListOfGroups($filter,
[strtolower($this->access->connection->ldapGroupMemberAssocAttr), $this->access->connection->ldapGroupDisplayName, 'dn']);
if (is_array($groups)) {
return [];
}
$search = $this->access->escapeFilterPart($search, true);
- $cacheKey = 'usersInGroup-'.$gid.'-'.$search.'-'.$limit.'-'.$offset;
+ $cacheKey = 'usersInGroup-' . $gid . '-' . $search . '-' . $limit . '-' . $offset;
// check for cache of the exact query
$groupUsers = $this->access->connection->getFromCache($cacheKey);
if (!is_null($groupUsers)) {
}
// check for cache of the query without limit and offset
- $groupUsers = $this->access->connection->getFromCache('usersInGroup-'.$gid.'-'.$search);
+ $groupUsers = $this->access->connection->getFromCache('usersInGroup-' . $gid . '-' . $search);
if (!is_null($groupUsers)) {
$groupUsers = array_slice($groupUsers, $offset, $limit);
$this->access->connection->writeToCache($cacheKey, $groupUsers);
$groupUsers = array_unique(array_merge($groupUsers, $primaryUsers, $posixGroupUsers));
natsort($groupUsers);
- $this->access->connection->writeToCache('usersInGroup-'.$gid.'-'.$search, $groupUsers);
+ $this->access->connection->writeToCache('usersInGroup-' . $gid . '-' . $search, $groupUsers);
$groupUsers = array_slice($groupUsers, $offset, $limit);
$this->access->connection->writeToCache($cacheKey, $groupUsers);
/**
* returns the number of users in a group, who match the search term
+ *
* @param string $gid the internal group name
* @param string $search optional, a search string
* @return int|bool
return $this->groupPluginManager->countUsersInGroup($gid, $search);
}
- $cacheKey = 'countUsersInGroup-'.$gid.'-'.$search;
+ $cacheKey = 'countUsersInGroup-' . $gid . '-' . $search;
if (!$this->enabled || !$this->groupExists($gid)) {
return false;
}
$search = $this->access->escapeFilterPart($search, true);
$isMemberUid =
(strtolower($this->access->connection->ldapGroupMemberAssocAttr)
- === 'memberuid');
+ === 'memberuid');
//we need to apply the search filter
//alternatives that need to be checked:
if (!$this->enabled) {
return [];
}
- $cacheKey = 'getGroups-'.$search.'-'.$limit.'-'.$offset;
+ $cacheKey = 'getGroups-' . $search . '-' . $limit . '-' . $offset;
//Check cache before driving unnecessary searches
- \OCP\Util::writeLog('user_ldap', 'getGroups '.$cacheKey, ILogger::DEBUG);
+ \OCP\Util::writeLog('user_ldap', 'getGroups ' . $cacheKey, ILogger::DEBUG);
$ldap_groups = $this->access->connection->getFromCache($cacheKey);
if (!is_null($ldap_groups)) {
return $ldap_groups;
$this->access->connection->ldapGroupFilter,
$this->access->getFilterPartForGroupSearch($search)
]);
- \OCP\Util::writeLog('user_ldap', 'getGroups Filter '.$filter, ILogger::DEBUG);
+ \OCP\Util::writeLog('user_ldap', 'getGroups Filter ' . $filter, ILogger::DEBUG);
$ldap_groups = $this->access->fetchListOfGroups($filter,
- [$this->access->connection->ldapGroupDisplayName, 'dn'],
- $limit,
- $offset);
+ [$this->access->connection->ldapGroupDisplayName, 'dn'],
+ $limit,
+ $offset);
$ldap_groups = $this->access->nextcloudGroupNames($ldap_groups);
$this->access->connection->writeToCache($cacheKey, $ldap_groups);
$chunkLimit = min($pagingSize, $overallLimit - $chunkOffset);
$ldapGroups = $this->getGroupsChunk($search, $chunkLimit, $chunkOffset);
$nread = count($ldapGroups);
- \OCP\Util::writeLog('user_ldap', 'getGroups('.$search.'): read '.$nread.' at offset '.$chunkOffset.' (limit: '.$chunkLimit.')', ILogger::DEBUG);
+ \OCP\Util::writeLog('user_ldap', 'getGroups(' . $search . '): read ' . $nread . ' at offset ' . $chunkOffset . ' (limit: ' . $chunkLimit . ')', ILogger::DEBUG);
if ($nread) {
$allGroups = array_merge($allGroups, $ldapGroups);
$chunkOffset += $nread;
/**
* check if a group exists
+ *
* @param string $gid
* @return bool
*/
public function groupExists($gid) {
- $groupExists = $this->access->connection->getFromCache('groupExists'.$gid);
+ $groupExists = $this->access->connection->getFromCache('groupExists' . $gid);
if (!is_null($groupExists)) {
return (bool)$groupExists;
}
//only, requires more checking.
$dn = $this->access->groupname2dn($gid);
if (!$dn) {
- $this->access->connection->writeToCache('groupExists'.$gid, false);
+ $this->access->connection->writeToCache('groupExists' . $gid, false);
return false;
}
- if(!$this->access->isDNPartOfBase($dn, $this->access->connection->ldapBaseGroups)) {
- $this->access->connection->writeToCache('groupExists'.$gid, false);
+ if (!$this->access->isDNPartOfBase($dn, $this->access->connection->ldapBaseGroups)) {
+ $this->access->connection->writeToCache('groupExists' . $gid, false);
return false;
}
//if group really still exists, we will be able to read its objectclass
if (!is_array($this->access->readAttribute($dn, '', $this->access->connection->ldapGroupFilter))) {
- $this->access->connection->writeToCache('groupExists'.$gid, false);
+ $this->access->connection->writeToCache('groupExists' . $gid, false);
return false;
}
- $this->access->connection->writeToCache('groupExists'.$gid, true);
+ $this->access->connection->writeToCache('groupExists' . $gid, true);
return true;
}
- protected function filterValidGroups (array $listOfGroups): array {
+ protected function filterValidGroups(array $listOfGroups): array {
$validGroupDNs = [];
- foreach($listOfGroups as $key => $item) {
+ foreach ($listOfGroups as $key => $item) {
$dn = is_string($item) ? $item : $item['dn'][0];
$gid = $this->access->dn2groupname($dn);
- if(!$gid) {
+ if (!$gid) {
continue;
}
- if($this->groupExists($gid)) {
+ if ($this->groupExists($gid)) {
$validGroupDNs[$key] = $item;
}
}
/**
* Check if backend implements actions
+ *
* @param int $actions bitwise-or'ed actions
* @return boolean
*
/**
* Return access for LDAP interaction.
+ *
* @return Access instance of Access for LDAP interaction
*/
public function getLDAPAccess($gid) {
/**
* create a group
+ *
* @param string $gid
* @return bool
* @throws \Exception
/**
* delete a group
+ *
* @param string $gid gid of the group to delete
* @return bool
* @throws \Exception
if ($ret = $this->groupPluginManager->deleteGroup($gid)) {
#delete group in nextcloud internal db
$this->access->getGroupMapper()->unmap($gid);
- $this->access->connection->writeToCache("groupExists".$gid, false);
+ $this->access->connection->writeToCache("groupExists" . $gid, false);
}
return $ret;
}
/**
* Add a user to a group
+ *
* @param string $uid Name of the user to add to group
* @param string $gid Name of the group in which add the user
* @return bool
/**
* Removes a user from a group
+ *
* @param string $uid Name of the user to remove from group
* @param string $gid Name of the group from which remove the user
* @return bool
/**
* Gets group details
+ *
* @param string $gid Name of the group
* @return array | false
* @throws \Exception
* Return LDAP connection resource from a cloned connection.
* The cloned connection needs to be closed manually.
* of the current access.
+ *
* @param string $gid
* @return resource of the LDAP connection
*/
/**
* Constructor
+ *
* @param string[] $serverConfigPrefixes array containing the config Prefixes
*/
public function __construct($serverConfigPrefixes, ILDAPWrapper $ldap, GroupPluginManager $groupPluginManager) {
/**
* Tries the backends one after the other until a positive result is returned from the specified method
+ *
* @param string $gid the gid connected to the request
* @param string $method the method of the group backend that shall be called
* @param array $parameters an array of parameters to be passed
$cacheKey = $this->getGroupCacheKey($gid);
foreach ($this->backends as $configPrefix => $backend) {
if ($result = call_user_func_array([$backend, $method], $parameters)) {
- if(!$this->isSingleBackend()) {
+ if (!$this->isSingleBackend()) {
$this->writeToCache($cacheKey, $configPrefix);
}
return $result;
/**
* Asks the backend connected to the server that supposely takes care of the gid from the request.
+ *
* @param string $gid the gid connected to the request
* @param string $method the method of the group backend that shall be called
* @param array $parameters an array of parameters to be passed
/**
* is user in group?
+ *
* @param string $uid uid of the user
* @param string $gid gid of the group
* @return bool
/**
* Get all groups a user belongs to
+ *
* @param string $uid Name of the user
* @return string[] with group names
*
/**
* get a list of all users in a group
+ *
* @return string[] with user ids
*/
public function usersInGroup($gid, $search = '', $limit = -1, $offset = 0) {
/**
* delete a group
+ *
* @param string $gid gid of the group to delete
* @return bool
*/
/**
* Add a user to a group
+ *
* @param string $uid Name of the user to add to group
* @param string $gid Name of the group in which add the user
* @return bool
/**
* Removes a user from a group
+ *
* @param string $uid Name of the user to remove from group
* @param string $gid Name of the group from which remove the user
* @return bool
/**
* returns the number of users in a group, who match the search term
+ *
* @param string $gid the internal group name
* @param string $search optional, a search string
* @return int|bool
/**
* get an array with group details
+ *
* @param string $gid
* @return array|false
*/
/**
* get a list of all groups
+ *
* @return string[] with group names
*
* Returns a list with all groups
/**
* check if a group exists
+ *
* @param string $gid
* @return bool
*/
/**
* Check if backend implements actions
+ *
* @param int $actions bitwise-or'ed actions
* @return boolean
*
/**
* Return access for LDAP interaction.
+ *
* @param string $gid
* @return Access instance of Access for LDAP interaction
*/
/**
* Return a new LDAP connection for the specified group.
* The connection needs to be closed manually.
+ *
* @param string $gid
* @return resource of the LDAP connection
*/
/**
* returns prefixes for each saved LDAP/AD server configuration.
+ *
* @param bool $activeConfigurations optional, whether only active configuration shall be
* retrieved, defaults to false
* @return array with a list of the available prefixes
/**
*
* determines the host for every configured connection
+ *
* @return array an array with configprefix as keys
*
*/
/**
* deletes a given saved LDAP/AD server configuration.
+ *
* @param string $prefix the configuration prefix of the config to delete
* @return bool true on success, false otherwise
*/
DELETE
FROM `*PREFIX*appconfig`
WHERE `configkey` LIKE ?
- '.$saveOtherConfigurations.'
+ ' . $saveOtherConfigurations . '
AND `appid` = \'user_ldap\'
AND `configkey` NOT IN (\'enabled\', \'installed_version\', \'types\', \'bgjUpdateGroupsLastRun\')
');
- $delRows = $query->execute([$prefix.'%']);
+ $delRows = $query->execute([$prefix . '%']);
if ($delRows === null) {
return false;
/**
* checks whether there is one or more disabled LDAP configurations
- * @throws \Exception
+ *
* @return bool
+ * @throws \Exception
*/
public function haveDisabledConfigurations() {
$all = $this->getServerConfigurationPrefixes(false);
/**
* extracts the domain from a given URL
+ *
* @param string $url the URL
* @return string|false domain as string on success, false otherwise
*/
/**
* sanitizes a DN received from the LDAP server
+ *
* @param array $dn the DN in question
* @return array|string the sanitized DN
*/
return $result;
}
- if(!is_string($dn)) {
+ if (!is_string($dn)) {
throw new \LogicException('String expected ' . \gettype($dn) . ' given');
}
if (($sanitizedDn = $this->sanitizeDnCache->get($dn)) !== null) {
- return $sanitizedDn;
+ return $sanitizedDn;
}
//OID sometimes gives back DNs with whitespace after the comma
'\;' => '\5c3B',
'\"' => '\5c22',
'\#' => '\5c23',
- '(' => '\28',
- ')' => '\29',
- '*' => '\2A',
+ '(' => '\28',
+ ')' => '\29',
+ '*' => '\2A',
];
$sanitizedDn = str_replace(array_keys($replacements), array_values($replacements), $sanitizedDn);
$this->sanitizeDnCache->set($dn, $sanitizedDn);
/**
* converts a stored DN so it can be used as base parameter for LDAP queries, internally we store them for usage in LDAP filters
+ *
* @param string $dn the DN
* @return string
*/
$userSession = \OC::$server->getUserSession();
$userPluginManager = \OC::$server->query('LDAPUserPluginManager');
- $userBackend = new User_Proxy(
+ $userBackend = new User_Proxy(
$configPrefixes, $ldapWrapper, $ocConfig, $notificationManager, $userSession, $userPluginManager
);
$uid = $userBackend->loginName2UserName($param['uid']);
/**
* Class AbstractMapping
-*
+ *
* @package OCA\User_LDAP\Mapping
*/
abstract class AbstractMapping {
/**
* returns the DB table name which holds the mappings
+ *
* @return string
*/
abstract protected function getTableName(bool $includePrefix = true);
/**
* checks whether a provided string represents an existing table col
+ *
* @param string $col
* @return bool
*/
/**
* Gets the value of one column based on a provided value of another column
+ *
* @param string $fetchCol
* @param string $compareCol
* @param string $search
- * @throws \Exception
* @return string|false
+ * @throws \Exception
*/
protected function getXbyY($fetchCol, $compareCol, $search) {
if (!$this->isColNameValid($fetchCol)) {
}
$query = $this->dbc->prepare('
SELECT `' . $fetchCol . '`
- FROM `'. $this->getTableName() .'`
+ FROM `' . $this->getTableName() . '`
WHERE `' . $compareCol . '` = ?
');
/**
* Performs a DELETE or UPDATE query to the database.
+ *
* @param \Doctrine\DBAL\Driver\Statement $query
* @param array $parameters
* @return bool true if at least one row was modified, false otherwise
/**
* Gets the LDAP DN based on the provided name.
* Replaces Access::ocname2dn
+ *
* @param string $name
* @return string|false
*/
public function getDNByName($name) {
$dn = array_search($name, $this->cache);
- if($dn === false) {
+ if ($dn === false) {
$dn = $this->getXbyY('ldap_dn', 'owncloud_name', $name);
$this->cache[$dn] = $name;
}
/**
* Updates the DN based on the given UUID
+ *
* @param string $fdn
* @param string $uuid
* @return bool
$r = $this->modify($query, [$fdn, $uuid]);
- if($r && is_string($oldDn) && isset($this->cache[$oldDn])) {
+ if ($r && is_string($oldDn) && isset($this->cache[$oldDn])) {
$this->cache[$fdn] = $this->cache[$oldDn];
unset($this->cache[$oldDn]);
}
/**
* Gets the name based on the provided LDAP DN.
+ *
* @param string $fdn
* @return string|false
*/
public function getNameByDN($fdn) {
- if(!isset($this->cache[$fdn])) {
+ if (!isset($this->cache[$fdn])) {
$this->cache[$fdn] = $this->getXbyY('owncloud_name', 'ldap_dn', $fdn);
}
return $this->cache[$fdn];
/**
* Searches mapped names by the giving string in the name column
+ *
* @param string $search
* @param string $prefixMatch
* @param string $postfixMatch
public function getNamesBySearch($search, $prefixMatch = "", $postfixMatch = "") {
$query = $this->dbc->prepare('
SELECT `owncloud_name`
- FROM `'. $this->getTableName() .'`
+ FROM `' . $this->getTableName() . '`
WHERE `owncloud_name` LIKE ?
');
- $res = $query->execute([$prefixMatch.$this->dbc->escapeLikeParameter($search).$postfixMatch]);
+ $res = $query->execute([$prefixMatch . $this->dbc->escapeLikeParameter($search) . $postfixMatch]);
$names = [];
if ($res !== false) {
while ($row = $query->fetch()) {
/**
* Gets the name based on the provided LDAP UUID.
+ *
* @param string $uuid
* @return string|false
*/
/**
* Gets the UUID based on the provided LDAP DN
+ *
* @param string $dn
* @return false|string
* @throws \Exception
/**
* gets a piece of the mapping list
+ *
* @param int $offset
* @param int $limit
* @return array
/**
* attempts to map the given entry
+ *
* @param string $fdn fully distinguished name (from LDAP)
* @param string $name
* @param string $uuid a unique identifier as used in LDAP
}
$row = [
- 'ldap_dn' => $fdn,
- 'owncloud_name' => $name,
+ 'ldap_dn' => $fdn,
+ 'owncloud_name' => $name,
'directory_uuid' => $uuid
];
try {
$result = $this->dbc->insertIfNotExist($this->getTableName(), $row);
- if((bool)$result === true) {
+ if ((bool)$result === true) {
$this->cache[$fdn] = $name;
}
// insertIfNotExist returns values as int
/**
* removes a mapping based on the owncloud_name of the entry
+ *
* @param string $name
* @return bool
*/
public function unmap($name) {
$query = $this->dbc->prepare('
- DELETE FROM `'. $this->getTableName() .'`
+ DELETE FROM `' . $this->getTableName() . '`
WHERE `owncloud_name` = ?');
return $this->modify($query, [$name]);
/**
* Truncate's the mapping table
+ *
* @return bool
*/
public function clear() {
abstract class Proxy {
private static $accesses = [];
private $ldap = null;
- /** @var bool */
+ /** @var bool */
private $isSingleBackend;
/** @var \OCP\ICache|null */
static $coreNotificationManager;
if ($fs === null) {
$ocConfig = \OC::$server->getConfig();
- $fs = new FilesystemHelper();
- $log = new LogWrapper();
- $avatarM = \OC::$server->getAvatarManager();
- $db = \OC::$server->getDatabaseConnection();
- $userMap = new UserMapping($db);
+ $fs = new FilesystemHelper();
+ $log = new LogWrapper();
+ $avatarM = \OC::$server->getAvatarManager();
+ $db = \OC::$server->getDatabaseConnection();
+ $userMap = new UserMapping($db);
$groupMap = new GroupMapping($db);
$coreUserManager = \OC::$server->getUserManager();
$coreNotificationManager = \OC::$server->getNotificationManager();
* @return string
*/
protected function getUserCacheKey($uid) {
- return 'user-'.$uid.'-lastSeenOn';
+ return 'user-' . $uid . '-lastSeenOn';
}
/**
* @return string
*/
protected function getGroupCacheKey($gid) {
- return 'group-'.$gid.'-lastSeenOn';
+ return 'group-' . $gid . '-lastSeenOn';
}
/**
abstract protected function activeBackends(): int;
- protected function isSingleBackend(): bool{
- if($this->isSingleBackend === null) {
+ protected function isSingleBackend(): bool {
+ if ($this->isSingleBackend === null) {
$this->isSingleBackend = $this->activeBackends() === 1;
}
return $this->isSingleBackend;
/**
* Takes care of the request to the User backend
+ *
* @param string $id
* @param string $method string, the method of the user backend that shall be called
* @param array $parameters an array of parameters to be passed
if ($key === null) {
return $prefix;
}
- return $prefix.hash('sha256', $key);
+ return $prefix . hash('sha256', $key);
}
/**
if ($this->cache === null) {
return;
}
- $key = $this->getCacheKey($key);
+ $key = $this->getCacheKey($key);
$value = base64_encode(json_encode($value));
$this->cache->set($key, $value, 2592000);
}
/**
* Tries the backends one after the other until a positive result is returned from the specified method
+ *
* @param string $uid the uid connected to the request
* @param string $method the method of the user backend that shall be called
* @param array $parameters an array of parameters to be passed
$instance = $this->getAccess($configPrefix);
}
if ($result = call_user_func_array([$instance, $method], $parameters)) {
- if(!$this->isSingleBackend()) {
+ if (!$this->isSingleBackend()) {
$this->writeToCache($cacheKey, $configPrefix);
}
return $result;
/**
* Asks the backend connected to the server that supposely takes care of the uid from the request.
+ *
* @param string $uid the uid connected to the request
* @param string $method the method of the user backend that shall be called
* @param array $parameters an array of parameters to be passed
/**
* Check if backend implements actions
+ *
* @param int $actions bitwise-or'ed actions
* @return boolean
*
/**
* Backend name to be shown in user management
+ *
* @return string the name of the backend to be shown
*/
public function getBackendName() {
/**
* check if a user exists
+ *
* @param string $uid the username
* @return boolean
*/
/**
* check if a user exists on LDAP
+ *
* @param string|\OCA\User_LDAP\User\User $user either the Nextcloud user
* name or an instance of that user
* @return boolean
/**
* Check if the password is correct
+ *
* @param string $uid The username
* @param string $password The password
* @return bool
$id = 'LOGINNAME,' . $loginName;
return $this->handleRequest($id, 'loginName2UserName', [$loginName]);
}
-
+
/**
* returns the username for the given LDAP DN, if available
*
/**
* get the user's home directory
+ *
* @param string $uid the username
* @return boolean
*/
/**
* get display name of the user
+ *
* @param string $uid user ID of the user
* @return string display name
*/
/**
* checks whether the user is allowed to change his avatar in Nextcloud
+ *
* @param string $uid the Nextcloud user name
* @return boolean either the user can or cannot
*/
/**
* Get a list of all display names and user ids.
+ *
* @param string $search
* @param string|null $limit
* @param string|null $offset
/**
* delete a user
+ *
* @param string $uid The username of the user to delete
* @return bool
*
public function deleteUser($uid) {
return $this->handleRequest($uid, 'deleteUser', [$uid]);
}
-
+
/**
* Set password
+ *
* @param string $uid The username
* @param string $password The new password
* @return bool
/**
* Count the number of users
+ *
* @return int|bool
*/
public function countUsers() {
/**
* Return access for LDAP interaction.
+ *
* @param string $uid
* @return Access instance of Access for LDAP interaction
*/
public function getLDAPAccess($uid) {
return $this->handleRequest($uid, 'getLDAPAccess', [$uid]);
}
-
+
/**
* Return a new LDAP connection for the specified user.
* The connection needs to be closed manually.
+ *
* @param string $uid
* @return resource of the LDAP connection
*/
/**
* Creates a new user in LDAP
+ *
* @param $username
* @param $password
* @return bool
*/
public function createUser($username, $password) {
- return $this->handleRequest($username, 'createUser', [$username,$password]);
+ return $this->handleRequest($username, 'createUser', [$username, $password]);
}
}
$conMethods = get_class_methods('\OCA\User_LDAP\Connection');
$accMethods = get_class_methods('\OCA\User_LDAP\Access');
}
- $lw = $this->createMock(ILDAPWrapper::class);
+ $lw = $this->createMock(ILDAPWrapper::class);
$connector = $this->getMockBuilder('\OCA\User_LDAP\Connection')
->setMethods($conMethods)
->setConstructorArgs([$lw, null, null])
->method('isDNPartOfBase')
->willReturn(true);
- $groupBackend = new GroupLDAP($access,$pluginManager);
+ $groupBackend = new GroupLDAP($access, $pluginManager);
$users = $groupBackend->countUsersInGroup('group', '3');
$this->assertSame(2, $users);
public function testCountUsersWithPlugin() {
/** @var GroupPluginManager|\PHPUnit_Framework_MockObject_MockObject $pluginManager */
$pluginManager = $this->getMockBuilder('\OCA\User_LDAP\GroupPluginManager')
- ->setMethods(['implementsActions','countUsersInGroup'])
+ ->setMethods(['implementsActions', 'countUsersInGroup'])
->getMock();
$pluginManager->expects($this->once())
$ldap = new GroupLDAP($access, $pluginManager);
- $this->assertEquals($ldap->countUsersInGroup('gid', 'search'),42);
+ $this->assertEquals($ldap->countUsersInGroup('gid', 'search'), 42);
}
public function testGidNumber2NameSuccess() {
$uid = 'someUser';
$gid = 'someGroup';
- $cacheKey = 'inGroup'.$uid.':'.$gid;
+ $cacheKey = 'inGroup' . $uid . ':' . $gid;
$access->connection->expects($this->once())
->method('getFromCache')
->willReturn([$group1, $group2]);
$access->expects($this->any())
->method('dn2groupname')
- ->willReturnCallback(function(string $dn) {
+ ->willReturnCallback(function (string $dn) {
return ldap_explode_dn($dn, 1)[0];
});
$access->expects($this->any())
->method('groupname2dn')
->willReturnCallback(function (string $gid) use ($group1, $group2) {
- if($gid === $group1['cn']) {
+ if ($gid === $group1['cn']) {
return $group1['dn'][0];
}
- if($gid === $group2['cn']) {
+ if ($gid === $group2['cn']) {
return $group2['dn'][0];
}
});
public function testCreateGroupWithPlugin() {
/** @var GroupPluginManager|\PHPUnit_Framework_MockObject_MockObject $pluginManager */
$pluginManager = $this->getMockBuilder('\OCA\User_LDAP\GroupPluginManager')
- ->setMethods(['implementsActions','createGroup'])
+ ->setMethods(['implementsActions', 'createGroup'])
->getMock();
$pluginManager->expects($this->once())
$ldap = new GroupLDAP($access, $pluginManager);
- $this->assertEquals($ldap->createGroup('gid'),true);
+ $this->assertEquals($ldap->createGroup('gid'), true);
}
public function testDeleteGroupWithPlugin() {
/** @var GroupPluginManager|\PHPUnit_Framework_MockObject_MockObject $pluginManager */
$pluginManager = $this->getMockBuilder('\OCA\User_LDAP\GroupPluginManager')
- ->setMethods(['implementsActions','deleteGroup'])
+ ->setMethods(['implementsActions', 'deleteGroup'])
->getMock();
$pluginManager->expects($this->once())
$ldap = new GroupLDAP($access, $pluginManager);
- $this->assertEquals($ldap->deleteGroup('gid'),'result');
+ $this->assertEquals($ldap->deleteGroup('gid'), 'result');
}
public function testAddToGroupWithPlugin() {
/** @var GroupPluginManager|\PHPUnit_Framework_MockObject_MockObject $pluginManager */
$pluginManager = $this->getMockBuilder('\OCA\User_LDAP\GroupPluginManager')
- ->setMethods(['implementsActions','addToGroup'])
+ ->setMethods(['implementsActions', 'addToGroup'])
->getMock();
$pluginManager->expects($this->once())
$ldap = new GroupLDAP($access, $pluginManager);
- $this->assertEquals($ldap->addToGroup('uid', 'gid'),'result');
+ $this->assertEquals($ldap->addToGroup('uid', 'gid'), 'result');
}
public function testRemoveFromGroupWithPlugin() {
/** @var GroupPluginManager|\PHPUnit_Framework_MockObject_MockObject $pluginManager */
$pluginManager = $this->getMockBuilder('\OCA\User_LDAP\GroupPluginManager')
- ->setMethods(['implementsActions','removeFromGroup'])
+ ->setMethods(['implementsActions', 'removeFromGroup'])
->getMock();
$pluginManager->expects($this->once())
$ldap = new GroupLDAP($access, $pluginManager);
- $this->assertEquals($ldap->removeFromGroup('uid', 'gid'),'result');
+ $this->assertEquals($ldap->removeFromGroup('uid', 'gid'), 'result');
}
public function testGetGroupDetailsWithPlugin() {
/** @var GroupPluginManager|\PHPUnit_Framework_MockObject_MockObject $pluginManager */
$pluginManager = $this->getMockBuilder('\OCA\User_LDAP\GroupPluginManager')
- ->setMethods(['implementsActions','getGroupDetails'])
+ ->setMethods(['implementsActions', 'getGroupDetails'])
->getMock();
$pluginManager->expects($this->once())
$ldap = new GroupLDAP($access, $pluginManager);
- $this->assertEquals($ldap->getGroupDetails('gid'),'result');
+ $this->assertEquals($ldap->getGroupDetails('gid'), 'result');
}
projects / nextcloud-server.git / commitdiff