mbk-lab
/
nextcloud
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

LDAP simplify User_Proxy and Group_Proxy signatures 

- make User_Proxy and Group_Proxy easy to instantiate
- simplify dependent code
- move commands to info.xml
- make UpdateGroups job class non-static

Signed-off-by: Arthur Schiwon <blizzz@arthur-schiwon.de>
This commit is contained in:
Arthur Schiwon 2020-10-22 11:25:33 +02:00
parent 872f03209c
commit 86e5e7d927
No known key found for this signature in database
GPG Key ID: 7424F1874854DF23
18 changed files with 126 additions and 309 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
apps/user_ldap/appinfo/info.xml
View File

@ -40,6 +40,17 @@ A user logs into Nextcloud with their LDAP or AD credentials, and is granted acc
</post-migration> </post-migration>
</repair-steps> </repair-steps>
<commands>
<command>OCA\User_LDAP\Command\CheckUser</command>
<command>OCA\User_LDAP\Command\CreateEmptyConfig</command>
<command>OCA\User_LDAP\Command\DeleteConfig</command>
<command>OCA\User_LDAP\Command\Search</command>
<command>OCA\User_LDAP\Command\SetConfig</command>
<command>OCA\User_LDAP\Command\ShowConfig</command>
<command>OCA\User_LDAP\Command\ShowRemnants</command>
<command>OCA\User_LDAP\Command\TestConfig</command>
</commands>
<settings> <settings>
<admin>OCA\User_LDAP\Settings\Admin</admin> <admin>OCA\User_LDAP\Settings\Admin</admin>
<admin-section>OCA\User_LDAP\Settings\Section</admin-section> <admin-section>OCA\User_LDAP\Settings\Section</admin-section>

61
apps/user_ldap/appinfo/register_command.php
View File

@ -1,61 +0,0 @@
<?php
/**
* @copyright Copyright (c) 2016, ownCloud, Inc.
*
* @author Arthur Schiwon <blizzz@arthur-schiwon.de>
* @author Joas Schilling <coding@schilljs.com>
* @author Morris Jobke <hey@morrisjobke.de>
* @author Roeland Jago Douma <roeland@famdouma.nl>
* @author Roger Szabo <roger.szabo@web.de>
* @author Vinicius Cubas Brand <vinicius@eita.org.br>
*
* @license AGPL-3.0
*
* This code is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License, version 3,
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License, version 3,
* along with this program. If not, see <http://www.gnu.org/licenses/>
*
*/
use OCA\User_LDAP\Helper;
use OCA\User_LDAP\LDAP;
use OCA\User_LDAP\User_Proxy;
use OCA\User_LDAP\Mapping\UserMapping;
use OCA\User_LDAP\User\DeletedUsersIndex;
$dbConnection = \OC::$server->getDatabaseConnection();
$userMapping = new UserMapping($dbConnection);
$helper = new Helper(\OC::$server->getConfig());
$ocConfig = \OC::$server->getConfig();
$uBackend = new User_Proxy(
$helper->getServerConfigurationPrefixes(true),
new LDAP(),
$ocConfig,
\OC::$server->getNotificationManager(),
\OC::$server->getUserSession(),
\OC::$server->query(\OCA\User_LDAP\UserPluginManager::class)
);
$deletedUsersIndex = new DeletedUsersIndex(
$ocConfig, $dbConnection, $userMapping
);
$application->add(new OCA\User_LDAP\Command\ShowConfig($helper));
$application->add(new OCA\User_LDAP\Command\SetConfig());
$application->add(new OCA\User_LDAP\Command\TestConfig());
$application->add(new OCA\User_LDAP\Command\CreateEmptyConfig($helper));
$application->add(new OCA\User_LDAP\Command\DeleteConfig($helper));
$application->add(new OCA\User_LDAP\Command\Search($ocConfig));
$application->add(new OCA\User_LDAP\Command\ShowRemnants(
$deletedUsersIndex, \OC::$server->getDateTimeFormatter())
);
$application->add(new OCA\User_LDAP\Command\CheckUser(
$uBackend, $helper, $deletedUsersIndex, $userMapping)
);

27
apps/user_ldap/lib/AppInfo/Application.php
View File

@ -46,11 +46,9 @@ use OCP\AppFramework\Bootstrap\IBootstrap;
use OCP\AppFramework\Bootstrap\IRegistrationContext; use OCP\AppFramework\Bootstrap\IRegistrationContext;
use OCP\AppFramework\IAppContainer; use OCP\AppFramework\IAppContainer;
use OCP\EventDispatcher\IEventDispatcher; use OCP\EventDispatcher\IEventDispatcher;
use OCP\IConfig;
use OCP\IGroupManager; use OCP\IGroupManager;
use OCP\IL10N; use OCP\IL10N;
use OCP\IServerContainer; use OCP\IServerContainer;
use OCP\IUserSession;
use OCP\Notification\IManager as INotificationManager; use OCP\Notification\IManager as INotificationManager;
use Symfony\Component\EventDispatcher\EventDispatcherInterface; use Symfony\Component\EventDispatcher\EventDispatcherInterface;
@ -86,28 +84,23 @@ class Application extends App implements IBootstrap {
} }
public function boot(IBootContext $context): void { public function boot(IBootContext $context): void {
$context->injectFn(function (IConfig $config, $context->injectFn(function (
INotificationManager $notificationManager, INotificationManager $notificationManager,
IUserSession $userSession, IAppContainer $appContainer,
IAppContainer $appContainer, EventDispatcherInterface $legacyDispatcher,
EventDispatcherInterface $legacyDispatcher, IEventDispatcher $dispatcher,
IEventDispatcher $dispatcher, IGroupManager $groupManager,
IGroupManager $groupManager) { User_Proxy $userBackend,
$helper = new Helper($config); Group_Proxy $groupBackend,
Helper $helper
) {
$configPrefixes = $helper->getServerConfigurationPrefixes(true); $configPrefixes = $helper->getServerConfigurationPrefixes(true);
if (count($configPrefixes) > 0) { if (count($configPrefixes) > 0) {
$ldapWrapper = new LDAP();
$notificationManager->registerNotifierService(Notifier::class); $notificationManager->registerNotifierService(Notifier::class);
$userPluginManager = $appContainer->get(UserPluginManager::class); $userPluginManager = $appContainer->get(UserPluginManager::class);
$groupPluginManager = $appContainer->get(GroupPluginManager::class); $groupPluginManager = $appContainer->get(GroupPluginManager::class);
$userBackend = new User_Proxy(
$configPrefixes, $ldapWrapper, $config, $notificationManager, $userSession, $userPluginManager
);
$groupBackend = new Group_Proxy($configPrefixes, $ldapWrapper, $groupPluginManager);
\OC_User::useBackend($userBackend); \OC_User::useBackend($userBackend);
$groupManager->addBackend($groupBackend); $groupManager->addBackend($groupBackend);

26
apps/user_ldap/lib/Command/Search.php
View File

@ -29,11 +29,9 @@
namespace OCA\User_LDAP\Command; namespace OCA\User_LDAP\Command;
use OCA\User_LDAP\Group_Proxy; use OCA\User_LDAP\Group_Proxy;
use OCA\User_LDAP\GroupPluginManager;
use OCA\User_LDAP\Helper; use OCA\User_LDAP\Helper;
use OCA\User_LDAP\LDAP; use OCA\User_LDAP\LDAP;
use OCA\User_LDAP\User_Proxy; use OCA\User_LDAP\User_Proxy;
use OCA\User_LDAP\UserPluginManager;
use OCP\IConfig; use OCP\IConfig;
use Symfony\Component\Console\Command\Command; use Symfony\Component\Console\Command\Command;
@ -45,13 +43,16 @@ use Symfony\Component\Console\Output\OutputInterface;
class Search extends Command { class Search extends Command {
/** @var \OCP\IConfig */ /** @var \OCP\IConfig */
protected $ocConfig; protected $ocConfig;
/** @var User_Proxy */
private $userProxy;
/** @var Group_Proxy */
private $groupProxy;
/** public function __construct(IConfig $ocConfig, User_Proxy $userProxy, Group_Proxy $groupProxy) {
* @param \OCP\IConfig $ocConfig
*/
public function __construct(IConfig $ocConfig) {
$this->ocConfig = $ocConfig;
parent::__construct(); parent::__construct();
$this->ocConfig = $ocConfig;
$this->userProxy = $userProxy;
$this->groupProxy = $groupProxy;
} }
protected function configure() { protected function configure() {
@ -117,7 +118,7 @@ class Search extends Command {
$this->validateOffsetAndLimit($offset, $limit); $this->validateOffsetAndLimit($offset, $limit);
if ($input->getOption('group')) { if ($input->getOption('group')) {
$proxy = new Group_Proxy($configPrefixes, $ldapWrapper, \OC::$server->query(GroupPluginManager::class)); $proxy = $this->groupProxy;
$getMethod = 'getGroups'; $getMethod = 'getGroups';
$printID = false; $printID = false;
// convert the limit of groups to null. This will show all the groups available instead of // convert the limit of groups to null. This will show all the groups available instead of
@ -126,14 +127,7 @@ class Search extends Command {
$limit = null; $limit = null;
} }
} else { } else {
$proxy = new User_Proxy( $proxy = $this->userProxy;
$configPrefixes,
$ldapWrapper,
$this->ocConfig,
\OC::$server->getNotificationManager(),
\OC::$server->getUserSession(),
\OC::$server->query(UserPluginManager::class)
);
$getMethod = 'getDisplayNames'; $getMethod = 'getDisplayNames';
$printID = true; $printID = true;
} }

8
apps/user_ldap/lib/Group_Proxy.php
View File

@ -34,13 +34,9 @@ class Group_Proxy extends Proxy implements \OCP\GroupInterface, IGroupLDAP, IGet
private $backends = []; private $backends = [];
private $refBackend = null; private $refBackend = null;
/** public function __construct(Helper $helper, ILDAPWrapper $ldap, GroupPluginManager $groupPluginManager) {
* Constructor
*
* @param string[] $serverConfigPrefixes array containing the config Prefixes
*/
public function __construct($serverConfigPrefixes, ILDAPWrapper $ldap, GroupPluginManager $groupPluginManager) {
parent::__construct($ldap); parent::__construct($ldap);
$serverConfigPrefixes = $helper->getServerConfigurationPrefixes(true);
foreach ($serverConfigPrefixes as $configPrefix) { foreach ($serverConfigPrefixes as $configPrefix) {
$this->backends[$configPrefix] = $this->backends[$configPrefix] =
new \OCA\User_LDAP\Group_LDAP($this->getAccess($configPrefix), $groupPluginManager); new \OCA\User_LDAP\Group_LDAP($this->getAccess($configPrefix), $groupPluginManager);

26
apps/user_ldap/lib/Helper.php
View File

@ -76,7 +76,7 @@ class Helper {
* except the default (first) server shall be connected to. * except the default (first) server shall be connected to.
* *
*/ */
public function getServerConfigurationPrefixes($activeConfigurations = false) { public function getServerConfigurationPrefixes($activeConfigurations = false): array {
$referenceConfigkey = 'ldap_configuration_active'; $referenceConfigkey = 'ldap_configuration_active';
$keys = $this->getServersConfig($referenceConfigkey); $keys = $this->getServersConfig($referenceConfigkey);
@ -188,18 +188,11 @@ class Helper {
/** /**
* checks whether there is one or more disabled LDAP configurations * checks whether there is one or more disabled LDAP configurations
*
* @return bool
* @throws \Exception
*/ */
public function haveDisabledConfigurations() { public function haveDisabledConfigurations(): bool {
$all = $this->getServerConfigurationPrefixes(false); $all = $this->getServerConfigurationPrefixes(false);
$active = $this->getServerConfigurationPrefixes(true); $active = $this->getServerConfigurationPrefixes(true);
if (!is_array($all) || !is_array($active)) {
throw new \Exception('Unexpected Return Value');
}
return count($all) !== count($active) || count($all) === 0; return count($all) !== count($active) || count($all) === 0;
} }
@ -312,20 +305,7 @@ class Helper {
throw new \Exception('key uid is expected to be set in $param'); throw new \Exception('key uid is expected to be set in $param');
} }
//ain't it ironic? $userBackend = \OC::$server->get(User_Proxy::class);
$helper = new Helper(\OC::$server->getConfig());
$configPrefixes = $helper->getServerConfigurationPrefixes(true);
$ldapWrapper = new LDAP();
$ocConfig = \OC::$server->getConfig();
$notificationManager = \OC::$server->getNotificationManager();
$userSession = \OC::$server->getUserSession();
$userPluginManager = \OC::$server->query(UserPluginManager::class);
$userBackend = new User_Proxy(
$configPrefixes, $ldapWrapper, $ocConfig, $notificationManager, $userSession, $userPluginManager
);
$uid = $userBackend->loginName2UserName($param['uid']); $uid = $userBackend->loginName2UserName($param['uid']);
if ($uid !== false) { if ($uid !== false) {
$param['uid'] = $uid; $param['uid'] = $uid;

13
apps/user_ldap/lib/Jobs/CleanUp.php
View File

@ -35,7 +35,6 @@ use OCA\User_LDAP\Mapping\UserMapping;
use OCA\User_LDAP\User\DeletedUsersIndex; use OCA\User_LDAP\User\DeletedUsersIndex;
use OCA\User_LDAP\User_LDAP; use OCA\User_LDAP\User_LDAP;
use OCA\User_LDAP\User_Proxy; use OCA\User_LDAP\User_Proxy;
use OCA\User_LDAP\UserPluginManager;
/** /**
* Class CleanUp * Class CleanUp
@ -69,10 +68,11 @@ class CleanUp extends TimedJob {
/** @var DeletedUsersIndex */ /** @var DeletedUsersIndex */
protected $dui; protected $dui;
public function __construct() { public function __construct(User_Proxy $userBackend) {
$minutes = \OC::$server->getConfig()->getSystemValue( $minutes = \OC::$server->getConfig()->getSystemValue(
'ldapUserCleanupInterval', (string)$this->defaultIntervalMin); 'ldapUserCleanupInterval', (string)$this->defaultIntervalMin);
$this->setInterval((int)$minutes * 60); $this->setInterval((int)$minutes * 60);
$this->userBackend = $userBackend;
} }
/** /**
@ -99,15 +99,6 @@ class CleanUp extends TimedJob {
if (isset($arguments['userBackend'])) { if (isset($arguments['userBackend'])) {
$this->userBackend = $arguments['userBackend']; $this->userBackend = $arguments['userBackend'];
} else {
$this->userBackend = new User_Proxy(
$this->ldapHelper->getServerConfigurationPrefixes(true),
new LDAP(),
$this->ocConfig,
\OC::$server->getNotificationManager(),
\OC::$server->getUserSession(),
\OC::$server->query(UserPluginManager::class)
);
} }
if (isset($arguments['db'])) { if (isset($arguments['db'])) {

104
apps/user_ldap/lib/Jobs/UpdateGroups.php
View File

@ -33,42 +33,36 @@
namespace OCA\User_LDAP\Jobs; namespace OCA\User_LDAP\Jobs;
use OCA\User_LDAP\Access; use OC\BackgroundJob\TimedJob;
use OCA\User_LDAP\Connection; use OCA\User_LDAP\Group_Proxy;
use OCA\User_LDAP\FilesystemHelper;
use OCA\User_LDAP\GroupPluginManager;
use OCA\User_LDAP\Helper;
use OCA\User_LDAP\LDAP;
use OCA\User_LDAP\LogWrapper;
use OCA\User_LDAP\Mapping\GroupMapping;
use OCA\User_LDAP\Mapping\UserMapping;
use OCA\User_LDAP\User\Manager;
use OCP\EventDispatcher\IEventDispatcher; use OCP\EventDispatcher\IEventDispatcher;
use OCP\Group\Events\UserAddedEvent; use OCP\Group\Events\UserAddedEvent;
use OCP\Group\Events\UserRemovedEvent; use OCP\Group\Events\UserRemovedEvent;
use OCP\ILogger; use OCP\ILogger;
class UpdateGroups extends \OC\BackgroundJob\TimedJob { class UpdateGroups extends TimedJob {
private static $groupsFromDB; private $groupsFromDB;
private static $groupBE; /** @var Group_Proxy */
private $groupBackend;
public function __construct() { public function __construct(Group_Proxy $groupBackend) {
$this->interval = self::getRefreshInterval(); $this->interval = $this->getRefreshInterval();
$this->groupBackend = $groupBackend;
} }
/** /**
* @param mixed $argument * @param mixed $argument
*/ */
public function run($argument) { public function run($argument) {
self::updateGroups(); $this->updateGroups();
} }
public static function updateGroups() { public function updateGroups() {
\OCP\Util::writeLog('user_ldap', 'Run background job "updateGroups"', ILogger::DEBUG); \OCP\Util::writeLog('user_ldap', 'Run background job "updateGroups"', ILogger::DEBUG);
$knownGroups = array_keys(self::getKnownGroups()); $knownGroups = array_keys($this->getKnownGroups());
$actualGroups = self::getGroupBE()->getGroups(); $actualGroups = $this->groupBackend->getGroups();
if (empty($actualGroups) && empty($knownGroups)) { if (empty($actualGroups) && empty($knownGroups)) {
\OCP\Util::writeLog('user_ldap', \OCP\Util::writeLog('user_ldap',
@ -77,9 +71,9 @@ class UpdateGroups extends \OC\BackgroundJob\TimedJob {
return; return;
} }
self::handleKnownGroups(array_intersect($actualGroups, $knownGroups)); $this->handleKnownGroups(array_intersect($actualGroups, $knownGroups));
self::handleCreatedGroups(array_diff($actualGroups, $knownGroups)); $this->handleCreatedGroups(array_diff($actualGroups, $knownGroups));
self::handleRemovedGroups(array_diff($knownGroups, $actualGroups)); $this->handleRemovedGroups(array_diff($knownGroups, $actualGroups));
\OCP\Util::writeLog('user_ldap', 'bgJ "updateGroups" – Finished.', ILogger::DEBUG); \OCP\Util::writeLog('user_ldap', 'bgJ "updateGroups" – Finished.', ILogger::DEBUG);
} }
@ -87,7 +81,7 @@ class UpdateGroups extends \OC\BackgroundJob\TimedJob {
/** /**
* @return int * @return int
*/ */
private static function getRefreshInterval() { private function getRefreshInterval() {
//defaults to every hour //defaults to every hour
return \OC::$server->getConfig()->getAppValue('user_ldap', 'bgjRefreshInterval', 3600); return \OC::$server->getConfig()->getAppValue('user_ldap', 'bgjRefreshInterval', 3600);
} }
@ -95,7 +89,7 @@ class UpdateGroups extends \OC\BackgroundJob\TimedJob {
/** /**
* @param string[] $groups * @param string[] $groups
*/ */
private static function handleKnownGroups($groups) { private function handleKnownGroups($groups) {
/** @var IEventDispatcher $dispatcher */ /** @var IEventDispatcher $dispatcher */
$dispatcher = \OC::$server->query(IEventDispatcher::class); $dispatcher = \OC::$server->query(IEventDispatcher::class);
$groupManager = \OC::$server->getGroupManager(); $groupManager = \OC::$server->getGroupManager();
@ -107,10 +101,12 @@ class UpdateGroups extends \OC\BackgroundJob\TimedJob {
SET `owncloudusers` = ? SET `owncloudusers` = ?
WHERE `owncloudname` = ? WHERE `owncloudname` = ?
'); ');
if (!is_array($this->groupsFromDB)) {
$this->getKnownGroups();
}
foreach ($groups as $group) { foreach ($groups as $group) {
//we assume, that self::$groupsFromDB has been retrieved already $knownUsers = unserialize($this->groupsFromDB[$group]['owncloudusers']);
$knownUsers = unserialize(self::$groupsFromDB[$group]['owncloudusers']); $actualUsers = $this->groupBackend->usersInGroup($group);
$actualUsers = self::getGroupBE()->usersInGroup($group);
$hasChanged = false; $hasChanged = false;
$groupObject = $groupManager->get($group); $groupObject = $groupManager->get($group);
@ -142,7 +138,7 @@ class UpdateGroups extends \OC\BackgroundJob\TimedJob {
/** /**
* @param string[] $createdGroups * @param string[] $createdGroups
*/ */
private static function handleCreatedGroups($createdGroups) { private function handleCreatedGroups($createdGroups) {
\OCP\Util::writeLog('user_ldap', 'bgJ "updateGroups" – dealing with created Groups.', ILogger::DEBUG); \OCP\Util::writeLog('user_ldap', 'bgJ "updateGroups" – dealing with created Groups.', ILogger::DEBUG);
$query = \OC_DB::prepare(' $query = \OC_DB::prepare('
INSERT INSERT
@ -153,7 +149,7 @@ class UpdateGroups extends \OC\BackgroundJob\TimedJob {
\OCP\Util::writeLog('user_ldap', \OCP\Util::writeLog('user_ldap',
'bgJ "updateGroups" – new group "'.$createdGroup.'" found.', 'bgJ "updateGroups" – new group "'.$createdGroup.'" found.',
ILogger::INFO); ILogger::INFO);
$users = serialize(self::getGroupBE()->usersInGroup($createdGroup)); $users = serialize($this->groupBackend->usersInGroup($createdGroup));
$query->execute([$createdGroup, $users]); $query->execute([$createdGroup, $users]);
} }
\OCP\Util::writeLog('user_ldap', \OCP\Util::writeLog('user_ldap',
@ -164,7 +160,7 @@ class UpdateGroups extends \OC\BackgroundJob\TimedJob {
/** /**
* @param string[] $removedGroups * @param string[] $removedGroups
*/ */
private static function handleRemovedGroups($removedGroups) { private function handleRemovedGroups($removedGroups) {
\OCP\Util::writeLog('user_ldap', 'bgJ "updateGroups" – dealing with removed groups.', ILogger::DEBUG); \OCP\Util::writeLog('user_ldap', 'bgJ "updateGroups" – dealing with removed groups.', ILogger::DEBUG);
$query = \OC_DB::prepare(' $query = \OC_DB::prepare('
DELETE DELETE
@ -182,59 +178,23 @@ class UpdateGroups extends \OC\BackgroundJob\TimedJob {
ILogger::DEBUG); ILogger::DEBUG);
} }
/**
* @return \OCA\User_LDAP\Group_LDAP|\OCA\User_LDAP\Group_Proxy
*/
private static function getGroupBE() {
if (!is_null(self::$groupBE)) {
return self::$groupBE;
}
$helper = new Helper(\OC::$server->getConfig());
$configPrefixes = $helper->getServerConfigurationPrefixes(true);
$ldapWrapper = new LDAP();
if (count($configPrefixes) === 1) {
//avoid the proxy when there is only one LDAP server configured
$dbc = \OC::$server->getDatabaseConnection();
$userManager = new Manager(
\OC::$server->getConfig(),
new FilesystemHelper(),
new LogWrapper(),
\OC::$server->getAvatarManager(),
new \OCP\Image(),
$dbc,
\OC::$server->getUserManager(),
\OC::$server->getNotificationManager());
$connector = new Connection($ldapWrapper, $configPrefixes[0]);
$ldapAccess = new Access($connector, $ldapWrapper, $userManager, $helper, \OC::$server->getConfig(), \OC::$server->getUserManager());
$groupMapper = new GroupMapping($dbc);
$userMapper = new UserMapping($dbc);
$ldapAccess->setGroupMapper($groupMapper);
$ldapAccess->setUserMapper($userMapper);
self::$groupBE = new \OCA\User_LDAP\Group_LDAP($ldapAccess, \OC::$server->query(GroupPluginManager::class));
} else {
self::$groupBE = new \OCA\User_LDAP\Group_Proxy($configPrefixes, $ldapWrapper, \OC::$server->query(GroupPluginManager::class));
}
return self::$groupBE;
}
/** /**
* @return array * @return array
*/ */
private static function getKnownGroups() { private function getKnownGroups() {
if (is_array(self::$groupsFromDB)) { if (is_array($this->groupsFromDB)) {
return self::$groupsFromDB; $this->groupsFromDB;
} }
$query = \OC_DB::prepare(' $query = \OC_DB::prepare('
SELECT `owncloudname`, `owncloudusers` SELECT `owncloudname`, `owncloudusers`
FROM `*PREFIX*ldap_group_members` FROM `*PREFIX*ldap_group_members`
'); ');
$result = $query->execute()->fetchAll(); $result = $query->execute()->fetchAll();
self::$groupsFromDB = []; $this->groupsFromDB = [];
foreach ($result as $dataset) { foreach ($result as $dataset) {
self::$groupsFromDB[$dataset['owncloudname']] = $dataset; $this->groupsFromDB[$dataset['owncloudname']] = $dataset;
} }
return self::$groupsFromDB; return $this->groupsFromDB;
} }
} }

7
apps/user_ldap/lib/Migration/UUIDFix.php
View File

@ -50,11 +50,4 @@ abstract class UUIDFix extends QueuedJob {
} }
} }
} }
/**
* @param Proxy $proxy
*/
public function overrideProxy(Proxy $proxy) {
$this->proxy = $proxy;
}
} }

12
apps/user_ldap/lib/Migration/UUIDFixGroup.php
View File

@ -26,18 +26,12 @@
namespace OCA\User_LDAP\Migration; namespace OCA\User_LDAP\Migration;
use OCA\User_LDAP\Helper; use OCA\User_LDAP\Group_Proxy;
use OCA\User_LDAP\LDAP;
use OCA\User_LDAP\Mapping\GroupMapping; use OCA\User_LDAP\Mapping\GroupMapping;
use OCA\User_LDAP\User_Proxy;
use OCA\User_LDAP\UserPluginManager;
use OCP\IConfig;
class UUIDFixGroup extends UUIDFix { class UUIDFixGroup extends UUIDFix {
public function __construct(GroupMapping $mapper, LDAP $ldap, IConfig $config, Helper $helper) { public function __construct(GroupMapping $mapper, Group_Proxy $proxy) {
$this->mapper = $mapper; $this->mapper = $mapper;
$this->proxy = new User_Proxy($helper->getServerConfigurationPrefixes(true), $ldap, $config, $this->proxy = $proxy;
\OC::$server->getNotificationManager(), \OC::$server->getUserSession(),
\OC::$server->query(UserPluginManager::class));
} }
} }

11
apps/user_ldap/lib/Migration/UUIDFixUser.php
View File

@ -26,17 +26,12 @@
namespace OCA\User_LDAP\Migration; namespace OCA\User_LDAP\Migration;
use OCA\User_LDAP\Group_Proxy; use OCA\User_LDAP\User_Proxy;
use OCA\User_LDAP\GroupPluginManager;
use OCA\User_LDAP\Helper;
use OCA\User_LDAP\LDAP;
use OCA\User_LDAP\Mapping\UserMapping; use OCA\User_LDAP\Mapping\UserMapping;
use OCP\IConfig;
class UUIDFixUser extends UUIDFix { class UUIDFixUser extends UUIDFix {
public function __construct(UserMapping $mapper, LDAP $ldap, IConfig $config, Helper $helper) { public function __construct(UserMapping $mapper, User_Proxy $proxy) {
$this->mapper = $mapper; $this->mapper = $mapper;
$groupPluginManager = \OC::$server->query(GroupPluginManager::class); $this->proxy = $proxy;
$this->proxy = new Group_Proxy($helper->getServerConfigurationPrefixes(true), $ldap, $groupPluginManager);
} }
} }

12
apps/user_ldap/lib/User_Proxy.php
View File

@ -42,17 +42,8 @@ class User_Proxy extends Proxy implements \OCP\IUserBackend, \OCP\UserInterface,
/** @var User_LDAP */ /** @var User_LDAP */
private $refBackend = null; private $refBackend = null;
/**
* Constructor
*
* @param array $serverConfigPrefixes array containing the config Prefixes
* @param ILDAPWrapper $ldap
* @param IConfig $ocConfig
* @param INotificationManager $notificationManager
* @param IUserSession $userSession
*/
public function __construct( public function __construct(
array $serverConfigPrefixes, Helper $helper,
ILDAPWrapper $ldap, ILDAPWrapper $ldap,
IConfig $ocConfig, IConfig $ocConfig,
INotificationManager $notificationManager, INotificationManager $notificationManager,
@ -60,6 +51,7 @@ class User_Proxy extends Proxy implements \OCP\IUserBackend, \OCP\UserInterface,
UserPluginManager $userPluginManager UserPluginManager $userPluginManager
) { ) {
parent::__construct($ldap); parent::__construct($ldap);
$serverConfigPrefixes = $helper->getServerConfigurationPrefixes(true);
foreach ($serverConfigPrefixes as $configPrefix) { foreach ($serverConfigPrefixes as $configPrefix) {
$this->backends[$configPrefix] = $this->backends[$configPrefix] =
new User_LDAP($this->getAccess($configPrefix), $ocConfig, $notificationManager, $userSession, $userPluginManager); new User_LDAP($this->getAccess($configPrefix), $ocConfig, $notificationManager, $userSession, $userPluginManager);

95
apps/user_ldap/tests/Jobs/CleanUpTest.php
View File

@ -26,44 +26,49 @@
namespace OCA\User_LDAP\Tests\Jobs; namespace OCA\User_LDAP\Tests\Jobs;
use Exception;
use OCA\User_LDAP\Helper; use OCA\User_LDAP\Helper;
use OCA\User_LDAP\Jobs\CleanUp;
use OCA\User_LDAP\User\DeletedUsersIndex;
use OCA\User_LDAP\User_Proxy;
use OCP\IConfig; use OCP\IConfig;
use OCP\IDBConnection; use OCP\IDBConnection;
use Test\TestCase;
class CleanUpTest extends \Test\TestCase { class CleanUpTest extends TestCase {
public function getMocks() { /** @var CleanUp */
$mocks = []; protected $bgJob;
$mocks['userBackend'] =
$this->getMockBuilder('\OCA\User_LDAP\User_Proxy')
->disableOriginalConstructor()
->getMock();
$mocks['deletedUsersIndex'] =
$this->getMockBuilder('\OCA\User_LDAP\User\DeletedUsersIndex')
->disableOriginalConstructor()
->getMock();
$mocks['ocConfig'] = $this->createMock(IConfig::class);
$mocks['db'] = $this->createMock(IDBConnection::class);
$mocks['helper'] = $this->createMock(Helper::class);
return $mocks; /** @var array */
protected $mocks;
public function setUp(): void {
$this->createMocks();
$this->bgJob = new CleanUp($this->mocks['userBackend']);
$this->bgJob->setArguments($this->mocks);
}
protected function createMocks(): void {
$this->mocks = [];
$this->mocks['userBackend'] = $this->createMock(User_Proxy::class);
$this->mocks['deletedUsersIndex'] = $this->createMock(DeletedUsersIndex::class);
$this->mocks['ocConfig'] = $this->createMock(IConfig::class);
$this->mocks['db'] = $this->createMock(IDBConnection::class);
$this->mocks['helper'] = $this->createMock(Helper::class);
} }
/** /**
* clean up job must not run when there are disabled configurations * clean up job must not run when there are disabled configurations
*/ */
public function test_runNotAllowedByDisabledConfigurations() { public function test_runNotAllowedByDisabledConfigurations() {
$args = $this->getMocks(); $this->mocks['helper']->expects($this->once())
$args['helper']->expects($this->once())
->method('haveDisabledConfigurations') ->method('haveDisabledConfigurations')
->willReturn(true); ->willReturn(true);
$args['ocConfig']->expects($this->never()) $this->mocks['ocConfig']->expects($this->never())
->method('getSystemValue'); ->method('getSystemValue');
$bgJob = new \OCA\User_LDAP\Jobs\CleanUp(); $result = $this->bgJob->isCleanUpAllowed();
$bgJob->setArguments($args);
$result = $bgJob->isCleanUpAllowed();
$this->assertSame(false, $result); $this->assertSame(false, $result);
} }
@ -72,18 +77,14 @@ class CleanUpTest extends \Test\TestCase {
* returning unexpected results * returning unexpected results
*/ */
public function test_runNotAllowedByBrokenHelper() { public function test_runNotAllowedByBrokenHelper() {
$args = $this->getMocks(); $this->mocks['helper']->expects($this->once())
$args['helper']->expects($this->once())
->method('haveDisabledConfigurations') ->method('haveDisabledConfigurations')
->will($this->throwException(new \Exception())); ->will($this->throwException(new Exception()));
$args['ocConfig']->expects($this->never()) $this->mocks['ocConfig']->expects($this->never())
->method('getSystemValue'); ->method('getSystemValue');
$bgJob = new \OCA\User_LDAP\Jobs\CleanUp(); $result = $this->bgJob->isCleanUpAllowed();
$bgJob->setArguments($args);
$result = $bgJob->isCleanUpAllowed();
$this->assertSame(false, $result); $this->assertSame(false, $result);
} }
@ -91,19 +92,15 @@ class CleanUpTest extends \Test\TestCase {
* clean up job must not run when it is not enabled * clean up job must not run when it is not enabled
*/ */
public function test_runNotAllowedBySysConfig() { public function test_runNotAllowedBySysConfig() {
$args = $this->getMocks(); $this->mocks['helper']->expects($this->once())
$args['helper']->expects($this->once())
->method('haveDisabledConfigurations') ->method('haveDisabledConfigurations')
->willReturn(false); ->willReturn(false);
$args['ocConfig']->expects($this->once()) $this->mocks['ocConfig']->expects($this->once())
->method('getSystemValue') ->method('getSystemValue')
->willReturn(false); ->willReturn(false);
$bgJob = new \OCA\User_LDAP\Jobs\CleanUp(); $result = $this->bgJob->isCleanUpAllowed();
$bgJob->setArguments($args);
$result = $bgJob->isCleanUpAllowed();
$this->assertSame(false, $result); $this->assertSame(false, $result);
} }
@ -111,19 +108,15 @@ class CleanUpTest extends \Test\TestCase {
* clean up job is allowed to run * clean up job is allowed to run
*/ */
public function test_runIsAllowed() { public function test_runIsAllowed() {
$args = $this->getMocks(); $this->mocks['helper']->expects($this->once())
$args['helper']->expects($this->once())
->method('haveDisabledConfigurations') ->method('haveDisabledConfigurations')
->willReturn(false); ->willReturn(false);
$args['ocConfig']->expects($this->once()) $this->mocks['ocConfig']->expects($this->once())
->method('getSystemValue') ->method('getSystemValue')
->willReturn(true); ->willReturn(true);
$bgJob = new \OCA\User_LDAP\Jobs\CleanUp(); $result = $this->bgJob->isCleanUpAllowed();
$bgJob->setArguments($args);
$result = $bgJob->isCleanUpAllowed();
$this->assertSame(true, $result); $this->assertSame(true, $result);
} }
@ -131,12 +124,7 @@ class CleanUpTest extends \Test\TestCase {
* check whether offset will be reset when it needs to * check whether offset will be reset when it needs to
*/ */
public function test_OffsetResetIsNecessary() { public function test_OffsetResetIsNecessary() {
$args = $this->getMocks(); $result = $this->bgJob->isOffsetResetNecessary($this->bgJob->getChunkSize() - 1);
$bgJob = new \OCA\User_LDAP\Jobs\CleanUp();
$bgJob->setArguments($args);
$result = $bgJob->isOffsetResetNecessary($bgJob->getChunkSize() - 1);
$this->assertSame(true, $result); $this->assertSame(true, $result);
} }
@ -144,12 +132,7 @@ class CleanUpTest extends \Test\TestCase {
* make sure offset is not reset when it is not due * make sure offset is not reset when it is not due
*/ */
public function test_OffsetResetIsNotNecessary() { public function test_OffsetResetIsNotNecessary() {
$args = $this->getMocks(); $result = $this->bgJob->isOffsetResetNecessary($this->bgJob->getChunkSize());
$bgJob = new \OCA\User_LDAP\Jobs\CleanUp();
$bgJob->setArguments($args);
$result = $bgJob->isOffsetResetNecessary($bgJob->getChunkSize());
$this->assertSame(false, $result); $this->assertSame(false, $result);
} }
} }

9
apps/user_ldap/tests/Migration/AbstractUUIDFixTest.php
View File

@ -74,18 +74,13 @@ abstract class AbstractUUIDFixTest extends TestCase {
->willReturn(['s01', 's03']); ->willReturn(['s01', 's03']);
} }
protected function mockProxy($className) { protected function instantiateJob($className) {
$this->proxy = $this->createMock($className); $this->job = new $className($this->mapper, $this->proxy);
$this->proxy->expects($this->any()) $this->proxy->expects($this->any())
->method('getLDAPAccess') ->method('getLDAPAccess')
->willReturn($this->access); ->willReturn($this->access);
} }
protected function instantiateJob($className) {
$this->job = new $className($this->mapper, $this->ldap, $this->config, $this->helper);
$this->job->overrideProxy($this->proxy);
}
public function testRunSingleRecord() { public function testRunSingleRecord() {
$args = [ $args = [
'records' => [ 'records' => [

4
apps/user_ldap/tests/Migration/UUIDFixGroupTest.php
View File

@ -40,11 +40,9 @@ class UUIDFixGroupTest extends AbstractUUIDFixTest {
$this->isUser = false; $this->isUser = false;
parent::setUp(); parent::setUp();
$this->isUser = false;
$this->mapper = $this->createMock(GroupMapping::class); $this->mapper = $this->createMock(GroupMapping::class);
$this->proxy = $this->createMock(Group_Proxy::class);
$this->mockProxy(Group_Proxy::class);
$this->instantiateJob(UUIDFixGroup::class); $this->instantiateJob(UUIDFixGroup::class);
} }
} }

2
apps/user_ldap/tests/Migration/UUIDFixUserTest.php
View File

@ -40,8 +40,8 @@ class UUIDFixUserTest extends AbstractUUIDFixTest {
parent::setUp(); parent::setUp();
$this->mapper = $this->createMock(UserMapping::class); $this->mapper = $this->createMock(UserMapping::class);
$this->proxy = $this->createMock(User_Proxy::class);
$this->mockProxy(User_Proxy::class);
$this->instantiateJob(UUIDFixUser::class); $this->instantiateJob(UUIDFixUser::class);
} }
} }

6
apps/user_ldap/tests/User_ProxyTest.php
View File

@ -29,6 +29,7 @@
namespace OCA\User_LDAP\Tests; namespace OCA\User_LDAP\Tests;
use OCA\User_LDAP\Helper;
use OCA\User_LDAP\ILDAPWrapper; use OCA\User_LDAP\ILDAPWrapper;
use OCA\User_LDAP\User_Proxy; use OCA\User_LDAP\User_Proxy;
use OCA\User_LDAP\UserPluginManager; use OCA\User_LDAP\UserPluginManager;
@ -38,6 +39,8 @@ use OCP\Notification\IManager as INotificationManager;
use Test\TestCase; use Test\TestCase;
class User_ProxyTest extends TestCase { class User_ProxyTest extends TestCase {
/** @var Helper|\PHPUnit\Framework\MockObject\MockObject */
protected $helper;
/** @var ILDAPWrapper|\PHPUnit\Framework\MockObject\MockObject */ /** @var ILDAPWrapper|\PHPUnit\Framework\MockObject\MockObject */
private $ldapWrapper; private $ldapWrapper;
/** @var IConfig|\PHPUnit\Framework\MockObject\MockObject */ /** @var IConfig|\PHPUnit\Framework\MockObject\MockObject */
@ -54,6 +57,7 @@ class User_ProxyTest extends TestCase {
protected function setUp(): void { protected function setUp(): void {
parent::setUp(); parent::setUp();
$this->helper = $this->createMock(Helper::class);
$this->ldapWrapper = $this->createMock(ILDAPWrapper::class); $this->ldapWrapper = $this->createMock(ILDAPWrapper::class);
$this->config = $this->createMock(IConfig::class); $this->config = $this->createMock(IConfig::class);
$this->notificationManager = $this->createMock(INotificationManager::class); $this->notificationManager = $this->createMock(INotificationManager::class);
@ -61,7 +65,7 @@ class User_ProxyTest extends TestCase {
$this->userPluginManager = $this->createMock(UserPluginManager::class); $this->userPluginManager = $this->createMock(UserPluginManager::class);
$this->proxy = $this->getMockBuilder(User_Proxy::class) $this->proxy = $this->getMockBuilder(User_Proxy::class)
->setConstructorArgs([ ->setConstructorArgs([
[], $this->helper,
$this->ldapWrapper, $this->ldapWrapper,
$this->config, $this->config,
$this->notificationManager, $this->notificationManager,

1
psalm.xml
View File

@ -79,7 +79,6 @@
<referencedVariable name="$l"/> <referencedVariable name="$l"/>
<referencedVariable name="$theme"/> <referencedVariable name="$theme"/>
<!-- false positive: https://github.com/nextcloud/server/blob/cb057829f72c70e819f456edfadbb29d72dba832/lib/private/Console/Application.php#L92 --> <!-- false positive: https://github.com/nextcloud/server/blob/cb057829f72c70e819f456edfadbb29d72dba832/lib/private/Console/Application.php#L92 -->
<file name="apps/*/appinfo/register_command.php" />
<file name="core/register_command.php" /> <file name="core/register_command.php" />
</errorLevel> </errorLevel>
</UndefinedGlobalVariable> </UndefinedGlobalVariable>