use OCP\Files\Events\Node\NodeWrittenEvent;
use OCP\Files\InvalidPathException;
use OCP\Files\NotFoundException;
+use OCP\Server;
use Psr\Log\LoggerInterface;
/**
'path' => mb_substr($node->getInternalPath(), 5),
];
} catch (InvalidPathException|NotFoundException $e) {
- \OCP\Server::get(LoggerInterface::class)->error(
+ Server::get(LoggerInterface::class)->error(
'Exception thrown in file read: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
);
return;
$source = $event->getSource();
$this->renamedNodes[$source->getId()] = $source;
} catch (InvalidPathException|NotFoundException $e) {
- \OCP\Server::get(LoggerInterface::class)->error(
+ Server::get(LoggerInterface::class)->error(
'Exception thrown in file rename: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
);
return;
'newpath' => mb_substr($target->getInternalPath(), 5),
];
} catch (InvalidPathException|NotFoundException $e) {
- \OCP\Server::get(LoggerInterface::class)->error(
+ Server::get(LoggerInterface::class)->error(
'Exception thrown in file rename: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
);
return;
'path' => mb_substr($event->getNode()->getInternalPath(), 5),
];
} catch (InvalidPathException|NotFoundException $e) {
- \OCP\Server::get(LoggerInterface::class)->error(
+ Server::get(LoggerInterface::class)->error(
'Exception thrown in file create: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
);
return;
'newpath' => mb_substr($event->getTarget()->getInternalPath(), 5),
];
} catch (InvalidPathException|NotFoundException $e) {
- \OCP\Server::get(LoggerInterface::class)->error(
+ Server::get(LoggerInterface::class)->error(
'Exception thrown in file copy: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
);
return;
'path' => mb_substr($node->getInternalPath(), 5),
];
} catch (InvalidPathException|NotFoundException $e) {
- \OCP\Server::get(LoggerInterface::class)->error(
+ Server::get(LoggerInterface::class)->error(
'Exception thrown in file write: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
);
return;
'path' => mb_substr($event->getNode()->getInternalPath(), 5),
];
} catch (InvalidPathException|NotFoundException $e) {
- \OCP\Server::get(LoggerInterface::class)->error(
+ Server::get(LoggerInterface::class)->error(
'Exception thrown in file delete: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
);
return;
use OCP\Share;
use OCP\Share\Events\ShareCreatedEvent;
use OCP\Share\Events\ShareDeletedEvent;
+use OCP\SystemTag\ManagerEvent;
use OCP\User\Events\BeforeUserLoggedInEvent;
use OCP\User\Events\BeforeUserLoggedOutEvent;
use OCP\User\Events\PasswordUpdatedEvent;
private function tagHooks(IAuditLogger $logger,
IEventDispatcher $eventDispatcher): void {
- $eventDispatcher->addListener(\OCP\SystemTag\ManagerEvent::EVENT_CREATE, function (\OCP\SystemTag\ManagerEvent $event) use ($logger): void {
+ $eventDispatcher->addListener(ManagerEvent::EVENT_CREATE, function (ManagerEvent $event) use ($logger): void {
$tagActions = new TagManagement($logger);
$tagActions->createTag($event->getTag());
});
use OCP\Files\InvalidPathException;
use OCP\Files\NotFoundException;
use OCP\Preview\BeforePreviewFetchedEvent;
+use OCP\Server;
use Psr\Log\LoggerInterface;
/**
array_keys($params)
);
} catch (InvalidPathException|NotFoundException $e) {
- \OCP\Server::get(LoggerInterface::class)->error(
+ Server::get(LoggerInterface::class)->error(
'Exception thrown in file preview: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
);
return;
use OCP\IURLGenerator;
use OCP\IUserManager;
use OCP\Share\Exceptions\ShareNotFound;
+use OCP\Util;
use Psr\Log\LoggerInterface;
/**
private function mapUid($uid) {
// FIXME this should be a method in the user management instead
$this->logger->debug('shareWith before, ' . $uid, ['app' => $this->appName]);
- \OCP\Util::emitHook(
+ Util::emitHook(
'\OCA\Files_Sharing\API\Server2Server',
'preLoginNameUsedAsUserName',
['uid' => &$uid]
parent::setUp();
$this->notificationManager = $this->createMock(\OCP\Notification\IManager::class);
- $this->userManager = $this->createMock(\OCP\IUserManager::class);
+ $this->userManager = $this->createMock(IUserManager::class);
$this->listener = new Listener(
$this->notificationManager,
use OCA\Dashboard\Service\DashboardService;
use OCP\AppFramework\Controller;
-use OCP\AppFramework\Http;
use OCP\AppFramework\Http\Attribute\FrontpageRoute;
use OCP\AppFramework\Http\Attribute\NoAdminRequired;
use OCP\AppFramework\Http\Attribute\NoCSRFRequired;
use OCP\AppFramework\Http\Attribute\OpenAPI;
+use OCP\AppFramework\Http\FeaturePolicy;
use OCP\AppFramework\Http\TemplateResponse;
use OCP\AppFramework\Services\IInitialState;
use OCP\Dashboard\IIconWidget;
use OCP\IConfig;
use OCP\IL10N;
use OCP\IRequest;
+use OCP\Util;
#[OpenAPI(scope: OpenAPI::SCOPE_IGNORE)]
class DashboardController extends Controller {
#[NoAdminRequired]
#[FrontpageRoute(verb: 'GET', url: '/')]
public function index(): TemplateResponse {
- \OCP\Util::addStyle('dashboard', 'dashboard');
- \OCP\Util::addScript('dashboard', 'main', 'theming');
+ Util::addStyle('dashboard', 'dashboard');
+ Util::addScript('dashboard', 'main', 'theming');
$widgets = array_map(function (IWidget $widget) {
return [
]);
// For the weather widget we should allow the geolocation
- $featurePolicy = new Http\FeaturePolicy();
+ $featurePolicy = new FeaturePolicy();
$featurePolicy->addAllowedGeoLocationDomain('\'self\'');
$response->setFeaturePolicy($featurePolicy);
use OCA\DAV\CalDAV\CalDavBackend;
use OCA\DAV\CalDAV\CalendarRoot;
use OCA\DAV\CalDAV\DefaultCalendarValidator;
+use OCA\DAV\CalDAV\Proxy\ProxyMapper;
+use OCA\DAV\CalDAV\Schedule\IMipPlugin;
use OCA\DAV\CalDAV\Security\RateLimitingPlugin;
use OCA\DAV\CalDAV\Validation\CalDavValidatePlugin;
use OCA\DAV\Connector\LegacyDAVACL;
use OCA\DAV\Connector\Sabre\MaintenancePlugin;
use OCA\DAV\Connector\Sabre\Principal;
use OCP\Accounts\IAccountManager;
+use OCP\EventDispatcher\IEventDispatcher;
+use OCP\IConfig;
+use OCP\Server;
use Psr\Log\LoggerInterface;
$authBackend = new Auth(
\OC::$server->getShareManager(),
\OC::$server->getUserSession(),
\OC::$server->getAppManager(),
- \OC::$server->query(\OCA\DAV\CalDAV\Proxy\ProxyMapper::class),
+ \OC::$server->query(ProxyMapper::class),
\OC::$server->get(KnownUserService::class),
\OC::$server->getConfig(),
\OC::$server->getL10NFactory(),
$userManager = \OC::$server->getUserManager();
$random = \OC::$server->getSecureRandom();
$logger = \OC::$server->get(LoggerInterface::class);
-$dispatcher = \OC::$server->get(\OCP\EventDispatcher\IEventDispatcher::class);
-$config = \OC::$server->get(\OCP\IConfig::class);
+$dispatcher = \OC::$server->get(IEventDispatcher::class);
+$config = \OC::$server->get(IConfig::class);
$calDavBackend = new CalDavBackend(
$db,
$server->addPlugin(new \OCA\DAV\CalDAV\Schedule\Plugin(\OC::$server->getConfig(), \OC::$server->get(LoggerInterface::class), \OC::$server->get(DefaultCalendarValidator::class)));
if ($sendInvitations) {
- $server->addPlugin(\OC::$server->query(\OCA\DAV\CalDAV\Schedule\IMipPlugin::class));
+ $server->addPlugin(\OC::$server->query(IMipPlugin::class));
}
$server->addPlugin(new ExceptionLoggerPlugin('caldav', $logger));
-$server->addPlugin(\OCP\Server::get(RateLimitingPlugin::class));
-$server->addPlugin(\OCP\Server::get(CalDavValidatePlugin::class));
+$server->addPlugin(Server::get(RateLimitingPlugin::class));
+$server->addPlugin(Server::get(CalDavValidatePlugin::class));
// And off we go!
$server->exec();
// Backends
use OC\KnownUser\KnownUserService;
use OCA\DAV\AppInfo\PluginManager;
+use OCA\DAV\CalDAV\Proxy\ProxyMapper;
use OCA\DAV\CardDAV\AddressBookRoot;
use OCA\DAV\CardDAV\CardDavBackend;
+use OCA\DAV\CardDAV\ImageExportPlugin;
+use OCA\DAV\CardDAV\PhotoCache;
use OCA\DAV\CardDAV\Security\CardDavRateLimitingPlugin;
use OCA\DAV\CardDAV\Validation\CardDavValidatePlugin;
use OCA\DAV\Connector\LegacyDAVACL;
use OCA\DAV\Connector\Sabre\Principal;
use OCP\Accounts\IAccountManager;
use OCP\App\IAppManager;
+use OCP\EventDispatcher\IEventDispatcher;
+use OCP\IGroupManager;
+use OCP\Server;
use Psr\Log\LoggerInterface;
use Sabre\CardDAV\Plugin;
\OC::$server->getShareManager(),
\OC::$server->getUserSession(),
\OC::$server->getAppManager(),
- \OC::$server->query(\OCA\DAV\CalDAV\Proxy\ProxyMapper::class),
+ \OC::$server->query(ProxyMapper::class),
\OC::$server->get(KnownUserService::class),
\OC::$server->getConfig(),
\OC::$server->getL10NFactory(),
$db,
$principalBackend,
\OC::$server->getUserManager(),
- \OC::$server->get(\OCP\EventDispatcher\IEventDispatcher::class),
+ \OC::$server->get(IEventDispatcher::class),
\OC::$server->get(\OCA\DAV\CardDAV\Sharing\Backend::class),
);
$principalCollection->disableListing = !$debugging; // Disable listing
$pluginManager = new PluginManager(\OC::$server, \OC::$server->query(IAppManager::class));
-$addressBookRoot = new AddressBookRoot($principalBackend, $cardDavBackend, $pluginManager, \OC::$server->getUserSession()->getUser(), \OC::$server->get(\OCP\IGroupManager::class));
+$addressBookRoot = new AddressBookRoot($principalBackend, $cardDavBackend, $pluginManager, \OC::$server->getUserSession()->getUser(), \OC::$server->get(IGroupManager::class));
$addressBookRoot->disableListing = !$debugging; // Disable listing
$nodes = [
$server->addPlugin(new \Sabre\DAV\Sync\Plugin());
$server->addPlugin(new \Sabre\CardDAV\VCFExportPlugin());
-$server->addPlugin(new \OCA\DAV\CardDAV\ImageExportPlugin(new \OCA\DAV\CardDAV\PhotoCache(
+$server->addPlugin(new ImageExportPlugin(new PhotoCache(
\OC::$server->getAppDataDir('dav-photocache'),
\OC::$server->get(LoggerInterface::class)
)));
$server->addPlugin(new ExceptionLoggerPlugin('carddav', \OC::$server->get(LoggerInterface::class)));
-$server->addPlugin(\OCP\Server::get(CardDavRateLimitingPlugin::class));
-$server->addPlugin(\OCP\Server::get(CardDavValidatePlugin::class));
+$server->addPlugin(Server::get(CardDavRateLimitingPlugin::class));
+$server->addPlugin(Server::get(CardDavValidatePlugin::class));
// And off we go!
$server->exec();
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
-
+use OC\Files\Filesystem;
+use OC\Files\Storage\Wrapper\PermissionsMask;
+use OC\Files\View;
+use OCA\DAV\Connector\LegacyPublicAuth;
+use OCA\DAV\Connector\Sabre\ServerFactory;
+use OCA\DAV\Files\Sharing\FilesDropPlugin;
+use OCA\DAV\Files\Sharing\PublicLinkCheckPlugin;
+use OCA\DAV\Storage\PublicOwnerWrapper;
+use OCA\FederatedFileSharing\FederatedShareProvider;
use OCP\BeforeSabrePubliclyLoadedEvent;
+use OCP\Constants;
use OCP\EventDispatcher\IEventDispatcher;
+use OCP\Files\IRootFolder;
+use OCP\Server;
use Psr\Log\LoggerInterface;
// load needed apps
\OC::$server->getSession()->close();
// Backends
-$authBackend = new OCA\DAV\Connector\LegacyPublicAuth(
+$authBackend = new LegacyPublicAuth(
\OC::$server->getRequest(),
\OC::$server->getShareManager(),
\OC::$server->getSession(),
/** @var IEventDispatcher $eventDispatcher */
$eventDispatcher = \OC::$server->get(IEventDispatcher::class);
-$serverFactory = new OCA\DAV\Connector\Sabre\ServerFactory(
+$serverFactory = new ServerFactory(
\OC::$server->getConfig(),
\OC::$server->get(LoggerInterface::class),
\OC::$server->getDatabaseConnection(),
$requestUri = \OC::$server->getRequest()->getRequestUri();
-$linkCheckPlugin = new \OCA\DAV\Files\Sharing\PublicLinkCheckPlugin();
-$filesDropPlugin = new \OCA\DAV\Files\Sharing\FilesDropPlugin();
+$linkCheckPlugin = new PublicLinkCheckPlugin();
+$filesDropPlugin = new FilesDropPlugin();
$server = $serverFactory->createServer($baseuri, $requestUri, $authPlugin, function (\Sabre\DAV\Server $server) use ($authBackend, $linkCheckPlugin, $filesDropPlugin) {
$isAjax = in_array('XMLHttpRequest', explode(',', $_SERVER['HTTP_X_REQUESTED_WITH'] ?? ''));
- /** @var \OCA\FederatedFileSharing\FederatedShareProvider $shareProvider */
- $federatedShareProvider = \OC::$server->query(\OCA\FederatedFileSharing\FederatedShareProvider::class);
+ /** @var FederatedShareProvider $shareProvider */
+ $federatedShareProvider = \OC::$server->query(FederatedShareProvider::class);
if ($federatedShareProvider->isOutgoingServer2serverShareEnabled() === false && !$isAjax) {
// this is what is thrown when trying to access a non-existing share
throw new \Sabre\DAV\Exception\NotAuthenticated();
$share = $authBackend->getShare();
$owner = $share->getShareOwner();
- $isReadable = $share->getPermissions() & \OCP\Constants::PERMISSION_READ;
+ $isReadable = $share->getPermissions() & Constants::PERMISSION_READ;
$fileId = $share->getNodeId();
// FIXME: should not add storage wrappers outside of preSetup, need to find a better way
- $previousLog = \OC\Files\Filesystem::logWarningWhenAddingStorageWrapper(false);
- \OC\Files\Filesystem::addStorageWrapper('sharePermissions', function ($mountPoint, $storage) use ($share) {
- return new \OC\Files\Storage\Wrapper\PermissionsMask(['storage' => $storage, 'mask' => $share->getPermissions() | \OCP\Constants::PERMISSION_SHARE]);
+ $previousLog = Filesystem::logWarningWhenAddingStorageWrapper(false);
+ Filesystem::addStorageWrapper('sharePermissions', function ($mountPoint, $storage) use ($share) {
+ return new PermissionsMask(['storage' => $storage, 'mask' => $share->getPermissions() | Constants::PERMISSION_SHARE]);
});
- \OC\Files\Filesystem::addStorageWrapper('shareOwner', function ($mountPoint, $storage) use ($share) {
- return new \OCA\DAV\Storage\PublicOwnerWrapper(['storage' => $storage, 'owner' => $share->getShareOwner()]);
+ Filesystem::addStorageWrapper('shareOwner', function ($mountPoint, $storage) use ($share) {
+ return new PublicOwnerWrapper(['storage' => $storage, 'owner' => $share->getShareOwner()]);
});
- \OC\Files\Filesystem::logWarningWhenAddingStorageWrapper($previousLog);
+ Filesystem::logWarningWhenAddingStorageWrapper($previousLog);
- $rootFolder = \OCP\Server::get(\OCP\Files\IRootFolder::class);
+ $rootFolder = Server::get(IRootFolder::class);
$userFolder = $rootFolder->getUserFolder($owner);
$node = $userFolder->getFirstNodeById($fileId);
if (!$node) {
$filesDropPlugin->enable();
}
- $view = new \OC\Files\View($node->getPath());
+ $view = new View($node->getPath());
$filesDropPlugin->setView($view);
$filesDropPlugin->setShare($share);
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
+use OC\Files\Filesystem;
+use OCA\DAV\Connector\Sabre\Auth;
+use OCA\DAV\Connector\Sabre\BearerAuth;
+use OCA\DAV\Connector\Sabre\ServerFactory;
+use OCA\DAV\Events\SabrePluginAddEvent;
+use OCP\EventDispatcher\IEventDispatcher;
+use OCP\SabrePluginEvent;
use Psr\Log\LoggerInterface;
// no php execution timeout for webdav
// Turn off output buffering to prevent memory problems
\OC_Util::obEnd();
-$dispatcher = \OC::$server->get(\OCP\EventDispatcher\IEventDispatcher::class);
+$dispatcher = \OC::$server->get(IEventDispatcher::class);
-$serverFactory = new \OCA\DAV\Connector\Sabre\ServerFactory(
+$serverFactory = new ServerFactory(
\OC::$server->getConfig(),
\OC::$server->get(LoggerInterface::class),
\OC::$server->getDatabaseConnection(),
);
// Backends
-$authBackend = new \OCA\DAV\Connector\Sabre\Auth(
+$authBackend = new Auth(
\OC::$server->getSession(),
\OC::$server->getUserSession(),
\OC::$server->getRequest(),
'principals/'
);
$authPlugin = new \Sabre\DAV\Auth\Plugin($authBackend);
-$bearerAuthPlugin = new \OCA\DAV\Connector\Sabre\BearerAuth(
+$bearerAuthPlugin = new BearerAuth(
\OC::$server->getUserSession(),
\OC::$server->getSession(),
\OC::$server->getRequest()
$server = $serverFactory->createServer($baseuri, $requestUri, $authPlugin, function () {
// use the view for the logged in user
- return \OC\Files\Filesystem::getView();
+ return Filesystem::getView();
});
// allow setup of additional plugins
-$event = new \OCP\SabrePluginEvent($server);
+$event = new SabrePluginEvent($server);
$dispatcher->dispatch('OCA\DAV\Connector\Sabre::addPlugin', $event);
-$event = new \OCA\DAV\Events\SabrePluginAddEvent($server);
+$event = new SabrePluginAddEvent($server);
$dispatcher->dispatchTyped($event);
// And off we go!
* SPDX-FileCopyrightText: 2018 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
*/
+use OCA\DAV\Db\DirectMapper;
use OCA\DAV\Direct\ServerFactory;
+use OCP\AppFramework\Utility\ITimeFactory;
// no php execution timeout for webdav
if (!str_contains(@ini_get('disable_functions'), 'set_time_limit')) {
$baseuri,
$requestUri,
\OC::$server->getRootFolder(),
- \OC::$server->query(\OCA\DAV\Db\DirectMapper::class),
- \OC::$server->query(\OCP\AppFramework\Utility\ITimeFactory::class),
+ \OC::$server->query(DirectMapper::class),
+ \OC::$server->query(ITimeFactory::class),
\OC::$server->getBruteForceThrottler(),
\OC::$server->getRequest()
);
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
-
use OC\Files\Filesystem;
use OC\Files\Storage\Wrapper\PermissionsMask;
use OC\Files\View;
+use OCA\DAV\Connector\Sabre\PublicAuth;
+use OCA\DAV\Connector\Sabre\ServerFactory;
+use OCA\DAV\Files\Sharing\FilesDropPlugin;
+use OCA\DAV\Files\Sharing\PublicLinkCheckPlugin;
use OCA\DAV\Storage\PublicOwnerWrapper;
use OCA\DAV\Storage\PublicShareWrapper;
use OCA\FederatedFileSharing\FederatedShareProvider;
use OCP\BeforeSabrePubliclyLoadedEvent;
+use OCP\Constants;
use OCP\EventDispatcher\IEventDispatcher;
+use OCP\Files\IRootFolder;
use OCP\Files\Mount\IMountManager;
use OCP\IConfig;
use OCP\IDBConnection;
use OCP\IUserSession;
use OCP\L10N\IFactory;
use OCP\Security\Bruteforce\IThrottler;
+use OCP\Server;
use OCP\Share\IManager;
use Psr\Log\LoggerInterface;
use Sabre\DAV\Exception\NotAuthenticated;
OC_App::loadApps($RUNTIME_APPTYPES);
OC_Util::obEnd();
-$session = \OCP\Server::get(ISession::class);
-$request = \OCP\Server::get(IRequest::class);
-$eventDispatcher = \OCP\Server::get(IEventDispatcher::class);
+$session = Server::get(ISession::class);
+$request = Server::get(IRequest::class);
+$eventDispatcher = Server::get(IEventDispatcher::class);
$session->close();
$requestUri = $request->getRequestUri();
// Backends
-$authBackend = new OCA\DAV\Connector\Sabre\PublicAuth(
+$authBackend = new PublicAuth(
$request,
- \OCP\Server::get(IManager::class),
+ Server::get(IManager::class),
$session,
- \OCP\Server::get(IThrottler::class),
- \OCP\Server::get(LoggerInterface::class)
+ Server::get(IThrottler::class),
+ Server::get(LoggerInterface::class)
);
$authPlugin = new \Sabre\DAV\Auth\Plugin($authBackend);
-$l10nFactory = \OCP\Server::get(IFactory::class);
-$serverFactory = new OCA\DAV\Connector\Sabre\ServerFactory(
- \OCP\Server::get(IConfig::class),
- \OCP\Server::get(LoggerInterface::class),
- \OCP\Server::get(IDBConnection::class),
- \OCP\Server::get(IUserSession::class),
- \OCP\Server::get(IMountManager::class),
- \OCP\Server::get(ITagManager::class),
+$l10nFactory = Server::get(IFactory::class);
+$serverFactory = new ServerFactory(
+ Server::get(IConfig::class),
+ Server::get(LoggerInterface::class),
+ Server::get(IDBConnection::class),
+ Server::get(IUserSession::class),
+ Server::get(IMountManager::class),
+ Server::get(ITagManager::class),
$request,
- \OCP\Server::get(IPreview::class),
+ Server::get(IPreview::class),
$eventDispatcher,
$l10nFactory->get('dav'),
);
-$linkCheckPlugin = new \OCA\DAV\Files\Sharing\PublicLinkCheckPlugin();
-$filesDropPlugin = new \OCA\DAV\Files\Sharing\FilesDropPlugin();
+$linkCheckPlugin = new PublicLinkCheckPlugin();
+$filesDropPlugin = new FilesDropPlugin();
// Define root url with /public.php/dav/files/TOKEN
/** @var string $baseuri defined in public.php */
if ($server->httpRequest->getMethod() !== 'GET') {
// If this is *not* a GET request we only allow access to public DAV from AJAX or when Server2Server is allowed
$isAjax = in_array('XMLHttpRequest', explode(',', $_SERVER['HTTP_X_REQUESTED_WITH'] ?? ''));
- $federatedShareProvider = \OCP\Server::get(FederatedShareProvider::class);
+ $federatedShareProvider = Server::get(FederatedShareProvider::class);
if ($federatedShareProvider->isOutgoingServer2serverShareEnabled() === false && $isAjax === false) {
// this is what is thrown when trying to access a non-existing share
throw new NotAuthenticated();
$share = $authBackend->getShare();
$owner = $share->getShareOwner();
- $isReadable = $share->getPermissions() & \OCP\Constants::PERMISSION_READ;
+ $isReadable = $share->getPermissions() & Constants::PERMISSION_READ;
$fileId = $share->getNodeId();
// FIXME: should not add storage wrappers outside of preSetup, need to find a better way
/** @psalm-suppress MissingClosureParamType */
Filesystem::addStorageWrapper('sharePermissions', function ($mountPoint, $storage) use ($share) {
- return new PermissionsMask(['storage' => $storage, 'mask' => $share->getPermissions() | \OCP\Constants::PERMISSION_SHARE]);
+ return new PermissionsMask(['storage' => $storage, 'mask' => $share->getPermissions() | Constants::PERMISSION_SHARE]);
});
/** @psalm-suppress MissingClosureParamType */
/** @psalm-suppress InternalMethod */
Filesystem::logWarningWhenAddingStorageWrapper($previousLog);
- $rootFolder = \OCP\Server::get(\OCP\Files\IRootFolder::class);
+ $rootFolder = Server::get(IRootFolder::class);
$userFolder = $rootFolder->getUserFolder($owner);
$node = $userFolder->getFirstNodeById($fileId);
if (!$node) {
<?php
+use OCA\DAV\Server;
+
/**
* SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
\OC_Util::obEnd();
$request = \OC::$server->getRequest();
-$server = new \OCA\DAV\Server($request, $baseuri);
+$server = new Server($request, $baseuri);
$server->exec();
use OCA\DAV\CalDAV\Reminder\NotificationProvider\PushProvider;
use OCA\DAV\CalDAV\Reminder\NotificationProviderManager;
use OCA\DAV\CalDAV\Reminder\Notifier;
-
use OCA\DAV\Capabilities;
+
use OCA\DAV\CardDAV\ContactsManager;
use OCA\DAV\CardDAV\PhotoCache;
use OCA\DAV\CardDAV\SyncService;
use OCP\Federation\Events\TrustedServerRemovedEvent;
use OCP\Files\AppData\IAppDataFactory;
use OCP\IUser;
+use OCP\Server;
use OCP\User\Events\OutOfOfficeChangedEvent;
use OCP\User\Events\OutOfOfficeClearedEvent;
use OCP\User\Events\OutOfOfficeScheduledEvent;
$dispatcher->addListener(UserUpdatedEvent::class, function (UserUpdatedEvent $event) use ($container): void {
/** @var SyncService $syncService */
- $syncService = \OCP\Server::get(SyncService::class);
+ $syncService = Server::get(SyncService::class);
$syncService->updateUser($event->getUser());
});
*/
namespace OCA\DAV\BackgroundJob;
+use OCA\DAV\CalDAV\Reminder\NotificationProvider\ProviderNotAvailableException;
+use OCA\DAV\CalDAV\Reminder\NotificationTypeDoesNotExistException;
use OCA\DAV\CalDAV\Reminder\ReminderService;
use OCP\AppFramework\Utility\ITimeFactory;
use OCP\BackgroundJob\TimedJob;
}
/**
- * @throws \OCA\DAV\CalDAV\Reminder\NotificationProvider\ProviderNotAvailableException
- * @throws \OCA\DAV\CalDAV\Reminder\NotificationTypeDoesNotExistException
+ * @throws ProviderNotAvailableException
+ * @throws NotificationTypeDoesNotExistException
* @throws \OC\User\NoUserException
*/
public function run($argument):void {
namespace OCA\DAV\CalDAV\AppCalendar;
+use OCA\DAV\CalDAV\CachedSubscriptionImpl;
+use OCA\DAV\CalDAV\CalendarImpl;
use OCA\DAV\CalDAV\Integration\ExternalCalendar;
use OCA\DAV\CalDAV\Integration\ICalendarProvider;
use OCP\Calendar\IManager;
return array_values(
array_filter($this->manager->getCalendarsForPrincipal($principalUri, $calendarUris), function ($c) {
// We must not provide a wrapper for DAV calendars
- return ! (($c instanceof \OCA\DAV\CalDAV\CalendarImpl) || ($c instanceof \OCA\DAV\CalDAV\CachedSubscriptionImpl));
+ return ! (($c instanceof CalendarImpl) || ($c instanceof CachedSubscriptionImpl));
})
);
}
/**
* @param boolean $value
- * @param \OCA\DAV\CalDAV\Calendar $calendar
+ * @param Calendar $calendar
* @return string|null
*/
public function setPublishStatus($value, $calendar) {
}
/**
- * @param \OCA\DAV\CalDAV\Calendar $calendar
+ * @param Calendar $calendar
* @return mixed
*/
public function getPublishStatus($calendar) {
use OCA\DAV\CalDAV\Auth\CustomPrincipalPlugin;
use OCA\DAV\CalDAV\Auth\PublicPrincipalPlugin;
use OCA\DAV\CalDAV\DefaultCalendarValidator;
+use OCA\DAV\CalDAV\Publishing\PublishPlugin;
use OCA\DAV\Connector\Sabre\AnonymousOptionsPlugin;
use OCA\DAV\Connector\Sabre\BlockLegacyClientPlugin;
use OCA\DAV\Connector\Sabre\CachingTree;
use OCA\DAV\Connector\Sabre\DavAclPlugin;
+use OCA\DAV\Connector\Sabre\ExceptionLoggerPlugin;
+use OCA\DAV\Connector\Sabre\LockPlugin;
+use OCA\DAV\Connector\Sabre\MaintenancePlugin;
use OCA\DAV\Events\SabrePluginAuthInitEvent;
use OCA\DAV\RootCollection;
use OCA\Theming\ThemingDefaults;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\IConfig;
+use OCP\Server;
use Psr\Log\LoggerInterface;
use Sabre\VObject\ITip\Message;
*/
public function __construct(bool $public = true) {
$baseUri = \OC::$WEBROOT . '/remote.php/dav/';
- $logger = \OCP\Server::get(LoggerInterface::class);
- $dispatcher = \OCP\Server::get(IEventDispatcher::class);
+ $logger = Server::get(LoggerInterface::class);
+ $dispatcher = Server::get(IEventDispatcher::class);
$root = new RootCollection();
$this->server = new \OCA\DAV\Connector\Sabre\Server(new CachingTree($root));
// Add maintenance plugin
- $this->server->addPlugin(new \OCA\DAV\Connector\Sabre\MaintenancePlugin(\OC::$server->getConfig(), \OC::$server->getL10N('dav')));
+ $this->server->addPlugin(new MaintenancePlugin(\OC::$server->getConfig(), \OC::$server->getL10N('dav')));
// Set URL explicitly due to reverse-proxy situations
$this->server->httpRequest->setUrl($baseUri);
$this->server->setBaseUri($baseUri);
$this->server->addPlugin(new BlockLegacyClientPlugin(
- \OCP\Server::get(IConfig::class),
- \OCP\Server::get(ThemingDefaults::class),
+ Server::get(IConfig::class),
+ Server::get(ThemingDefaults::class),
));
$this->server->addPlugin(new AnonymousOptionsPlugin());
$event = new SabrePluginAuthInitEvent($this->server);
$dispatcher->dispatchTyped($event);
- $this->server->addPlugin(new \OCA\DAV\Connector\Sabre\ExceptionLoggerPlugin('webdav', $logger));
- $this->server->addPlugin(new \OCA\DAV\Connector\Sabre\LockPlugin());
+ $this->server->addPlugin(new ExceptionLoggerPlugin('webdav', $logger));
+ $this->server->addPlugin(new LockPlugin());
$this->server->addPlugin(new \Sabre\DAV\Sync\Plugin());
// acl
$this->server->addPlugin(new \Sabre\CalDAV\Subscriptions\Plugin());
$this->server->addPlugin(new \Sabre\CalDAV\Notifications\Plugin());
//$this->server->addPlugin(new \OCA\DAV\DAV\Sharing\Plugin($authBackend, \OC::$server->getRequest()));
- $this->server->addPlugin(new \OCA\DAV\CalDAV\Publishing\PublishPlugin(
+ $this->server->addPlugin(new PublishPlugin(
\OC::$server->getConfig(),
\OC::$server->getURLGenerator()
));
use OCP\Mail\Headers\AutoSubmitted;
use OCP\Mail\IEMailTemplate;
use OCP\Mail\IMailer;
+use OCP\Util;
use Psr\Log\LoggerInterface;
use Sabre\VObject;
use Sabre\VObject\Component\VEvent;
$lang = $fallbackLanguage;
}
$l10n = $this->getL10NForLang($lang);
- $fromEMail = \OCP\Util::getDefaultEmailAddress('reminders-noreply');
+ $fromEMail = Util::getDefaultEmailAddress('reminders-noreply');
$template = $this->mailer->createEMailTemplate('dav.calendarReminder');
$template->addHeader();
*/
namespace OCA\DAV\CalDAV\Reminder;
+use OCA\DAV\CalDAV\Reminder\NotificationProvider\ProviderNotAvailableException;
+
/**
* Class NotificationProviderManager
*
if (isset($this->providers[$type])) {
return $this->providers[$type];
}
- throw new NotificationProvider\ProviderNotAvailableException($type);
+ throw new ProviderNotAvailableException($type);
}
throw new NotificationTypeDoesNotExistException($type);
}
use OCP\IConfig;
use OCP\IUserSession;
use OCP\Mail\IMailer;
+use OCP\Mail\Provider\Address;
+use OCP\Mail\Provider\Attachment;
use OCP\Mail\Provider\IManager as IMailManager;
use OCP\Mail\Provider\IMessageSend;
use OCP\Util;
// construct mail message and set required parameters
$message = $mailService->initiateMessage();
$message->setFrom(
- (new \OCP\Mail\Provider\Address($sender, $fromName))
+ (new Address($sender, $fromName))
);
$message->setTo(
- (new \OCP\Mail\Provider\Address($recipient, $recipientName))
+ (new Address($recipient, $recipientName))
);
$message->setSubject($template->renderSubject());
$message->setBodyPlain($template->renderText());
$message->setBodyHtml($template->renderHtml());
- $message->setAttachments((new \OCP\Mail\Provider\Attachment(
+ $message->setAttachments((new Attachment(
$itip_msg,
'event.ics',
'text/calendar; method=' . $iTipMessage->method,
use OCA\DAV\CalDAV\CalDavBackend;
use OCA\DAV\CalDAV\Calendar;
use OCA\DAV\CalDAV\CalendarHome;
+use OCA\DAV\CalDAV\CalendarObject;
use OCA\DAV\CalDAV\DefaultCalendarValidator;
use OCP\IConfig;
use Psr\Log\LoggerInterface;
return;
}
- /** @var \OCA\DAV\CalDAV\Calendar $calendarNode */
+ /** @var Calendar $calendarNode */
$calendarNode = $this->server->tree->getNodeForPath($calendarPath);
// extract addresses for owner
$addresses = $this->getAddressesForPrincipal($calendarNode->getOwner());
// determine if we are updating a calendar event
if (!$isNew) {
// retrieve current calendar event node
- /** @var \OCA\DAV\CalDAV\CalendarObject $currentNode */
+ /** @var CalendarObject $currentNode */
$currentNode = $this->server->tree->getNodeForPath($request->getPath());
// convert calendar event string data to VCalendar object
/** @var \Sabre\VObject\Component\VCalendar $currentObject */
$calendarTimeZone = new DateTimeZone('UTC');
$homePath = $result[0][200]['{' . self::NS_CALDAV . '}calendar-home-set']->getHref();
- /** @var \OCA\DAV\CalDAV\Calendar $node */
+ /** @var Calendar $node */
foreach ($this->server->tree->getNodeForPath($homePath)->getChildren() as $node) {
if (!$node instanceof ICalendar) {
* This report is used by clients to request calendar objects based on
* complex conditions.
*
- * @param Xml\Request\CalendarSearchReport $report
+ * @param CalendarSearchReport $report
* @return void
*/
private function calendarSearch($report) {
*/
private function register(IManager $cm, $addressBooks, $urlGenerator) {
foreach ($addressBooks as $addressBookInfo) {
- $addressBook = new \OCA\DAV\CardDAV\AddressBook($this->backend, $addressBookInfo, $this->l10n);
+ $addressBook = new AddressBook($this->backend, $addressBookInfo, $this->l10n);
$cm->registerAddressBook(
new AddressBookImpl(
$addressBook,
use OCP\Files\NotPermittedException;
use OCP\Files\SimpleFS\ISimpleFile;
use OCP\Files\SimpleFS\ISimpleFolder;
+use OCP\Image;
use Psr\Log\LoggerInterface;
use Sabre\CardDAV\Card;
use Sabre\VObject\Document;
throw new NotFoundException;
}
- $photo = new \OCP\Image();
+ $photo = new Image();
/** @var ISimpleFile $file */
$file = $folder->getFile('photo.' . $ext);
$photo->loadFromData($file->getContent());
use OCP\IRequest;
use OCP\IUser;
use OCP\IUserSession;
+use OCP\Server;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\NotFoundExceptionInterface;
use Sabre\CardDAV\Backend;
$addressBook,
$this->l10n,
$this->config,
- \OCP\Server::get(IUserSession::class),
+ Server::get(IUserSession::class),
$request,
$trustedServers,
$this->groupManager
use OCP\Comments\IComment;
use OCP\Comments\ICommentsManager;
+use OCP\Comments\MessageTooLongException;
use OCP\IUserSession;
use Sabre\DAV\Exception\BadRequest;
use Sabre\DAV\Exception\NotFound;
return $comment;
} catch (\InvalidArgumentException $e) {
throw new BadRequest('Invalid input values', 0, $e);
- } catch (\OCP\Comments\MessageTooLongException $e) {
+ } catch (MessageTooLongException $e) {
$msg = 'Message exceeds allowed character limit of ';
- throw new BadRequest($msg . \OCP\Comments\IComment::MAX_MESSAGE_LENGTH, 0, $e);
+ throw new BadRequest($msg . IComment::MAX_MESSAGE_LENGTH, 0, $e);
}
}
}
namespace OCA\DAV\Connector;
use OCA\DAV\Connector\Sabre\PublicAuth;
+use OCP\Defaults;
use OCP\IRequest;
use OCP\ISession;
use OCP\Security\Bruteforce\IThrottler;
$this->throttler = $throttler;
// setup realm
- $defaults = new \OCP\Defaults();
+ $defaults = new Defaults();
$this->realm = $defaults->getName() ?: 'Nextcloud';
}
use OC\User\Session;
use OCA\DAV\Connector\Sabre\Exception\PasswordLoginForbidden;
use OCA\DAV\Connector\Sabre\Exception\TooManyRequests;
+use OCP\Defaults;
use OCP\IRequest;
use OCP\ISession;
use OCP\Security\Bruteforce\IThrottler;
$this->principalPrefix = $principalPrefix;
// setup realm
- $defaults = new \OCP\Defaults();
+ $defaults = new Defaults();
$this->realm = $defaults->getName() ?: 'Nextcloud';
}
*/
namespace OCA\DAV\Connector\Sabre;
+use OCP\Defaults;
use OCP\IRequest;
use OCP\ISession;
use OCP\IUserSession;
$this->principalPrefix = $principalPrefix;
// setup realm
- $defaults = new \OCP\Defaults();
+ $defaults = new Defaults();
$this->realm = $defaults->getName() ?: 'Nextcloud';
}
use OCA\DAV\Connector\Sabre\Exception\FileLocked;
use OCA\DAV\Connector\Sabre\Exception\Forbidden;
use OCA\DAV\Connector\Sabre\Exception\InvalidPath;
+use OCP\App\IAppManager;
use OCP\Files\FileInfo;
use OCP\Files\Folder;
use OCP\Files\ForbiddenException;
use OCP\Files\InvalidPathException;
+use OCP\Files\NotFoundException;
use OCP\Files\NotPermittedException;
use OCP\Files\StorageNotAvailableException;
use OCP\IL10N;
use OCP\L10N\IFactory;
use OCP\Lock\ILockingProvider;
use OCP\Lock\LockedException;
+use OCP\Server;
use OCP\Share\IManager as IShareManager;
use Psr\Log\LoggerInterface;
use Sabre\DAV\Exception\BadRequest;
use Sabre\DAV\IFile;
use Sabre\DAV\INode;
-class Directory extends \OCA\DAV\Connector\Sabre\Node implements \Sabre\DAV\ICollection, \Sabre\DAV\IQuota, \Sabre\DAV\IMoveTarget, \Sabre\DAV\ICopyTarget {
+class Directory extends Node implements \Sabre\DAV\ICollection, \Sabre\DAV\IQuota, \Sabre\DAV\IMoveTarget, \Sabre\DAV\ICopyTarget {
/**
* Cached directory content
* @var \OCP\Files\FileInfo[]
'type' => FileInfo::TYPE_FILE
], null);
}
- $node = new \OCA\DAV\Connector\Sabre\File($this->fileView, $info);
+ $node = new File($this->fileView, $info);
// only allow 1 process to upload a file at once but still allow reading the file while writing the part file
$node->acquireLock(ILockingProvider::LOCK_SHARED);
$this->fileView->unlockFile($path . '.upload.part', ILockingProvider::LOCK_EXCLUSIVE);
$node->releaseLock(ILockingProvider::LOCK_SHARED);
return $result;
- } catch (\OCP\Files\StorageNotAvailableException $e) {
+ } catch (StorageNotAvailableException $e) {
throw new \Sabre\DAV\Exception\ServiceUnavailable($e->getMessage(), $e->getCode(), $e);
} catch (InvalidPathException $ex) {
throw new InvalidPath($ex->getMessage(), false, $ex);
if (!$this->fileView->mkdir($newPath)) {
throw new \Sabre\DAV\Exception\Forbidden('Could not create directory ' . $newPath);
}
- } catch (\OCP\Files\StorageNotAvailableException $e) {
+ } catch (StorageNotAvailableException $e) {
throw new \Sabre\DAV\Exception\ServiceUnavailable($e->getMessage(), 0, $e);
} catch (InvalidPathException $ex) {
throw new InvalidPath($ex->getMessage(), false, $ex);
try {
$this->fileView->verifyPath($this->path, $name, true);
$info = $this->fileView->getFileInfo($path);
- } catch (\OCP\Files\StorageNotAvailableException $e) {
+ } catch (StorageNotAvailableException $e) {
throw new \Sabre\DAV\Exception\ServiceUnavailable($e->getMessage(), 0, $e);
} catch (InvalidPathException $ex) {
throw new InvalidPath($ex->getMessage(), false, $ex);
if ($info->getMimeType() === FileInfo::MIMETYPE_FOLDER) {
$node = new \OCA\DAV\Connector\Sabre\Directory($this->fileView, $info, $this->tree, $this->shareManager);
} else {
- $node = new \OCA\DAV\Connector\Sabre\File($this->fileView, $info, $this->shareManager, $request, $l10n);
+ $node = new File($this->fileView, $info, $this->shareManager, $request, $l10n);
}
if ($this->tree) {
$this->tree->cacheNode($node);
*
* @return \Sabre\DAV\INode[]
* @throws \Sabre\DAV\Exception\Locked
- * @throws \OCA\DAV\Connector\Sabre\Exception\Forbidden
+ * @throws Forbidden
*/
public function getChildren() {
if (!is_null($this->dirContent)) {
if (!$this->info->isReadable()) {
// return 403 instead of 404 because a 404 would make
// the caller believe that the collection itself does not exist
- if (\OCP\Server::get(\OCP\App\IAppManager::class)->isInstalled('files_accesscontrol')) {
+ if (Server::get(IAppManager::class)->isInstalled('files_accesscontrol')) {
throw new Forbidden('No read permissions. This might be caused by files_accesscontrol, check your configured rules');
} else {
throw new Forbidden('No read permissions');
try {
$storageInfo = \OC_Helper::getStorageInfo($relativePath, $this->info, false);
- if ($storageInfo['quota'] === \OCP\Files\FileInfo::SPACE_UNLIMITED) {
- $free = \OCP\Files\FileInfo::SPACE_UNLIMITED;
+ if ($storageInfo['quota'] === FileInfo::SPACE_UNLIMITED) {
+ $free = FileInfo::SPACE_UNLIMITED;
} else {
$free = $storageInfo['free'];
}
$free
];
return $this->quotaInfo;
- } catch (\OCP\Files\NotFoundException $e) {
+ } catch (NotFoundException $e) {
$this->getLogger()->warning('error while getting quota into', ['exception' => $e]);
return [0, 0];
- } catch (\OCP\Files\StorageNotAvailableException $e) {
+ } catch (StorageNotAvailableException $e) {
$this->getLogger()->warning('error while getting quota into', ['exception' => $e]);
return [0, 0];
} catch (NotPermittedException $e) {
namespace OCA\DAV\Connector\Sabre\Exception;
use Exception;
+use OCP\Files\LockNotAcquiredException;
class FileLocked extends \Sabre\DAV\Exception {
/**
* @param int $code
*/
public function __construct($message = '', $code = 0, ?Exception $previous = null) {
- if ($previous instanceof \OCP\Files\LockNotAcquiredException) {
+ if ($previous instanceof LockNotAcquiredException) {
$message = sprintf('Target file %s is locked by another process.', $previous->path);
}
parent::__construct($message, $code, $previous);
use OCA\DAV\Connector\Sabre\Exception\FileLocked;
use OCA\DAV\Connector\Sabre\Exception\Forbidden as DAVForbiddenException;
use OCA\DAV\Connector\Sabre\Exception\UnsupportedMediaType;
+use OCP\App\IAppManager;
use OCP\Encryption\Exceptions\GenericEncryptionException;
use OCP\Files\EntityTooLargeException;
use OCP\Files\FileInfo;
use OCP\L10N\IFactory as IL10NFactory;
use OCP\Lock\ILockingProvider;
use OCP\Lock\LockedException;
+use OCP\Server;
use OCP\Share\IManager;
use Psr\Log\LoggerInterface;
use Sabre\DAV\Exception;
}
$needsPartFile = $partStorage->needsPartFile() && (strlen($this->path) > 1);
- $view = \OC\Files\Filesystem::getView();
+ $view = Filesystem::getView();
if ($needsPartFile) {
// mark file as partial while uploading (ignored by the scanner)
$run = true;
if (!$exists) {
- \OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_create, [
- \OC\Files\Filesystem::signal_param_path => $hookPath,
- \OC\Files\Filesystem::signal_param_run => &$run,
+ \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_create, [
+ Filesystem::signal_param_path => $hookPath,
+ Filesystem::signal_param_run => &$run,
]);
} else {
- \OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_update, [
- \OC\Files\Filesystem::signal_param_path => $hookPath,
- \OC\Files\Filesystem::signal_param_run => &$run,
+ \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_update, [
+ Filesystem::signal_param_path => $hookPath,
+ Filesystem::signal_param_run => &$run,
]);
}
- \OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_write, [
- \OC\Files\Filesystem::signal_param_path => $hookPath,
- \OC\Files\Filesystem::signal_param_run => &$run,
+ \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_write, [
+ Filesystem::signal_param_path => $hookPath,
+ Filesystem::signal_param_run => &$run,
]);
return $run;
}
return;
}
if (!$exists) {
- \OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_post_create, [
- \OC\Files\Filesystem::signal_param_path => $hookPath
+ \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_create, [
+ Filesystem::signal_param_path => $hookPath
]);
} else {
- \OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_post_update, [
- \OC\Files\Filesystem::signal_param_path => $hookPath
+ \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_update, [
+ Filesystem::signal_param_path => $hookPath
]);
}
- \OC_Hook::emit(\OC\Files\Filesystem::CLASSNAME, \OC\Files\Filesystem::signal_post_write, [
- \OC\Files\Filesystem::signal_param_path => $hookPath
+ \OC_Hook::emit(Filesystem::CLASSNAME, Filesystem::signal_post_write, [
+ Filesystem::signal_param_path => $hookPath
]);
}
* @return array|bool
*/
public function getDirectDownload() {
- if (\OCP\Server::get(\OCP\App\IAppManager::class)->isEnabledForUser('encryption')) {
+ if (Server::get(IAppManager::class)->isEnabledForUser('encryption')) {
return [];
}
[$storage, $internalPath] = $this->fileView->resolvePath($this->path);
}
}
- if ($node instanceof \OCA\DAV\Connector\Sabre\File) {
+ if ($node instanceof File) {
//Add OC-Checksum header
$checksum = $node->getChecksum();
if ($checksum !== null && $checksum !== '') {
public function handleGetProperties(PropFind $propFind, \Sabre\DAV\INode $node) {
$httpRequest = $this->server->httpRequest;
- if ($node instanceof \OCA\DAV\Connector\Sabre\Node) {
+ if ($node instanceof Node) {
/**
* This was disabled, because it made dir listing throw an exception,
* so users were unable to navigate into folders where one subitem
});
}
- if ($node instanceof \OCA\DAV\Connector\Sabre\File) {
+ if ($node instanceof File) {
$propFind->handle(self::DOWNLOADURL_PROPERTYNAME, function () use ($node) {
try {
$directDownloadUrl = $node->getDirectDownload();
*/
public function handleUpdateProperties($path, PropPatch $propPatch) {
$node = $this->tree->getNodeForPath($path);
- if (!($node instanceof \OCA\DAV\Connector\Sabre\Node)) {
+ if (!($node instanceof Node)) {
return;
}
return;
}
$node = $this->server->tree->getNodeForPath($filePath);
- if ($node instanceof \OCA\DAV\Connector\Sabre\Node) {
+ if ($node instanceof Node) {
$fileId = $node->getFileId();
if (!is_null($fileId)) {
$this->server->httpResponse->setHeader('OC-FileId', $fileId);
namespace OCA\DAV\Connector\Sabre;
use OC\Files\View;
+use OCA\Circles\Api\v1\Circles;
use OCP\App\IAppManager;
use OCP\Files\Folder;
use OCP\Files\Node as INode;
if (!$this->appManager->isEnabledForUser('circles') || !class_exists('\OCA\Circles\Api\v1\Circles')) {
return [];
}
- return \OCA\Circles\Api\v1\Circles::getFilesForCircles($circlesIds);
+ return Circles::getFilesForCircles($circlesIds);
}
return $results;
}
- protected function wrapNode(\OCP\Files\Node $node): File|Directory {
+ protected function wrapNode(INode $node): File|Directory {
if ($node instanceof \OCP\Files\File) {
return new File($this->fileView, $node);
} else {
use OC\Files\Node\Folder;
use OC\Files\View;
use OCA\DAV\Connector\Sabre\Exception\InvalidPath;
+use OCP\Constants;
use OCP\Files\DavUtil;
use OCP\Files\FileInfo;
+use OCP\Files\InvalidPathException;
use OCP\Files\IRootFolder;
use OCP\Files\NotFoundException;
use OCP\Files\Storage\ISharedStorage;
}
if (!$mountpoint->getOption('readonly', false) && $mountpointpath === $this->info->getPath()) {
- $permissions |= \OCP\Constants::PERMISSION_DELETE | \OCP\Constants::PERMISSION_UPDATE;
+ $permissions |= Constants::PERMISSION_DELETE | Constants::PERMISSION_UPDATE;
}
}
/*
* Files can't have create or delete permissions
*/
- if ($this->info->getType() === \OCP\Files\FileInfo::TYPE_FILE) {
- $permissions &= ~(\OCP\Constants::PERMISSION_CREATE | \OCP\Constants::PERMISSION_DELETE);
+ if ($this->info->getType() === FileInfo::TYPE_FILE) {
+ $permissions &= ~(Constants::PERMISSION_CREATE | Constants::PERMISSION_DELETE);
}
return $permissions;
dirname($path),
basename($path),
);
- } catch (\OCP\Files\InvalidPathException $ex) {
+ } catch (InvalidPathException $ex) {
throw new InvalidPath($ex->getMessage());
}
}
use OC\Files\FileInfo;
use OC\Files\Storage\FailedStorage;
+use OC\Files\View;
use OCA\DAV\Connector\Sabre\Exception\FileLocked;
use OCA\DAV\Connector\Sabre\Exception\Forbidden;
use OCA\DAV\Connector\Sabre\Exception\InvalidPath;
use OCP\Files\ForbiddenException;
+use OCP\Files\InvalidPathException;
+use OCP\Files\Mount\IMountManager;
use OCP\Files\StorageInvalidException;
use OCP\Files\StorageNotAvailableException;
use OCP\Lock\LockedException;
* @param \OC\Files\View $view
* @param \OCP\Files\Mount\IMountManager $mountManager
*/
- public function init(\Sabre\DAV\INode $rootNode, \OC\Files\View $view, \OCP\Files\Mount\IMountManager $mountManager) {
+ public function init(\Sabre\DAV\INode $rootNode, View $view, IMountManager $mountManager) {
$this->rootNode = $rootNode;
$this->fileView = $view;
$this->mountManager = $mountManager;
if ($path) {
try {
$this->fileView->verifyPath($path, basename($path));
- } catch (\OCP\Files\InvalidPathException $ex) {
+ } catch (InvalidPathException $ex) {
throw new InvalidPath($ex->getMessage());
}
}
}
if ($info->getType() === 'dir') {
- $node = new \OCA\DAV\Connector\Sabre\Directory($this->fileView, $info, $this);
+ $node = new Directory($this->fileView, $info, $this);
} else {
- $node = new \OCA\DAV\Connector\Sabre\File($this->fileView, $info);
+ $node = new File($this->fileView, $info);
}
$this->cache[$path] = $node;
[$destinationDir, $destinationName] = \Sabre\Uri\split($destinationPath);
try {
$this->fileView->verifyPath($destinationDir, $destinationName);
- } catch (\OCP\Files\InvalidPathException $ex) {
+ } catch (InvalidPathException $ex) {
throw new InvalidPath($ex->getMessage());
}
namespace OCA\DAV\Connector\Sabre;
use OC\KnownUser\KnownUserService;
+use OCA\Circles\Api\v1\Circles;
use OCA\Circles\Exceptions\CircleNotFoundException;
use OCA\DAV\CalDAV\Proxy\ProxyMapper;
use OCA\DAV\Traits\PrincipalProxyTrait;
}
try {
- $circle = \OCA\Circles\Api\v1\Circles::detailsCircle($circleUniqueId, true);
+ $circle = Circles::detailsCircle($circleUniqueId, true);
} catch (QueryException $ex) {
return null;
} catch (CircleNotFoundException $ex) {
throw new Exception('Principal not found');
}
- $circles = \OCA\Circles\Api\v1\Circles::joinedCircles($name, true);
+ $circles = Circles::joinedCircles($name, true);
$circles = array_map(function ($circle) {
/** @var \OCA\Circles\Model\Circle $circle */
namespace OCA\DAV\Connector\Sabre;
+use OCP\Defaults;
use OCP\IRequest;
use OCP\ISession;
use OCP\Security\Bruteforce\IThrottler;
$this->logger = $logger;
// setup realm
- $defaults = new \OCP\Defaults();
+ $defaults = new Defaults();
$this->realm = $defaults->getName();
}
use OCA\DAV\AppInfo\PluginManager;
use OCA\DAV\CalDAV\DefaultCalendarValidator;
+use OCA\DAV\DAV\CustomPropertiesBackend;
use OCA\DAV\DAV\ViewOnlyPlugin;
use OCA\DAV\Files\ErrorPagePlugin;
use OCA\Theming\ThemingDefaults;
Plugin $authPlugin,
callable $viewCallBack): Server {
// Fire up server
- $objectTree = new \OCA\DAV\Connector\Sabre\ObjectTree();
- $server = new \OCA\DAV\Connector\Sabre\Server($objectTree);
+ $objectTree = new ObjectTree();
+ $server = new Server($objectTree);
// Set URL explicitly due to reverse-proxy situations
$server->httpRequest->setUrl($requestUri);
$server->setBaseUri($baseUri);
// Load plugins
- $server->addPlugin(new \OCA\DAV\Connector\Sabre\MaintenancePlugin($this->config, $this->l10n));
+ $server->addPlugin(new MaintenancePlugin($this->config, $this->l10n));
$server->addPlugin(new BlockLegacyClientPlugin(
$this->config,
\OCP\Server::get(ThemingDefaults::class),
));
- $server->addPlugin(new \OCA\DAV\Connector\Sabre\AnonymousOptionsPlugin());
+ $server->addPlugin(new AnonymousOptionsPlugin());
$server->addPlugin($authPlugin);
// FIXME: The following line is a workaround for legacy components relying on being able to send a GET to /
- $server->addPlugin(new \OCA\DAV\Connector\Sabre\DummyGetResponsePlugin());
- $server->addPlugin(new \OCA\DAV\Connector\Sabre\ExceptionLoggerPlugin('webdav', $this->logger));
- $server->addPlugin(new \OCA\DAV\Connector\Sabre\LockPlugin());
+ $server->addPlugin(new DummyGetResponsePlugin());
+ $server->addPlugin(new ExceptionLoggerPlugin('webdav', $this->logger));
+ $server->addPlugin(new LockPlugin());
$server->addPlugin(new RequestIdHeaderPlugin($this->request));
'/OneNote/',
'/Microsoft-WebDAV-MiniRedir/',
])) {
- $server->addPlugin(new \OCA\DAV\Connector\Sabre\FakeLockerPlugin());
+ $server->addPlugin(new FakeLockerPlugin());
}
$server->addPlugin(new ErrorPagePlugin($this->request, $this->config));
// Create Nextcloud Dir
if ($rootInfo->getType() === 'dir') {
- $root = new \OCA\DAV\Connector\Sabre\Directory($view, $rootInfo, $objectTree);
+ $root = new Directory($view, $rootInfo, $objectTree);
} else {
- $root = new \OCA\DAV\Connector\Sabre\File($view, $rootInfo);
+ $root = new File($view, $rootInfo);
}
$objectTree->init($root, $view, $this->mountManager);
$server->addPlugin(
- new \OCA\DAV\Connector\Sabre\FilesPlugin(
+ new FilesPlugin(
$objectTree,
$this->config,
$this->request,
!$this->config->getSystemValue('debug', false)
)
);
- $server->addPlugin(new \OCA\DAV\Connector\Sabre\QuotaPlugin($view, true));
- $server->addPlugin(new \OCA\DAV\Connector\Sabre\ChecksumUpdatePlugin());
+ $server->addPlugin(new QuotaPlugin($view, true));
+ $server->addPlugin(new ChecksumUpdatePlugin());
// Allow view-only plugin for webdav requests
$server->addPlugin(new ViewOnlyPlugin(
));
if ($this->userSession->isLoggedIn()) {
- $server->addPlugin(new \OCA\DAV\Connector\Sabre\TagsPlugin($objectTree, $this->tagManager));
- $server->addPlugin(new \OCA\DAV\Connector\Sabre\SharesPlugin(
+ $server->addPlugin(new TagsPlugin($objectTree, $this->tagManager));
+ $server->addPlugin(new SharesPlugin(
$objectTree,
$this->userSession,
$userFolder,
\OC::$server->getShareManager()
));
- $server->addPlugin(new \OCA\DAV\Connector\Sabre\CommentPropertiesPlugin(\OC::$server->getCommentsManager(), $this->userSession));
- $server->addPlugin(new \OCA\DAV\Connector\Sabre\FilesReportPlugin(
+ $server->addPlugin(new CommentPropertiesPlugin(\OC::$server->getCommentsManager(), $this->userSession));
+ $server->addPlugin(new FilesReportPlugin(
$objectTree,
$view,
\OC::$server->getSystemTagManager(),
// custom properties plugin must be the last one
$server->addPlugin(
new \Sabre\DAV\PropertyStorage\Plugin(
- new \OCA\DAV\DAV\CustomPropertiesBackend(
+ new CustomPropertiesBackend(
$server,
$objectTree,
$this->databaseConnection,
)
);
}
- $server->addPlugin(new \OCA\DAV\Connector\Sabre\CopyEtagHeaderPlugin());
+ $server->addPlugin(new CopyEtagHeaderPlugin());
// Load dav plugins from apps
$event = new SabrePluginEvent($server);
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*/
-
+use OCP\ITagManager;
use Sabre\DAV\PropFind;
use Sabre\DAV\PropPatch;
* @param \Sabre\DAV\Tree $tree tree
* @param \OCP\ITagManager $tagManager tag manager
*/
- public function __construct(\Sabre\DAV\Tree $tree, \OCP\ITagManager $tagManager) {
+ public function __construct(\Sabre\DAV\Tree $tree, ITagManager $tagManager) {
$this->tree = $tree;
$this->tagManager = $tagManager;
$this->tagger = null;
PropFind $propFind,
\Sabre\DAV\INode $node,
) {
- if (!($node instanceof \OCA\DAV\Connector\Sabre\Node)) {
+ if (!($node instanceof Node)) {
return;
}
// need prefetch ?
- if ($node instanceof \OCA\DAV\Connector\Sabre\Directory
+ if ($node instanceof Directory
&& $propFind->getDepth() !== 0
&& (!is_null($propFind->getStatus(self::TAGS_PROPERTYNAME))
|| !is_null($propFind->getStatus(self::FAVORITE_PROPERTYNAME))
*/
public function handleUpdateProperties($path, PropPatch $propPatch) {
$node = $this->tree->getNodeForPath($path);
- if (!($node instanceof \OCA\DAV\Connector\Sabre\Node)) {
+ if (!($node instanceof Node)) {
return;
}
*/
public function handleDownload(Request $request, Response $response): ?bool {
$node = $this->tree->getNodeForPath($request->getPath());
- if (!($node instanceof \OCA\DAV\Connector\Sabre\Directory)) {
+ if (!($node instanceof Directory)) {
// only handle directories
return null;
}
use OC\Files\View;
use OCA\DAV\Connector\Sabre\CachingTree;
use OCA\DAV\Connector\Sabre\Directory;
+use OCA\DAV\Connector\Sabre\File;
use OCA\DAV\Connector\Sabre\FilesPlugin;
use OCA\DAV\Connector\Sabre\TagsPlugin;
use OCP\Files\Cache\ICacheEntry;
/** @var SearchResult[] $nodes */
$nodes = array_map(function (Node $node) {
if ($node instanceof Folder) {
- $davNode = new \OCA\DAV\Connector\Sabre\Directory($this->view, $node, $this->tree, $this->shareManager);
+ $davNode = new Directory($this->view, $node, $this->tree, $this->shareManager);
} else {
- $davNode = new \OCA\DAV\Connector\Sabre\File($this->view, $node, $this->shareManager);
+ $davNode = new File($this->view, $node, $this->shareManager);
}
$path = $this->getHrefForNode($node);
$this->tree->cacheNode($davNode, $path);
*/
namespace OCA\DAV\Files;
+use OC\Files\Filesystem;
use OCA\DAV\Connector\Sabre\Directory;
use OCP\Files\FileInfo;
use Sabre\DAV\Exception\Forbidden;
*/
public function __construct($principalInfo, FileInfo $userFolder) {
$this->principalInfo = $principalInfo;
- $view = \OC\Files\Filesystem::getView();
+ $view = Filesystem::getView();
parent::__construct($view, $userFolder);
}
use OCA\DAV\DAV\GroupPrincipalBackend;
use OCA\DAV\DAV\SystemPrincipalBackend;
use OCA\DAV\Provisioning\Apple\AppleProvisioningNode;
+use OCA\DAV\SystemTag\SystemTagsByIdCollection;
+use OCA\DAV\SystemTag\SystemTagsInUseCollection;
+use OCA\DAV\SystemTag\SystemTagsRelationsCollection;
use OCA\DAV\Upload\CleanupService;
use OCP\Accounts\IAccountManager;
use OCP\App\IAppManager;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\Files\IRootFolder;
use OCP\IConfig;
+use OCP\Server;
use Psr\Log\LoggerInterface;
use Sabre\DAV\SimpleCollection;
$dispatcher = \OC::$server->get(IEventDispatcher::class);
$config = \OC::$server->get(IConfig::class);
$proxyMapper = \OC::$server->query(ProxyMapper::class);
- $rootFolder = \OCP\Server::get(IRootFolder::class);
+ $rootFolder = Server::get(IRootFolder::class);
$userPrincipalBackend = new Principal(
$userManager,
$publicCalendarRoot = new PublicCalendarRoot($caldavBackend, $l10n, $config, $logger);
- $systemTagCollection = new SystemTag\SystemTagsByIdCollection(
+ $systemTagCollection = new SystemTagsByIdCollection(
\OC::$server->getSystemTagManager(),
\OC::$server->getUserSession(),
$groupManager
);
- $systemTagRelationsCollection = new SystemTag\SystemTagsRelationsCollection(
+ $systemTagRelationsCollection = new SystemTagsRelationsCollection(
\OC::$server->getSystemTagManager(),
\OC::$server->getSystemTagObjectMapper(),
\OC::$server->getUserSession(),
$dispatcher,
$rootFolder,
);
- $systemTagInUseCollection = \OCP\Server::get(SystemTag\SystemTagsInUseCollection::class);
+ $systemTagInUseCollection = Server::get(SystemTagsInUseCollection::class);
$commentsCollection = new Comments\RootCollection(
\OC::$server->getCommentsManager(),
$userManager,
*/
namespace OCA\DAV;
+use OC\Files\Filesystem;
use OCA\DAV\AppInfo\PluginManager;
use OCA\DAV\BulkUpload\BulkUploadPlugin;
+use OCA\DAV\CalDAV\BirthdayCalendar\EnablePlugin;
use OCA\DAV\CalDAV\BirthdayService;
use OCA\DAV\CalDAV\DefaultCalendarValidator;
+use OCA\DAV\CalDAV\EventComparisonService;
+use OCA\DAV\CalDAV\ICSExportPlugin\ICSExportPlugin;
+use OCA\DAV\CalDAV\Publishing\PublishPlugin;
use OCA\DAV\CalDAV\Schedule\IMipPlugin;
+use OCA\DAV\CalDAV\Schedule\IMipService;
use OCA\DAV\CalDAV\Security\RateLimitingPlugin;
use OCA\DAV\CalDAV\Validation\CalDavValidatePlugin;
use OCA\DAV\CardDAV\HasPhotoPlugin;
use OCA\DAV\CardDAV\Validation\CardDavValidatePlugin;
use OCA\DAV\Comments\CommentsPlugin;
use OCA\DAV\Connector\Sabre\AnonymousOptionsPlugin;
+use OCA\DAV\Connector\Sabre\AppleQuirksPlugin;
use OCA\DAV\Connector\Sabre\Auth;
use OCA\DAV\Connector\Sabre\BearerAuth;
use OCA\DAV\Connector\Sabre\BlockLegacyClientPlugin;
use OCA\DAV\Connector\Sabre\CopyEtagHeaderPlugin;
use OCA\DAV\Connector\Sabre\DavAclPlugin;
use OCA\DAV\Connector\Sabre\DummyGetResponsePlugin;
+use OCA\DAV\Connector\Sabre\ExceptionLoggerPlugin;
use OCA\DAV\Connector\Sabre\FakeLockerPlugin;
use OCA\DAV\Connector\Sabre\FilesPlugin;
use OCA\DAV\Connector\Sabre\FilesReportPlugin;
+use OCA\DAV\Connector\Sabre\LockPlugin;
+use OCA\DAV\Connector\Sabre\MaintenancePlugin;
use OCA\DAV\Connector\Sabre\PropfindCompressionPlugin;
use OCA\DAV\Connector\Sabre\QuotaPlugin;
use OCA\DAV\Connector\Sabre\RequestIdHeaderPlugin;
use OCA\DAV\Events\SabrePluginAddEvent;
use OCA\DAV\Events\SabrePluginAuthInitEvent;
use OCA\DAV\Files\ErrorPagePlugin;
+use OCA\DAV\Files\FileSearchBackend;
use OCA\DAV\Files\LazySearchBackend;
use OCA\DAV\Profiler\ProfilerPlugin;
use OCA\DAV\Provisioning\Apple\AppleProvisioningPlugin;
use OCA\DAV\Upload\ChunkingV2Plugin;
use OCA\Theming\ThemingDefaults;
use OCP\AppFramework\Http\Response;
+use OCP\AppFramework\Utility\ITimeFactory;
+use OCP\Defaults;
use OCP\Diagnostics\IEventLogger;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\Files\IFilenameValidator;
use OCP\IPreview;
use OCP\IRequest;
use OCP\IUserSession;
+use OCP\Mail\IMailer;
use OCP\Profiler\IProfiler;
use OCP\SabrePluginEvent;
use Psr\Log\LoggerInterface;
$this->server = new \OCA\DAV\Connector\Sabre\Server(new CachingTree($root));
// Add maintenance plugin
- $this->server->addPlugin(new \OCA\DAV\Connector\Sabre\MaintenancePlugin(\OC::$server->getConfig(), \OC::$server->getL10N('dav')));
+ $this->server->addPlugin(new MaintenancePlugin(\OC::$server->getConfig(), \OC::$server->getL10N('dav')));
- $this->server->addPlugin(new \OCA\DAV\Connector\Sabre\AppleQuirksPlugin());
+ $this->server->addPlugin(new AppleQuirksPlugin());
// Backends
$authBackend = new Auth(
$this->server->addPlugin(new DummyGetResponsePlugin());
}
- $this->server->addPlugin(new \OCA\DAV\Connector\Sabre\ExceptionLoggerPlugin('webdav', $logger));
- $this->server->addPlugin(new \OCA\DAV\Connector\Sabre\LockPlugin());
+ $this->server->addPlugin(new ExceptionLoggerPlugin('webdav', $logger));
+ $this->server->addPlugin(new LockPlugin());
$this->server->addPlugin(new \Sabre\DAV\Sync\Plugin());
// acl
if ($this->requestIsForSubtree(['calendars', 'public-calendars', 'system-calendars', 'principals'])) {
$this->server->addPlugin(new DAV\Sharing\Plugin($authBackend, \OC::$server->getRequest(), \OC::$server->getConfig()));
$this->server->addPlugin(new \OCA\DAV\CalDAV\Plugin());
- $this->server->addPlugin(new \OCA\DAV\CalDAV\ICSExportPlugin\ICSExportPlugin(\OC::$server->getConfig(), $logger));
+ $this->server->addPlugin(new ICSExportPlugin(\OC::$server->getConfig(), $logger));
$this->server->addPlugin(new \OCA\DAV\CalDAV\Schedule\Plugin(\OC::$server->getConfig(), \OC::$server->get(LoggerInterface::class), \OC::$server->get(DefaultCalendarValidator::class)));
$this->server->addPlugin(\OC::$server->get(\OCA\DAV\CalDAV\Trashbin\Plugin::class));
}
$this->server->addPlugin(new \Sabre\CalDAV\Notifications\Plugin());
- $this->server->addPlugin(new \OCA\DAV\CalDAV\Publishing\PublishPlugin(
+ $this->server->addPlugin(new PublishPlugin(
\OC::$server->getConfig(),
\OC::$server->getURLGenerator()
));
$userSession = \OC::$server->getUserSession();
$user = $userSession->getUser();
if ($user !== null) {
- $view = \OC\Files\Filesystem::getView();
+ $view = Filesystem::getView();
$config = \OCP\Server::get(IConfig::class);
$this->server->addPlugin(
new FilesPlugin(
));
if (\OC::$server->getConfig()->getAppValue('dav', 'sendInvitations', 'yes') === 'yes') {
$this->server->addPlugin(new IMipPlugin(
- \OC::$server->get(\OCP\IConfig::class),
- \OC::$server->get(\OCP\Mail\IMailer::class),
+ \OC::$server->get(IConfig::class),
+ \OC::$server->get(IMailer::class),
\OC::$server->get(LoggerInterface::class),
- \OC::$server->get(\OCP\AppFramework\Utility\ITimeFactory::class),
- \OC::$server->get(\OCP\Defaults::class),
+ \OC::$server->get(ITimeFactory::class),
+ \OC::$server->get(Defaults::class),
$userSession,
- \OC::$server->get(\OCA\DAV\CalDAV\Schedule\IMipService::class),
- \OC::$server->get(\OCA\DAV\CalDAV\EventComparisonService::class),
+ \OC::$server->get(IMipService::class),
+ \OC::$server->get(EventComparisonService::class),
\OC::$server->get(\OCP\Mail\Provider\IManager::class)
));
}
$userFolder,
\OC::$server->getAppManager()
));
- $lazySearchBackend->setBackend(new \OCA\DAV\Files\FileSearchBackend(
+ $lazySearchBackend->setBackend(new FileSearchBackend(
$this->server->tree,
$user,
\OC::$server->getRootFolder(),
)
);
}
- $this->server->addPlugin(new \OCA\DAV\CalDAV\BirthdayCalendar\EnablePlugin(
+ $this->server->addPlugin(new EnablePlugin(
\OC::$server->getConfig(),
\OC::$server->query(BirthdayService::class),
$user
use OCA\DAV\BackgroundJob\CleanupInvitationTokenJob;
use OCP\AppFramework\Utility\ITimeFactory;
+use OCP\DB\QueryBuilder\IExpressionBuilder;
use OCP\DB\QueryBuilder\IQueryBuilder;
use OCP\IDBConnection;
use Test\TestCase;
/** @var ITimeFactory | \PHPUnit\Framework\MockObject\MockObject */
private $timeFactory;
- /** @var \OCA\DAV\BackgroundJob\CleanupInvitationTokenJob */
+ /** @var CleanupInvitationTokenJob */
private $backgroundJob;
protected function setUp(): void {
->willReturn(1337);
$queryBuilder = $this->createMock(IQueryBuilder::class);
- $expr = $this->createMock(\OCP\DB\QueryBuilder\IExpressionBuilder::class);
+ $expr = $this->createMock(IExpressionBuilder::class);
$stmt = $this->createMock(\Doctrine\DBAL\Driver\Statement::class);
$this->dbConnection->expects($this->once())
/** @var IConfig | MockObject */
private $config;
- /** @var \OCA\DAV\BackgroundJob\GenerateBirthdayCalendarBackgroundJob */
+ /** @var GenerateBirthdayCalendarBackgroundJob */
private $backgroundJob;
protected function setUp(): void {
/** @var IUser|\PHPUnit\Framework\MockObject\MockObject */
protected $user;
- /** @var \OCA\DAV\CalDAV\BirthdayCalendar\EnablePlugin $plugin */
+ /** @var EnablePlugin $plugin */
protected $plugin;
protected $request;
use OCP\Mail\IEMailTemplate;
use OCP\Mail\IMailer;
use OCP\Mail\IMessage;
+use OCP\Util;
use PHPUnit\Framework\MockObject\MockObject;
use Sabre\VObject\Component\VCalendar;
$message->expects($this->once())
->method('setFrom')
- ->with([\OCP\Util::getDefaultEmailAddress('reminders-noreply')])
+ ->with([Util::getDefaultEmailAddress('reminders-noreply')])
->willReturn($message);
if ($replyTo) {
* @throws NotificationTypeDoesNotExistException
*/
public function testGetProviderForUnknownType(): void {
- $this->expectException(\OCA\DAV\CalDAV\Reminder\NotificationTypeDoesNotExistException::class);
+ $this->expectException(NotificationTypeDoesNotExistException::class);
$this->expectExceptionMessage('Type NOT EXISTENT is not an accepted type of notification');
$this->providerManager->getProvider('NOT EXISTENT');
* @throws ProviderNotAvailableException
*/
public function testGetProviderForUnRegisteredType(): void {
- $this->expectException(\OCA\DAV\CalDAV\Reminder\NotificationProvider\ProviderNotAvailableException::class);
+ $this->expectException(ProviderNotAvailableException::class);
$this->expectExceptionMessage('No notification provider for type AUDIO available');
$this->providerManager->getProvider('AUDIO');
use OCA\DAV\CalDAV\Proxy\Proxy;
use OCA\DAV\CalDAV\Proxy\ProxyMapper;
+use OCA\DAV\CalDAV\ResourceBooking\ResourcePrincipalBackend;
+use OCA\DAV\CalDAV\ResourceBooking\RoomPrincipalBackend;
use OCP\IGroupManager;
use OCP\IUser;
use OCP\IUserSession;
use Test\TestCase;
abstract class AbstractPrincipalBackendTest extends TestCase {
- /** @var \OCA\DAV\CalDAV\ResourceBooking\ResourcePrincipalBackend|\OCA\DAV\CalDAV\ResourceBooking\RoomPrincipalBackend */
+ /** @var ResourcePrincipalBackend|RoomPrincipalBackend */
protected $principalBackend;
/** @var IUserSession|\PHPUnit\Framework\MockObject\MockObject */
class SearchPluginTest extends TestCase {
protected $server;
- /** @var \OCA\DAV\CalDAV\Search\SearchPlugin $plugin */
+ /** @var SearchPlugin $plugin */
protected $plugin;
protected function setUp(): void {
*/
class ListAddressbooksTest extends TestCase {
- private \OCP\IUserManager|MockObject $userManager;
+ private IUserManager|MockObject $userManager;
private CardDavBackend|MockObject $cardDavBackend;
private ListAddressbooks $command;
*/
namespace OCA\DAV\Tests\unit\Comments;
+use OCA\DAV\Comments\CommentNode;
use OCA\DAV\Comments\EntityCollection;
use OCP\Comments\IComment;
use OCP\Comments\ICommentsManager;
+use OCP\Comments\NotFoundException;
use OCP\IUserManager;
use OCP\IUserSession;
use Psr\Log\LoggerInterface;
->disableOriginalConstructor()
->getMock();
- $this->collection = new \OCA\DAV\Comments\EntityCollection(
+ $this->collection = new EntityCollection(
'19',
'files',
$this->commentsManager,
);
$node = $this->collection->getChild('55');
- $this->assertTrue($node instanceof \OCA\DAV\Comments\CommentNode);
+ $this->assertTrue($node instanceof CommentNode);
}
$this->commentsManager->expects($this->once())
->method('get')
->with('55')
- ->will($this->throwException(new \OCP\Comments\NotFoundException()));
+ ->will($this->throwException(new NotFoundException()));
$this->collection->getChild('55');
}
$result = $this->collection->getChildren();
$this->assertSame(count($result), 1);
- $this->assertTrue($result[0] instanceof \OCA\DAV\Comments\CommentNode);
+ $this->assertTrue($result[0] instanceof CommentNode);
}
public function testFindChildren(): void {
$result = $this->collection->findChildren(5, 15, $dt);
$this->assertSame(count($result), 1);
- $this->assertTrue($result[0] instanceof \OCA\DAV\Comments\CommentNode);
+ $this->assertTrue($result[0] instanceof CommentNode);
}
public function testChildExistsTrue(): void {
$this->commentsManager->expects($this->once())
->method('get')
->with('44')
- ->will($this->throwException(new \OCP\Comments\NotFoundException()));
+ ->will($this->throwException(new NotFoundException()));
$this->assertFalse($this->collection->childExists('44'));
}
namespace OCA\DAV\Tests\unit\Comments;
use OCA\DAV\Comments\EntityCollection as EntityCollectionImplemantation;
+use OCA\DAV\Comments\EntityTypeCollection;
use OCP\Comments\ICommentsManager;
use OCP\IUserManager;
use OCP\IUserSession;
protected $userManager;
/** @var LoggerInterface|\PHPUnit\Framework\MockObject\MockObject */
protected $logger;
- /** @var \OCA\DAV\Comments\EntityTypeCollection */
+ /** @var EntityTypeCollection */
protected $collection;
/** @var IUserSession|\PHPUnit\Framework\MockObject\MockObject */
protected $userSession;
$instance = $this;
- $this->collection = new \OCA\DAV\Comments\EntityTypeCollection(
+ $this->collection = new EntityTypeCollection(
'files',
$this->commentsManager,
$this->userManager,
use OC\EventDispatcher\EventDispatcher;
use OCA\DAV\Comments\EntityTypeCollection as EntityTypeCollectionImplementation;
+use OCA\DAV\Comments\RootCollection;
use OCP\Comments\CommentsEntityEvent;
use OCP\Comments\ICommentsManager;
use OCP\EventDispatcher\IEventDispatcher;
protected $userManager;
/** @var LoggerInterface|\PHPUnit\Framework\MockObject\MockObject */
protected $logger;
- /** @var \OCA\DAV\Comments\RootCollection */
+ /** @var RootCollection */
protected $collection;
/** @var \OCP\IUserSession|\PHPUnit\Framework\MockObject\MockObject */
protected $userSession;
$this->logger
);
- $this->collection = new \OCA\DAV\Comments\RootCollection(
+ $this->collection = new RootCollection(
$this->commentsManager,
$this->userManager,
$this->userSession,
*/
namespace OCA\DAV\Tests\unit\Connector;
+use OCA\DAV\Connector\LegacyPublicAuth;
use OCP\IRequest;
use OCP\ISession;
use OCP\Security\Bruteforce\IThrottler;
private $request;
/** @var IManager|\PHPUnit\Framework\MockObject\MockObject */
private $shareManager;
- /** @var \OCA\DAV\Connector\LegacyPublicAuth */
+ /** @var LegacyPublicAuth */
private $auth;
/** @var IThrottler|\PHPUnit\Framework\MockObject\MockObject */
private $throttler;
->disableOriginalConstructor()
->getMock();
- $this->auth = new \OCA\DAV\Connector\LegacyPublicAuth(
+ $this->auth = new LegacyPublicAuth(
$this->request,
$this->shareManager,
$this->session,
*/
namespace OCA\DAV\Tests\unit\Connector\Sabre;
+use OC\Authentication\Exceptions\PasswordLoginForbiddenException;
use OC\Authentication\TwoFactorAuth\Manager;
use OC\User\Session;
+use OCA\DAV\Connector\Sabre\Auth;
+use OCA\DAV\Connector\Sabre\Exception\PasswordLoginForbidden;
use OCP\IRequest;
use OCP\ISession;
use OCP\IUser;
class AuthTest extends TestCase {
/** @var ISession&MockObject */
private $session;
- /** @var \OCA\DAV\Connector\Sabre\Auth */
+ /** @var Auth */
private $auth;
/** @var Session&MockObject */
private $userSession;
$this->throttler = $this->getMockBuilder(IThrottler::class)
->disableOriginalConstructor()
->getMock();
- $this->auth = new \OCA\DAV\Connector\Sabre\Auth(
+ $this->auth = new Auth(
$this->session,
$this->userSession,
$this->request,
public function testValidateUserPassWithPasswordLoginForbidden(): void {
- $this->expectException(\OCA\DAV\Connector\Sabre\Exception\PasswordLoginForbidden::class);
+ $this->expectException(PasswordLoginForbidden::class);
$this->userSession
->expects($this->once())
->expects($this->once())
->method('logClientIn')
->with('MyTestUser', 'MyTestPassword')
- ->will($this->throwException(new \OC\Authentication\Exceptions\PasswordLoginForbiddenException()));
+ ->will($this->throwException(new PasswordLoginForbiddenException()));
$this->session
->expects($this->once())
->method('close');
*/
namespace OCA\DAV\Tests\unit\Connector\Sabre;
+use OC\User\Session;
use OCA\DAV\Connector\Sabre\BearerAuth;
use OCP\IRequest;
use OCP\ISession;
protected function setUp(): void {
parent::setUp();
- $this->userSession = $this->createMock(\OC\User\Session::class);
+ $this->userSession = $this->createMock(Session::class);
$this->session = $this->createMock(ISession::class);
$this->request = $this->createMock(IRequest::class);
use OCA\DAV\CalDAV\DefaultCalendarValidator;
use OCA\DAV\Connector\Sabre\Directory;
use OCA\DAV\Connector\Sabre\File;
+use OCA\DAV\DAV\CustomPropertiesBackend;
use OCP\IUser;
use PHPUnit\Framework\MockObject\MockObject;
use Sabre\DAV\Tree;
private $tree;
/**
- * @var \OCA\DAV\DAV\CustomPropertiesBackend
+ * @var CustomPropertiesBackend
*/
private $plugin;
$this->defaultCalendarValidator = $this->createMock(DefaultCalendarValidator::class);
- $this->plugin = new \OCA\DAV\DAV\CustomPropertiesBackend(
+ $this->plugin = new CustomPropertiesBackend(
$this->server,
$this->tree,
\OC::$server->getDatabaseConnection(),
use OC\Files\Storage\Wrapper\Quota;
use OC\Files\View;
use OCA\DAV\Connector\Sabre\Directory;
+use OCA\DAV\Connector\Sabre\Exception\Forbidden;
+use OCA\DAV\Connector\Sabre\Exception\InvalidPath;
use OCP\Constants;
use OCP\Files\ForbiddenException;
+use OCP\Files\InvalidPathException;
use OCP\Files\Mount\IMountPoint;
+use OCP\Files\StorageNotAvailableException;
use Test\Traits\UserTrait;
-class TestViewDirectory extends \OC\Files\View {
+class TestViewDirectory extends View {
private $updatables;
private $deletables;
private $canRename;
public function testDeleteForbidden(): void {
- $this->expectException(\OCA\DAV\Connector\Sabre\Exception\Forbidden::class);
+ $this->expectException(Forbidden::class);
// deletion allowed
$this->info->expects($this->once())
$this->view->expects($this->once())
->method('getFileInfo')
- ->willThrowException(new \OCP\Files\StorageNotAvailableException());
+ ->willThrowException(new StorageNotAvailableException());
$dir = new Directory($this->view, $this->info);
$dir->getChild('.');
public function testGetChildThrowInvalidPath(): void {
- $this->expectException(\OCA\DAV\Connector\Sabre\Exception\InvalidPath::class);
+ $this->expectException(InvalidPath::class);
$this->view->expects($this->once())
->method('verifyPath')
- ->willThrowException(new \OCP\Files\InvalidPathException());
+ ->willThrowException(new InvalidPathException());
$this->view->expects($this->never())
->method('getFileInfo');
* @dataProvider moveFailedInvalidCharsProvider
*/
public function testMoveFailedInvalidChars($source, $destination, $updatables, $deletables): void {
- $this->expectException(\OCA\DAV\Connector\Sabre\Exception\InvalidPath::class);
+ $this->expectException(InvalidPath::class);
$this->moveTest($source, $destination, $updatables, $deletables);
}
use OC\Files\Storage\Temporary;
use OC\Files\Storage\Wrapper\PermissionsMask;
use OC\Files\View;
+use OCA\DAV\Connector\Sabre\Exception\FileLocked;
+use OCA\DAV\Connector\Sabre\Exception\Forbidden;
+use OCA\DAV\Connector\Sabre\Exception\InvalidPath;
use OCA\DAV\Connector\Sabre\File;
use OCP\Constants;
+use OCP\Encryption\Exceptions\GenericEncryptionException;
+use OCP\Files\EntityTooLargeException;
use OCP\Files\FileInfo;
use OCP\Files\ForbiddenException;
+use OCP\Files\InvalidContentException;
+use OCP\Files\InvalidPathException;
+use OCP\Files\LockNotAcquiredException;
+use OCP\Files\NotPermittedException;
use OCP\Files\Storage\IStorage;
+use OCP\Files\StorageNotAvailableException;
use OCP\IConfig;
use OCP\IRequestId;
use OCP\ITempManager;
use OCP\IUserManager;
use OCP\Lock\ILockingProvider;
+use OCP\Lock\LockedException;
+use OCP\Server;
+use OCP\Util;
use PHPUnit\Framework\MockObject\MockObject;
use Test\HookHelper;
use Test\TestCase;
}
protected function tearDown(): void {
- $userManager = \OCP\Server::get(IUserManager::class);
+ $userManager = Server::get(IUserManager::class);
$userManager->get($this->user)->delete();
parent::tearDown();
false
],
[
- new \OCP\Files\NotPermittedException(),
+ new NotPermittedException(),
'Sabre\DAV\Exception\Forbidden'
],
[
- new \OCP\Files\EntityTooLargeException(),
+ new EntityTooLargeException(),
'OCA\DAV\Connector\Sabre\Exception\EntityTooLarge'
],
[
- new \OCP\Files\InvalidContentException(),
+ new InvalidContentException(),
'OCA\DAV\Connector\Sabre\Exception\UnsupportedMediaType'
],
[
- new \OCP\Files\InvalidPathException(),
+ new InvalidPathException(),
'Sabre\DAV\Exception\Forbidden'
],
[
- new \OCP\Files\ForbiddenException('', true),
+ new ForbiddenException('', true),
'OCA\DAV\Connector\Sabre\Exception\Forbidden'
],
[
- new \OCP\Files\LockNotAcquiredException('/test.txt', 1),
+ new LockNotAcquiredException('/test.txt', 1),
'OCA\DAV\Connector\Sabre\Exception\FileLocked'
],
[
- new \OCP\Lock\LockedException('/test.txt'),
+ new LockedException('/test.txt'),
'OCA\DAV\Connector\Sabre\Exception\FileLocked'
],
[
- new \OCP\Encryption\Exceptions\GenericEncryptionException(),
+ new GenericEncryptionException(),
'Sabre\DAV\Exception\ServiceUnavailable'
],
[
- new \OCP\Files\StorageNotAvailableException(),
+ new StorageNotAvailableException(),
'Sabre\DAV\Exception\ServiceUnavailable'
],
[
// setup
$storage = $this->getMockBuilder(Local::class)
->onlyMethods(['writeStream'])
- ->setConstructorArgs([['datadir' => \OCP\Server::get(ITempManager::class)->getTemporaryFolder()]])
+ ->setConstructorArgs([['datadir' => Server::get(ITempManager::class)->getTemporaryFolder()]])
->getMock();
- \OC\Files\Filesystem::mount($storage, [], $this->user . '/');
+ Filesystem::mount($storage, [], $this->user . '/');
/** @var View | MockObject $view */
$view = $this->getMockBuilder(View::class)
->onlyMethods(['getRelativePath', 'resolvePath'])
->willReturnArgument(0);
$info = new \OC\Files\FileInfo('/test.txt', $this->getMockStorage(), null, [
- 'permissions' => \OCP\Constants::PERMISSION_ALL,
+ 'permissions' => Constants::PERMISSION_ALL,
'type' => FileInfo::TYPE_FOLDER,
], null);
- $file = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $file = new File($view, $info);
// action
$caughtException = null;
* @return null|string of the PUT operation which is usually the etag
*/
private function doPut($path, $viewRoot = null, ?Request $request = null) {
- $view = \OC\Files\Filesystem::getView();
+ $view = Filesystem::getView();
if (!is_null($viewRoot)) {
- $view = new \OC\Files\View($viewRoot);
+ $view = new View($viewRoot);
} else {
$viewRoot = '/' . $this->user . '/files';
}
$this->getMockStorage(),
null,
[
- 'permissions' => \OCP\Constants::PERMISSION_ALL,
+ 'permissions' => Constants::PERMISSION_ALL,
'type' => FileInfo::TYPE_FOLDER,
],
null
);
- /** @var \OCA\DAV\Connector\Sabre\File | MockObject $file */
- $file = $this->getMockBuilder(\OCA\DAV\Connector\Sabre\File::class)
+ /** @var File|MockObject $file */
+ $file = $this->getMockBuilder(File::class)
->setConstructorArgs([$view, $info, null, $request])
->onlyMethods(['header'])
->getMock();
* Test that putting a file triggers update hooks
*/
public function testPutOverwriteFileTriggersHooks(): void {
- $view = \OC\Files\Filesystem::getView();
+ $view = Filesystem::getView();
$view->file_put_contents('/foo.txt', 'some content that will be replaced');
HookHelper::setUpHooks();
* where the root is the share root)
*/
public function testPutSingleFileTriggersHooksDifferentRoot(): void {
- $view = \OC\Files\Filesystem::getView();
+ $view = Filesystem::getView();
$view->mkdir('noderoot');
HookHelper::setUpHooks();
* Test put file with cancelled hook
*/
public function testPutSingleFileCancelPreHook(): void {
- \OCP\Util::connectHook(
+ Util::connectHook(
Filesystem::CLASSNAME,
Filesystem::signal_create,
'\Test\HookHelper',
], $this->requestId, $this->config, null);
$info = new \OC\Files\FileInfo('/test.txt', $this->getMockStorage(), null, [
- 'permissions' => \OCP\Constants::PERMISSION_ALL,
+ 'permissions' => Constants::PERMISSION_ALL,
'type' => FileInfo::TYPE_FOLDER,
], null);
- $file = new \OCA\DAV\Connector\Sabre\File($view, $info, null, $request);
+ $file = new File($view, $info, null, $request);
// action
$thrown = false;
* Test exception during final rename in simple upload mode
*/
public function testSimplePutFailsMoveFromStorage(): void {
- $view = new \OC\Files\View('/' . $this->user . '/files');
+ $view = new View('/' . $this->user . '/files');
// simulate situation where the target file is locked
$view->lockFile('/test.txt', ILockingProvider::LOCK_EXCLUSIVE);
$info = new \OC\Files\FileInfo('/' . $this->user . '/files/test.txt', $this->getMockStorage(), null, [
- 'permissions' => \OCP\Constants::PERMISSION_ALL,
+ 'permissions' => Constants::PERMISSION_ALL,
'type' => FileInfo::TYPE_FOLDER,
], null);
- $file = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $file = new File($view, $info);
// action
$thrown = false;
// afterMethod unlocks
$view->unlockFile($info->getPath(), ILockingProvider::LOCK_SHARED);
- } catch (\OCA\DAV\Connector\Sabre\Exception\FileLocked $e) {
+ } catch (FileLocked $e) {
$thrown = true;
}
->willReturnArgument(0);
$info = new \OC\Files\FileInfo("/i\nvalid", $this->getMockStorage(), null, [
- 'permissions' => \OCP\Constants::PERMISSION_ALL,
+ 'permissions' => Constants::PERMISSION_ALL,
'type' => FileInfo::TYPE_FOLDER,
], null);
- $file = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $file = new File($view, $info);
// action
$thrown = false;
// afterMethod unlocks
$view->unlockFile($info->getPath(), ILockingProvider::LOCK_SHARED);
- } catch (\OCA\DAV\Connector\Sabre\Exception\InvalidPath $e) {
+ } catch (InvalidPath $e) {
$thrown = true;
}
*
*/
public function testSetNameInvalidChars(): void {
- $this->expectException(\OCA\DAV\Connector\Sabre\Exception\InvalidPath::class);
+ $this->expectException(InvalidPath::class);
// setup
/** @var View|MockObject */
->willReturnArgument(0);
$info = new \OC\Files\FileInfo('/valid', $this->getMockStorage(), null, [
- 'permissions' => \OCP\Constants::PERMISSION_ALL,
+ 'permissions' => Constants::PERMISSION_ALL,
'type' => FileInfo::TYPE_FOLDER,
], null);
- $file = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $file = new File($view, $info);
$file->setName("/i\nvalid");
}
], $this->requestId, $this->config, null);
$info = new \OC\Files\FileInfo('/test.txt', $this->getMockStorage(), null, [
- 'permissions' => \OCP\Constants::PERMISSION_ALL,
+ 'permissions' => Constants::PERMISSION_ALL,
'type' => FileInfo::TYPE_FOLDER,
], null);
- $file = new \OCA\DAV\Connector\Sabre\File($view, $info, null, $request);
+ $file = new File($view, $info, null, $request);
// action
$thrown = false;
->willReturn(true);
$info = new \OC\Files\FileInfo('/test.txt', $this->getMockStorage(), null, [
- 'permissions' => \OCP\Constants::PERMISSION_ALL,
+ 'permissions' => Constants::PERMISSION_ALL,
'type' => FileInfo::TYPE_FOLDER,
], null);
- $file = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $file = new File($view, $info);
// action
$file->delete();
'type' => FileInfo::TYPE_FOLDER,
], null);
- $file = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $file = new File($view, $info);
// action
$file->delete();
->willReturn(false);
$info = new \OC\Files\FileInfo('/test.txt', $this->getMockStorage(), null, [
- 'permissions' => \OCP\Constants::PERMISSION_ALL,
+ 'permissions' => Constants::PERMISSION_ALL,
'type' => FileInfo::TYPE_FOLDER,
], null);
- $file = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $file = new File($view, $info);
// action
$file->delete();
public function testDeleteThrowsWhenDeletionThrows(): void {
- $this->expectException(\OCA\DAV\Connector\Sabre\Exception\Forbidden::class);
+ $this->expectException(Forbidden::class);
// setup
/** @var View|MockObject */
->willThrowException(new ForbiddenException('', true));
$info = new \OC\Files\FileInfo('/test.txt', $this->getMockStorage(), null, [
- 'permissions' => \OCP\Constants::PERMISSION_ALL,
+ 'permissions' => Constants::PERMISSION_ALL,
'type' => FileInfo::TYPE_FOLDER,
], null);
- $file = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $file = new File($view, $info);
// action
$file->delete();
* Test whether locks are set before and after the operation
*/
public function testPutLocking(): void {
- $view = new \OC\Files\View('/' . $this->user . '/files/');
+ $view = new View('/' . $this->user . '/files/');
$path = 'test-locking.txt';
$info = new \OC\Files\FileInfo(
$this->getMockStorage(),
null,
[
- 'permissions' => \OCP\Constants::PERMISSION_ALL,
+ 'permissions' => Constants::PERMISSION_ALL,
'type' => FileInfo::TYPE_FOLDER,
],
null
);
- $file = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $file = new File($view, $info);
$this->assertFalse(
- $this->isFileLocked($view, $path, \OCP\Lock\ILockingProvider::LOCK_SHARED),
+ $this->isFileLocked($view, $path, ILockingProvider::LOCK_SHARED),
'File unlocked before put'
);
$this->assertFalse(
- $this->isFileLocked($view, $path, \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE),
+ $this->isFileLocked($view, $path, ILockingProvider::LOCK_EXCLUSIVE),
'File unlocked before put'
);
->method('writeCallback')
->willReturnCallback(
function () use ($view, $path, &$wasLockedPre): void {
- $wasLockedPre = $this->isFileLocked($view, $path, \OCP\Lock\ILockingProvider::LOCK_SHARED);
- $wasLockedPre = $wasLockedPre && !$this->isFileLocked($view, $path, \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE);
+ $wasLockedPre = $this->isFileLocked($view, $path, ILockingProvider::LOCK_SHARED);
+ $wasLockedPre = $wasLockedPre && !$this->isFileLocked($view, $path, ILockingProvider::LOCK_EXCLUSIVE);
}
);
$eventHandler->expects($this->once())
->method('postWriteCallback')
->willReturnCallback(
function () use ($view, $path, &$wasLockedPost): void {
- $wasLockedPost = $this->isFileLocked($view, $path, \OCP\Lock\ILockingProvider::LOCK_SHARED);
- $wasLockedPost = $wasLockedPost && !$this->isFileLocked($view, $path, \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE);
+ $wasLockedPost = $this->isFileLocked($view, $path, ILockingProvider::LOCK_SHARED);
+ $wasLockedPost = $wasLockedPost && !$this->isFileLocked($view, $path, ILockingProvider::LOCK_EXCLUSIVE);
}
);
- \OCP\Util::connectHook(
+ Util::connectHook(
Filesystem::CLASSNAME,
Filesystem::signal_write,
$eventHandler,
'writeCallback'
);
- \OCP\Util::connectHook(
+ Util::connectHook(
Filesystem::CLASSNAME,
Filesystem::signal_post_write,
$eventHandler,
$this->assertTrue($wasLockedPost, 'File was locked during post-hooks');
$this->assertFalse(
- $this->isFileLocked($view, $path, \OCP\Lock\ILockingProvider::LOCK_SHARED),
+ $this->isFileLocked($view, $path, ILockingProvider::LOCK_SHARED),
'File unlocked after put'
);
$this->assertFalse(
- $this->isFileLocked($view, $path, \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE),
+ $this->isFileLocked($view, $path, ILockingProvider::LOCK_EXCLUSIVE),
'File unlocked after put'
);
}
*
* @return array list of part files
*/
- private function listPartFiles(?\OC\Files\View $userView = null, $path = '') {
+ private function listPartFiles(?View $userView = null, $path = '') {
if ($userView === null) {
- $userView = \OC\Files\Filesystem::getView();
+ $userView = Filesystem::getView();
}
$files = [];
[$storage, $internalPath] = $userView->resolvePath($path);
->willReturn(false);
$info = new \OC\Files\FileInfo('/test.txt', $this->getMockStorage(), null, [
- 'permissions' => \OCP\Constants::PERMISSION_ALL,
+ 'permissions' => Constants::PERMISSION_ALL,
'type' => FileInfo::TYPE_FILE,
], null);
- $file = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $file = new File($view, $info);
$file->get();
}
public function testGetFopenThrows(): void {
- $this->expectException(\OCA\DAV\Connector\Sabre\Exception\Forbidden::class);
+ $this->expectException(Forbidden::class);
/** @var View|MockObject */
$view = $this->getMockBuilder(View::class)
->willThrowException(new ForbiddenException('', true));
$info = new \OC\Files\FileInfo('/test.txt', $this->getMockStorage(), null, [
- 'permissions' => \OCP\Constants::PERMISSION_ALL,
+ 'permissions' => Constants::PERMISSION_ALL,
'type' => FileInfo::TYPE_FILE,
], null);
- $file = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $file = new File($view, $info);
$file->get();
}
->method('fopen');
$info = new \OC\Files\FileInfo('/test.txt', $this->getMockStorage(), null, [
- 'permissions' => \OCP\Constants::PERMISSION_CREATE, // no read perm
+ 'permissions' => Constants::PERMISSION_CREATE, // no read perm
'type' => FileInfo::TYPE_FOLDER,
], null);
- $file = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $file = new File($view, $info);
$file->get();
}
}
public function testPutLockExpired(): void {
- $view = new \OC\Files\View('/' . $this->user . '/files/');
+ $view = new View('/' . $this->user . '/files/');
$path = 'test-locking.txt';
$info = new \OC\Files\FileInfo(
$this->getMockStorage(),
null,
[
- 'permissions' => \OCP\Constants::PERMISSION_ALL,
+ 'permissions' => Constants::PERMISSION_ALL,
'type' => FileInfo::TYPE_FOLDER,
],
null
);
- $file = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $file = new File($view, $info);
// don't lock before the PUT to simulate an expired shared lock
$this->assertNotEmpty($file->put($this->getStream('test data')));
}
public function testGetPropertiesForFile(): void {
- /** @var \OCA\DAV\Connector\Sabre\File | \PHPUnit\Framework\MockObject\MockObject $node */
+ /** @var File|\PHPUnit\Framework\MockObject\MockObject $node */
$node = $this->createTestNode('\OCA\DAV\Connector\Sabre\File');
$propFind = new PropFind(
}
public function testGetPropertiesStorageNotAvailable(): void {
- /** @var \OCA\DAV\Connector\Sabre\File | \PHPUnit\Framework\MockObject\MockObject $node */
+ /** @var File|\PHPUnit\Framework\MockObject\MockObject $node */
$node = $this->createTestNode('\OCA\DAV\Connector\Sabre\File');
$propFind = new PropFind(
0
);
- /** @var \OCA\DAV\Connector\Sabre\File | \PHPUnit\Framework\MockObject\MockObject $node */
+ /** @var File|\PHPUnit\Framework\MockObject\MockObject $node */
$node = $this->createTestNode('\OCA\DAV\Connector\Sabre\File');
$node->expects($this->any())
->method('getDavPermissions')
}
public function testGetPropertiesForDirectory(): void {
- /** @var \OCA\DAV\Connector\Sabre\Directory | \PHPUnit\Framework\MockObject\MockObject $node */
+ /** @var Directory|\PHPUnit\Framework\MockObject\MockObject $node */
$node = $this->createTestNode('\OCA\DAV\Connector\Sabre\Directory');
$propFind = new PropFind(
}
public function testGetPropertiesForRootDirectory(): void {
- /** @var \OCA\DAV\Connector\Sabre\Directory|\PHPUnit\Framework\MockObject\MockObject $node */
+ /** @var Directory|\PHPUnit\Framework\MockObject\MockObject $node */
$node = $this->getMockBuilder(Directory::class)
->disableOriginalConstructor()
->getMock();
// No read permissions can be caused by files access control.
// But we still want to load the directory list, so this is okay for us.
// $this->expectException(\Sabre\DAV\Exception\NotFound::class);
-
- /** @var \OCA\DAV\Connector\Sabre\Directory|\PHPUnit\Framework\MockObject\MockObject $node */
+ /** @var Directory|\PHPUnit\Framework\MockObject\MockObject $node */
$node = $this->getMockBuilder(Directory::class)
->disableOriginalConstructor()
->getMock();
}
public function testHasPreview(): void {
- /** @var \OCA\DAV\Connector\Sabre\Directory | \PHPUnit\Framework\MockObject\MockObject $node */
+ /** @var Directory|\PHPUnit\Framework\MockObject\MockObject $node */
$node = $this->createTestNode('\OCA\DAV\Connector\Sabre\Directory');
$propFind = new PropFind(
use OC\Files\View;
use OCA\DAV\Connector\Sabre\Directory;
+use OCA\DAV\Connector\Sabre\FilesPlugin;
use OCA\DAV\Connector\Sabre\FilesReportPlugin as FilesReportPluginImplementation;
use OCP\App\IAppManager;
use OCP\Files\File;
$filesNode2,
);
- /** @var \OCA\DAV\Connector\Sabre\Directory&MockObject $reportTargetNode */
+ /** @var Directory&MockObject $reportTargetNode */
$result = $this->plugin->findNodesByFileIds($reportTargetNode, ['111', '222']);
$this->assertCount(2, $result);
$filesNode2,
);
- /** @var \OCA\DAV\Connector\Sabre\Directory&MockObject $reportTargetNode */
+ /** @var Directory&MockObject $reportTargetNode */
$result = $this->plugin->findNodesByFileIds($reportTargetNode, ['111', '222']);
$this->assertCount(2, $result);
$validator = $this->createMock(IFilenameValidator::class);
$this->server->addPlugin(
- new \OCA\DAV\Connector\Sabre\FilesPlugin(
+ new FilesPlugin(
$this->tree,
$config,
$this->createMock(IRequest::class),
use OC\Files\Node\Folder;
use OC\Files\View;
use OC\Share20\ShareAttributes;
+use OCA\DAV\Connector\Sabre\File;
use OCA\Files_Sharing\SharedMount;
use OCA\Files_Sharing\SharedStorage;
use OCP\Constants;
->disableOriginalConstructor()
->getMock();
- $node = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $node = new File($view, $info);
$this->assertEquals($expected, $node->getDavPermissions());
}
->disableOriginalConstructor()
->getMock();
- $node = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $node = new File($view, $info);
$this->invokePrivate($node, 'shareManager', [$shareManager]);
$this->assertEquals($expected, $node->getSharePermissions($user));
}
->disableOriginalConstructor()
->getMock();
- $node = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $node = new File($view, $info);
$this->invokePrivate($node, 'shareManager', [$shareManager]);
$this->assertEquals($attributes->toArray(), $node->getShareAttributes());
}
->disableOriginalConstructor()
->getMock();
- $node = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $node = new File($view, $info);
$this->invokePrivate($node, 'shareManager', [$shareManager]);
$this->assertEquals([], $node->getShareAttributes());
}
->disableOriginalConstructor()
->getMock();
- $node = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $node = new File($view, $info);
$result = $this->invokePrivate($node, 'sanitizeMtime', [$mtime]);
$this->assertEquals($expected, $result);
}
->disableOriginalConstructor()
->getMock();
- $node = new \OCA\DAV\Connector\Sabre\File($view, $info);
+ $node = new File($view, $info);
$result = $this->invokePrivate($node, 'sanitizeMtime', [$mtime]);
}
}
use OC\Files\FileInfo;
use OC\Files\Filesystem;
use OC\Files\Mount\Manager;
+use OC\Files\Storage\Common;
use OC\Files\Storage\Temporary;
use OC\Files\View;
use OCA\DAV\Connector\Sabre\Directory;
+use OCA\DAV\Connector\Sabre\Exception\InvalidPath;
+use OCA\DAV\Connector\Sabre\File;
use OCA\DAV\Connector\Sabre\ObjectTree;
use OCP\Files\Mount\IMountManager;
->with($this->identicalTo($sourcePath))
->willReturn(false);
- /** @var \OCA\DAV\Connector\Sabre\ObjectTree $objectTree */
+ /** @var ObjectTree $objectTree */
$mountManager = Filesystem::getMountManager();
$objectTree->init($rootDir, $view, $mountManager);
$objectTree->copy($sourcePath, $targetPath);
$objectTree->expects($this->never())
->method('getNodeForPath');
- /** @var \OCA\DAV\Connector\Sabre\ObjectTree $objectTree */
+ /** @var ObjectTree $objectTree */
$mountManager = Filesystem::getMountManager();
$objectTree->init($rootDir, $view, $mountManager);
$objectTree->copy($sourcePath, $targetPath);
$fileInfo->method('getName')
->willReturn($outputFileName);
$fileInfo->method('getStorage')
- ->willReturn($this->createMock(\OC\Files\Storage\Common::class));
+ ->willReturn($this->createMock(Common::class));
$view->method('getFileInfo')
->with($fileInfoQueryPath)
->willReturn($fileInfo);
- $tree = new \OCA\DAV\Connector\Sabre\ObjectTree();
+ $tree = new ObjectTree();
$tree->init($rootNode, $view, $mountManager);
$node = $tree->getNodeForPath($inputFileName);
$this->assertEquals($outputFileName, $node->getName());
if ($type === 'file') {
- $this->assertTrue($node instanceof \OCA\DAV\Connector\Sabre\File);
+ $this->assertTrue($node instanceof File);
} else {
- $this->assertTrue($node instanceof \OCA\DAV\Connector\Sabre\Directory);
+ $this->assertTrue($node instanceof Directory);
}
}
public function testGetNodeForPathInvalidPath(): void {
- $this->expectException(\OCA\DAV\Connector\Sabre\Exception\InvalidPath::class);
+ $this->expectException(InvalidPath::class);
$path = '/foo\bar';
->getMock();
$mountManager = $this->createMock(IMountManager::class);
- $tree = new \OCA\DAV\Connector\Sabre\ObjectTree();
+ $tree = new ObjectTree();
$tree->init($rootNode, $view, $mountManager);
$tree->getNodeForPath($path);
->getMock();
$mountManager = $this->createMock(IMountManager::class);
- $tree = new \OCA\DAV\Connector\Sabre\ObjectTree();
+ $tree = new ObjectTree();
$tree->init($rootNode, $view, $mountManager);
$this->assertInstanceOf('\Sabre\DAV\INode', $tree->getNodeForPath($path));
*/
namespace OCA\DAV\Tests\unit\Connector;
+use OCA\DAV\Connector\Sabre\PublicAuth;
use OCP\IRequest;
use OCP\ISession;
use OCP\Security\Bruteforce\IThrottler;
$this->throttler = $this->createMock(IThrottler::class);
$this->logger = $this->createMock(LoggerInterface::class);
- $this->auth = new \OCA\DAV\Connector\Sabre\PublicAuth(
+ $this->auth = new PublicAuth(
$this->request,
$this->shareManager,
$this->session,
/** @var \Sabre\DAV\Server | \PHPUnit\Framework\MockObject\MockObject */
private $server;
- /** @var \OCA\DAV\Connector\Sabre\QuotaPlugin | \PHPUnit\Framework\MockObject\MockObject */
+ /** @var QuotaPlugin|\PHPUnit\Framework\MockObject\MockObject */
private $plugin;
private function init($quota, $checkedPath = ''): void {
*/
namespace OCA\DAV\Tests\unit\Connector\Sabre\RequestTest;
-class ExceptionPlugin extends \OCA\DAV\Connector\Sabre\ExceptionLoggerPlugin {
+use OCA\DAV\Connector\Sabre\ExceptionLoggerPlugin;
+
+class ExceptionPlugin extends ExceptionLoggerPlugin {
/**
* @var \Throwable[]
*/
use MountProviderTrait;
/**
- * @var \OCA\DAV\Connector\Sabre\ServerFactory
+ * @var ServerFactory
*/
protected $serverFactory;
use OCA\DAV\Connector\Sabre\Directory;
use OCA\DAV\Connector\Sabre\File;
use OCA\DAV\Connector\Sabre\Node;
+use OCA\DAV\Connector\Sabre\SharesPlugin;
use OCA\DAV\Upload\UploadFile;
use OCP\Files\Folder;
use OCP\IUser;
use Sabre\DAV\Tree;
class SharesPluginTest extends \Test\TestCase {
- public const SHARETYPES_PROPERTYNAME = \OCA\DAV\Connector\Sabre\SharesPlugin::SHARETYPES_PROPERTYNAME;
+ public const SHARETYPES_PROPERTYNAME = SharesPlugin::SHARETYPES_PROPERTYNAME;
/**
* @var \Sabre\DAV\Server
private $userFolder;
/**
- * @var \OCA\DAV\Connector\Sabre\SharesPlugin
+ * @var SharesPlugin
*/
private $plugin;
->willReturn($user);
$this->userFolder = $this->createMock(Folder::class);
- $this->plugin = new \OCA\DAV\Connector\Sabre\SharesPlugin(
+ $this->plugin = new SharesPlugin(
$this->tree,
$userSession,
$this->userFolder,
use OCA\DAV\Connector\Sabre\Directory;
use OCA\DAV\Connector\Sabre\File;
use OCA\DAV\Connector\Sabre\Node;
+use OCA\DAV\Connector\Sabre\TagList;
+use OCA\DAV\Connector\Sabre\TagsPlugin;
use OCA\DAV\Upload\UploadFile;
use OCP\ITagManager;
use OCP\ITags;
use Sabre\DAV\Tree;
class TagsPluginTest extends \Test\TestCase {
- public const TAGS_PROPERTYNAME = \OCA\DAV\Connector\Sabre\TagsPlugin::TAGS_PROPERTYNAME;
- public const FAVORITE_PROPERTYNAME = \OCA\DAV\Connector\Sabre\TagsPlugin::FAVORITE_PROPERTYNAME;
- public const TAG_FAVORITE = \OCA\DAV\Connector\Sabre\TagsPlugin::TAG_FAVORITE;
+ public const TAGS_PROPERTYNAME = TagsPlugin::TAGS_PROPERTYNAME;
+ public const FAVORITE_PROPERTYNAME = TagsPlugin::FAVORITE_PROPERTYNAME;
+ public const TAG_FAVORITE = TagsPlugin::TAG_FAVORITE;
/**
* @var \Sabre\DAV\Server
private $tagger;
/**
- * @var \OCA\DAV\Connector\Sabre\TagsPlugin
+ * @var TagsPlugin
*/
private $plugin;
->method('load')
->with('files')
->willReturn($this->tagger);
- $this->plugin = new \OCA\DAV\Connector\Sabre\TagsPlugin($this->tree, $this->tagManager);
+ $this->plugin = new TagsPlugin($this->tree, $this->tagManager);
$this->plugin->initialize($this->server);
}
[self::TAGS_PROPERTYNAME, self::FAVORITE_PROPERTYNAME],
[
200 => [
- self::TAGS_PROPERTYNAME => new \OCA\DAV\Connector\Sabre\TagList(['tag1', 'tag2']),
+ self::TAGS_PROPERTYNAME => new TagList(['tag1', 'tag2']),
self::FAVORITE_PROPERTYNAME => true,
]
]
[self::TAGS_PROPERTYNAME],
[
200 => [
- self::TAGS_PROPERTYNAME => new \OCA\DAV\Connector\Sabre\TagList(['tag1', 'tag2']),
+ self::TAGS_PROPERTYNAME => new TagList(['tag1', 'tag2']),
]
]
],
[self::TAGS_PROPERTYNAME, self::FAVORITE_PROPERTYNAME],
[
200 => [
- self::TAGS_PROPERTYNAME => new \OCA\DAV\Connector\Sabre\TagList([]),
+ self::TAGS_PROPERTYNAME => new TagList([]),
self::FAVORITE_PROPERTYNAME => false,
]
]
// properties to set
$propPatch = new \Sabre\DAV\PropPatch([
- self::TAGS_PROPERTYNAME => new \OCA\DAV\Connector\Sabre\TagList(['tag1', 'tag2', 'tagkeep'])
+ self::TAGS_PROPERTYNAME => new TagList(['tag1', 'tag2', 'tagkeep'])
]);
$this->plugin->handleUpdateProperties(
// properties to set
$propPatch = new \Sabre\DAV\PropPatch([
- self::TAGS_PROPERTYNAME => new \OCA\DAV\Connector\Sabre\TagList(['tag1', 'tag2'])
+ self::TAGS_PROPERTYNAME => new TagList(['tag1', 'tag2'])
]);
$this->plugin->handleUpdateProperties(
namespace OCA\DAV\Tests\unit\SystemTag;
use OC\SystemTag\SystemTag;
+use OCA\DAV\SystemTag\SystemTagMappingNode;
use OCP\IUser;
use OCP\SystemTag\ISystemTag;
use OCP\SystemTag\ISystemTagManager;
if ($tag === null) {
$tag = new SystemTag(1, 'Test', true, true);
}
- return new \OCA\DAV\SystemTag\SystemTagMappingNode(
+ return new SystemTagMappingNode(
$tag,
123,
'files',
namespace OCA\DAV\Tests\unit\SystemTag;
use OC\SystemTag\SystemTag;
+use OCA\DAV\SystemTag\SystemTagNode;
use OCP\IUser;
use OCP\SystemTag\ISystemTag;
use OCP\SystemTag\ISystemTagManager;
if ($tag === null) {
$tag = new SystemTag(1, 'Test', true, true);
}
- return new \OCA\DAV\SystemTag\SystemTagNode(
+ return new SystemTagNode(
$tag,
$this->user,
$isAdmin,
use OC\SystemTag\SystemTag;
use OCA\DAV\SystemTag\SystemTagNode;
+use OCA\DAV\SystemTag\SystemTagPlugin;
use OCA\DAV\SystemTag\SystemTagsByIdCollection;
use OCA\DAV\SystemTag\SystemTagsObjectMappingCollection;
use OCP\IGroupManager;
use Sabre\HTTP\ResponseInterface;
class SystemTagPluginTest extends \Test\TestCase {
- public const ID_PROPERTYNAME = \OCA\DAV\SystemTag\SystemTagPlugin::ID_PROPERTYNAME;
- public const DISPLAYNAME_PROPERTYNAME = \OCA\DAV\SystemTag\SystemTagPlugin::DISPLAYNAME_PROPERTYNAME;
- public const USERVISIBLE_PROPERTYNAME = \OCA\DAV\SystemTag\SystemTagPlugin::USERVISIBLE_PROPERTYNAME;
- public const USERASSIGNABLE_PROPERTYNAME = \OCA\DAV\SystemTag\SystemTagPlugin::USERASSIGNABLE_PROPERTYNAME;
- public const CANASSIGN_PROPERTYNAME = \OCA\DAV\SystemTag\SystemTagPlugin::CANASSIGN_PROPERTYNAME;
- public const GROUPS_PROPERTYNAME = \OCA\DAV\SystemTag\SystemTagPlugin::GROUPS_PROPERTYNAME;
+ public const ID_PROPERTYNAME = SystemTagPlugin::ID_PROPERTYNAME;
+ public const DISPLAYNAME_PROPERTYNAME = SystemTagPlugin::DISPLAYNAME_PROPERTYNAME;
+ public const USERVISIBLE_PROPERTYNAME = SystemTagPlugin::USERVISIBLE_PROPERTYNAME;
+ public const USERASSIGNABLE_PROPERTYNAME = SystemTagPlugin::USERASSIGNABLE_PROPERTYNAME;
+ public const CANASSIGN_PROPERTYNAME = SystemTagPlugin::CANASSIGN_PROPERTYNAME;
+ public const GROUPS_PROPERTYNAME = SystemTagPlugin::GROUPS_PROPERTYNAME;
/**
* @var \Sabre\DAV\Server
private $user;
/**
- * @var \OCA\DAV\SystemTag\SystemTagPlugin
+ * @var SystemTagPlugin
*/
private $plugin;
$this->tagMapper = $this->getMockBuilder(ISystemTagObjectMapper::class)
->getMock();
- $this->plugin = new \OCA\DAV\SystemTag\SystemTagPlugin(
+ $this->plugin = new SystemTagPlugin(
$this->tagManager,
$this->groupManager,
$this->userSession,
namespace OCA\DAV\Tests\unit\SystemTag;
use OC\SystemTag\SystemTag;
+use OCA\DAV\SystemTag\SystemTagsByIdCollection;
use OCP\IGroupManager;
use OCP\IUser;
use OCP\IUserSession;
->method('isAdmin')
->with('testuser')
->willReturn($isAdmin);
- return new \OCA\DAV\SystemTag\SystemTagsByIdCollection(
+ return new SystemTagsByIdCollection(
$this->tagManager,
$userSession,
$groupManager
namespace OCA\DAV\Tests\unit\SystemTag;
use OC\SystemTag\SystemTag;
+use OCA\DAV\SystemTag\SystemTagsObjectMappingCollection;
use OCP\IUser;
use OCP\SystemTag\ISystemTagManager;
use OCP\SystemTag\ISystemTagObjectMapper;
}
public function getNode(array $writableNodeIds = []) {
- return new \OCA\DAV\SystemTag\SystemTagsObjectMappingCollection(
+ return new SystemTagsObjectMappingCollection(
111,
'files',
$this->user,
*/
namespace OCA\DAV\Tests\unit\SystemTag;
+use OCA\DAV\SystemTag\SystemTagsObjectTypeCollection;
use OCP\Files\Folder;
+use OCP\Files\Node;
use OCP\IGroupManager;
use OCP\IUser;
use OCP\IUserSession;
class SystemTagsObjectTypeCollectionTest extends \Test\TestCase {
/**
- * @var \OCA\DAV\SystemTag\SystemTagsObjectTypeCollection
+ * @var SystemTagsObjectTypeCollection
*/
private $node;
return false;
};
- $this->node = new \OCA\DAV\SystemTag\SystemTagsObjectTypeCollection(
+ $this->node = new SystemTagsObjectTypeCollection(
'files',
$this->tagManager,
$this->tagMapper,
$this->userFolder->expects($this->once())
->method('getFirstNodeById')
->with('555')
- ->willReturn($this->createMock(\OCP\Files\Node::class));
+ ->willReturn($this->createMock(Node::class));
$childNode = $this->node->getChild('555');
$this->assertInstanceOf('\OCA\DAV\SystemTag\SystemTagsObjectMappingCollection', $childNode);
$this->userFolder->expects($this->once())
->method('getFirstNodeById')
->with('123')
- ->willReturn($this->createMock(\OCP\Files\Node::class));
+ ->willReturn($this->createMock(Node::class));
$this->assertTrue($this->node->childExists('123'));
}
*/
namespace OCA\DAV\Tests\unit\Upload;
+use OCA\DAV\Upload\AssemblyStream;
use Sabre\DAV\File;
class AssemblyStreamTest extends \Test\TestCase {
* @dataProvider providesNodes()
*/
public function testGetContents($expected, $nodes): void {
- $stream = \OCA\DAV\Upload\AssemblyStream::wrap($nodes);
+ $stream = AssemblyStream::wrap($nodes);
$content = stream_get_contents($stream);
$this->assertEquals($expected, $content);
* @dataProvider providesNodes()
*/
public function testGetContentsFread($expected, $nodes): void {
- $stream = \OCA\DAV\Upload\AssemblyStream::wrap($nodes);
+ $stream = AssemblyStream::wrap($nodes);
$content = '';
while (!feof($stream)) {
* @dataProvider providesNodes()
*/
public function testSeek($expected, $nodes): void {
- $stream = \OCA\DAV\Upload\AssemblyStream::wrap($nodes);
+ $stream = AssemblyStream::wrap($nodes);
$offset = floor(strlen($expected) * 0.6);
if (fseek($stream, $offset) === -1) {
namespace OCA\DAV\Tests\unit\Upload;
use OCA\DAV\Connector\Sabre\Directory;
+use OCA\DAV\Upload\FutureFile;
class FutureFileTest extends \Test\TestCase {
public function testGetContentType(): void {
$d->expects($this->once())
->method('delete');
- $f = new \OCA\DAV\Upload\FutureFile($d, 'foo.txt');
+ $f = new FutureFile($d, 'foo.txt');
$f->delete();
}
}
/**
- * @return \OCA\DAV\Upload\FutureFile
+ * @return FutureFile
*/
private function mockFutureFile() {
$d = $this->getMockBuilder(Directory::class)
->method('getChildren')
->willReturn([]);
- return new \OCA\DAV\Upload\FutureFile($d, 'foo.txt');
+ return new FutureFile($d, 'foo.txt');
}
}
*/
namespace OCA\Encryption\Crypto;
+use OCA\Encryption\Exceptions\PrivateKeyMissingException;
use OCA\Encryption\KeyManager;
use OCA\Encryption\Session;
use OCA\Encryption\Util;
* @param string $user
* @param string $password
* @return bool|string
- * @throws \OCA\Encryption\Exceptions\PrivateKeyMissingException
+ * @throws PrivateKeyMissingException
*/
protected function getPrivateKey($user, $password) {
$recoveryKeyId = $this->keyManager->getRecoveryKeyId();
use OC\Encryption\Exceptions\DecryptionFailedException;
use OC\Files\Cache\Scanner;
use OC\Files\View;
+use OCA\Encryption\Exceptions\MultiKeyEncryptException;
use OCA\Encryption\Exceptions\PublicKeyMissingException;
use OCA\Encryption\KeyManager;
use OCA\Encryption\Session;
* of a write operation
* @throws PublicKeyMissingException
* @throws \Exception
- * @throws \OCA\Encryption\Exceptions\MultiKeyEncryptException
+ * @throws MultiKeyEncryptException
*/
public function end($path, $position = '0') {
$result = '';
*/
public function login($params) {
// ensure filesystem is loaded
- if (!\OC\Files\Filesystem::$loaded) {
+ if (!Filesystem::$loaded) {
$this->setupFS($params['uid']);
}
if ($this->util->isMasterKeyEnabled() === false) {
public function getPrivateKey() {
$key = $this->session->get('privateKey');
if (is_null($key)) {
- throw new Exceptions\PrivateKeyMissingException('please try to log-out and log-in again', 0);
+ throw new PrivateKeyMissingException('please try to log-out and log-in again', 0);
}
return $key;
}
private $configMock;
/** @var \OCP\IL10N|\PHPUnit\Framework\MockObject\MockObject */
private $l10nMock;
- /** @var \OCA\Encryption\Recovery|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var Recovery|\PHPUnit\Framework\MockObject\MockObject */
private $recoveryMock;
public function adminRecoveryProvider() {
/** @var \OCP\IUserSession|\PHPUnit\Framework\MockObject\MockObject */
private $userSessionMock;
- /** @var \OCA\Encryption\KeyManager|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var KeyManager|\PHPUnit\Framework\MockObject\MockObject */
private $keyManagerMock;
- /** @var \OCA\Encryption\Crypto\Crypt|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var Crypt|\PHPUnit\Framework\MockObject\MockObject */
private $cryptMock;
- /** @var \OCA\Encryption\Session|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var Session|\PHPUnit\Framework\MockObject\MockObject */
private $sessionMock;
/** @var MockObject|IUser */
private $user;
/** @var \OCP\ISession|\PHPUnit\Framework\MockObject\MockObject */
private $ocSessionMock;
- /** @var \OCA\Encryption\Util|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var Util|\PHPUnit\Framework\MockObject\MockObject */
private $utilMock;
protected function setUp(): void {
/** @var \OCP\IL10N|\PHPUnit\Framework\MockObject\MockObject */
private $l10nMock;
- /** @var \OCA\Encryption\Session | \PHPUnit\Framework\MockObject\MockObject */
+ /** @var Session|\PHPUnit\Framework\MockObject\MockObject */
protected $sessionMock;
/** @var IManager | \PHPUnit\Framework\MockObject\MockObject */
namespace OCA\Encryption\Tests\Crypto;
use OCA\Encryption\Crypto\Crypt;
+use OCP\Encryption\Exceptions\GenericEncryptionException;
use OCP\IConfig;
use OCP\IL10N;
use OCP\IUserSession;
* @dataProvider dataTestHasSignatureFail
*/
public function testHasSignatureFail($cipher): void {
- $this->expectException(\OCP\Encryption\Exceptions\GenericEncryptionException::class);
+ $this->expectException(GenericEncryptionException::class);
$data = 'encryptedContent00iv001234567890123456xx';
$this->invokePrivate($this->crypt, 'hasSignature', [$data, $cipher]);
['encryption.use_legacy_base64_encoding', false])
->willReturnOnConsecutiveCalls(true, false);
- /** @var \OCA\Encryption\Crypto\Crypt | \PHPUnit\Framework\MockObject\MockObject $crypt */
+ /** @var Crypt|\PHPUnit\Framework\MockObject\MockObject $crypt */
$crypt = $this->getMockBuilder(Crypt::class)
->setConstructorArgs(
[
class EncryptAllTest extends TestCase {
- /** @var \PHPUnit\Framework\MockObject\MockObject | \OCA\Encryption\KeyManager */
+ /** @var \PHPUnit\Framework\MockObject\MockObject|KeyManager */
protected $keyManager;
- /** @var \PHPUnit\Framework\MockObject\MockObject | \OCA\Encryption\Util */
+ /** @var \PHPUnit\Framework\MockObject\MockObject|Util */
protected $util;
/** @var \PHPUnit\Framework\MockObject\MockObject | \OCP\IUserManager */
protected $userManager;
- /** @var \PHPUnit\Framework\MockObject\MockObject | \OCA\Encryption\Users\Setup */
+ /** @var \PHPUnit\Framework\MockObject\MockObject|Setup */
protected $setupUser;
/** @var \PHPUnit\Framework\MockObject\MockObject | \OC\Files\View */
*/
namespace OCA\Encryption\Tests\Crypto;
+use OC\Encryption\Exceptions\DecryptionFailedException;
+use OC\Files\View;
use OCA\Encryption\Crypto\Crypt;
use OCA\Encryption\Crypto\DecryptAll;
use OCA\Encryption\Crypto\EncryptAll;
/** @var Encryption */
private $instance;
- /** @var \OCA\Encryption\KeyManager|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var KeyManager|\PHPUnit\Framework\MockObject\MockObject */
private $keyManagerMock;
- /** @var \OCA\Encryption\Crypto\EncryptAll|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var EncryptAll|\PHPUnit\Framework\MockObject\MockObject */
private $encryptAllMock;
- /** @var \OCA\Encryption\Crypto\DecryptAll|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var DecryptAll|\PHPUnit\Framework\MockObject\MockObject */
private $decryptAllMock;
- /** @var \OCA\Encryption\Session|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var Session|\PHPUnit\Framework\MockObject\MockObject */
private $sessionMock;
- /** @var \OCA\Encryption\Crypto\Crypt|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var Crypt|\PHPUnit\Framework\MockObject\MockObject */
private $cryptMock;
- /** @var \OCA\Encryption\Util|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var Util|\PHPUnit\Framework\MockObject\MockObject */
private $utilMock;
/** @var LoggerInterface|\PHPUnit\Framework\MockObject\MockObject */
->method('decryptAllModeActivated')
->willReturn(false);
- $this->expectException(\OCA\Encryption\Exceptions\PublicKeyMissingException::class);
+ $this->expectException(PublicKeyMissingException::class);
$this->instance->begin('/foo/bar', 'user2', 'r', [], ['users' => ['user1', 'user2', 'user3']]);
$this->endTest();
->willReturnCallback(function ($path, $version, $view): void {
$this->assertSame('path', $path);
$this->assertSame(2, $version);
- $this->assertTrue($view instanceof \OC\Files\View);
+ $this->assertTrue($view instanceof View);
});
$this->instance->update('path', 'user1', []);
}
public function testDecrypt(): void {
- $this->expectException(\OC\Encryption\Exceptions\DecryptionFailedException::class);
+ $this->expectException(DecryptionFailedException::class);
$this->expectExceptionMessage('Cannot decrypt this file, probably this is a shared file. Please ask the file owner to reshare the file with you.');
$this->instance->decrypt('abc');
public function testRegisterHooksWithInstance(): void {
$mock = $this->getMockBuilder(IHook::class)->disableOriginalConstructor()->getMock();
- /** @var \OCA\Encryption\Hooks\Contracts\IHook $mock */
+ /** @var IHook $mock */
self::$instance->registerHook($mock);
$hookInstances = self::invokePrivate(self::$instance, 'hookInstances');
]
)->setMethods(['initMountPoints'])->getMock();
- /** @var \OCA\Encryption\Hooks\UserHooks $userHooks */
+ /** @var UserHooks $userHooks */
$this->assertNull($userHooks->setPassphrase($this->params));
}
use OC\Files\FileInfo;
use OC\Files\View;
use OCA\Encryption\Crypto\Crypt;
+use OCA\Encryption\Crypto\Encryption;
+use OCA\Encryption\Exceptions\PrivateKeyMissingException;
+use OCA\Encryption\Exceptions\PublicKeyMissingException;
use OCA\Encryption\KeyManager;
use OCA\Encryption\Session;
use OCA\Encryption\Util;
/** @var \OCP\Encryption\Keys\IStorage|\PHPUnit\Framework\MockObject\MockObject */
private $keyStorageMock;
- /** @var \OCA\Encryption\Crypto\Crypt|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var Crypt|\PHPUnit\Framework\MockObject\MockObject */
private $cryptMock;
/** @var \OCP\IUserSession|\PHPUnit\Framework\MockObject\MockObject */
private $userMock;
- /** @var \OCA\Encryption\Session|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var Session|\PHPUnit\Framework\MockObject\MockObject */
private $sessionMock;
/** @var LoggerInterface|\PHPUnit\Framework\MockObject\MockObject */
private $logMock;
- /** @var \OCA\Encryption\Util|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var Util|\PHPUnit\Framework\MockObject\MockObject */
private $utilMock;
/** @var \OCP\IConfig|\PHPUnit\Framework\MockObject\MockObject */
public function testUserHasKeysMissingPrivateKey(): void {
- $this->expectException(\OCA\Encryption\Exceptions\PrivateKeyMissingException::class);
+ $this->expectException(PrivateKeyMissingException::class);
$this->keyStorageMock->expects($this->exactly(2))
->method('getUserKey')
public function testUserHasKeysMissingPublicKey(): void {
- $this->expectException(\OCA\Encryption\Exceptions\PublicKeyMissingException::class);
+ $this->expectException(PublicKeyMissingException::class);
$this->keyStorageMock->expects($this->exactly(2))
->method('getUserKey')
* @param bool $useMasterKey
*/
public function testInit($useMasterKey): void {
- /** @var \OCA\Encryption\KeyManager|\PHPUnit\Framework\MockObject\MockObject $instance */
+ /** @var KeyManager|\PHPUnit\Framework\MockObject\MockObject $instance */
$instance = $this->getMockBuilder(KeyManager::class)
->setConstructorArgs(
[
public function testGetPublicMasterKey(): void {
$this->keyStorageMock->expects($this->once())->method('getSystemUserKey')
- ->with('systemKeyId.publicKey', \OCA\Encryption\Crypto\Encryption::ID)
+ ->with('systemKeyId.publicKey', Encryption::ID)
->willReturn(true);
$this->assertTrue(
* @param $masterKey
*/
public function testValidateMasterKey($masterKey): void {
- /** @var \OCA\Encryption\KeyManager | \PHPUnit\Framework\MockObject\MockObject $instance */
+ /** @var KeyManager|\PHPUnit\Framework\MockObject\MockObject $instance */
$instance = $this->getMockBuilder(KeyManager::class)
->setConstructorArgs(
[
$this->cryptMock->expects($this->once())->method('createKeyPair')
->willReturn(['publicKey' => 'public', 'privateKey' => 'private']);
$this->keyStorageMock->expects($this->once())->method('setSystemUserKey')
- ->with('systemKeyId.publicKey', 'public', \OCA\Encryption\Crypto\Encryption::ID);
+ ->with('systemKeyId.publicKey', 'public', Encryption::ID);
$this->cryptMock->expects($this->once())->method('encryptPrivateKey')
->with('private', 'masterKeyPassword', 'systemKeyId')
->willReturn('EncryptedKey');
}
public function testValidateMasterKeyLocked(): void {
- /** @var \OCA\Encryption\KeyManager | \PHPUnit_Framework_MockObject_MockObject $instance */
+ /** @var KeyManager|\PHPUnit_Framework_MockObject_MockObject $instance */
$instance = $this->getMockBuilder(KeyManager::class)
->setConstructorArgs(
[
*/
private $user;
/**
- * @var \OCA\Encryption\KeyManager|\PHPUnit\Framework\MockObject\MockObject
+ * @var KeyManager|\PHPUnit\Framework\MockObject\MockObject
*/
private $keyManagerMock;
/**
*/
private $configMock;
/**
- * @var \OCA\Encryption\Crypto\Crypt|\PHPUnit\Framework\MockObject\MockObject
+ * @var Crypt|\PHPUnit\Framework\MockObject\MockObject
*/
private $cryptMock;
/**
*/
namespace OCA\Encryption\Tests;
+use OCA\Encryption\Exceptions\PrivateKeyMissingException;
use OCA\Encryption\Session;
use OCP\ISession;
use Test\TestCase;
public function testThatGetPrivateKeyThrowsExceptionWhenNotSet(): void {
- $this->expectException(\OCA\Encryption\Exceptions\PrivateKeyMissingException::class);
+ $this->expectException(PrivateKeyMissingException::class);
$this->expectExceptionMessage('Private Key missing for user: please try to log-out and log-in again');
$this->instance->getPrivateKey();
* @expectExceptionMessage 'Please activate decrypt all mode first'
*/
public function testGetDecryptAllKeyException(): void {
- $this->expectException(\OCA\Encryption\Exceptions\PrivateKeyMissingException::class);
+ $this->expectException(PrivateKeyMissingException::class);
$this->instance->getDecryptAllKey();
}
* @expectExceptionMessage 'No key found while in decrypt all mode'
*/
public function testGetDecryptAllKeyException2(): void {
- $this->expectException(\OCA\Encryption\Exceptions\PrivateKeyMissingException::class);
+ $this->expectException(PrivateKeyMissingException::class);
$this->instance->prepareDecryptAll('user', null);
$this->instance->getDecryptAllKey();
class SetupTest extends TestCase {
/**
- * @var \OCA\Encryption\KeyManager|\PHPUnit\Framework\MockObject\MockObject
+ * @var KeyManager|\PHPUnit\Framework\MockObject\MockObject
*/
private $keyManagerMock;
/**
- * @var \OCA\Encryption\Crypto\Crypt|\PHPUnit\Framework\MockObject\MockObject
+ * @var Crypt|\PHPUnit\Framework\MockObject\MockObject
*/
private $cryptMock;
/**
$this->filesMock = $this->createMock(View::class);
$this->userManagerMock = $this->createMock(IUserManager::class);
- /** @var \OCA\Encryption\Crypto\Crypt $cryptMock */
+ /** @var Crypt $cryptMock */
$cryptMock = $this->getMockBuilder(Crypt::class)
->disableOriginalConstructor()
->getMock();
use OCP\HintException;
use OCP\IL10N;
use OCP\IURLGenerator;
+use OCP\Util;
/**
* Class AddressHandler - parse, modify and construct federated sharing addresses
if (rtrim($normalizedServer1, '/') === rtrim($normalizedServer2, '/')) {
// FIXME this should be a method in the user management instead
- \OCP\Util::emitHook(
+ Util::emitHook(
'\OCA\Files_Sharing\API\Server2Server',
'preLoginNameUsedAsUserName',
['uid' => &$user1]
);
- \OCP\Util::emitHook(
+ Util::emitHook(
'\OCA\Files_Sharing\API\Server2Server',
'preLoginNameUsedAsUserName',
['uid' => &$user2]
use OCP\AppFramework\Http\Attribute\NoCSRFRequired;
use OCP\AppFramework\Http\Attribute\OpenAPI;
use OCP\AppFramework\Http\Attribute\PublicPage;
+use OCP\AppFramework\Http\DataResponse;
use OCP\AppFramework\OCS\OCSBadRequestException;
use OCP\AppFramework\OCS\OCSException;
use OCP\AppFramework\OCSController;
use OCP\IRequest;
use OCP\IUserManager;
use OCP\Log\Audit\CriticalActionPerformedEvent;
+use OCP\Server;
use OCP\Share;
use OCP\Share\Exceptions\ShareNotFound;
use Psr\Log\LoggerInterface;
throw new OCSException('internal server error, was not able to add share from ' . $remote, 500);
}
- return new Http\DataResponse();
+ return new DataResponse();
}
/**
try {
$provider = $this->cloudFederationProviderManager->getCloudFederationProvider('file');
[$newToken, $localId] = $provider->notificationReceived('REQUEST_RESHARE', $id, $notification);
- return new Http\DataResponse([
+ return new DataResponse([
'token' => $newToken,
'remoteId' => $localId
]);
$this->logger->debug('internal server error, can not process notification: ' . $e->getMessage(), ['exception' => $e]);
}
- return new Http\DataResponse();
+ return new DataResponse();
}
/**
$this->logger->debug('internal server error, can not process notification: ' . $e->getMessage(), ['exception' => $e]);
}
- return new Http\DataResponse();
+ return new DataResponse();
}
/**
$this->logger->debug('processing unshare notification failed: ' . $e->getMessage(), ['exception' => $e]);
}
- return new Http\DataResponse();
+ return new DataResponse();
}
private function cleanupRemote($remote) {
$provider = $this->cloudFederationProviderManager->getCloudFederationProvider('file');
$notification = ['sharedSecret' => $token];
$provider->notificationReceived('RESHARE_UNDO', $id, $notification);
- return new Http\DataResponse();
+ return new DataResponse();
} catch (\Exception $e) {
throw new OCSBadRequestException();
}
* @return bool
*/
private function isS2SEnabled($incoming = false) {
- $result = \OCP\Server::get(IAppManager::class)->isEnabledForUser('files_sharing');
+ $result = Server::get(IAppManager::class)->isEnabledForUser('files_sharing');
if ($incoming) {
$result = $result && $this->federatedShareProvider->isIncomingServer2serverShareEnabled();
throw new OCSBadRequestException();
}
- return new Http\DataResponse();
+ return new DataResponse();
}
/**
$affected = $query->executeStatement();
if ($affected > 0) {
- return new Http\DataResponse(['remote' => $cloudId->getRemote(), 'owner' => $cloudId->getUser()]);
+ return new DataResponse(['remote' => $cloudId->getRemote(), 'owner' => $cloudId->getUser()]);
} else {
throw new OCSBadRequestException('Share not found or token invalid');
}
->from('share')
->where(
$qb->expr()->orX(
- $qb->expr()->eq('share_type', $qb->createNamedParameter(\OCP\Share\IShare::TYPE_REMOTE)),
- $qb->expr()->eq('share_type', $qb->createNamedParameter(\OCP\Share\IShare::TYPE_REMOTE_GROUP))
+ $qb->expr()->eq('share_type', $qb->createNamedParameter(IShare::TYPE_REMOTE)),
+ $qb->expr()->eq('share_type', $qb->createNamedParameter(IShare::TYPE_REMOTE_GROUP))
)
);
use OCP\AppFramework\Services\IInitialState;
use OCP\EventDispatcher\Event;
use OCP\EventDispatcher\IEventListener;
+use OCP\Util;
/** @template-implements IEventListener<LoadAdditionalScriptsEvent> */
class LoadAdditionalScriptsListener implements IEventListener {
if ($this->federatedShareProvider->isIncomingServer2serverShareEnabled()) {
$this->initialState->provideInitialState('notificationsEnabled', $this->appManager->isEnabledForUser('notifications'));
- \OCP\Util::addInitScript('federatedfilesharing', 'external');
+ Util::addInitScript('federatedfilesharing', 'external');
}
}
}
use OCA\FederatedFileSharing\FederatedShareProvider;
use OCA\Files_Sharing\Activity\Providers\RemoteShares;
use OCA\Files_Sharing\External\Manager;
+use OCA\GlobalSiteSelector\Service\SlaveService;
use OCP\Activity\IManager as IActivityManager;
use OCP\App\IAppManager;
use OCP\Constants;
}
try {
- $slaveService = Server::get(\OCA\GlobalSiteSelector\Service\SlaveService::class);
+ $slaveService = Server::get(SlaveService::class);
} catch (\Throwable $e) {
Server::get(LoggerInterface::class)->error(
$e->getMessage(),
use OCA\FederatedFileSharing\AddressHandler;
use OCP\Contacts\IManager;
use OCP\EventDispatcher\IEventDispatcher;
+use OCP\HintException;
use OCP\ICacheFactory;
use OCP\IL10N;
use OCP\IURLGenerator;
* @param string $id
*/
public function testSplitUserRemoteError($id): void {
- $this->expectException(\OCP\HintException::class);
+ $this->expectException(HintException::class);
$this->addressHandler->splitUserRemote($id);
}
namespace OCA\FederatedFileSharing\Tests\Controller;
use OC\Federation\CloudIdManager;
+use OC\Share20\Share;
use OCA\FederatedFileSharing\AddressHandler;
use OCA\FederatedFileSharing\Controller\MountPublicLinkController;
use OCA\FederatedFileSharing\FederatedShareProvider;
->disableOriginalConstructor()->getMock();
$this->rootFolder = $this->getMockBuilder('OCP\Files\IRootFolder')->disableOriginalConstructor()->getMock();
$this->userManager = $this->getMockBuilder(IUserManager::class)->disableOriginalConstructor()->getMock();
- $this->share = new \OC\Share20\Share($this->rootFolder, $this->userManager);
+ $this->share = new Share($this->rootFolder, $this->userManager);
$this->session = $this->getMockBuilder(ISession::class)->disableOriginalConstructor()->getMock();
$this->l10n = $this->getMockBuilder(IL10N::class)->disableOriginalConstructor()->getMock();
$this->userSession = $this->getMockBuilder(IUserSession::class)->disableOriginalConstructor()->getMock();
*/
namespace OCA\FederatedFileSharing\Tests;
+use OCA\FederatedFileSharing\AddressHandler;
use OCA\FederatedFileSharing\Controller\RequestHandlerController;
+use OCA\FederatedFileSharing\FederatedShareProvider;
+use OCA\FederatedFileSharing\Notifications;
use OCP\AppFramework\Http\DataResponse;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\Federation\ICloudFederationFactory;
/** @var RequestHandlerController */
private $requestHandler;
- /** @var \OCA\FederatedFileSharing\FederatedShareProvider|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var FederatedShareProvider|\PHPUnit\Framework\MockObject\MockObject */
private $federatedShareProvider;
- /** @var \OCA\FederatedFileSharing\Notifications|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var Notifications|\PHPUnit\Framework\MockObject\MockObject */
private $notifications;
- /** @var \OCA\FederatedFileSharing\AddressHandler|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var AddressHandler|\PHPUnit\Framework\MockObject\MockObject */
private $addressHandler;
/** @var IUserManager|\PHPUnit\Framework\MockObject\MockObject */
use OCA\FederatedFileSharing\FederatedShareProvider;
use OCA\FederatedFileSharing\Notifications;
use OCA\FederatedFileSharing\TokenHandler;
+use OCP\Constants;
use OCP\Contacts\IManager as IContactsManager;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\Federation\ICloudFederationProviderManager;
$share1->setSharedWith('user@server.com')
->setSharedBy($u1->getUID())
->setShareOwner($u1->getUID())
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setShareType(IShare::TYPE_REMOTE)
->setNode($file1);
$this->provider->create($share1);
$share2->setSharedWith('user@server.com')
->setSharedBy($u2->getUID())
->setShareOwner($u1->getUID())
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setShareType(IShare::TYPE_REMOTE)
->setNode($file2);
$this->provider->create($share2);
$share1->setSharedWith('user@server.com')
->setSharedBy($u1->getUID())
->setShareOwner($u1->getUID())
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setShareType(IShare::TYPE_REMOTE)
->setNode($file1);
$this->provider->create($share1);
$share2->setSharedWith('foobar@localhost')
->setSharedBy($u1->getUID())
->setShareOwner($u1->getUID())
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setShareType(IShare::TYPE_REMOTE)
->setNode($file1);
$this->provider->create($share2);
class AdminTest extends TestCase {
/** @var Admin */
private $admin;
- /** @var \OCA\FederatedFileSharing\FederatedShareProvider */
+ /** @var FederatedShareProvider */
private $federatedShareProvider;
/** @var IConfig|\PHPUnit\Framework\MockObject\MockObject */
private $gsConfig;
\OC_Util::tearDownFS();
\OC::$server->getUserSession()->setUser(null);
- \OC\Files\Filesystem::tearDown();
+ Filesystem::tearDown();
\OC::$server->getUserSession()->login($user, $password);
\OC::$server->getUserFolder($user);
namespace OCA\Federation\DAV;
use OCA\Federation\DbHandler;
+use OCP\Defaults;
use Sabre\DAV\Auth\Backend\AbstractBasic;
use Sabre\HTTP\RequestInterface;
use Sabre\HTTP\ResponseInterface;
$this->principalPrefix = 'principals/system/';
// setup realm
- $defaults = new \OCP\Defaults();
+ $defaults = new Defaults();
$this->realm = $defaults->getName();
}
use OCA\Federation\Controller\SettingsController;
use OCA\Federation\TrustedServers;
use OCP\AppFramework\Http\DataResponse;
+use OCP\HintException;
use OCP\IL10N;
use OCP\IRequest;
use Test\TestCase;
/** @var \PHPUnit\Framework\MockObject\MockObject | \OCP\IL10N */
private $l10n;
- /** @var \PHPUnit\Framework\MockObject\MockObject | \OCA\Federation\TrustedServers */
+ /** @var \PHPUnit\Framework\MockObject\MockObject|TrustedServers */
private $trustedServers;
protected function setUp(): void {
* @dataProvider checkServerFails
*/
public function testAddServerFail(bool $isTrustedServer, bool $isNextcloud): void {
- $this->expectException(\OCP\HintException::class);
+ $this->expectException(HintException::class);
$this->trustedServers
->expects($this->any())
* @dataProvider checkServerFails
*/
public function testCheckServerFail(bool $isTrustedServer, bool $isNextcloud): void {
- $this->expectException(\OCP\HintException::class);
+ $this->expectException(HintException::class);
$this->trustedServers
->expects($this->any())
namespace OCA\Federation\Tests;
use OC\OCS\DiscoveryService;
+use OCA\DAV\CardDAV\SyncService;
use OCA\Federation\DbHandler;
use OCA\Federation\SyncFederationAddressBooks;
+use OCA\Federation\TrustedServers;
use PHPUnit\Framework\MockObject\MockObject;
use Psr\Log\LoggerInterface;
$syncService->expects($this->once())->method('syncRemoteAddressBook')
->willReturn('1');
- /** @var \OCA\DAV\CardDAV\SyncService $syncService */
+ /** @var SyncService $syncService */
$s = new SyncFederationAddressBooks($dbHandler, $syncService, $this->discoveryService, $this->logger);
$s->syncThemAll(function ($url, $ex): void {
$this->callBacks[] = [$url, $ex];
$syncService->expects($this->once())->method('syncRemoteAddressBook')
->willThrowException(new \Exception('something did not work out'));
- /** @var \OCA\DAV\CardDAV\SyncService $syncService */
+ /** @var SyncService $syncService */
$s = new SyncFederationAddressBooks($dbHandler, $syncService, $this->discoveryService, $this->logger);
$s->syncThemAll(function ($url, $ex): void {
$this->callBacks[] = [$url, $ex];
'sync_token' => '0'
]
]);
- $dbHandler->method('getServerStatus')->willReturn(\OCA\Federation\TrustedServers::STATUS_FAILURE);
+ $dbHandler->method('getServerStatus')->willReturn(TrustedServers::STATUS_FAILURE);
$dbHandler->expects($this->once())->method('setServerStatus')->
with('https://cloud.drop.box', 1);
$syncService = $this->getMockBuilder('OCA\DAV\CardDAV\SyncService')
$syncService->expects($this->once())->method('syncRemoteAddressBook')
->willReturn('0');
- /** @var \OCA\DAV\CardDAV\SyncService $syncService */
+ /** @var SyncService $syncService */
$s = new SyncFederationAddressBooks($dbHandler, $syncService, $this->discoveryService, $this->logger);
$s->syncThemAll(function ($url, $ex): void {
$this->callBacks[] = [$url, $ex];
use OCP\AppFramework\Utility\ITimeFactory;
use OCP\BackgroundJob\IJobList;
use OCP\EventDispatcher\IEventDispatcher;
+use OCP\Federation\Events\TrustedServerRemovedEvent;
+use OCP\HintException;
use OCP\Http\Client\IClient;
use OCP\Http\Client\IClientService;
use OCP\Http\Client\IResponse;
$this->dispatcher->expects($this->once())->method('dispatchTyped')
->willReturnCallback(
function ($event): void {
- $this->assertSame(get_class($event), \OCP\Federation\Events\TrustedServerRemovedEvent::class);
+ $this->assertSame(get_class($event), TrustedServerRemovedEvent::class);
/** @var \OCP\Federated\Events\TrustedServerRemovedEvent $event */
$this->assertSame('url_hash', $event->getUrlHash());
}
* @dataProvider dataTestCheckNextcloudVersionTooLow
*/
public function testCheckNextcloudVersionTooLow(string $status): void {
- $this->expectException(\OCP\HintException::class);
+ $this->expectException(HintException::class);
$this->expectExceptionMessage('Remote server version is too low. 9.0 is required.');
$this->invokePrivate($this->trustedServers, 'checkNextcloudVersion', [$status]);
use OC\Core\Command\InterruptedException;
use OC\DB\Connection;
use OC\DB\ConnectionAdapter;
+use OC\Files\Utils\Scanner;
use OC\FilesMetadata\FilesMetadataManager;
use OC\ForbiddenException;
use OCP\EventDispatcher\IEventDispatcher;
protected function scanFiles(string $user, string $path, ?string $scanMetadata, OutputInterface $output, bool $backgroundScan = false, bool $recursive = true, bool $homeOnly = false): void {
$connection = $this->reconnectToDatabase($output);
- $scanner = new \OC\Files\Utils\Scanner(
+ $scanner = new Scanner(
$user,
new ConnectionAdapter($connection),
\OC::$server->get(IEventDispatcher::class),
use OC\Core\Command\InterruptedException;
use OC\DB\Connection;
use OC\DB\ConnectionAdapter;
+use OC\Files\Utils\Scanner;
use OC\ForbiddenException;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\Files\IRootFolder;
}
$connection = $this->reconnectToDatabase($output);
- $scanner = new \OC\Files\Utils\Scanner(
+ $scanner = new Scanner(
null,
new ConnectionAdapter($connection),
\OC::$server->query(IEventDispatcher::class),
namespace OCA\Files\Controller;
use OC\Files\Node\Node;
+use OCA\Files\Helper;
use OCA\Files\ResponseDefinitions;
use OCA\Files\Service\TagService;
use OCA\Files\Service\UserConfig;
use OCP\Files\Folder;
use OCP\Files\IRootFolder;
use OCP\Files\NotFoundException;
+use OCP\Files\StorageNotAvailableException;
use OCP\IConfig;
use OCP\IL10N;
use OCP\IPreview;
if (!is_null($tags)) {
try {
$this->tagService->updateFileTags($path, $tags);
- } catch (\OCP\Files\NotFoundException $e) {
+ } catch (NotFoundException $e) {
return new DataResponse([
'message' => $e->getMessage()
], Http::STATUS_NOT_FOUND);
- } catch (\OCP\Files\StorageNotAvailableException $e) {
+ } catch (StorageNotAvailableException $e) {
return new DataResponse([
'message' => $e->getMessage()
], Http::STATUS_SERVICE_UNAVAILABLE);
$shareTypesForNodes = $this->getShareTypesForNodes($nodes);
return array_values(array_map(function (Node $node) use ($shareTypesForNodes) {
$shareTypes = $shareTypesForNodes[$node->getId()] ?? [];
- $file = \OCA\Files\Helper::formatFileInfo($node->getFileInfo());
+ $file = Helper::formatFileInfo($node->getFileInfo());
$file['hasPreview'] = $this->previewManager->isAvailable($node);
$parts = explode('/', dirname($node->getPath()), 4);
if (isset($parts[3])) {
namespace OCA\Files\Controller;
use OC\Files\FilenameValidator;
+use OC\Files\Filesystem;
use OCA\Files\AppInfo\Application;
use OCA\Files\Event\LoadAdditionalScriptsEvent;
use OCA\Files\Event\LoadSearchPlugins;
use OCP\IRequest;
use OCP\IURLGenerator;
use OCP\IUserSession;
+use OCP\Util;
/**
* @package OCA\Files\Controller
* @throws \OCP\Files\NotFoundException
*/
protected function getStorageInfo(string $dir = '/') {
- $rootInfo = \OC\Files\Filesystem::getFileInfo('/', false);
+ $rootInfo = Filesystem::getFileInfo('/', false);
return \OC_Helper::getStorageInfo($dir, $rootInfo ?: null);
}
}
// Load the files we need
- \OCP\Util::addInitScript('files', 'init');
- \OCP\Util::addScript('files', 'main');
+ Util::addInitScript('files', 'init');
+ Util::addScript('files', 'main');
$userId = $this->userSession->getUser()->getUID();
*/
namespace OCA\Files;
+use OC\Files\Filesystem;
use OCP\Files\FileInfo;
use OCP\ITagManager;
+use OCP\Util;
/**
* Helper class for manipulating file information
public static function buildFileStorageStatistics($dir) {
// information about storage capacities
$storageInfo = \OC_Helper::getStorageInfo($dir);
- $l = \OCP\Util::getL10N('files');
- $maxUploadFileSize = \OCP\Util::maxUploadFilesize($dir, $storageInfo['free']);
- $maxHumanFileSize = \OCP\Util::humanFileSize($maxUploadFileSize);
+ $l = Util::getL10N('files');
+ $maxUploadFileSize = Util::maxUploadFilesize($dir, $storageInfo['free']);
+ $maxHumanFileSize = Util::humanFileSize($maxUploadFileSize);
$maxHumanFileSize = $l->t('Upload (max. %s)', [$maxHumanFileSize]);
return [
} elseif ($aType !== 'dir' and $bType === 'dir') {
return 1;
} else {
- return \OCP\Util::naturalSortCompare($a->getName(), $b->getName());
+ return Util::naturalSortCompare($a->getName(), $b->getName());
}
}
* @return \OCP\Files\FileInfo[] files
*/
public static function getFiles($dir, $sortAttribute = 'name', $sortDescending = false, $mimetypeFilter = '') {
- $content = \OC\Files\Filesystem::getDirectoryContent($dir, $mimetypeFilter);
+ $content = Filesystem::getDirectoryContent($dir, $mimetypeFilter);
return self::sortFiles($content, $sortAttribute, $sortDescending);
}
use OCA\Files\Event\LoadSearchPlugins;
use OCP\EventDispatcher\Event;
use OCP\EventDispatcher\IEventListener;
+use OCP\Util;
/** @template-implements IEventListener<LoadSearchPlugins> */
class LoadSearchPluginsListener implements IEventListener {
return;
}
- \OCP\Util::addScript('files', 'search');
+ Util::addScript('files', 'search');
}
}
use OCP\Collaboration\Reference\RenderReferenceEvent;
use OCP\EventDispatcher\Event;
use OCP\EventDispatcher\IEventListener;
+use OCP\Util;
/** @template-implements IEventListener<RenderReferenceEvent> */
class RenderReferenceEventListener implements IEventListener {
return;
}
- \OCP\Util::addScript('files', 'reference-files');
+ Util::addScript('files', 'reference-files');
}
}
use OC\Encryption\Manager as EncryptionManager;
use OC\Files\Filesystem;
use OC\Files\View;
+use OCA\Encryption\Util;
use OCA\Files\Exception\TransferOwnershipException;
use OCP\Encryption\IManager as IEncryptionManager;
use OCP\Files\Config\IUserMountCache;
use OCP\Files\InvalidPathException;
use OCP\Files\IRootFolder;
use OCP\Files\Mount\IMountManager;
+use OCP\Files\NotFoundException;
use OCP\IUser;
use OCP\IUserManager;
use OCP\L10N\IFactory;
+use OCP\Server;
use OCP\Share\IManager as IShareManager;
use OCP\Share\IShare;
use Symfony\Component\Console\Helper\ProgressBar;
$progress->start();
if ($this->encryptionManager->isEnabled()) {
- $masterKeyEnabled = \OCP\Server::get(\OCA\Encryption\Util::class)->isMasterKeyEnabled();
+ $masterKeyEnabled = Server::get(Util::class)->isMasterKeyEnabled();
} else {
$masterKeyEnabled = false;
}
):void {
$output->writeln('Restoring shares ...');
$progress = new ProgressBar($output, count($shares));
- $rootFolder = \OCP\Server::get(IRootFolder::class);
+ $rootFolder = Server::get(IRootFolder::class);
foreach ($shares as ['share' => $share, 'suffix' => $suffix]) {
try {
// Normally the ID is preserved,
// but for transferes between different storages the ID might change
$newNodeId = $share->getNode()->getId();
- } catch (\OCP\Files\NotFoundException) {
+ } catch (NotFoundException) {
// ID has changed due to transfer between different storages
// Try to get the new ID from the target path and suffix of the share
$node = $rootFolder->get(Filesystem::normalizePath($targetLocation . '/' . $suffix));
$this->shareManager->updateShare($share);
}
}
- } catch (\OCP\Files\NotFoundException $e) {
+ } catch (NotFoundException $e) {
$output->writeln('<error>Share with id ' . $share->getId() . ' points at deleted file, skipping</error>');
} catch (\Throwable $e) {
$output->writeln('<error>Could not restore share with id ' . $share->getId() . ':' . $e->getMessage() . ' : ' . $e->getTraceAsString() . '</error>');
$this->shareManager->moveShare($share, $destinationUid);
continue;
}
- } catch (\OCP\Files\NotFoundException $e) {
+ } catch (NotFoundException $e) {
$output->writeln('<error>Share with id ' . $share->getId() . ' points at deleted file, skipping</error>');
} catch (\Throwable $e) {
$output->writeln('<error>Could not restore share with id ' . $share->getId() . ':' . $e->getTraceAsString() . '</error>');
use OCA\Files\AppInfo\Application;
use OCP\AppFramework\Http\TemplateResponse;
use OCP\Settings\ISettings;
+use OCP\Util;
class PersonalSettings implements ISettings {
public function getForm(): TemplateResponse {
- \OCP\Util::addScript(Application::APP_ID, 'settings-personal');
+ Util::addScript(Application::APP_ID, 'settings-personal');
return new TemplateResponse(Application::APP_ID, 'settings-personal');
}
use OCP\Files\IRootFolder;
use OCP\Files\StorageNotAvailableException;
use OCP\IDBConnection;
+use OCP\Server;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Test\TestCase;
protected function setUp(): void {
parent::setUp();
- $this->connection = \OCP\Server::get(IDBConnection::class);
+ $this->connection = Server::get(IDBConnection::class);
$this->user1 = $this->getUniqueID('user1_');
->disableOriginalConstructor()
->getMock();
- $rootFolder = \OCP\Server::get(IRootFolder::class);
+ $rootFolder = Server::get(IRootFolder::class);
// scan home storage so that mounts are properly setup
$rootFolder->getUserFolder($this->user1)->getStorage()->getScanner()->scan('');
use OCA\Files\Service\ViewConfig;
use OCP\AppFramework\Http;
use OCP\AppFramework\Http\DataResponse;
+use OCP\AppFramework\Http\FileDisplayResponse;
+use OCP\AppFramework\Http\Response;
use OCP\Files\File;
use OCP\Files\Folder;
use OCP\Files\IRootFolder;
$ret = $this->apiController->getThumbnail(10, 10, 'known.jpg');
$this->assertEquals(Http::STATUS_OK, $ret->getStatus());
- $this->assertInstanceOf(Http\FileDisplayResponse::class, $ret);
+ $this->assertInstanceOf(FileDisplayResponse::class, $ret);
}
public function testShowHiddenFiles(): void {
->method('setUserValue')
->with($this->user->getUID(), 'files', 'show_hidden', '0');
- $expected = new Http\Response();
+ $expected = new Response();
$actual = $this->apiController->showHiddenFiles($show);
$this->assertEquals($expected, $actual);
->method('setUserValue')
->with($this->user->getUID(), 'files', 'crop_image_previews', '1');
- $expected = new Http\Response();
+ $expected = new Response();
$actual = $this->apiController->cropImagePreviews($crop);
$this->assertEquals($expected, $actual);
use OCA\Files\Service\UserConfig;
use OCA\Files\Service\ViewConfig;
use OCP\App\IAppManager;
-use OCP\AppFramework\Http;
+use OCP\AppFramework\Http\ContentSecurityPolicy;
+use OCP\AppFramework\Http\RedirectResponse;
+use OCP\AppFramework\Http\TemplateResponse;
use OCP\AppFramework\Services\IInitialState;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\Files\File;
->method('getAppValue')
->willReturnArgument(2);
- $expected = new Http\TemplateResponse(
+ $expected = new TemplateResponse(
'files',
'index',
);
- $policy = new Http\ContentSecurityPolicy();
+ $policy = new ContentSecurityPolicy();
$policy->addAllowedWorkerSrcDomain('\'self\'');
$policy->addAllowedFrameDomain('\'self\'');
$expected->setContentSecurityPolicy($policy);
->with('files.view.indexViewFileid', ['view' => 'trashbin', 'dir' => '/test.d1462861890/sub', 'fileid' => '123'])
->willReturn('/apps/files/trashbin/123?dir=/test.d1462861890/sub');
- $expected = new Http\RedirectResponse('/apps/files/trashbin/123?dir=/test.d1462861890/sub');
+ $expected = new RedirectResponse('/apps/files/trashbin/123?dir=/test.d1462861890/sub');
$this->assertEquals($expected, $this->viewController->index('', '', '123'));
}
}
<?php
+use OC\Files\FileInfo;
+use OCA\Files\Helper;
+use OCP\ITagManager;
+use OCP\ITags;
+
/**
* SPDX-FileCopyrightText: 2017-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
*/
class HelperTest extends \Test\TestCase {
private function makeFileInfo($name, $size, $mtime, $isDir = false) {
- return new \OC\Files\FileInfo(
+ return new FileInfo(
'/' . $name,
null,
'/',
$this->markTestSkipped('Skip mtime sorting on 32bit');
}
$files = self::getTestFileList();
- $files = \OCA\Files\Helper::sortFiles($files, $sort, $sortDescending);
+ $files = Helper::sortFiles($files, $sort, $sortDescending);
$fileNames = [];
foreach ($files as $fileInfo) {
$fileNames[] = $fileInfo->getName();
}
public function testPopulateTags(): void {
- $tagManager = $this->createMock(\OCP\ITagManager::class);
- $tagger = $this->createMock(\OCP\ITags::class);
+ $tagManager = $this->createMock(ITagManager::class);
+ $tagger = $this->createMock(ITags::class);
$tagManager->method('load')
->with('files')
->with([10, 22, 42])
->willReturn($tags);
- $result = \OCA\Files\Helper::populateTags($data, 'id', $tagManager);
+ $result = Helper::populateTags($data, 'id', $tagManager);
$this->assertSame([
['id' => 10, 'tags' => ['tag3']],
use OCA\Files\Service\TagService;
use OCP\Activity\IManager;
use OCP\EventDispatcher\IEventDispatcher;
+use OCP\Files\NotFoundException;
use OCP\ITags;
use OCP\IUser;
use OCP\IUserSession;
private $dispatcher;
/**
- * @var \OCA\Files\Service\TagService|\PHPUnit\Framework\MockObject\MockObject
+ * @var TagService|\PHPUnit\Framework\MockObject\MockObject
*/
private $tagService;
$caught = false;
try {
$this->tagService->updateFileTags('subdir/unexist.txt', [$tag1]);
- } catch (\OCP\Files\NotFoundException $e) {
+ } catch (NotFoundException $e) {
$caught = true;
}
$this->assertTrue($caught);
use OC\Core\Command\Base;
use OCA\Files_External\Lib\InsufficientDataForMeaningfulAnswerException;
use OCA\Files_External\Lib\StorageConfig;
+use OCA\Files_External\MountConfig;
use OCA\Files_External\NotFoundException;
use OCA\Files_External\Service\GlobalStoragesService;
use OCP\AppFramework\Http;
$backend = $storage->getBackend();
// update status (can be time-consuming)
$storage->setStatus(
- \OCA\Files_External\MountConfig::getBackendStatus(
+ MountConfig::getBackendStatus(
$backend->getStorageClass(),
$storage->getBackendOptions(),
false
*/
namespace OCA\Files_External\Config;
+use OC\Files\Cache\Storage;
use OC\Files\Storage\FailedStorage;
use OC\Files\Storage\Wrapper\Availability;
use OC\Files\Storage\Wrapper\KnownMtime;
use OCA\Files_External\Lib\PersonalMount;
use OCA\Files_External\Lib\StorageConfig;
+use OCA\Files_External\MountConfig;
use OCA\Files_External\Service\UserGlobalStoragesService;
use OCA\Files_External\Service\UserStoragesService;
use OCP\Files\Config\IMountProvider;
use OCP\Files\Storage\IStorageFactory;
use OCP\Files\StorageNotAvailableException;
use OCP\IUser;
+use OCP\Server;
use Psr\Clock\ClockInterface;
use Psr\Log\LoggerInterface;
*/
private function prepareStorageConfig(StorageConfig &$storage, IUser $user): void {
foreach ($storage->getBackendOptions() as $option => $value) {
- $storage->setBackendOption($option, \OCA\Files_External\MountConfig::substitutePlaceholdersInConfig($value, $user->getUID()));
+ $storage->setBackendOption($option, MountConfig::substitutePlaceholdersInConfig($value, $user->getUID()));
}
$objectStore = $storage->getBackendOption('objectstore');
private function constructStorage(StorageConfig $storageConfig): IStorage {
$class = $storageConfig->getBackend()->getStorageClass();
if (!is_a($class, IConstructableStorage::class, true)) {
- \OCP\Server::get(LoggerInterface::class)->warning('Building a storage not implementing IConstructableStorage is deprecated since 31.0.0', ['class' => $class]);
+ Server::get(LoggerInterface::class)->warning('Building a storage not implementing IConstructableStorage is deprecated since 31.0.0', ['class' => $class]);
}
$storage = new $class($storageConfig->getBackendOptions());
}, $storageConfigs);
- \OC\Files\Cache\Storage::getGlobalCache()->loadForStorageIds(array_map(function (IStorage $storage) {
+ Storage::getGlobalCache()->loadForStorageIds(array_map(function (IStorage $storage) {
return $storage->getId();
}, $storages));
use OCP\AppFramework\Http\Attribute\NoAdminRequired;
use OCP\AppFramework\Http\DataResponse;
use OCP\AppFramework\OCSController;
+use OCP\Constants;
use OCP\IRequest;
/**
$isSystemMount = $mountConfig->getType() === StorageConfig::MOUNT_TYPE_ADMIN;
- $permissions = \OCP\Constants::PERMISSION_READ;
+ $permissions = Constants::PERMISSION_READ;
// personal mounts can be deleted
if (!$isSystemMount) {
- $permissions |= \OCP\Constants::PERMISSION_DELETE;
+ $permissions |= Constants::PERMISSION_DELETE;
}
$entry = [
use OCA\Files_External\Lib\Backend\Backend;
use OCA\Files_External\Lib\InsufficientDataForMeaningfulAnswerException;
use OCA\Files_External\Lib\StorageConfig;
+use OCA\Files_External\MountConfig;
use OCA\Files_External\NotFoundException;
use OCA\Files_External\Service\StoragesService;
use OCP\AppFramework\Controller;
$backend = $storage->getBackend();
// update status (can be time-consuming)
$storage->setStatus(
- \OCA\Files_External\MountConfig::getBackendStatus(
+ MountConfig::getBackendStatus(
$backend->getStorageClass(),
$storage->getBackendOptions(),
false,
use OC\Files\Cache\CacheEntry;
use OC\Files\ObjectStore\S3ConnectionTrait;
use OC\Files\ObjectStore\S3ObjectTrait;
+use OC\Files\Storage\Common;
use OCP\Cache\CappedMemoryCache;
use OCP\Constants;
use OCP\Files\FileInfo;
use OCP\Server;
use Psr\Log\LoggerInterface;
-class AmazonS3 extends \OC\Files\Storage\Common {
+class AmazonS3 extends Common {
use S3ConnectionTrait;
use S3ObjectTrait;
*/
namespace OCA\Files_External\Lib\Storage;
+use OC\Files\Storage\DAV;
use OCP\Files\Storage\IDisableEncryptionStorage;
use Sabre\DAV\Client;
* http://%host/%context/remote.php/webdav/%root
*
*/
-class OwnCloud extends \OC\Files\Storage\DAV implements IDisableEncryptionStorage {
+class OwnCloud extends DAV implements IDisableEncryptionStorage {
public const OC_URL_SUFFIX = 'remote.php/webdav';
public function __construct($params) {
use Icewind\Streams\IteratorDirectory;
use Icewind\Streams\RetryWrapper;
use OC\Files\Storage\Common;
+use OC\Files\View;
use OCP\Constants;
use OCP\Files\FileInfo;
use OCP\Files\IMimeTypeDetector;
return false;
}
- $view = new \OC\Files\View('/' . $userId . '/files_external');
+ $view = new View('/' . $userId . '/files_external');
return $view->getLocalFile('ssh_hostKeys');
} catch (\Exception $e) {
*/
namespace OCA\Files_External\Lib\Storage;
-abstract class StreamWrapper extends \OC\Files\Storage\Common {
+use OC\Files\Storage\Common;
+
+abstract class StreamWrapper extends Common {
abstract public function constructUrl(string $path): ?string;
use GuzzleHttp\Psr7\Uri;
use Icewind\Streams\CallbackWrapper;
use Icewind\Streams\IteratorDirectory;
+use OC\Files\Filesystem;
use OC\Files\ObjectStore\SwiftFactory;
+use OC\Files\Storage\Common;
+use OCP\Cache\CappedMemoryCache;
use OCP\Files\IMimeTypeDetector;
use OCP\Files\StorageBadConfigException;
use OpenStack\Common\Error\BadResponseError;
use OpenStack\ObjectStore\v1\Models\StorageObject;
use Psr\Log\LoggerInterface;
-class Swift extends \OC\Files\Storage\Common {
+class Swift extends Common {
/** @var SwiftFactory */
private $connectionFactory;
/**
$this->params = $params;
// FIXME: private class...
- $this->objectCache = new \OCP\Cache\CappedMemoryCache();
+ $this->objectCache = new CappedMemoryCache();
$this->connectionFactory = new SwiftFactory(
\OC::$server->getMemCacheFactory()->createDistributed('swift/'),
$this->params,
$dh = $this->opendir($path);
while (($file = readdir($dh)) !== false) {
- if (\OC\Files\Filesystem::isIgnoredDir($file)) {
+ if (Filesystem::isIgnoredDir($file)) {
continue;
}
$dh = $this->opendir($source);
while (($file = readdir($dh)) !== false) {
- if (\OC\Files\Filesystem::isIgnoredDir($file)) {
+ if (Filesystem::isIgnoredDir($file)) {
continue;
}
*/
namespace OCA\Files_External\Lib;
+use OC\Files\Filesystem;
use OCA\Files_External\Lib\Auth\AuthMechanism;
use OCA\Files_External\Lib\Auth\IUserProvided;
use OCA\Files_External\Lib\Backend\Backend;
* @param string $mountPoint path
*/
public function setMountPoint($mountPoint) {
- $this->mountPoint = \OC\Files\Filesystem::normalizePath($mountPoint);
+ $this->mountPoint = Filesystem::normalizePath($mountPoint);
}
/**
foreach ($backendOptions as $key => $value) {
if (isset($parameters[$key])) {
switch ($parameters[$key]->getType()) {
- case \OCA\Files_External\Lib\DefinitionParameter::VALUE_BOOLEAN:
+ case DefinitionParameter::VALUE_BOOLEAN:
$value = (bool)$value;
break;
}
use OCA\Files_External\Service\UserGlobalStoragesService;
use OCA\Files_External\Service\UserStoragesService;
use OCP\Files\StorageNotAvailableException;
+use OCP\IL10N;
+use OCP\Util;
use phpseclib\Crypt\AES;
use Psr\Log\LoggerInterface;
* @param Backend[] $backends
*/
public static function dependencyMessage(array $backends): string {
- $l = \OCP\Util::getL10N('files_external');
+ $l = Util::getL10N('files_external');
$message = '';
$dependencyGroups = [];
/**
* Returns a dependency missing message
*/
- private static function getSingleDependencyMessage(\OCP\IL10N $l, string $module, string $backend): string {
+ private static function getSingleDependencyMessage(IL10N $l, string $module, string $backend): string {
switch (strtolower($module)) {
case 'curl':
return $l->t('The cURL support in PHP is not enabled or installed. Mounting of %s is not possible. Please ask your system administrator to install it.', [$backend]);
use OC\Files\Filesystem;
use OCA\Files_External\Lib\StorageConfig;
+use OCA\Files_External\MountConfig;
/**
* Service class to manage global external storage
$this->triggerApplicableHooks(
$signal,
$storage->getMountPoint(),
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
['all']
);
return;
$this->triggerApplicableHooks(
$signal,
$storage->getMountPoint(),
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
$applicableUsers
);
$this->triggerApplicableHooks(
$signal,
$storage->getMountPoint(),
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
$applicableGroups
);
}
$this->triggerApplicableHooks(
Filesystem::signal_delete_mount,
$oldStorage->getMountPoint(),
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
['all']
);
}
$this->triggerApplicableHooks(
Filesystem::signal_delete_mount,
$oldStorage->getMountPoint(),
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
$userDeletions
);
$this->triggerApplicableHooks(
Filesystem::signal_delete_mount,
$oldStorage->getMountPoint(),
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
$groupDeletions
);
$this->triggerApplicableHooks(
Filesystem::signal_create_mount,
$newStorage->getMountPoint(),
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
$userAdditions
);
$this->triggerApplicableHooks(
Filesystem::signal_create_mount,
$newStorage->getMountPoint(),
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
$groupAdditions
);
$this->triggerApplicableHooks(
Filesystem::signal_create_mount,
$newStorage->getMountPoint(),
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
['all']
);
}
namespace OCA\Files_External\Service;
use OCA\Files_External\Lib\StorageConfig;
+use OCA\Files_External\MountConfig;
use Psr\Log\LoggerInterface;
/**
$storageOptions['priority'] = $backend->getPriority();
}
$storageConfig->setPriority($storageOptions['priority']);
- if ($mountType === \OCA\Files_External\MountConfig::MOUNT_TYPE_USER) {
+ if ($mountType === MountConfig::MOUNT_TYPE_USER) {
$applicableUsers = $storageConfig->getApplicableUsers();
if ($applicable !== 'all') {
$applicableUsers[] = $applicable;
$storageConfig->setApplicableUsers($applicableUsers);
}
- } elseif ($mountType === \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP) {
+ } elseif ($mountType === MountConfig::MOUNT_TYPE_GROUP) {
$applicableGroups = $storageConfig->getApplicableGroups();
$applicableGroups[] = $applicable;
$storageConfig->setApplicableGroups($applicableGroups);
$relativeMountPath = rtrim($parts[2], '/');
// note: we cannot do this after the loop because the decrypted config
// options might be needed for the config hash
- $storageOptions['options'] = \OCA\Files_External\MountConfig::decryptPasswords($storageOptions['options']);
+ $storageOptions['options'] = MountConfig::decryptPasswords($storageOptions['options']);
if (!isset($storageOptions['backend'])) {
$storageOptions['backend'] = $storageOptions['class']; // legacy compat
}
// but at this point we don't know the max-id, so use
// first group it by config hash
$storageOptions['mountpoint'] = $rootMountPath;
- $configId = \OCA\Files_External\MountConfig::makeConfigHash($storageOptions);
+ $configId = MountConfig::makeConfigHash($storageOptions);
if (isset($storagesWithConfigHash[$configId])) {
$currentStorage = $storagesWithConfigHash[$configId];
}
*/
namespace OCA\Files_External\Service;
+use OC\Files\Cache\Storage;
use OC\Files\Filesystem;
use OCA\Files_External\Lib\Auth\AuthMechanism;
use OCA\Files_External\Lib\Auth\InvalidAuth;
use OCP\Files\Config\IUserMountCache;
use OCP\Files\Events\InvalidateMountCacheEvent;
use OCP\Files\StorageNotAvailableException;
+use OCP\Util;
use Psr\Log\LoggerInterface;
/**
protected function triggerApplicableHooks($signal, $mountPoint, $mountType, $applicableArray): void {
$this->eventDispatcher->dispatchTyped(new InvalidateMountCacheEvent(null));
foreach ($applicableArray as $applicable) {
- \OCP\Util::emitHook(
+ Util::emitHook(
Filesystem::CLASSNAME,
$signal,
[
$this->triggerHooks($deletedStorage, Filesystem::signal_delete_mount);
// delete oc_storages entries and oc_filecache
- \OC\Files\Cache\Storage::cleanByMountId($id);
+ Storage::cleanByMountId($id);
}
/**
use OC\Files\Filesystem;
use OCA\Files_External\Lib\StorageConfig;
+use OCA\Files_External\MountConfig;
use OCA\Files_External\NotFoundException;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\Files\Config\IUserMountCache;
$this->triggerApplicableHooks(
$signal,
$storage->getMountPoint(),
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
[$user]
);
}
namespace OCA\Files_External\Settings;
use OCA\Files_External\Lib\Auth\Password\GlobalAuth;
+use OCA\Files_External\MountConfig;
use OCA\Files_External\Service\BackendService;
use OCA\Files_External\Service\GlobalStoragesService;
use OCP\AppFramework\Http\TemplateResponse;
'storages' => $this->globalStoragesService->getStorages(),
'backends' => $this->backendService->getAvailableBackends(),
'authMechanisms' => $this->backendService->getAuthMechanisms(),
- 'dependencies' => \OCA\Files_External\MountConfig::dependencyMessage($this->backendService->getBackends()),
+ 'dependencies' => MountConfig::dependencyMessage($this->backendService->getBackends()),
'allowUserMounting' => $this->backendService->isUserMountingAllowed(),
'globalCredentials' => $this->globalAuth->getAuth(''),
'globalCredentialsUid' => '',
namespace OCA\Files_External\Settings;
use OCA\Files_External\Lib\Auth\Password\GlobalAuth;
+use OCA\Files_External\MountConfig;
use OCA\Files_External\Service\BackendService;
use OCA\Files_External\Service\UserGlobalStoragesService;
use OCP\AppFramework\Http\TemplateResponse;
'storages' => $this->userGlobalStoragesService->getStorages(),
'backends' => $this->backendService->getAvailableBackends(),
'authMechanisms' => $this->backendService->getAuthMechanisms(),
- 'dependencies' => \OCA\Files_External\MountConfig::dependencyMessage($this->backendService->getBackends()),
+ 'dependencies' => MountConfig::dependencyMessage($this->backendService->getBackends()),
'allowUserMounting' => $this->backendService->isUserMountingAllowed(),
'globalCredentials' => $this->globalAuth->getAuth($uid),
'globalCredentialsUid' => $uid,
namespace OCA\Files_External\Tests\Auth\Password;
use OCA\Files_External\Lib\Auth\Password\GlobalAuth;
+use OCA\Files_External\Lib\InsufficientDataForMeaningfulAnswerException;
use OCA\Files_external\Lib\StorageConfig;
use OCP\IL10N;
use OCP\Security\ICredentialsManager;
public function testNoCredentialsPersonal(): void {
- $this->expectException(\OCA\Files_External\Lib\InsufficientDataForMeaningfulAnswerException::class);
+ $this->expectException(InsufficientDataForMeaningfulAnswerException::class);
$this->credentialsManager->expects($this->never())
->method('retrieve');
use OCA\Files_External\Lib\StorageConfig;
use OCA\Files_External\NotFoundException;
+use OCA\Files_External\Service\GlobalStoragesService;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Input\Input;
abstract class CommandTest extends TestCase {
/**
* @param StorageConfig[] $mounts
- * @return \OCA\Files_External\Service\GlobalStoragesService|\PHPUnit\Framework\MockObject\MockObject
+ * @return GlobalStoragesService|\PHPUnit\Framework\MockObject\MockObject
*/
protected function getGlobalStorageService(array $mounts = []) {
$mock = $this->getMockBuilder('OCA\Files_External\Service\GlobalStoragesService')
use OCA\Files_External\Controller\GlobalStoragesController;
use OCA\Files_External\Lib\Auth\AuthMechanism;
use OCA\Files_External\Lib\Backend\Backend;
-
use OCA\Files_External\Lib\StorageConfig;
+
+use OCA\Files_External\MountConfig;
use OCA\Files_External\NotFoundException;
use OCA\Files_External\Service\GlobalStoragesService;
use OCA\Files_External\Service\UserStoragesService;
protected $service;
protected function setUp(): void {
- \OCA\Files_External\MountConfig::$skipTest = true;
+ MountConfig::$skipTest = true;
}
protected function tearDown(): void {
- \OCA\Files_External\MountConfig::$skipTest = false;
+ MountConfig::$skipTest = false;
}
/**
}
/**
- * @return \OCA\Files_External\Lib\Auth\AuthMechanism|MockObject
+ * @return AuthMechanism|MockObject
*/
protected function getAuthMechMock($scheme = 'null', $class = '\OCA\Files_External\Lib\Auth\NullMechanism') {
$authMech = $this->getMockBuilder(AuthMechanism::class)
*/
namespace OCA\Files_External\Tests;
+use OCA\Files_External\Lib\Storage\OwnCloud;
+
/**
* Class OwnCloudFunctions
*
public function testConfig($config, $expectedUri): void {
$config['user'] = 'someuser';
$config['password'] = 'somepassword';
- $instance = new \OCA\Files_External\Lib\Storage\OwnCloud($config);
+ $instance = new OwnCloud($config);
$this->assertEquals($expectedUri, $instance->createBaseUri());
}
}
use OC\Files\SetupManagerFactory;
use OCA\Files_External\Lib\PersonalMount;
use OCA\Files_External\Lib\StorageConfig;
+use OCA\Files_External\Service\UserStoragesService;
use Test\TestCase;
class PersonalMountTest extends TestCase {
public function testFindByStorageId(): void {
$storageConfig = $this->createMock(StorageConfig::class);
- /** @var \OCA\Files_External\Service\UserStoragesService $storageService */
+ /** @var UserStoragesService $storageService */
$storageService = $this->getMockBuilder('\OCA\Files_External\Service\UserStoragesService')
->disableOriginalConstructor()
->getMock();
/**
* @param string $class
*
- * @return \OCA\Files_External\Lib\Auth\AuthMechanism|\PHPUnit\Framework\MockObject\MockObject
+ * @return AuthMechanism|\PHPUnit\Framework\MockObject\MockObject
*/
protected function getAuthMechanismMock($class) {
$backend = $this->getMockBuilder(AuthMechanism::class)
namespace OCA\Files_External\Tests\Service;
use OC\Files\Filesystem;
+use OCA\Files_External\MountConfig;
use OCA\Files_External\Service\GlobalStoragesService;
[
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'all'
],
],
[
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'user1',
],
],
[
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
'group1',
],
],
[
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'user1',
],
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'user2',
],
],
[
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
'group1'
],
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
'group2'
],
],
[
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'user1',
],
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'user2',
],
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
'group1'
],
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
'group2'
],
],
// delete the "all entry"
[
Filesystem::signal_delete_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'all',
],
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'user1',
],
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'user2',
],
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
'group1'
],
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
'group2'
],
],
[
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'user2',
],
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
'group2'
],
],
[
[
Filesystem::signal_delete_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'user2',
],
[
Filesystem::signal_delete_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
'group2'
],
],
[
[
Filesystem::signal_delete_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'user1',
],
[
Filesystem::signal_delete_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
'group1'
],
// create the "all" entry
[
Filesystem::signal_create_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'all'
],
],
[
Filesystem::signal_delete_mount,
'/mountpoint',
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'user1',
],
[
Filesystem::signal_delete_mount,
'/mountpoint',
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'user2',
],
[
Filesystem::signal_delete_mount,
'/mountpoint',
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
'group1',
],
[
Filesystem::signal_delete_mount,
'/mountpoint',
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
'group2',
],
// creates new one
[
Filesystem::signal_create_mount,
'/renamedMountpoint',
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'user1',
],
[
Filesystem::signal_create_mount,
'/renamedMountpoint',
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'user2',
],
[
Filesystem::signal_create_mount,
'/renamedMountpoint',
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
'group1',
],
[
Filesystem::signal_create_mount,
'/renamedMountpoint',
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
'group2',
],
];
[
[
Filesystem::signal_delete_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'user1',
],
[
Filesystem::signal_delete_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'user2',
],
[
Filesystem::signal_delete_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
'group1'
],
[
Filesystem::signal_delete_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+ MountConfig::MOUNT_TYPE_GROUP,
'group2'
],
],
[
[
Filesystem::signal_delete_mount,
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
'all',
],
],
*/
namespace OCA\Files_External\Tests\Service;
+use OC\Files\Cache\Storage;
use OC\Files\Filesystem;
-
use OCA\Files_External\Lib\Auth\AuthMechanism;
use OCA\Files_External\Lib\Auth\InvalidAuth;
+
use OCA\Files_External\Lib\Backend\Backend;
use OCA\Files_External\Lib\Backend\InvalidBackend;
use OCA\Files_External\Lib\StorageConfig;
+use OCA\Files_External\MountConfig;
use OCA\Files_External\NotFoundException;
use OCA\Files_External\Service\BackendService;
use OCA\Files_External\Service\DBConfigService;
use OCP\IDBConnection;
use OCP\IUser;
use OCP\Server;
+use OCP\Util;
class CleaningDBConfig extends DBConfigService {
private $mountIds = [];
'datadirectory',
\OC::$SERVERROOT . '/data/'
);
- \OCA\Files_External\MountConfig::$skipTest = true;
+ MountConfig::$skipTest = true;
$this->mountCache = $this->createMock(IUserMountCache::class);
$this->eventDispatcher = $this->createMock(IEventDispatcher::class);
->willReturn($backends);
$this->overwriteService(BackendService::class, $this->backendService);
- \OCP\Util::connectHook(
+ Util::connectHook(
Filesystem::CLASSNAME,
Filesystem::signal_create_mount,
get_class($this), 'createHookCallback');
- \OCP\Util::connectHook(
+ Util::connectHook(
Filesystem::CLASSNAME,
Filesystem::signal_delete_mount,
get_class($this), 'deleteHookCallback');
}
protected function tearDown(): void {
- \OCA\Files_External\MountConfig::$skipTest = false;
+ MountConfig::$skipTest = false;
self::$hookCalls = [];
if ($this->dbConfig) {
$this->dbConfig->clean();
}
public function testNonExistingStorage(): void {
- $this->expectException(\OCA\Files_External\NotFoundException::class);
+ $this->expectException(NotFoundException::class);
$this->ActualNonExistingStorageTest();
}
// manually trigger storage entry because normally it happens on first
// access, which isn't possible within this test
- $storageCache = new \OC\Files\Cache\Storage($rustyStorageId, true, Server::get(IDBConnection::class));
+ $storageCache = new Storage($rustyStorageId, true, Server::get(IDBConnection::class));
/** @var IUserMountCache $mountCache */
$mountCache = \OC::$server->get(IUserMountCache::class);
}
public function testDeleteUnexistingStorage(): void {
- $this->expectException(\OCA\Files_External\NotFoundException::class);
+ $this->expectException(NotFoundException::class);
$this->actualDeletedUnexistingStorageTest();
}
*/
namespace OCA\Files_External\Tests\Service;
+use OC\User\User;
use OCA\Files_External\Lib\StorageConfig;
use OCA\Files_External\NotFoundException;
use OCA\Files_External\Service\StoragesService;
$this->globalStoragesService = $this->service;
- $this->user = new \OC\User\User(self::USER_ID, null, \OC::$server->get(IEventDispatcher::class));
+ $this->user = new User(self::USER_ID, null, \OC::$server->get(IEventDispatcher::class));
/** @var \OCP\IUserSession|\PHPUnit\Framework\MockObject\MockObject $userSession */
$userSession = $this->createMock(IUserSession::class);
$userSession
namespace OCA\Files_External\Tests\Service;
use OC\Files\Filesystem;
-
use OCA\Files_External\Lib\StorageConfig;
+use OCA\Files_External\MountConfig;
+
+use OCA\Files_External\NotFoundException;
use OCA\Files_External\Service\GlobalStoragesService;
use OCA\Files_External\Service\StoragesService;
use OCA\Files_External\Service\UserStoragesService;
current(self::$hookCalls),
Filesystem::signal_create_mount,
$storage->getMountPoint(),
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
$this->userId
);
self::$hookCalls[1],
Filesystem::signal_delete_mount,
'/mountpoint',
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
$this->userId
);
}
self::$hookCalls[0],
Filesystem::signal_delete_mount,
'/mountpoint',
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
$this->userId
);
$this->assertHookCall(
self::$hookCalls[1],
Filesystem::signal_create_mount,
'/renamedMountpoint',
- \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+ MountConfig::MOUNT_TYPE_USER,
$this->userId
);
}
public function testGetAdminStorage(): void {
- $this->expectException(\OCA\Files_External\NotFoundException::class);
+ $this->expectException(NotFoundException::class);
$backend = $this->backendService->getBackend('identifier:\OCA\Files_External\Lib\Backend\SMB');
$authMechanism = $this->backendService->getAuthMechanism('identifier:\Auth\Mechanism');
namespace OCA\Files_External\Tests\Settings;
use OCA\Files_External\Lib\Auth\Password\GlobalAuth;
+use OCA\Files_External\MountConfig;
use OCA\Files_External\Service\BackendService;
use OCA\Files_External\Service\GlobalStoragesService;
use OCA\Files_External\Settings\Admin;
'storages' => ['a', 'b', 'c'],
'backends' => ['d', 'e', 'f'],
'authMechanisms' => ['g', 'h', 'i'],
- 'dependencies' => \OCA\Files_External\MountConfig::dependencyMessage($this->backendService->getBackends()),
+ 'dependencies' => MountConfig::dependencyMessage($this->backendService->getBackends()),
'allowUserMounting' => true,
'globalCredentials' => 'asdf:asdf',
'globalCredentialsUid' => '',
public function registerEventsScripts(IEventDispatcher $dispatcher): void {
$dispatcher->addListener(ResourcesLoadAdditionalScriptsEvent::class, function (): void {
- \OCP\Util::addScript('files_sharing', 'collaboration');
+ Util::addScript('files_sharing', 'collaboration');
});
- $dispatcher->addListener(\OCP\AppFramework\Http\Events\BeforeTemplateRenderedEvent::class, function (): void {
+ $dispatcher->addListener(BeforeTemplateRenderedEvent::class, function (): void {
/**
* Always add main sharing script
*/
parent::remove($file);
}
- public function moveFromCache(\OCP\Files\Cache\ICache $sourceCache, $sourcePath, $targetPath) {
+ public function moveFromCache(ICache $sourceCache, $sourcePath, $targetPath) {
$this->rootUnchanged = false;
return parent::moveFromCache($sourceCache, $sourcePath, $targetPath);
}
use OCP\AppFramework\OCS\OCSNotFoundException;
use OCP\AppFramework\OCSController;
use OCP\AppFramework\QueryException;
+use OCP\Files\Folder;
use OCP\Files\IRootFolder;
use OCP\Files\NotFoundException;
use OCP\IGroupManager;
}
$result['path'] = $userFolder->getRelativePath($node->getPath());
- if ($node instanceof \OCP\Files\Folder) {
+ if ($node instanceof Folder) {
$result['item_type'] = 'folder';
} else {
$result['item_type'] = 'file';
*/
namespace OCA\Files_Sharing\Controller;
+use OC\Files\View;
use OCA\Files_Sharing\External\Manager;
use OCA\Files_Sharing\ResponseDefinitions;
use OCP\AppFramework\Http;
* @return array enriched share info with data from the filecache
*/
private static function extendShareInfo($share) {
- $view = new \OC\Files\View('/' . \OC_User::getUser() . '/files/');
+ $view = new View('/' . \OC_User::getUser() . '/files/');
$info = $view->getFileInfo($share['mountpoint']);
if ($info === false) {
use Exception;
use OC\Files\FileInfo;
use OC\Files\Storage\Wrapper\Wrapper;
+use OCA\Circles\Api\v1\Circles;
use OCA\Files\Helper;
use OCA\Files_Sharing\Exceptions\SharingRightsException;
use OCA\Files_Sharing\External\Storage;
use OCA\Files_Sharing\ResponseDefinitions;
use OCA\Files_Sharing\SharedStorage;
+use OCA\GlobalSiteSelector\Service\SlaveService;
use OCP\App\IAppManager;
use OCP\AppFramework\Http;
use OCP\AppFramework\Http\Attribute\NoAdminRequired;
use OCP\AppFramework\OCSController;
use OCP\AppFramework\QueryException;
use OCP\Constants;
+use OCP\Files\File;
use OCP\Files\Folder;
use OCP\Files\InvalidPathException;
use OCP\Files\IRootFolder;
}
try {
- $slaveService = Server::get(\OCA\GlobalSiteSelector\Service\SlaveService::class);
+ $slaveService = Server::get(SlaveService::class);
} catch (\Throwable $e) {
$this->logger->error(
$e->getMessage(),
$permissions |= Constants::PERMISSION_READ;
}
- if ($node instanceof \OCP\Files\File) {
+ if ($node instanceof File) {
// Single file shares should never have delete or create permissions
$permissions &= ~Constants::PERMISSION_DELETE;
$permissions &= ~Constants::PERMISSION_CREATE;
}
// Public upload can only be set for folders
- if ($node instanceof \OCP\Files\File) {
+ if ($node instanceof File) {
throw new OCSNotFoundException($this->l->t('Public upload is only possible for publicly shared folders'));
}
throw new OCSNotFoundException($this->l->t('You cannot share to a Team if the app is not enabled'));
}
- $circle = \OCA\Circles\Api\v1\Circles::detailsCircle($shareWith);
+ $circle = Circles::detailsCircle($shareWith);
// Valid team is required to share
if ($circle === null) {
* @throws NotFoundException
*/
private function getSharesInDir(Node $folder): array {
- if (!($folder instanceof \OCP\Files\Folder)) {
+ if (!($folder instanceof Folder)) {
throw new OCSBadRequestException($this->l->t('Not a directory'));
}
try {
$node = $userFolder->get($path);
$this->lock($node);
- } catch (\OCP\Files\NotFoundException $e) {
+ } catch (NotFoundException $e) {
throw new OCSNotFoundException($this->l->t('Wrong path, file/folder does not exist'));
} catch (LockedException $e) {
throw new OCSNotFoundException($this->l->t('Could not lock path'));
throw new OCSForbiddenException($this->l->t('Public upload disabled by the administrator'));
}
- if (!($share->getNode() instanceof \OCP\Files\Folder)) {
+ if (!($share->getNode() instanceof Folder)) {
throw new OCSBadRequestException($this->l->t('Public upload is only possible for publicly shared folders'));
}
*
* @suppress PhanUndeclaredClassMethod
*/
- protected function canAccessShare(\OCP\Share\IShare $share, bool $checkGroups = true): bool {
+ protected function canAccessShare(IShare $share, bool $checkGroups = true): bool {
// A file with permissions 0 can't be accessed by us. So Don't show it
if ($share->getPermissions() === 0) {
return false;
* @param \OCP\Share\IShare $share the share to check
* @return boolean
*/
- protected function canEditShare(\OCP\Share\IShare $share): bool {
+ protected function canEditShare(IShare $share): bool {
// A file with permissions 0 can't be accessed by us. So Don't show it
if ($share->getPermissions() === 0) {
return false;
* @param \OCP\Share\IShare $share the share to check
* @return boolean
*/
- protected function canDeleteShare(\OCP\Share\IShare $share): bool {
+ protected function canDeleteShare(IShare $share): bool {
// A file with permissions 0 can't be accessed by us. So Don't show it
if ($share->getPermissions() === 0) {
return false;
*
* @suppress PhanUndeclaredClassMethod
*/
- protected function canDeleteShareFromSelf(\OCP\Share\IShare $share): bool {
+ protected function canDeleteShareFromSelf(IShare $share): bool {
if ($share->getShareType() !== IShare::TYPE_GROUP &&
$share->getShareType() !== IShare::TYPE_ROOM &&
$share->getShareType() !== IShare::TYPE_DECK &&
* @param \OCP\Files\Node $node
* @throws LockedException
*/
- private function lock(\OCP\Files\Node $node) {
+ private function lock(Node $node) {
$node->lock(ILockingProvider::LOCK_SHARED);
$this->lockedNode = $node;
}
return true;
}
- if ((\OCP\Constants::PERMISSION_SHARE & $share->getPermissions()) === 0) {
+ if ((Constants::PERMISSION_SHARE & $share->getPermissions()) === 0) {
return false;
}
$sharedWith = substr($share->getSharedWith(), $shareWithStart, $shareWithLength);
}
try {
- $member = \OCA\Circles\Api\v1\Circles::getMember($sharedWith, $userId, 1);
+ $member = Circles::getMember($sharedWith, $userId, 1);
if ($member->getLevel() >= 4) {
return true;
}
} else {
throw new \RuntimeException('Should not happen, instanceOfStorage but not a wrapper');
}
- /** @var \OCA\Files_Sharing\SharedStorage $storage */
+ /** @var SharedStorage $storage */
$inheritedAttributes = $storage->getShare()->getAttributes();
if ($inheritedAttributes !== null && $inheritedAttributes->getAttribute('permissions', 'download') === false) {
$share->setHideDownload(true);
use OCP\AppFramework\Http\Attribute\NoCSRFRequired;
use OCP\AppFramework\Http\Attribute\OpenAPI;
use OCP\AppFramework\Http\Attribute\PublicPage;
+use OCP\AppFramework\Http\DataResponse;
use OCP\AppFramework\Http\NotFoundResponse;
use OCP\AppFramework\Http\RedirectResponse;
use OCP\AppFramework\Http\TemplateResponse;
+use OCP\Constants;
use OCP\Defaults;
use OCP\EventDispatcher\IEventDispatcher;
+use OCP\Files\File;
use OCP\Files\Folder;
use OCP\Files\IRootFolder;
+use OCP\Files\Node;
use OCP\Files\NotFoundException;
use OCP\IConfig;
use OCP\IL10N;
*/
#[OpenAPI(scope: OpenAPI::SCOPE_IGNORE)]
class ShareController extends AuthPublicShareController {
- protected ?Share\IShare $share = null;
+ protected ?IShare $share = null;
public const SHARE_ACCESS = 'access';
public const SHARE_AUTH = 'auth';
$itemType = $itemSource = $uidOwner = '';
$token = $share;
$exception = null;
- if ($share instanceof \OCP\Share\IShare) {
+ if ($share instanceof IShare) {
try {
$token = $share->getToken();
$uidOwner = $share->getSharedBy();
* @param Share\IShare $share
* @return bool
*/
- private function validateShare(\OCP\Share\IShare $share) {
+ private function validateShare(IShare $share) {
// If the owner is disabled no access to the link is granted
$owner = $this->userManager->get($share->getShareOwner());
if ($owner === null || !$owner->isEnabled()) {
// We can't get the path of a file share
try {
- if ($shareNode instanceof \OCP\Files\File && $path !== '') {
+ if ($shareNode instanceof File && $path !== '') {
$this->emitAccessShareHook($share, 404, 'Share not found');
$this->emitShareAccessEvent($share, self::SHARE_ACCESS, 404, 'Share not found');
throw new NotFoundException($this->l10n->t('This share does not exist or is no longer available'));
$share = $this->shareManager->getShareByToken($token);
- if (!($share->getPermissions() & \OCP\Constants::PERMISSION_READ)) {
- return new \OCP\AppFramework\Http\DataResponse('Share has no read permission');
+ if (!($share->getPermissions() & Constants::PERMISSION_READ)) {
+ return new DataResponse('Share has no read permission');
}
if (!$this->validateShare($share)) {
}
// Single file share
- if ($share->getNode() instanceof \OCP\Files\File) {
+ if ($share->getNode() instanceof File) {
// Single file download
$this->singleFileDownloaded($share, $share->getNode());
}
}
}
- if ($node instanceof \OCP\Files\Folder) {
+ if ($node instanceof Folder) {
if ($files === null || $files === '') {
// The folder is downloaded
$this->singleFileDownloaded($share, $share->getNode());
* @param Share\IShare $share
* @throws NotFoundException when trying to download a folder of a "hide download" share
*/
- protected function singleFileDownloaded(Share\IShare $share, \OCP\Files\Node $node) {
+ protected function singleFileDownloaded(IShare $share, Node $node) {
if ($share->getHideDownload() && $node instanceof Folder) {
throw new NotFoundException('Downloading a folder');
}
$parameters = [$userPath];
if ($share->getShareType() === IShare::TYPE_EMAIL) {
- if ($node instanceof \OCP\Files\File) {
+ if ($node instanceof File) {
$subject = Downloads::SUBJECT_SHARED_FILE_BY_EMAIL_DOWNLOADED;
} else {
$subject = Downloads::SUBJECT_SHARED_FOLDER_BY_EMAIL_DOWNLOADED;
}
$parameters[] = $share->getSharedWith();
} else {
- if ($node instanceof \OCP\Files\File) {
+ if ($node instanceof File) {
$subject = Downloads::SUBJECT_PUBLIC_SHARED_FILE_DOWNLOADED;
$parameters[] = $remoteAddressHash;
} else {
use Generator;
use OC\Collaboration\Collaborators\SearchResult;
+use OC\Share\Share;
use OCA\Files_Sharing\ResponseDefinitions;
use OCP\AppFramework\Http;
use OCP\AppFramework\Http\Attribute\NoAdminRequired;
protected function isRemoteSharingAllowed(string $itemType): bool {
try {
// FIXME: static foo makes unit testing unnecessarily difficult
- $backend = \OC\Share\Share::getBackend($itemType);
+ $backend = Share::getBackend($itemType);
return $backend->isShareTypeAllowed(IShare::TYPE_REMOTE);
} catch (\Exception $e) {
return false;
protected function isRemoteGroupSharingAllowed(string $itemType): bool {
try {
// FIXME: static foo makes unit testing unnecessarily difficult
- $backend = \OC\Share\Share::getBackend($itemType);
+ $backend = Share::getBackend($itemType);
return $backend->isShareTypeAllowed(IShare::TYPE_REMOTE_GROUP);
} catch (\Exception $e) {
return false;
use OCP\AppFramework\Http\Template\SimpleMenuAction;
use OCP\AppFramework\Http\TemplateResponse;
use OCP\AppFramework\Services\IInitialState;
+use OCP\Constants;
use OCP\Defaults;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\Files\File;
if ($shareNode instanceof File) {
$view = 'public-file-share';
$this->initialState->provideInitialState('fileId', $shareNode->getId());
- } elseif (($share->getPermissions() & \OCP\Constants::PERMISSION_CREATE)
- && !($share->getPermissions() & \OCP\Constants::PERMISSION_READ)
+ } elseif (($share->getPermissions() & Constants::PERMISSION_CREATE)
+ && !($share->getPermissions() & Constants::PERMISSION_READ)
) {
// share is a folder with create but no read permissions -> file drop only
$view = 'public-file-drop';
$this->initialState->provideInitialState('view', $view);
// Load scripts and styles for UI
- \OCP\Util::addInitScript('files', 'init');
- \OCP\Util::addInitScript(Application::APP_ID, 'init');
- \OCP\Util::addInitScript(Application::APP_ID, 'init-public');
- \OCP\Util::addScript('files', 'main');
+ Util::addInitScript('files', 'init');
+ Util::addInitScript(Application::APP_ID, 'init');
+ Util::addInitScript(Application::APP_ID, 'init-public');
+ Util::addScript('files', 'main');
// Add file-request script if needed
$attributes = $share->getAttributes();
if ($shareNode->getMimePart() === 'image') {
// If this is a file and especially an image directly point to the image preview
$directLink = $this->urlGenerator->linkToRouteAbsolute('files_sharing.publicpreview.directLink', ['token' => $token]);
- } elseif (($share->getPermissions() & \OCP\Constants::PERMISSION_READ) && !$share->getHideDownload()) {
+ } elseif (($share->getPermissions() & Constants::PERMISSION_READ) && !$share->getHideDownload()) {
// Can read and no download restriction, so just download it
$directLink = $downloadUrl ?? $shareUrl;
}
private $storage;
/**
- * @param \OCA\Files_Sharing\External\Storage $storage
+ * @param Storage $storage
* @param ICloudId $cloudId
*/
public function __construct($storage, ICloudId $cloudId) {
use OCP\Federation\ICloudFederationFactory;
use OCP\Federation\ICloudFederationProviderManager;
use OCP\Files;
+use OCP\Files\Events\InvalidateMountCacheEvent;
use OCP\Files\NotFoundException;
use OCP\Files\Storage\IStorageFactory;
use OCP\Http\Client\IClientService;
$this->sendFeedbackToRemote($share['remote'], $share['share_token'], $share['remote_id'], 'accept');
$event = new FederatedShareAddedEvent($share['remote']);
$this->eventDispatcher->dispatchTyped($event);
- $this->eventDispatcher->dispatchTyped(new Files\Events\InvalidateMountCacheEvent($this->userManager->get($this->uid)));
+ $this->eventDispatcher->dispatchTyped(new InvalidateMountCacheEvent($this->userManager->get($this->uid)));
$result = true;
}
}
');
$result = (bool)$query->execute([$target, $targetHash, $sourceHash, $this->uid]);
- $this->eventDispatcher->dispatchTyped(new Files\Events\InvalidateMountCacheEvent($this->userManager->get($this->uid)));
+ $this->eventDispatcher->dispatchTyped(new InvalidateMountCacheEvent($this->userManager->get($this->uid)));
return $result;
}
use OCP\Files\StorageNotAvailableException;
class Scanner extends \OC\Files\Cache\Scanner {
- /** @var \OCA\Files_Sharing\External\Storage */
+ /** @var Storage */
protected $storage;
public function scan($path, $recursive = self::SCAN_RECURSIVE, $reuse = -1, $lock = true) {
use GuzzleHttp\Exception\RequestException;
use OC\Files\Storage\DAV;
use OC\ForbiddenException;
+use OC\Share\Share;
use OCA\Files_Sharing\External\Manager as ExternalShareManager;
use OCA\Files_Sharing\ISharedStorage;
use OCP\AppFramework\Http;
use OCP\OCM\Exceptions\OCMProviderException;
use OCP\OCM\IOCMDiscoveryService;
use OCP\Server;
+use OCP\Util;
use Psr\Log\LoggerInterface;
class Storage extends DAV implements ISharedStorage, IDisableEncryptionStorage, IReliableEtagStorage {
if (!isset($this->scanner)) {
$this->scanner = new Scanner($storage);
}
- /** @var \OCA\Files_Sharing\External\Scanner */
+ /** @var Scanner */
return $this->scanner;
}
}
public function isSharable(string $path): bool {
- if (\OCP\Util::isSharingDisabledForUser() || !\OC\Share\Share::isResharingAllowed()) {
+ if (Util::isSharingDisabledForUser() || !Share::isResharingAllowed()) {
return false;
}
return (bool)($this->getPermissions($path) & Constants::PERMISSION_SHARE);
use OC\Files\Filesystem;
use OC\Files\View;
use OCA\Files_Sharing\AppInfo\Application;
+use OCP\Util;
class Helper {
public static function registerHooks() {
- \OCP\Util::connectHook('OC_Filesystem', 'post_rename', '\OCA\Files_Sharing\Updater', 'renameHook');
- \OCP\Util::connectHook('OC_Filesystem', 'post_delete', '\OCA\Files_Sharing\Hooks', 'unshareChildren');
+ Util::connectHook('OC_Filesystem', 'post_rename', '\OCA\Files_Sharing\Updater', 'renameHook');
+ Util::connectHook('OC_Filesystem', 'post_delete', '\OCA\Files_Sharing\Hooks', 'unshareChildren');
- \OCP\Util::connectHook('OC_User', 'post_deleteUser', '\OCA\Files_Sharing\Hooks', 'deleteUser');
+ Util::connectHook('OC_User', 'post_deleteUser', '\OCA\Files_Sharing\Hooks', 'deleteUser');
}
/**
namespace OCA\Files_Sharing;
use OC\Files\Filesystem;
+use OC\Files\View;
class Hooks {
public static function deleteUser($params) {
public static function unshareChildren($params) {
$path = Filesystem::getView()->getAbsolutePath($params['path']);
- $view = new \OC\Files\View('/');
+ $view = new View('/');
// find share mount points within $path and unmount them
- $mountManager = \OC\Files\Filesystem::getMountManager();
+ $mountManager = Filesystem::getMountManager();
$mountedShares = $mountManager->findIn($path);
foreach ($mountedShares as $mount) {
if ($mount->getStorage()->instanceOfStorage(ISharedStorage::class)) {
// filter out excluded shares and group shares that includes self
- $shares = array_filter($shares, function (\OCP\Share\IShare $share) use ($user) {
+ $shares = array_filter($shares, function (IShare $share) use ($user) {
return $share->getPermissions() > 0 && $share->getShareOwner() !== $user->getUID();
});
* @param \OCP\IUser $user user
* @return array Tuple of [superShare, groupedShares]
*/
- private function buildSuperShares(array $allShares, \OCP\IUser $user) {
+ private function buildSuperShares(array $allShares, IUser $user) {
$result = [];
$groupedShares = $this->groupShares($allShares);
*/
class Scanner extends \OC\Files\Cache\Scanner {
/**
- * @var \OCA\Files_Sharing\SharedStorage $storage
+ * @var SharedStorage $storage
*/
protected $storage;
*/
namespace OCA\Files_Sharing\ShareBackend;
+use OC\Files\Filesystem;
+use OC\Files\View;
use OCA\FederatedFileSharing\FederatedShareProvider;
+use OCA\Files_Sharing\Helper;
+use OCP\Files\NotFoundException;
+use OCP\Server;
use OCP\Share\IShare;
+use OCP\Share_Backend_File_Dependent;
use Psr\Log\LoggerInterface;
-class File implements \OCP\Share_Backend_File_Dependent {
+class File implements Share_Backend_File_Dependent {
public const FORMAT_SHARED_STORAGE = 0;
public const FORMAT_GET_FOLDER_CONTENTS = 1;
public const FORMAT_FILE_APP_ROOT = 2;
public function isValidSource($itemSource, $uidOwner) {
try {
- $path = \OC\Files\Filesystem::getPath($itemSource);
+ $path = Filesystem::getPath($itemSource);
// FIXME: attributes should not be set here,
// keeping this pattern for now to avoid unexpected
// regressions
- $this->path = \OC\Files\Filesystem::normalizePath(basename($path));
+ $this->path = Filesystem::normalizePath(basename($path));
return true;
- } catch (\OCP\Files\NotFoundException $e) {
+ } catch (NotFoundException $e) {
return false;
}
}
return $path;
} else {
try {
- $path = \OC\Files\Filesystem::getPath($itemSource);
+ $path = Filesystem::getPath($itemSource);
return $path;
- } catch (\OCP\Files\NotFoundException $e) {
+ } catch (NotFoundException $e) {
return false;
}
}
* @return string
*/
public function generateTarget($itemSource, $shareWith) {
- $shareFolder = \OCA\Files_Sharing\Helper::getShareFolder();
- $target = \OC\Files\Filesystem::normalizePath($shareFolder . '/' . basename($itemSource));
+ $shareFolder = Helper::getShareFolder();
+ $target = Filesystem::normalizePath($shareFolder . '/' . basename($itemSource));
- \OC\Files\Filesystem::initMountPoints($shareWith);
- $view = new \OC\Files\View('/' . $shareWith . '/files');
+ Filesystem::initMountPoints($shareWith);
+ $view = new View('/' . $shareWith . '/files');
if (!$view->is_dir($shareFolder)) {
$dir = '';
}
}
- return \OCA\Files_Sharing\Helper::generateUniqueTarget($target, $view);
+ return Helper::generateUniqueTarget($target, $view);
}
public function formatItems($items, $format, $parameters = null) {
$file['uid_owner'] = $item['uid_owner'];
$file['displayname_owner'] = $item['displayname_owner'];
- $storage = \OC\Files\Filesystem::getStorage('/');
+ $storage = Filesystem::getStorage('/');
$cache = $storage->getCache();
$file['size'] = $item['size'];
$files[] = $file;
if (isset($fileOwner)) {
$source['fileOwner'] = $fileOwner;
} else {
- \OCP\Server::get(LoggerInterface::class)->error('No owner found for reshare', ['app' => 'files_sharing']);
+ Server::get(LoggerInterface::class)->error('No owner found for reshare', ['app' => 'files_sharing']);
}
return $source;
*/
namespace OCA\Files_Sharing\ShareBackend;
-class Folder extends File implements \OCP\Share_Backend_Collection {
+use OCP\Share_Backend_Collection;
+
+class Folder extends File implements Share_Backend_Collection {
public function getChildren($itemSource) {
$children = [];
$parents = [$itemSource];
use OC\Files\Mount\MountPoint;
use OC\Files\Mount\MoveableMount;
use OC\Files\View;
+use OCA\Files_Sharing\Exceptions\BrokenPath;
use OCP\Cache\CappedMemoryCache;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\Files\Events\InvalidateMountCacheEvent;
use OCP\Files\Storage\IStorageFactory;
use OCP\ICache;
use OCP\IUser;
+use OCP\Server;
use OCP\Share\Events\VerifyMountPointEvent;
+use OCP\Share\IShare;
use Psr\Log\LoggerInterface;
/**
*/
class SharedMount extends MountPoint implements MoveableMount, ISharedMountPoint {
/**
- * @var \OCA\Files_Sharing\SharedStorage $storage
+ * @var SharedStorage $storage
*/
protected $storage = null;
* @return string
*/
private function verifyMountPoint(
- \OCP\Share\IShare $share,
+ IShare $share,
array $mountpoints,
CappedMemoryCache $folderExistCache,
) {
}
$newMountPoint = $this->generateUniqueTarget(
- \OC\Files\Filesystem::normalizePath($parent . '/' . $mountPoint),
+ Filesystem::normalizePath($parent . '/' . $mountPoint),
$this->recipientView,
$mountpoints
);
*
* @param string $path the absolute path
* @return string e.g. turns '/admin/files/test.txt' into '/test.txt'
- * @throws \OCA\Files_Sharing\Exceptions\BrokenPath
+ * @throws BrokenPath
*/
protected function stripUserFilesPath($path) {
$trimmed = ltrim($path, '/');
// it is not a file relative to data/user/files
if (count($split) < 3 || $split[1] !== 'files') {
- \OCP\Server::get(LoggerInterface::class)->error('Can not strip userid and "files/" from path: ' . $path, ['app' => 'files_sharing']);
- throw new \OCA\Files_Sharing\Exceptions\BrokenPath('Path does not start with /user/files', 10);
+ Server::get(LoggerInterface::class)->error('Can not strip userid and "files/" from path: ' . $path, ['app' => 'files_sharing']);
+ throw new BrokenPath('Path does not start with /user/files', 10);
}
// skip 'user' and 'files'
$this->setMountPoint($target);
$this->storage->setMountPoint($relTargetPath);
} catch (\Exception $e) {
- \OCP\Server::get(LoggerInterface::class)->error(
+ Server::get(LoggerInterface::class)->error(
'Could not rename mount point for shared folder "' . $this->getMountPoint() . '" to "' . $target . '"',
[
'app' => 'files_sharing',
* @return bool
*/
public function removeMount() {
- $mountManager = \OC\Files\Filesystem::getMountManager();
- /** @var \OCA\Files_Sharing\SharedStorage $storage */
+ $mountManager = Filesystem::getMountManager();
+ /** @var SharedStorage $storage */
$storage = $this->getStorage();
$result = $storage->unshareStorage();
$mountManager->removeMount($this->mountPoint);
use OC\Files\Storage\FailedStorage;
use OC\Files\Storage\Home;
use OC\Files\Storage\Storage;
+use OC\Files\Storage\Wrapper\Jail;
use OC\Files\Storage\Wrapper\PermissionsMask;
use OC\Files\Storage\Wrapper\Wrapper;
+use OC\Share\Share;
use OC\User\NoUserException;
use OCA\Files_External\Config\ConfigAdapter;
use OCA\Files_Sharing\ISharedStorage as LegacyISharedStorage;
use OCP\Files\Storage\IStorage;
use OCP\Lock\ILockingProvider;
use OCP\Share\IShare;
+use OCP\Util;
use Psr\Log\LoggerInterface;
/**
* Convert target path to source path and pass the function call to the correct storage provider
*/
-class SharedStorage extends \OC\Files\Storage\Wrapper\Jail implements LegacyISharedStorage, ISharedStorage, IDisableEncryptionStorage {
+class SharedStorage extends Jail implements LegacyISharedStorage, ISharedStorage, IDisableEncryptionStorage {
/** @var \OCP\Share\IShare */
private $superShare;
// part files and the mount point always have delete permissions
if ($path === '' || pathinfo($path, PATHINFO_EXTENSION) === 'part') {
- $permissions |= \OCP\Constants::PERMISSION_DELETE;
+ $permissions |= Constants::PERMISSION_DELETE;
}
if ($this->sharingDisabledForUser) {
- $permissions &= ~\OCP\Constants::PERMISSION_SHARE;
+ $permissions &= ~Constants::PERMISSION_SHARE;
}
return $permissions;
}
public function isCreatable(string $path): bool {
- return (bool)($this->getPermissions($path) & \OCP\Constants::PERMISSION_CREATE);
+ return (bool)($this->getPermissions($path) & Constants::PERMISSION_CREATE);
}
public function isReadable(string $path): bool {
}
public function isUpdatable(string $path): bool {
- return (bool)($this->getPermissions($path) & \OCP\Constants::PERMISSION_UPDATE);
+ return (bool)($this->getPermissions($path) & Constants::PERMISSION_UPDATE);
}
public function isDeletable(string $path): bool {
- return (bool)($this->getPermissions($path) & \OCP\Constants::PERMISSION_DELETE);
+ return (bool)($this->getPermissions($path) & Constants::PERMISSION_DELETE);
}
public function isSharable(string $path): bool {
- if (\OCP\Util::isSharingDisabledForUser() || !\OC\Share\Share::isResharingAllowed()) {
+ if (Util::isSharingDisabledForUser() || !Share::isResharingAllowed()) {
return false;
}
- return (bool)($this->getPermissions($path) & \OCP\Constants::PERMISSION_SHARE);
+ return (bool)($this->getPermissions($path) & Constants::PERMISSION_SHARE);
}
public function fopen(string $path, string $mode) {
'source' => $source,
'mode' => $mode,
];
- \OCP\Util::emitHook('\OC\Files\Storage\Shared', 'fopen', $info);
+ Util::emitHook('\OC\Files\Storage\Shared', 'fopen', $info);
return $this->nonMaskedStorage->fopen($this->getUnjailedPath($path), $mode);
}
return new FailedCache();
}
- $this->cache = new \OCA\Files_Sharing\Cache(
+ $this->cache = new Cache(
$storage,
$sourceRoot,
\OC::$server->get(CacheDependencies::class),
if (!$storage) {
$storage = $this;
}
- return new \OCA\Files_Sharing\Scanner($storage);
+ return new Scanner($storage);
}
public function getOwner(string $path): string|false {
'target' => $this->getMountPoint() . '/' . $path,
'source' => $this->getUnjailedPath($path),
];
- \OCP\Util::emitHook('\OC\Files\Storage\Shared', 'file_get_contents', $info);
+ Util::emitHook('\OC\Files\Storage\Shared', 'file_get_contents', $info);
return parent::file_get_contents($path);
}
'target' => $this->getMountPoint() . '/' . $path,
'source' => $this->getUnjailedPath($path),
];
- \OCP\Util::emitHook('\OC\Files\Storage\Shared', 'file_put_contents', $info);
+ Util::emitHook('\OC\Files\Storage\Shared', 'file_put_contents', $info);
return parent::file_put_contents($path, $data);
}
namespace OCA\Files_Sharing;
use OC\Files\Cache\FileAccess;
+use OC\Files\Filesystem;
use OC\Files\Mount\MountPoint;
use OCP\Constants;
use OCP\Files\Folder;
continue;
}
- if ($dstMount instanceof \OCA\Files_Sharing\SharedMount) {
+ if ($dstMount instanceof SharedMount) {
if (!($dstMount->getShare()->getPermissions() & Constants::PERMISSION_SHARE)) {
$shareManager->deleteShare($share);
continue;
* @param string $newPath new path relative to data/user/files
*/
private static function renameChildren($oldPath, $newPath) {
- $absNewPath = \OC\Files\Filesystem::normalizePath('/' . \OC_User::getUser() . '/files/' . $newPath);
- $absOldPath = \OC\Files\Filesystem::normalizePath('/' . \OC_User::getUser() . '/files/' . $oldPath);
+ $absNewPath = Filesystem::normalizePath('/' . \OC_User::getUser() . '/files/' . $newPath);
+ $absOldPath = Filesystem::normalizePath('/' . \OC_User::getUser() . '/files/' . $oldPath);
- $mountManager = \OC\Files\Filesystem::getMountManager();
+ $mountManager = Filesystem::getMountManager();
$mountedShares = $mountManager->findIn('/' . \OC_User::getUser() . '/files/' . $oldPath);
foreach ($mountedShares as $mount) {
/** @var MountPoint $mount */
}
// Extract extra permissions
- /** @var \OCA\Files_Sharing\SharedStorage $storage */
+ /** @var SharedStorage $storage */
$share = $storage->getShare();
$canDownload = true;
namespace OCA\Files_Sharing\Tests;
use OC\Files\Cache\Scanner;
+use OC\Files\FileInfo;
use OC\Files\Filesystem;
+use OC\Files\Storage\Temporary;
+use OC\Files\View;
use OCA\Files_Sharing\Controller\ShareAPIController;
use OCP\App\IAppManager;
use OCP\AppFramework\OCS\OCSBadRequestException;
use OCP\AppFramework\OCS\OCSException;
use OCP\AppFramework\OCS\OCSForbiddenException;
use OCP\AppFramework\OCS\OCSNotFoundException;
+use OCP\Constants;
use OCP\IConfig;
use OCP\IDateTimeZone;
use OCP\IL10N;
}
protected function tearDown(): void {
- if ($this->view instanceof \OC\Files\View) {
+ if ($this->view instanceof View) {
$this->view->unlink($this->filename);
$this->view->deleteAll($this->folder);
}
/**
* @param string $userId The userId of the caller
- * @return \OCA\Files_Sharing\Controller\ShareAPIController
+ * @return ShareAPIController
*/
private function createOCS($userId) {
$l = $this->getMockBuilder(IL10N::class)->getMock();
public function testCreateShareUserFile(): void {
$this->setUp(); // for some reasons phpunit refuses to do this for us only for this test
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
- $result = $ocs->createShare($this->filename, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_USER, self::TEST_FILES_SHARING_API_USER2);
+ $result = $ocs->createShare($this->filename, Constants::PERMISSION_ALL, IShare::TYPE_USER, self::TEST_FILES_SHARING_API_USER2);
$ocs->cleanup();
$data = $result->getData();
public function testCreateShareUserFolder(): void {
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
- $result = $ocs->createShare($this->folder, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_USER, self::TEST_FILES_SHARING_API_USER2);
+ $result = $ocs->createShare($this->folder, Constants::PERMISSION_ALL, IShare::TYPE_USER, self::TEST_FILES_SHARING_API_USER2);
$ocs->cleanup();
$data = $result->getData();
public function testCreateShareGroupFile(): void {
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
- $result = $ocs->createShare($this->filename, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_GROUP, self::TEST_FILES_SHARING_API_GROUP1);
+ $result = $ocs->createShare($this->filename, Constants::PERMISSION_ALL, IShare::TYPE_GROUP, self::TEST_FILES_SHARING_API_GROUP1);
$ocs->cleanup();
$data = $result->getData();
public function testCreateShareGroupFolder(): void {
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
- $result = $ocs->createShare($this->folder, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_GROUP, self::TEST_FILES_SHARING_API_GROUP1);
+ $result = $ocs->createShare($this->folder, Constants::PERMISSION_ALL, IShare::TYPE_GROUP, self::TEST_FILES_SHARING_API_GROUP1);
$ocs->cleanup();
$data = $result->getData();
*/
public function testCreateShareLink(): void {
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
- $result = $ocs->createShare($this->folder, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK);
+ $result = $ocs->createShare($this->folder, Constants::PERMISSION_ALL, IShare::TYPE_LINK);
$ocs->cleanup();
$data = $result->getData();
- $this->assertEquals(\OCP\Constants::PERMISSION_ALL,
+ $this->assertEquals(Constants::PERMISSION_ALL,
$data['permissions']);
$this->assertEmpty($data['expiration']);
$this->assertTrue(is_string($data['token']));
*/
public function testCreateShareLinkPublicUpload(): void {
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
- $result = $ocs->createShare($this->folder, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'true');
+ $result = $ocs->createShare($this->folder, Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'true');
$ocs->cleanup();
$data = $result->getData();
$this->assertEquals(
- \OCP\Constants::PERMISSION_READ |
- \OCP\Constants::PERMISSION_CREATE |
- \OCP\Constants::PERMISSION_UPDATE |
- \OCP\Constants::PERMISSION_DELETE |
- \OCP\Constants::PERMISSION_SHARE,
+ Constants::PERMISSION_READ |
+ Constants::PERMISSION_CREATE |
+ Constants::PERMISSION_UPDATE |
+ Constants::PERMISSION_DELETE |
+ Constants::PERMISSION_SHARE,
$data['permissions']
);
$this->assertEmpty($data['expiration']);
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
try {
- $ocs->createShare($this->folder, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK);
+ $ocs->createShare($this->folder, Constants::PERMISSION_ALL, IShare::TYPE_LINK);
$this->fail();
} catch (OCSForbiddenException $e) {
}
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
try {
- $ocs->createShare($this->folder, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', '');
+ $ocs->createShare($this->folder, Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', '');
$this->fail();
} catch (OCSForbiddenException $e) {
}
// share with password should succeed
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
- $result = $ocs->createShare($this->folder, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', $password);
+ $result = $ocs->createShare($this->folder, Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', $password);
$ocs->cleanup();
$data = $result->getData();
\OC::$server->getConfig()->setAppValue('core', 'shareapi_exclude_groups', 'no');
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
- $result = $ocs->createShare($this->filename, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_USER, self::TEST_FILES_SHARING_API_USER2);
+ $result = $ocs->createShare($this->filename, Constants::PERMISSION_ALL, IShare::TYPE_USER, self::TEST_FILES_SHARING_API_USER2);
$ocs->cleanup();
$data = $result->getData();
\OC::$server->getConfig()->setAppValue('core', 'shareapi_exclude_groups_list', 'admin,group1,group2');
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
- $result = $ocs->createShare($this->filename, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_USER, self::TEST_FILES_SHARING_API_USER2);
+ $result = $ocs->createShare($this->filename, Constants::PERMISSION_ALL, IShare::TYPE_USER, self::TEST_FILES_SHARING_API_USER2);
$ocs->cleanup();
$data = $result->getData();
\OC::$server->getConfig()->setAppValue('core', 'shareapi_exclude_groups_list', 'admin,group');
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
- $ocs->createShare($this->filename, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_USER, self::TEST_FILES_SHARING_API_USER2);
+ $ocs->createShare($this->filename, Constants::PERMISSION_ALL, IShare::TYPE_USER, self::TEST_FILES_SHARING_API_USER2);
$ocs->cleanup();
// cleanup
*/
public function testPublicLinkUrl(): void {
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
- $result = $ocs->createShare($this->folder, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK);
+ $result = $ocs->createShare($this->folder, Constants::PERMISSION_ALL, IShare::TYPE_LINK);
$ocs->cleanup();
$data = $result->getData();
$share1 = $this->shareManager->getShareById($share1->getFullId());
$this->assertEquals(
- \OCP\Constants::PERMISSION_READ |
- \OCP\Constants::PERMISSION_CREATE |
- \OCP\Constants::PERMISSION_UPDATE |
- \OCP\Constants::PERMISSION_DELETE |
- \OCP\Constants::PERMISSION_SHARE,
+ Constants::PERMISSION_READ |
+ Constants::PERMISSION_CREATE |
+ Constants::PERMISSION_UPDATE |
+ Constants::PERMISSION_DELETE |
+ Constants::PERMISSION_SHARE,
$share1->getPermissions()
);
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
$share->setStatus(IShare::STATUS_ACCEPTED);
$this->shareManager->updateShare($share);
// user2 shares a file from the folder as link
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $view = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+ $view = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
$view->mkdir('localDir');
// move mount point to the folder "localDir"
// try to share "localDir"
$fileInfo2 = $view->getFileInfo('localDir');
- $this->assertTrue($fileInfo2 instanceof \OC\Files\FileInfo);
+ $this->assertTrue($fileInfo2 instanceof FileInfo);
$pass = true;
try {
'localDir',
self::TEST_FILES_SHARING_API_USER2,
self::TEST_FILES_SHARING_API_USER3,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
} catch (\Exception $e) {
$pass = false;
*/
public static function initTestMountPointsHook($data) {
if ($data['user'] === self::TEST_FILES_SHARING_API_USER1) {
- \OC\Files\Filesystem::mount(self::$tempStorage, [], '/' . self::TEST_FILES_SHARING_API_USER1 . '/files' . self::TEST_FOLDER_NAME);
+ Filesystem::mount(self::$tempStorage, [], '/' . self::TEST_FILES_SHARING_API_USER1 . '/files' . self::TEST_FOLDER_NAME);
}
}
* Tests mounting a folder that is an external storage mount point.
*/
public function testShareStorageMountPoint(): void {
- $tempStorage = new \OC\Files\Storage\Temporary([]);
+ $tempStorage = new Temporary([]);
$tempStorage->file_put_contents('test.txt', 'abcdef');
$tempStorage->getScanner()->scan('');
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
$share->setStatus(IShare::STATUS_ACCEPTED);
$this->shareManager->updateShare($share);
// user2: check that mount point name appears correctly
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $view = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+ $view = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
$this->assertTrue($view->file_exists($this->folder));
$this->assertTrue($view->file_exists($this->folder . '/test.txt'));
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
try {
- $result = $ocs->createShare($this->folder, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', '', null, $date);
+ $result = $ocs->createShare($this->folder, Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', '', null, $date);
$this->assertTrue($valid);
} catch (OCSNotFoundException $e) {
$this->assertFalse($valid);
$date->add(new \DateInterval('P5D'));
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
- $result = $ocs->createShare($this->filename, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', '', null, $date->format('Y-m-d'));
+ $result = $ocs->createShare($this->filename, Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', '', null, $date->format('Y-m-d'));
$ocs->cleanup();
$data = $result->getData();
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
try {
- $ocs->createShare($this->filename, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', '', null, $date->format('Y-m-d'));
+ $ocs->createShare($this->filename, Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', '', null, $date->format('Y-m-d'));
$this->fail();
} catch (OCSException $e) {
$this->assertEquals(404, $e->getCode());
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
try {
- $ocs->createShare($this->filename, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', '', null, $date->format('Y-m-d'));
+ $ocs->createShare($this->filename, Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', '', null, $date->format('Y-m-d'));
$this->fail();
} catch (OCSException $e) {
$this->assertEquals(404, $e->getCode());
public function testInvisibleSharesUser(): void {
// simulate a post request
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
- $result = $ocs->createShare($this->folder, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_USER, self::TEST_FILES_SHARING_API_USER2);
+ $result = $ocs->createShare($this->folder, Constants::PERMISSION_ALL, IShare::TYPE_USER, self::TEST_FILES_SHARING_API_USER2);
$ocs->cleanup();
$data = $result->getData();
$ocs->cleanup();
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER2);
- $ocs->createShare($this->folder, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK);
+ $ocs->createShare($this->folder, Constants::PERMISSION_ALL, IShare::TYPE_LINK);
$ocs->cleanup();
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
public function testInvisibleSharesGroup(): void {
// simulate a post request
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
- $result = $ocs->createShare($this->folder, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_GROUP, self::TEST_FILES_SHARING_API_GROUP1);
+ $result = $ocs->createShare($this->folder, Constants::PERMISSION_ALL, IShare::TYPE_GROUP, self::TEST_FILES_SHARING_API_GROUP1);
$ocs->cleanup();
$data = $result->getData();
\OC_Util::tearDownFS();
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER2);
- $ocs->createShare($this->folder, \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK);
+ $ocs->createShare($this->folder, Constants::PERMISSION_ALL, IShare::TYPE_LINK);
$ocs->cleanup();
$ocs = $this->createOCS(self::TEST_FILES_SHARING_API_USER1);
*/
namespace OCA\Files_Sharing\Tests;
+use OC\Files\Filesystem;
use OC\Files\Storage\Temporary;
use OC\Files\Storage\Wrapper\Jail;
+use OC\Files\View;
use OCA\Files_Sharing\SharedStorage;
+use OCP\Constants;
use OCP\Share\IShare;
/**
self::loginHelper(self::TEST_FILES_SHARING_API_USER1);
- $this->user2View = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+ $this->user2View = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
// prepare user1's dir structure
$this->view->mkdir('container');
->setShareType(IShare::TYPE_USER)
->setSharedWith(self::TEST_FILES_SHARING_API_USER2)
->setSharedBy(self::TEST_FILES_SHARING_API_USER1)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = $this->shareManager->createShare($share);
$share->setStatus(IShare::STATUS_ACCEPTED);
$this->shareManager->updateShare($share);
->setShareType(IShare::TYPE_USER)
->setSharedWith(self::TEST_FILES_SHARING_API_USER2)
->setSharedBy(self::TEST_FILES_SHARING_API_USER1)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL & ~(\OCP\Constants::PERMISSION_CREATE | \OCP\Constants::PERMISSION_DELETE));
+ ->setPermissions(Constants::PERMISSION_ALL & ~(Constants::PERMISSION_CREATE | Constants::PERMISSION_DELETE));
$share = $this->shareManager->createShare($share);
$share->setStatus(IShare::STATUS_ACCEPTED);
$this->shareManager->updateShare($share);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
// retrieve the shared storage
- $secondView = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2);
+ $secondView = new View('/' . self::TEST_FILES_SHARING_API_USER2);
[$this->sharedStorage,] = $secondView->resolvePath('files/shareddir');
$this->sharedCache = $this->sharedStorage->getCache();
}
->setShareType(IShare::TYPE_USER)
->setSharedWith(self::TEST_FILES_SHARING_API_USER3)
->setSharedBy(self::TEST_FILES_SHARING_API_USER1)
- ->setPermissions(\OCP\Constants::PERMISSION_READ);
+ ->setPermissions(Constants::PERMISSION_READ);
$share = $this->shareManager->createShare($share);
$share->setStatus(IShare::STATUS_ACCEPTED);
$this->shareManager->updateShare($share);
->setShareType(IShare::TYPE_USER)
->setSharedWith(self::TEST_FILES_SHARING_API_USER3)
->setSharedBy(self::TEST_FILES_SHARING_API_USER1)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = $this->shareManager->createShare($share);
$share->setStatus(IShare::STATUS_ACCEPTED);
$this->shareManager->updateShare($share);
self::loginHelper(self::TEST_FILES_SHARING_API_USER3);
- $thirdView = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER3 . '/files');
+ $thirdView = new View('/' . self::TEST_FILES_SHARING_API_USER3 . '/files');
$results = $thirdView->getDirectoryContent('/subdir');
$this->verifyFiles(
public function testGetPathByIdDirectShare(): void {
self::loginHelper(self::TEST_FILES_SHARING_API_USER1);
- \OC\Files\Filesystem::file_put_contents('test.txt', 'foo');
- $info = \OC\Files\Filesystem::getFileInfo('test.txt');
+ Filesystem::file_put_contents('test.txt', 'foo');
+ $info = Filesystem::getFileInfo('test.txt');
$rootFolder = \OC::$server->getUserFolder(self::TEST_FILES_SHARING_API_USER1);
$node = $rootFolder->get('test.txt');
->setShareType(IShare::TYPE_USER)
->setSharedWith(self::TEST_FILES_SHARING_API_USER2)
->setSharedBy(self::TEST_FILES_SHARING_API_USER1)
- ->setPermissions(\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_SHARE);
+ ->setPermissions(Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE | Constants::PERMISSION_SHARE);
$share = $this->shareManager->createShare($share);
$share->setStatus(IShare::STATUS_ACCEPTED);
$this->shareManager->updateShare($share);
\OC_Util::tearDownFS();
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $this->assertTrue(\OC\Files\Filesystem::file_exists('/test.txt'));
- [$sharedStorage] = \OC\Files\Filesystem::resolvePath('/' . self::TEST_FILES_SHARING_API_USER2 . '/files/test.txt');
+ $this->assertTrue(Filesystem::file_exists('/test.txt'));
+ [$sharedStorage] = Filesystem::resolvePath('/' . self::TEST_FILES_SHARING_API_USER2 . '/files/test.txt');
/**
- * @var \OCA\Files_Sharing\SharedStorage $sharedStorage
+ * @var SharedStorage $sharedStorage
*/
-
$sharedCache = $sharedStorage->getCache();
$this->assertEquals('', $sharedCache->getPathById($info->getId()));
}
public function testGetPathByIdShareSubFolder(): void {
self::loginHelper(self::TEST_FILES_SHARING_API_USER1);
- \OC\Files\Filesystem::mkdir('foo');
- \OC\Files\Filesystem::mkdir('foo/bar');
- \OC\Files\Filesystem::touch('foo/bar/test.txt');
- $folderInfo = \OC\Files\Filesystem::getFileInfo('foo');
- $fileInfo = \OC\Files\Filesystem::getFileInfo('foo/bar/test.txt');
+ Filesystem::mkdir('foo');
+ Filesystem::mkdir('foo/bar');
+ Filesystem::touch('foo/bar/test.txt');
+ $folderInfo = Filesystem::getFileInfo('foo');
+ $fileInfo = Filesystem::getFileInfo('foo/bar/test.txt');
$rootFolder = \OC::$server->getUserFolder(self::TEST_FILES_SHARING_API_USER1);
$node = $rootFolder->get('foo');
->setShareType(IShare::TYPE_USER)
->setSharedWith(self::TEST_FILES_SHARING_API_USER2)
->setSharedBy(self::TEST_FILES_SHARING_API_USER1)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = $this->shareManager->createShare($share);
$share->setStatus(IShare::STATUS_ACCEPTED);
$this->shareManager->updateShare($share);
\OC_Util::tearDownFS();
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $this->assertTrue(\OC\Files\Filesystem::file_exists('/foo'));
- [$sharedStorage] = \OC\Files\Filesystem::resolvePath('/' . self::TEST_FILES_SHARING_API_USER2 . '/files/foo');
+ $this->assertTrue(Filesystem::file_exists('/foo'));
+ [$sharedStorage] = Filesystem::resolvePath('/' . self::TEST_FILES_SHARING_API_USER2 . '/files/foo');
/**
- * @var \OCA\Files_Sharing\SharedStorage $sharedStorage
+ * @var SharedStorage $sharedStorage
*/
-
$sharedCache = $sharedStorage->getCache();
$this->assertEquals('', $sharedCache->getPathById($folderInfo->getId()));
$this->assertEquals('bar/test.txt', $sharedCache->getPathById($fileInfo->getId()));
public function testNumericStorageId(): void {
self::loginHelper(self::TEST_FILES_SHARING_API_USER1);
- \OC\Files\Filesystem::mkdir('foo');
+ Filesystem::mkdir('foo');
$rootFolder = \OC::$server->getUserFolder(self::TEST_FILES_SHARING_API_USER1);
$node = $rootFolder->get('foo');
->setShareType(IShare::TYPE_USER)
->setSharedWith(self::TEST_FILES_SHARING_API_USER2)
->setSharedBy(self::TEST_FILES_SHARING_API_USER1)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = $this->shareManager->createShare($share);
$share->setStatus(IShare::STATUS_ACCEPTED);
$this->shareManager->updateShare($share);
\OC_Util::tearDownFS();
- [$sourceStorage] = \OC\Files\Filesystem::resolvePath('/' . self::TEST_FILES_SHARING_API_USER1 . '/files/foo');
+ [$sourceStorage] = Filesystem::resolvePath('/' . self::TEST_FILES_SHARING_API_USER1 . '/files/foo');
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $this->assertTrue(\OC\Files\Filesystem::file_exists('/foo'));
+ $this->assertTrue(Filesystem::file_exists('/foo'));
/** @var SharedStorage $sharedStorage */
- [$sharedStorage] = \OC\Files\Filesystem::resolvePath('/' . self::TEST_FILES_SHARING_API_USER2 . '/files/foo');
+ [$sharedStorage] = Filesystem::resolvePath('/' . self::TEST_FILES_SHARING_API_USER2 . '/files/foo');
$this->assertEquals($sourceStorage->getCache()->getNumericStorageId(), $sharedStorage->getCache()->getNumericStorageId());
}
->setShareType(IShare::TYPE_USER)
->setSharedWith(self::TEST_FILES_SHARING_API_USER2)
->setSharedBy(self::TEST_FILES_SHARING_API_USER1)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = $this->shareManager->createShare($share);
$share->setStatus(IShare::STATUS_ACCEPTED);
$this->shareManager->updateShare($share);
\OC_Util::tearDownFS();
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $this->assertEquals('foo', \OC\Files\Filesystem::file_get_contents('/sub/foo.txt'));
+ $this->assertEquals('foo', Filesystem::file_get_contents('/sub/foo.txt'));
- \OC\Files\Filesystem::file_put_contents('/sub/bar.txt', 'bar');
+ Filesystem::file_put_contents('/sub/bar.txt', 'bar');
/** @var SharedStorage $sharedStorage */
- [$sharedStorage] = \OC\Files\Filesystem::resolvePath('/' . self::TEST_FILES_SHARING_API_USER2 . '/files/sub');
+ [$sharedStorage] = Filesystem::resolvePath('/' . self::TEST_FILES_SHARING_API_USER2 . '/files/sub');
$this->assertTrue($sharedStorage->getCache()->inCache('bar.txt'));
->setShareType(IShare::TYPE_USER)
->setSharedWith(self::TEST_FILES_SHARING_API_USER2)
->setSharedBy(self::TEST_FILES_SHARING_API_USER1)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = $this->shareManager->createShare($share);
$share->setStatus(IShare::STATUS_ACCEPTED);
$this->shareManager->updateShare($share);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
/** @var SharedStorage $sharedStorage */
- [$sharedStorage] = \OC\Files\Filesystem::resolvePath('/' . self::TEST_FILES_SHARING_API_USER2 . '/files/sub');
+ [$sharedStorage] = Filesystem::resolvePath('/' . self::TEST_FILES_SHARING_API_USER2 . '/files/sub');
$results = $sharedStorage->getCache()->search('foo.txt');
$this->assertCount(1, $results);
use OCA\Files_Sharing\Controller\ShareAPIController;
use OCP\App\IAppManager;
use OCP\AppFramework\Http\DataResponse;
+use OCP\AppFramework\OCS\OCSBadRequestException;
use OCP\AppFramework\OCS\OCSException;
+use OCP\AppFramework\OCS\OCSForbiddenException;
use OCP\AppFramework\OCS\OCSNotFoundException;
+use OCP\Constants;
use OCP\Files\File;
use OCP\Files\Folder;
use OCP\Files\IRootFolder;
use OCP\IURLGenerator;
use OCP\IUser;
use OCP\IUserManager;
+use OCP\Lock\ILockingProvider;
use OCP\Lock\LockedException;
use OCP\Mail\IMailer;
use OCP\Share\Exceptions\GenericShareException;
+use OCP\Share\Exceptions\ShareNotFound;
use OCP\Share\IAttributes as IShareAttributes;
use OCP\Share\IManager;
use OCP\Share\IProviderFactory;
}
public function testDeleteShareShareNotFound(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSNotFoundException::class);
+ $this->expectException(OCSNotFoundException::class);
$this->expectExceptionMessage('Wrong share ID, share does not exist');
$this->shareManager
->method('getShareById')
->willReturnCallback(function ($id): void {
if ($id === 'ocinternal:42' || $id === 'ocRoomShare:42' || $id === 'ocFederatedSharing:42' || $id === 'ocCircleShare:42' || $id === 'ocMailShare:42' || $id === 'deck:42' || $id === 'sciencemesh:42') {
- throw new \OCP\Share\Exceptions\ShareNotFound();
+ throw new ShareNotFound();
} else {
throw new \Exception();
}
$node->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$expected = new DataResponse();
$result = $this->ocs->deleteShare(42);
public function testDeleteShareLocked(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSNotFoundException::class);
+ $this->expectException(OCSNotFoundException::class);
$this->expectExceptionMessage('Could not delete share');
$node = $this->getMockBuilder(File::class)->getMock();
$node->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED)
+ ->with(ILockingProvider::LOCK_SHARED)
->will($this->throwException(new LockedException('mypath')));
$this->assertFalse($this->invokePrivate($this->ocs, 'canDeleteFromSelf', [$share]));
$node->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->assertFalse($this->invokePrivate($this->ocs, 'canDeleteFromSelf', [$share]));
$this->assertTrue($this->invokePrivate($this->ocs, 'canDeleteShare', [$share]));
$node->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->assertFalse($this->invokePrivate($this->ocs, 'canDeleteFromSelf', [$share]));
$this->assertTrue($this->invokePrivate($this->ocs, 'canDeleteShare', [$share]));
$node->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->assertFalse($this->invokePrivate($this->ocs, 'canDeleteFromSelf', [$share]));
$this->assertTrue($this->invokePrivate($this->ocs, 'canDeleteShare', [$share]));
$node->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$userFolder = $this->getMockBuilder(Folder::class)->getMock();
$this->rootFolder->method('getUserFolder')
* in the group the share is shared with
*/
public function testDeleteSharedWithGroupIDontBelongTo(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSNotFoundException::class);
+ $this->expectException(OCSNotFoundException::class);
$this->expectExceptionMessage('Wrong share ID, share does not exist');
$node = $this->getMockBuilder(File::class)->getMock();
$node->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$userFolder = $this->getMockBuilder(Folder::class)->getMock();
$this->rootFolder->method('getUserFolder')
/**
* @dataProvider dataGetShare
*/
- public function testGetShare(\OCP\Share\IShare $share, array $result): void {
+ public function testGetShare(IShare $share, array $result): void {
/** @var ShareAPIController|\PHPUnit\Framework\MockObject\MockObject $ocs */
$ocs = $this->getMockBuilder(ShareAPIController::class)
->setConstructorArgs([
public function testGetShareInvalidNode(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSNotFoundException::class);
+ $this->expectException(OCSNotFoundException::class);
$this->expectExceptionMessage('Wrong share ID, share does not exist');
$share = \OC::$server->getShareManager()->newShare();
->setSharedWith('recipient')
->setSharedBy('initiator')
->setShareOwner('currentUser')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file1)
->setId(4);
->setSharedWith('recipient')
->setSharedBy('currentUser')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file1)
->setId(8);
->setSharedWith('currentUser')
->setSharedBy('initiator')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file1)
->setId(15);
->setSharedWith('recipient')
->setSharedBy('initiator')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file1)
->setId(16);
->setSharedWith('recipient')
->setSharedBy('initiator')
->setShareOwner('currentUser')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file1)
->setId(23);
->setSharedWith('currentUserGroup')
->setSharedBy('initiator')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file1)
->setId(42);
->setSharedWith('recipient')
->setSharedBy('initiator')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file1)
->setId(108);
->setSharedWith('recipient')
->setSharedBy('initiator')
->setShareOwner('currentUser')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file1)
->setId(415);
->setSharedWith('recipient')
->setSharedBy('initiator')
->setShareOwner('currentUser')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file1)
->setId(416);
->setSharedWith('recipient')
->setSharedBy('initiator')
->setShareOwner('currentUser')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file1)
->setId(423);
->setSharedWith('recipient')
->setSharedBy('initiator')
->setShareOwner('currentUser')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file1)
->setId(442);
->setSharedWith('recipient')
->setSharedBy('initiator')
->setShareOwner('currentUser')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setExpirationDate(new \DateTime('2000-01-01T01:02:03'))
->setNode($file1)
->setId(815);
->setSharedWith('recipient')
->setSharedBy('initiator')
->setShareOwner('currentUser')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setExpirationDate(new \DateTime('2000-01-02T01:02:03'))
->setNode($file1)
->setId(816);
->setSharedWith('recipient')
->setSharedBy('initiator')
->setShareOwner('currentUser')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file2)
->setId(823);
* @dataProvider dataGetShares
*/
public function testGetShares(array $getSharesParameters, array $shares, array $extraShareTypes, array $expected): void {
- /** @var \OCA\Files_Sharing\Controller\ShareAPIController $ocs */
+ /** @var ShareAPIController $ocs */
$ocs = $this->getMockBuilder(ShareAPIController::class)
->setConstructorArgs([
$this->appName,
->willReturn($file);
$file->method('getPermissions')
- ->will($this->onConsecutiveCalls(\OCP\Constants::PERMISSION_SHARE, \OCP\Constants::PERMISSION_READ));
+ ->will($this->onConsecutiveCalls(Constants::PERMISSION_SHARE, Constants::PERMISSION_READ));
// getPermissions -> share
$share = $this->getMockBuilder(IShare::class)->getMock();
* @param bool helperAvailable
* @param bool canAccessShareByHelper
*/
- public function testCanAccessRoomShare(bool $expected, \OCP\Share\IShare $share, bool $helperAvailable, bool $canAccessShareByHelper): void {
+ public function testCanAccessRoomShare(bool $expected, IShare $share, bool $helperAvailable, bool $canAccessShareByHelper): void {
$userFolder = $this->getMockBuilder(Folder::class)->getMock();
$this->rootFolder->method('getUserFolder')
->with($this->currentUser)
public function testCreateShareNoPath(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSNotFoundException::class);
+ $this->expectException(OCSNotFoundException::class);
$this->expectExceptionMessage('Please specify a file or folder path');
$this->ocs->createShare();
public function testCreateShareInvalidPath(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSNotFoundException::class);
+ $this->expectException(OCSNotFoundException::class);
$this->expectExceptionMessage('Wrong path, file/folder does not exist');
$userFolder = $this->getMockBuilder(Folder::class)->getMock();
$userFolder->expects($this->once())
->method('get')
->with('invalid-path')
- ->will($this->throwException(new \OCP\Files\NotFoundException()));
+ ->will($this->throwException(new NotFoundException()));
$this->ocs->createShare('invalid-path');
}
public function testCreateShareInvalidPermissions(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSNotFoundException::class);
+ $this->expectException(OCSNotFoundException::class);
$this->expectExceptionMessage('Invalid permissions');
$share = $this->newShare();
$path->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->ocs->createShare('valid-path', 32);
}
public function testCreateShareUserNoShareWith(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSNotFoundException::class);
+ $this->expectException(OCSNotFoundException::class);
$this->expectExceptionMessage('Please specify a valid account to share with');
$share = $this->newShare();
$path->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
- $this->ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_USER);
+ $this->ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_USER);
}
public function testCreateShareUserNoValidShareWith(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSNotFoundException::class);
+ $this->expectException(OCSNotFoundException::class);
$this->expectExceptionMessage('Please specify a valid account to share with');
$share = $this->newShare();
->willReturn([]);
$path->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->userManager->method('userExists')
->with('invalidUser')
->willReturn(false);
- $this->ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_USER, 'invalidUser');
+ $this->ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_USER, 'invalidUser');
}
public function testCreateShareUser(): void {
$share = $this->newShare();
$this->shareManager->method('newShare')->willReturn($share);
- /** @var \OCA\Files_Sharing\Controller\ShareAPIController $ocs */
+ /** @var ShareAPIController $ocs */
$ocs = $this->getMockBuilder(ShareAPIController::class)
->setConstructorArgs([
$this->appName,
$path->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->shareManager->method('createShare')
- ->with($this->callback(function (\OCP\Share\IShare $share) use ($path) {
+ ->with($this->callback(function (IShare $share) use ($path) {
return $share->getNode() === $path &&
$share->getPermissions() === (
- \OCP\Constants::PERMISSION_ALL &
- ~\OCP\Constants::PERMISSION_DELETE &
- ~\OCP\Constants::PERMISSION_CREATE
+ Constants::PERMISSION_ALL &
+ ~Constants::PERMISSION_DELETE &
+ ~Constants::PERMISSION_CREATE
) &&
$share->getShareType() === IShare::TYPE_USER &&
$share->getSharedWith() === 'validUser' &&
->willReturnArgument(0);
$expected = new DataResponse([]);
- $result = $ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_USER, 'validUser');
+ $result = $ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_USER, 'validUser');
$this->assertInstanceOf(get_class($expected), $result);
$this->assertEquals($expected->getData(), $result->getData());
public function testCreateShareGroupNoValidShareWith(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSNotFoundException::class);
+ $this->expectException(OCSNotFoundException::class);
$this->expectExceptionMessage('Please specify a valid group');
$share = $this->newShare();
$path->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
- $this->ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_GROUP, 'invalidGroup');
+ $this->ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_GROUP, 'invalidGroup');
}
public function testCreateShareGroup(): void {
->method('getParam')
->willReturnMap([
['path', null, 'valid-path'],
- ['permissions', null, \OCP\Constants::PERMISSION_ALL],
+ ['permissions', null, Constants::PERMISSION_ALL],
['shareType', '-1', IShare::TYPE_GROUP],
['shareWith', null, 'validGroup'],
]);
$path->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->shareManager->method('createShare')
- ->with($this->callback(function (\OCP\Share\IShare $share) use ($path) {
+ ->with($this->callback(function (IShare $share) use ($path) {
return $share->getNode() === $path &&
- $share->getPermissions() === \OCP\Constants::PERMISSION_ALL &&
+ $share->getPermissions() === Constants::PERMISSION_ALL &&
$share->getShareType() === IShare::TYPE_GROUP &&
$share->getSharedWith() === 'validGroup' &&
$share->getSharedBy() === 'currentUser';
->willReturnArgument(0);
$expected = new DataResponse([]);
- $result = $ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_GROUP, 'validGroup');
+ $result = $ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_GROUP, 'validGroup');
$this->assertInstanceOf(get_class($expected), $result);
$this->assertEquals($expected->getData(), $result->getData());
public function testCreateShareGroupNotAllowed(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSNotFoundException::class);
+ $this->expectException(OCSNotFoundException::class);
$this->expectExceptionMessage('Group sharing is disabled by the administrator');
$share = $this->newShare();
->method('allowGroupSharing')
->willReturn(false);
- $this->ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_GROUP, 'invalidGroup');
+ $this->ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_GROUP, 'invalidGroup');
}
public function testCreateShareLinkNoLinksAllowed(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSNotFoundException::class);
+ $this->expectException(OCSNotFoundException::class);
$this->expectExceptionMessage('Public link sharing is disabled by the administrator');
$this->request
$this->shareManager->method('newShare')->willReturn(\OC::$server->getShareManager()->newShare());
- $this->ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK);
+ $this->ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_LINK);
}
public function testCreateShareLinkNoPublicUpload(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSForbiddenException::class);
+ $this->expectException(OCSForbiddenException::class);
$this->expectExceptionMessage('Public upload disabled by the administrator');
$path = $this->getMockBuilder(Folder::class)->getMock();
$this->shareManager->method('newShare')->willReturn(\OC::$server->getShareManager()->newShare());
$this->shareManager->method('shareApiAllowLinks')->willReturn(true);
- $this->ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'true');
+ $this->ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'true');
}
public function testCreateShareLinkPublicUploadFile(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSNotFoundException::class);
+ $this->expectException(OCSNotFoundException::class);
$this->expectExceptionMessage('Public upload is only possible for publicly shared folders');
$path = $this->getMockBuilder(File::class)->getMock();
$this->shareManager->method('shareApiAllowLinks')->willReturn(true);
$this->shareManager->method('shareApiLinkAllowPublicUpload')->willReturn(true);
- $this->ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'true');
+ $this->ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'true');
}
public function testCreateShareLinkPublicUploadFolder(): void {
$this->shareManager->method('shareApiLinkAllowPublicUpload')->willReturn(true);
$this->shareManager->expects($this->once())->method('createShare')->with(
- $this->callback(function (\OCP\Share\IShare $share) use ($path) {
+ $this->callback(function (IShare $share) use ($path) {
return $share->getNode() === $path &&
$share->getShareType() === IShare::TYPE_LINK &&
- $share->getPermissions() === (\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_CREATE | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE) &&
+ $share->getPermissions() === (Constants::PERMISSION_READ | Constants::PERMISSION_CREATE | Constants::PERMISSION_UPDATE | Constants::PERMISSION_DELETE) &&
$share->getSharedBy() === 'currentUser' &&
$share->getPassword() === null &&
$share->getExpirationDate() === null;
)->willReturnArgument(0);
$expected = new DataResponse([]);
- $result = $ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'true', '', null, '');
+ $result = $ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'true', '', null, '');
$this->assertInstanceOf(get_class($expected), $result);
$this->assertEquals($expected->getData(), $result->getData());
$this->shareManager->method('shareApiLinkAllowPublicUpload')->willReturn(true);
$this->shareManager->expects($this->once())->method('createShare')->with(
- $this->callback(function (\OCP\Share\IShare $share) use ($path) {
+ $this->callback(function (IShare $share) use ($path) {
return $share->getNode() === $path &&
$share->getShareType() === IShare::TYPE_LINK &&
- $share->getPermissions() === \OCP\Constants::PERMISSION_ALL &&
+ $share->getPermissions() === Constants::PERMISSION_ALL &&
$share->getSharedBy() === 'currentUser' &&
$share->getPassword() === 'password' &&
$share->getExpirationDate() === null;
)->willReturnArgument(0);
$expected = new DataResponse([]);
- $result = $ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', 'password', null, '');
+ $result = $ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', 'password', null, '');
$this->assertInstanceOf(get_class($expected), $result);
$this->assertEquals($expected->getData(), $result->getData());
$this->appManager->method('isEnabledForUser')->with('spreed')->willReturn(true);
$this->shareManager->expects($this->once())->method('createShare')->with(
- $this->callback(function (\OCP\Share\IShare $share) use ($path) {
+ $this->callback(function (IShare $share) use ($path) {
return $share->getNode() === $path &&
$share->getShareType() === IShare::TYPE_LINK &&
- $share->getPermissions() === \OCP\Constants::PERMISSION_ALL &&
+ $share->getPermissions() === Constants::PERMISSION_ALL &&
$share->getSharedBy() === 'currentUser' &&
$share->getPassword() === 'password' &&
$share->getSendPasswordByTalk() === true &&
)->willReturnArgument(0);
$expected = new DataResponse([]);
- $result = $ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', 'password', 'true', '');
+ $result = $ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', 'password', 'true', '');
$this->assertInstanceOf(get_class($expected), $result);
$this->assertEquals($expected->getData(), $result->getData());
public function testCreateShareLinkSendPasswordByTalkWithTalkDisabled(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSForbiddenException::class);
+ $this->expectException(OCSForbiddenException::class);
$this->expectExceptionMessage('Sharing valid-path sending the password by Nextcloud Talk failed because Nextcloud Talk is not enabled');
$ocs = $this->mockFormatShare();
$this->shareManager->expects($this->never())->method('createShare');
- $ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', 'password', 'true', '');
+ $ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', 'password', 'true', '');
}
public function testCreateShareValidExpireDate(): void {
$this->shareManager->method('shareApiLinkAllowPublicUpload')->willReturn(true);
$this->shareManager->expects($this->once())->method('createShare')->with(
- $this->callback(function (\OCP\Share\IShare $share) use ($path) {
+ $this->callback(function (IShare $share) use ($path) {
$date = new \DateTime('2000-01-01');
$date->setTime(0, 0, 0);
return $share->getNode() === $path &&
$share->getShareType() === IShare::TYPE_LINK &&
- $share->getPermissions() === \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_SHARE &&
+ $share->getPermissions() === Constants::PERMISSION_READ | Constants::PERMISSION_SHARE &&
$share->getSharedBy() === 'currentUser' &&
$share->getPassword() === null &&
$share->getExpirationDate() == $date;
public function testCreateShareInvalidExpireDate(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSNotFoundException::class);
+ $this->expectException(OCSNotFoundException::class);
$this->expectExceptionMessage('Invalid date, date format must be YYYY-MM-DD');
$ocs = $this->mockFormatShare();
$this->shareManager->method('shareApiAllowLinks')->willReturn(true);
$this->shareManager->method('shareApiLinkAllowPublicUpload')->willReturn(true);
- $ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', '', null, 'a1b2d3');
+ $ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_LINK, null, 'false', '', null, 'a1b2d3');
}
public function testCreateShareRemote(): void {
$share = $this->newShare();
$this->shareManager->method('newShare')->willReturn($share);
- /** @var \OCA\Files_Sharing\Controller\ShareAPIController $ocs */
+ /** @var ShareAPIController $ocs */
$ocs = $this->getMockBuilder(ShareAPIController::class)
->setConstructorArgs([
$this->appName,
$path->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->shareManager->method('createShare')
- ->with($this->callback(function (\OCP\Share\IShare $share) use ($path) {
+ ->with($this->callback(function (IShare $share) use ($path) {
return $share->getNode() === $path &&
$share->getPermissions() === (
- \OCP\Constants::PERMISSION_ALL &
- ~\OCP\Constants::PERMISSION_DELETE &
- ~\OCP\Constants::PERMISSION_CREATE
+ Constants::PERMISSION_ALL &
+ ~Constants::PERMISSION_DELETE &
+ ~Constants::PERMISSION_CREATE
) &&
$share->getShareType() === IShare::TYPE_REMOTE &&
$share->getSharedWith() === 'user@example.org' &&
$this->shareManager->method('outgoingServer2ServerSharesAllowed')->willReturn(true);
$expected = new DataResponse([]);
- $result = $ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_REMOTE, 'user@example.org');
+ $result = $ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_REMOTE, 'user@example.org');
$this->assertInstanceOf(get_class($expected), $result);
$this->assertEquals($expected->getData(), $result->getData());
$share = $this->newShare();
$this->shareManager->method('newShare')->willReturn($share);
- /** @var \OCA\Files_Sharing\Controller\ShareAPIController $ocs */
+ /** @var ShareAPIController $ocs */
$ocs = $this->getMockBuilder(ShareAPIController::class)
->setConstructorArgs([
$this->appName,
$path->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->shareManager->method('createShare')
- ->with($this->callback(function (\OCP\Share\IShare $share) use ($path) {
+ ->with($this->callback(function (IShare $share) use ($path) {
return $share->getNode() === $path &&
$share->getPermissions() === (
- \OCP\Constants::PERMISSION_ALL &
- ~\OCP\Constants::PERMISSION_DELETE &
- ~\OCP\Constants::PERMISSION_CREATE
+ Constants::PERMISSION_ALL &
+ ~Constants::PERMISSION_DELETE &
+ ~Constants::PERMISSION_CREATE
) &&
$share->getShareType() === IShare::TYPE_REMOTE_GROUP &&
$share->getSharedWith() === 'group@example.org' &&
$this->shareManager->method('outgoingServer2ServerGroupSharesAllowed')->willReturn(true);
$expected = new DataResponse([]);
- $result = $ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_REMOTE_GROUP, 'group@example.org');
+ $result = $ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_REMOTE_GROUP, 'group@example.org');
$this->assertInstanceOf(get_class($expected), $result);
$this->assertEquals($expected->getData(), $result->getData());
$path->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->appManager->method('isEnabledForUser')
->with('spreed')
->with(
$share,
'recipientRoom',
- \OCP\Constants::PERMISSION_ALL &
- ~\OCP\Constants::PERMISSION_DELETE &
- ~\OCP\Constants::PERMISSION_CREATE,
+ Constants::PERMISSION_ALL &
+ ~Constants::PERMISSION_DELETE &
+ ~Constants::PERMISSION_CREATE,
''
)->willReturnCallback(
function ($share): void {
$share->setSharedWith('recipientRoom');
$share->setPermissions(
- \OCP\Constants::PERMISSION_ALL &
- ~\OCP\Constants::PERMISSION_DELETE &
- ~\OCP\Constants::PERMISSION_CREATE
+ Constants::PERMISSION_ALL &
+ ~Constants::PERMISSION_DELETE &
+ ~Constants::PERMISSION_CREATE
);
}
);
->willReturn($helper);
$this->shareManager->method('createShare')
- ->with($this->callback(function (\OCP\Share\IShare $share) use ($path) {
+ ->with($this->callback(function (IShare $share) use ($path) {
return $share->getNode() === $path &&
$share->getPermissions() === (
- \OCP\Constants::PERMISSION_ALL &
- ~\OCP\Constants::PERMISSION_DELETE &
- ~\OCP\Constants::PERMISSION_CREATE
+ Constants::PERMISSION_ALL &
+ ~Constants::PERMISSION_DELETE &
+ ~Constants::PERMISSION_CREATE
) &&
$share->getShareType() === IShare::TYPE_ROOM &&
$share->getSharedWith() === 'recipientRoom' &&
->willReturnArgument(0);
$expected = new DataResponse([]);
- $result = $ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_ROOM, 'recipientRoom');
+ $result = $ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_ROOM, 'recipientRoom');
$this->assertInstanceOf(get_class($expected), $result);
$this->assertEquals($expected->getData(), $result->getData());
public function testCreateShareRoomHelperNotAvailable(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSForbiddenException::class);
+ $this->expectException(OCSForbiddenException::class);
$this->expectExceptionMessage('Sharing valid-path failed because the back end does not support room shares');
$ocs = $this->mockFormatShare();
$path->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->appManager->method('isEnabledForUser')
->with('spreed')
$this->shareManager->expects($this->never())->method('createShare');
- $ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_ROOM, 'recipientRoom');
+ $ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_ROOM, 'recipientRoom');
}
public function testCreateShareRoomHelperThrowException(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSNotFoundException::class);
+ $this->expectException(OCSNotFoundException::class);
$this->expectExceptionMessage('Exception thrown by the helper');
$ocs = $this->mockFormatShare();
$path->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->appManager->method('isEnabledForUser')
->with('spreed')
->with(
$share,
'recipientRoom',
- \OCP\Constants::PERMISSION_ALL &
- ~\OCP\Constants::PERMISSION_DELETE &
- ~\OCP\Constants::PERMISSION_CREATE,
+ Constants::PERMISSION_ALL &
+ ~Constants::PERMISSION_DELETE &
+ ~Constants::PERMISSION_CREATE,
''
)->willReturnCallback(
function ($share): void {
$this->shareManager->expects($this->never())->method('createShare');
- $ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_ROOM, 'recipientRoom');
+ $ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_ROOM, 'recipientRoom');
}
/**
$userFolder->method('getStorage')->willReturn($storage);
$path->method('getStorage')->willReturn($storage);
- $path->method('getPermissions')->willReturn(\OCP\Constants::PERMISSION_READ);
+ $path->method('getPermissions')->willReturn(Constants::PERMISSION_READ);
$userFolder->expects($this->once())
->method('get')
->with('valid-path')
$this->shareManager
->expects($this->once())
->method('createShare')
- ->with($this->callback(function (\OCP\Share\IShare $share) {
- return $share->getPermissions() === \OCP\Constants::PERMISSION_READ;
+ ->with($this->callback(function (IShare $share) {
+ return $share->getPermissions() === Constants::PERMISSION_READ;
}))
->willReturnArgument(0);
- $ocs->createShare('valid-path', \OCP\Constants::PERMISSION_ALL, IShare::TYPE_USER, 'validUser');
+ $ocs->createShare('valid-path', Constants::PERMISSION_ALL, IShare::TYPE_USER, 'validUser');
}
public function testUpdateShareCantAccess(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSNotFoundException::class);
+ $this->expectException(OCSNotFoundException::class);
$this->expectExceptionMessage('Wrong share ID, share does not exist');
[$userFolder, $node] = $this->getNonSharedUserFolder();
$node->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->shareManager->method('getShareById')->with('ocinternal:42')->willReturn($share);
public function testUpdateNoParametersLink(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSBadRequestException::class);
+ $this->expectException(OCSBadRequestException::class);
$this->expectExceptionMessage('Wrong or no update parameter given');
$node = $this->getMockBuilder(Folder::class)->getMock();
$share = $this->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_LINK)
->setNode($node);
$node->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->shareManager->method('getShareById')->with('ocinternal:42')->willReturn($share);
public function testUpdateNoParametersOther(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSBadRequestException::class);
+ $this->expectException(OCSBadRequestException::class);
$this->expectExceptionMessage('Wrong or no update parameter given');
$node = $this->getMockBuilder(Folder::class)->getMock();
$share = $this->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_GROUP)
->setNode($node);
$node->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->shareManager->method('getShareById')->with('ocinternal:42')->willReturn($share);
$node->method('getId')
->willReturn(42);
$share = $this->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_LINK)
->setPassword('password')
->setNote('note')
->setLabel('label')
->setHideDownload(true)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ ->setPermissions(Constants::PERMISSION_ALL)
->setNode($node);
$node->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->shareManager->method('getShareById')->with('ocinternal:42')->willReturn($share);
$this->shareManager->expects($this->once())->method('updateShare')->with(
- $this->callback(function (\OCP\Share\IShare $share) {
- return $share->getPermissions() === \OCP\Constants::PERMISSION_READ &&
+ $this->callback(function (IShare $share) {
+ return $share->getPermissions() === Constants::PERMISSION_READ &&
$share->getPassword() === null &&
$share->getExpirationDate() === null &&
// Once set a note or a label are never back to null, only to an
->willReturn(42);
$share = \OC::$server->getShareManager()->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_LINK)
->setNode($folder);
$this->shareManager->method('shareApiLinkAllowPublicUpload')->willReturn(true);
$this->shareManager->expects($this->once())->method('updateShare')->with(
- $this->callback(function (\OCP\Share\IShare $share) {
+ $this->callback(function (IShare $share) {
$date = new \DateTime('2000-01-01');
$date->setTime(0, 0, 0);
- return $share->getPermissions() === (\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_CREATE | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE) &&
+ return $share->getPermissions() === (Constants::PERMISSION_READ | Constants::PERMISSION_CREATE | Constants::PERMISSION_UPDATE | Constants::PERMISSION_DELETE) &&
$share->getPassword() === 'password' &&
$share->getExpirationDate() == $date &&
$share->getNote() === 'note' &&
->willReturn(42);
$share = \OC::$server->getShareManager()->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_LINK)
->setPassword('password')
$this->shareManager->method('getSharedWith')->willReturn([]);
$this->shareManager->expects($this->once())->method('updateShare')->with(
- $this->callback(function (\OCP\Share\IShare $share) {
- return $share->getPermissions() === (\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_CREATE | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE) &&
+ $this->callback(function (IShare $share) {
+ return $share->getPermissions() === (Constants::PERMISSION_READ | Constants::PERMISSION_CREATE | Constants::PERMISSION_UPDATE | Constants::PERMISSION_DELETE) &&
$share->getPassword() === 'password' &&
$share->getExpirationDate() === null;
})
public function publicLinkValidPermissionsProvider() {
return [
- [\OCP\Constants::PERMISSION_CREATE],
- [\OCP\Constants::PERMISSION_READ],
- [\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_UPDATE],
- [\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_DELETE],
- [\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_CREATE],
+ [Constants::PERMISSION_CREATE],
+ [Constants::PERMISSION_READ],
+ [Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE],
+ [Constants::PERMISSION_READ | Constants::PERMISSION_DELETE],
+ [Constants::PERMISSION_READ | Constants::PERMISSION_CREATE],
];
}
->willReturn(42);
$share = \OC::$server->getShareManager()->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_LINK)
->setPassword('password')
public function publicLinkInvalidPermissionsProvider1() {
return [
- [\OCP\Constants::PERMISSION_DELETE],
- [\OCP\Constants::PERMISSION_UPDATE],
- [\OCP\Constants::PERMISSION_SHARE],
+ [Constants::PERMISSION_DELETE],
+ [Constants::PERMISSION_UPDATE],
+ [Constants::PERMISSION_SHARE],
];
}
* @dataProvider publicLinkInvalidPermissionsProvider1
*/
public function testUpdateLinkShareSetInvalidCRUDPermissions1($permissions): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSBadRequestException::class);
+ $this->expectException(OCSBadRequestException::class);
$this->expectExceptionMessage('Share must at least have READ or CREATE permissions');
$this->testUpdateLinkShareSetCRUDPermissions($permissions);
public function publicLinkInvalidPermissionsProvider2() {
return [
- [\OCP\Constants::PERMISSION_CREATE | \OCP\Constants::PERMISSION_DELETE],
- [\OCP\Constants::PERMISSION_CREATE | \OCP\Constants::PERMISSION_UPDATE],
+ [Constants::PERMISSION_CREATE | Constants::PERMISSION_DELETE],
+ [Constants::PERMISSION_CREATE | Constants::PERMISSION_UPDATE],
];
}
* @dataProvider publicLinkInvalidPermissionsProvider2
*/
public function testUpdateLinkShareSetInvalidCRUDPermissions2($permissions): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSBadRequestException::class);
+ $this->expectException(OCSBadRequestException::class);
$this->expectExceptionMessage('Share must have READ permission if UPDATE or DELETE permission is set');
$this->testUpdateLinkShareSetCRUDPermissions($permissions);
}
public function testUpdateLinkShareInvalidDate(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSBadRequestException::class);
+ $this->expectException(OCSBadRequestException::class);
$this->expectExceptionMessage('Invalid date. Format must be YYYY-MM-DD');
$ocs = $this->mockFormatShare();
->willReturn(42);
$share = \OC::$server->getShareManager()->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_LINK)
->setNode($folder);
[null, 'true', null, 'password'],
// legacy had no delete
[
- \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_CREATE | \OCP\Constants::PERMISSION_UPDATE,
+ Constants::PERMISSION_READ | Constants::PERMISSION_CREATE | Constants::PERMISSION_UPDATE,
'true', null, 'password'
],
// correct
[
- \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_CREATE | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE,
+ Constants::PERMISSION_READ | Constants::PERMISSION_CREATE | Constants::PERMISSION_UPDATE | Constants::PERMISSION_DELETE,
null, null, 'password'
],
];
* @dataProvider publicUploadParamsProvider
*/
public function testUpdateLinkSharePublicUploadNotAllowed($permissions, $publicUpload, $expireDate, $password): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSForbiddenException::class);
+ $this->expectException(OCSForbiddenException::class);
$this->expectExceptionMessage('Public upload disabled by the administrator');
$ocs = $this->mockFormatShare();
$folder->method('getId')->willReturn(42);
$share = \OC::$server->getShareManager()->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_LINK)
->setNode($folder);
public function testUpdateLinkSharePublicUploadOnFile(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSBadRequestException::class);
+ $this->expectException(OCSBadRequestException::class);
$this->expectExceptionMessage('Public upload is only possible for publicly shared folders');
$ocs = $this->mockFormatShare();
->willReturn($userFolder);
$share = \OC::$server->getShareManager()->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_LINK)
->setNode($file);
->with($this->currentUser)
->willReturn($userFolder);
$share = $this->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_LINK)
->setPassword('password')
->setNote('note')
->setLabel('label')
->setHideDownload(true)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ ->setPermissions(Constants::PERMISSION_ALL)
->setNode($node);
$node->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->shareManager->method('getShareById')->with('ocinternal:42')->willReturn($share);
$this->shareManager->expects($this->once())->method('updateShare')->with(
- $this->callback(function (\OCP\Share\IShare $share) use ($date) {
- return $share->getPermissions() === \OCP\Constants::PERMISSION_ALL &&
+ $this->callback(function (IShare $share) use ($date) {
+ return $share->getPermissions() === Constants::PERMISSION_ALL &&
$share->getPassword() === 'newpassword' &&
$share->getSendPasswordByTalk() === true &&
$share->getExpirationDate() === $date &&
->willReturn($userFolder);
$node->method('getId')->willReturn(42);
$share = $this->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_LINK)
->setPassword('password')
->setNote('note')
->setLabel('label')
->setHideDownload(true)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ ->setPermissions(Constants::PERMISSION_ALL)
->setNode($node);
$node->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->shareManager->method('getShareById')->with('ocinternal:42')->willReturn($share);
$this->appManager->method('isEnabledForUser')->with('spreed')->willReturn(true);
$this->shareManager->expects($this->once())->method('updateShare')->with(
- $this->callback(function (\OCP\Share\IShare $share) use ($date) {
- return $share->getPermissions() === \OCP\Constants::PERMISSION_ALL &&
+ $this->callback(function (IShare $share) use ($date) {
+ return $share->getPermissions() === Constants::PERMISSION_ALL &&
$share->getPassword() === 'password' &&
$share->getSendPasswordByTalk() === true &&
$share->getExpirationDate() === $date &&
public function testUpdateLinkShareSendPasswordByTalkWithTalkDisabledDoesNotChangeOther(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSForbiddenException::class);
+ $this->expectException(OCSForbiddenException::class);
$this->expectExceptionMessage('"Sending the password by Nextcloud Talk" for sharing a file or folder failed because Nextcloud Talk is not enabled.');
$ocs = $this->mockFormatShare();
->willReturn($userFolder);
$node->method('getId')->willReturn(42);
$share = $this->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_LINK)
->setPassword('password')
->setNote('note')
->setLabel('label')
->setHideDownload(true)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ ->setPermissions(Constants::PERMISSION_ALL)
->setNode($node);
$node->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->shareManager->method('getShareById')->with('ocinternal:42')->willReturn($share);
->willReturn($userFolder);
$node->method('getId')->willReturn(42);
$share = $this->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_LINK)
->setPassword('password')
->setNote('note')
->setLabel('label')
->setHideDownload(true)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ ->setPermissions(Constants::PERMISSION_ALL)
->setNode($node);
$node->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->shareManager->method('getShareById')->with('ocinternal:42')->willReturn($share);
$this->appManager->method('isEnabledForUser')->with('spreed')->willReturn(true);
$this->shareManager->expects($this->once())->method('updateShare')->with(
- $this->callback(function (\OCP\Share\IShare $share) use ($date) {
- return $share->getPermissions() === \OCP\Constants::PERMISSION_ALL &&
+ $this->callback(function (IShare $share) use ($date) {
+ return $share->getPermissions() === Constants::PERMISSION_ALL &&
$share->getPassword() === 'password' &&
$share->getSendPasswordByTalk() === false &&
$share->getExpirationDate() === $date &&
->willReturn(42);
$share = $this->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_LINK)
->setPassword('password')
->setNote('note')
->setLabel('label')
->setHideDownload(true)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ ->setPermissions(Constants::PERMISSION_ALL)
->setNode($node);
$node->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->shareManager->method('getShareById')->with('ocinternal:42')->willReturn($share);
$this->appManager->method('isEnabledForUser')->with('spreed')->willReturn(false);
$this->shareManager->expects($this->once())->method('updateShare')->with(
- $this->callback(function (\OCP\Share\IShare $share) use ($date) {
- return $share->getPermissions() === \OCP\Constants::PERMISSION_ALL &&
+ $this->callback(function (IShare $share) use ($date) {
+ return $share->getPermissions() === Constants::PERMISSION_ALL &&
$share->getPassword() === 'password' &&
$share->getSendPasswordByTalk() === false &&
$share->getExpirationDate() === $date &&
->willReturn(42);
$share = $this->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_LINK)
->setPassword('password')
->setNote('note')
->setLabel('label')
->setHideDownload(true)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ ->setPermissions(Constants::PERMISSION_ALL)
->setNode($node);
$node->expects($this->once())
->method('lock')
- ->with(\OCP\Lock\ILockingProvider::LOCK_SHARED);
+ ->with(ILockingProvider::LOCK_SHARED);
$this->shareManager->method('getShareById')->with('ocinternal:42')->willReturn($share);
$this->shareManager->expects($this->once())->method('updateShare')->with(
- $this->callback(function (\OCP\Share\IShare $share) {
+ $this->callback(function (IShare $share) {
$date = new \DateTime('2010-12-23');
$date->setTime(0, 0, 0);
- return $share->getPermissions() === \OCP\Constants::PERMISSION_ALL &&
+ return $share->getPermissions() === Constants::PERMISSION_ALL &&
$share->getPassword() === 'password' &&
$share->getSendPasswordByTalk() === true &&
$share->getExpirationDate() == $date &&
->willReturn(42);
$share = \OC::$server->getShareManager()->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_LINK)
->setPassword('password')
->setNote('note')
->setLabel('label')
->setHideDownload(true)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ ->setPermissions(Constants::PERMISSION_ALL)
->setNode($folder);
$this->shareManager->method('getShareById')->with('ocinternal:42')->willReturn($share);
$this->shareManager->method('shareApiLinkAllowPublicUpload')->willReturn(true);
$this->shareManager->expects($this->once())->method('updateShare')->with(
- $this->callback(function (\OCP\Share\IShare $share) use ($date) {
- return $share->getPermissions() === (\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_CREATE | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE) &&
+ $this->callback(function (IShare $share) use ($date) {
+ return $share->getPermissions() === (Constants::PERMISSION_READ | Constants::PERMISSION_CREATE | Constants::PERMISSION_UPDATE | Constants::PERMISSION_DELETE) &&
$share->getPassword() === 'password' &&
$share->getSendPasswordByTalk() === true &&
$share->getExpirationDate() === $date &&
->willReturn(42);
$share = \OC::$server->getShareManager()->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_LINK)
->setPassword('password')
->setNote('note')
->setLabel('label')
->setHideDownload(true)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ ->setPermissions(Constants::PERMISSION_ALL)
->setNode($folder);
$this->shareManager->method('getShareById')->with('ocinternal:42')->willReturn($share);
$this->shareManager->method('shareApiLinkAllowPublicUpload')->willReturn(true);
$this->shareManager->expects($this->once())->method('updateShare')->with(
- $this->callback(function (\OCP\Share\IShare $share) use ($date): bool {
- return $share->getPermissions() === (\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_CREATE | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE) &&
+ $this->callback(function (IShare $share) use ($date): bool {
+ return $share->getPermissions() === (Constants::PERMISSION_READ | Constants::PERMISSION_CREATE | Constants::PERMISSION_UPDATE | Constants::PERMISSION_DELETE) &&
$share->getPassword() === 'password' &&
$share->getSendPasswordByTalk() === true &&
$share->getExpirationDate() === $date &&
->willReturn(42);
$share = \OC::$server->getShareManager()->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_LINK)
->setPassword('password')
->setNote('note')
->setLabel('label')
->setHideDownload(true)
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($folder);
$this->shareManager->method('getShareById')->with('ocinternal:42')->willReturn($share);
$this->shareManager->method('shareApiLinkAllowPublicUpload')->willReturn(true);
$this->shareManager->expects($this->once())->method('updateShare')->with(
- $this->callback(function (\OCP\Share\IShare $share) use ($date) {
- return $share->getPermissions() === (\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_CREATE | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE) &&
+ $this->callback(function (IShare $share) use ($date) {
+ return $share->getPermissions() === (Constants::PERMISSION_READ | Constants::PERMISSION_CREATE | Constants::PERMISSION_UPDATE | Constants::PERMISSION_DELETE) &&
$share->getPassword() === 'password' &&
$share->getSendPasswordByTalk() === true &&
$share->getExpirationDate() === $date &&
->willReturn(42);
$share = \OC::$server->getShareManager()->newShare();
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL)
+ $share->setPermissions(Constants::PERMISSION_ALL)
->setSharedBy($this->currentUser)
->setShareType(IShare::TYPE_USER)
->setNode($file);
$this->shareManager->method('shareApiLinkAllowPublicUpload')->willReturn(true);
$this->shareManager->expects($this->once())->method('updateShare')->with(
- $this->callback(function (\OCP\Share\IShare $share) {
- return $share->getPermissions() === \OCP\Constants::PERMISSION_ALL;
+ $this->callback(function (IShare $share) {
+ return $share->getPermissions() === Constants::PERMISSION_ALL;
})
)->willReturnArgument(0);
->setShareOwner('anotheruser')
->setShareType(IShare::TYPE_GROUP)
->setSharedWith('group1')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($folder);
// note: updateShare will modify the received instance but getSharedWith will reread from the database,
->setShareOwner('anotheruser')
->setShareType(IShare::TYPE_GROUP)
->setSharedWith('group1')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($folder);
$this->request
->setShareOwner($this->currentUser)
->setShareType(IShare::TYPE_GROUP)
->setSharedWith('group1')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($folder);
// note: updateShare will modify the received instance but getSharedWith will reread from the database,
->setShareOwner($this->currentUser)
->setShareType(IShare::TYPE_GROUP)
->setSharedWith('group1')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($folder);
$this->shareManager->method('getShareById')->with('ocinternal:42')->willReturn($share);
->setSharedWith('recipient')
->setSharedBy('initiator')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setAttributes($shareAttributes)
->setNode($file)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setSharedWith('recipient')
->setSharedBy('initiator')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setTarget('myTarget')
->setSharedWith('recipient')
->setSharedBy('initiator')
->setShareOwner('currentUser')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setTarget('myTarget')
->setSharedWith('recipientGroup')
->setSharedBy('initiator')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setTarget('myTarget')
->setSharedWith('recipientGroup2')
->setSharedBy('initiator')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setTarget('myTarget')
$share->setShareType(IShare::TYPE_LINK)
->setSharedBy('initiator')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setTarget('myTarget')
$share->setShareType(IShare::TYPE_LINK)
->setSharedBy('initiator')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setTarget('myTarget')
->setSharedBy('initiator')
->setSharedWith('user@server.com')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($folder)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setExpirationDate(new \DateTime('2001-02-03T04:05:06'))
->setSharedBy('initiator')
->setSharedWith('user@server.com')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($folder)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setExpirationDate(new \DateTime('2001-02-03T04:05:06'))
->setSharedWithDisplayName('The display name')
->setSharedWithAvatar('path/to/the/avatar')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($folder)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setTarget('myTarget')
->setSharedBy('initiator')
->setSharedWith('Circle (Public circle, circleOwner) [4815162342]')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($folder)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setTarget('myTarget')
->setSharedBy('initiator')
->setSharedWith('Circle (Public circle, circleOwner)')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($folder)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setTarget('myTarget')
->setSharedBy('initiator')
->setSharedWith('recipient')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setTarget('myTarget')
->setNote('personal note')
->setSharedBy('initiator')
->setSharedWith('user@server.com')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($folder)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setTarget('myTarget')
->setSharedBy('initiator')
->setSharedWith('user@server.com')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($folder)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setTarget('myTarget')
->setSharedWith('recipient')
->setSharedBy('initiator')
->setShareOwner('currentUser')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($fileWithPreview)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setTarget('myTarget')
* @param array $users
* @param $exception
*/
- public function testFormatShare(array $expects, \OCP\Share\IShare $share, array $users, $exception): void {
+ public function testFormatShare(array $expects, IShare $share, array $users, $exception): void {
$this->userManager->method('get')->willReturnMap($users);
$recipientGroup = $this->createMock(IGroup::class);
->setSharedWith('recipientRoom')
->setSharedBy('initiator')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setTarget('myTarget')
->setSharedWith('recipientRoom')
->setSharedBy('initiator')
->setShareOwner('owner')
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file)
->setShareTime(new \DateTime('2000-01-01T00:01:02'))
->setTarget('myTarget')
* @param bool $helperAvailable
* @param array $formatShareByHelper
*/
- public function testFormatRoomShare(array $expects, \OCP\Share\IShare $share, bool $helperAvailable, array $formatShareByHelper): void {
+ public function testFormatRoomShare(array $expects, IShare $share, bool $helperAvailable, array $formatShareByHelper): void {
$this->rootFolder->method('getUserFolder')
->with($this->currentUser)
->willReturnSelf();
use OCP\Accounts\IAccountManager;
use OCP\Accounts\IAccountProperty;
use OCP\Activity\IManager;
+use OCP\AppFramework\Http\ContentSecurityPolicy;
use OCP\AppFramework\Http\DataResponse;
use OCP\AppFramework\Http\Template\ExternalShareMenuAction;
use OCP\AppFramework\Http\Template\LinkMenuAction;
use OCP\IUser;
use OCP\IUserManager;
use OCP\Security\ISecureRandom;
+use OCP\Server;
use OCP\Share\Exceptions\ShareNotFound;
use OCP\Share\IPublicShareTemplateFactory;
use OCP\Share\IShare;
)
);
- $this->shareController = new \OCA\Files_Sharing\Controller\ShareController(
+ $this->shareController = new ShareController(
$this->appName,
$this->createMock(IRequest::class),
$this->config,
->willReturn($account);
/** @var Manager */
- $manager = \OCP\Server::get(Manager::class);
+ $manager = Server::get(Manager::class);
$share = $manager->newShare();
$share->setId(42)
->setPermissions(Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE)
$this->assertEquals($expectedInitialState, $initialState);
- $csp = new \OCP\AppFramework\Http\ContentSecurityPolicy();
+ $csp = new ContentSecurityPolicy();
$csp->addAllowedFrameDomain('\'self\'');
$expectedResponse = new PublicTemplateResponse('files', 'index');
$expectedResponse->setContentSecurityPolicy($csp);
->willReturn($account);
/** @var Manager */
- $manager = \OCP\Server::get(Manager::class);
+ $manager = Server::get(Manager::class);
$share = $manager->newShare();
$share->setId(42)
->setPermissions(Constants::PERMISSION_CREATE)
$this->assertEquals($expectedInitialState, $initialState);
- $csp = new \OCP\AppFramework\Http\ContentSecurityPolicy();
+ $csp = new ContentSecurityPolicy();
$csp->addAllowedFrameDomain('\'self\'');
$expectedResponse = new PublicTemplateResponse('files', 'index');
$expectedResponse->setContentSecurityPolicy($csp);
->willReturn($account);
/** @var IShare */
- $share = \OCP\Server::get(Manager::class)->newShare();
+ $share = Server::get(Manager::class)->newShare();
$share->setId(42);
$share->setPassword('password')
->setShareOwner('ownerUID')
->setNode($file)
->setNote($note)
->setToken('token')
- ->setPermissions(\OCP\Constants::PERMISSION_ALL & ~\OCP\Constants::PERMISSION_SHARE)
+ ->setPermissions(Constants::PERMISSION_ALL & ~Constants::PERMISSION_SHARE)
->setTarget("/$filename");
$this->session->method('exists')->with('public_link_authenticated')->willReturn(true);
$response = $this->shareController->showShare();
- $csp = new \OCP\AppFramework\Http\ContentSecurityPolicy();
+ $csp = new ContentSecurityPolicy();
$csp->addAllowedFrameDomain('\'self\'');
$expectedResponse = new PublicTemplateResponse('files', 'index');
$expectedResponse->setContentSecurityPolicy($csp);
public function testShowShareInvalid(): void {
- $this->expectException(\OCP\Files\NotFoundException::class);
+ $this->expectException(NotFoundException::class);
$filename = 'file1.txt';
$this->shareController->setToken('token');
$share
->expects($this->once())
->method('getPermissions')
- ->willReturn(\OCP\Constants::PERMISSION_CREATE);
+ ->willReturn(Constants::PERMISSION_CREATE);
$this->shareManager
->expects($this->once())
use OCA\Files_Sharing\Controller\ShareesAPIController;
use OCA\Files_Sharing\Tests\TestCase;
-use OCP\AppFramework\Http;
use OCP\AppFramework\Http\DataResponse;
use OCP\AppFramework\OCS\OCSBadRequestException;
use OCP\Collaboration\Collaborators\ISearch;
}
});
- $this->assertInstanceOf(Http\DataResponse::class, $sharees->search($search, $itemType, $page, $perPage, $shareType));
+ $this->assertInstanceOf(DataResponse::class, $sharees->search($search, $itemType, $page, $perPage, $shareType));
}
public function dataSearchInvalid(): array {
}
public function testSearchNoItemType(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSBadRequestException::class);
+ $this->expectException(OCSBadRequestException::class);
$this->expectExceptionMessage('Missing itemType');
$this->sharees->search('', null, 1, 10, [], false);
*/
namespace OCA\Files_Sharing\Tests;
+use OC\Files\Filesystem;
use OCA\Files_Sharing\DeleteOrphanedSharesJob;
+use OCP\Constants;
+use OCP\Server;
use OCP\Share\IShare;
/**
$appManager->disableApp('files_trashbin');
// just in case...
- \OC\Files\Filesystem::getLoader()->removeStorageWrapper('oc_trashbin');
+ Filesystem::getLoader()->removeStorageWrapper('oc_trashbin');
}
public static function tearDownAfterClass(): void {
\OC::registerShareHooks(\OC::$server->getSystemConfig());
- $this->job = \OCP\Server::get(DeleteOrphanedSharesJob::class);
+ $this->job = Server::get(DeleteOrphanedSharesJob::class);
}
protected function tearDown(): void {
$share->setNode($testSubFolder)
->setShareType(IShare::TYPE_USER)
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setSharedWith($this->user2)
->setSharedBy($this->user1);
use OC\Files\Filesystem;
use OC\Files\View;
+use OCP\Constants;
use OCP\Share\IShare;
/**
->setShareType(IShare::TYPE_USER)
->setSharedWith(self::TEST_FILES_SHARING_API_USER2)
->setSharedBy(self::TEST_FILES_SHARING_API_USER1)
- ->setPermissions(\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_SHARE);
+ ->setPermissions(Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE | Constants::PERMISSION_SHARE);
$share = $shareManager->createShare($share);
$this->shareManager->acceptShare($share, self::TEST_FILES_SHARING_API_USER2);
$node = $rootFolder->getUserFolder(self::TEST_FILES_SHARING_API_USER1)
->setShareType(IShare::TYPE_USER)
->setSharedWith(self::TEST_FILES_SHARING_API_USER2)
->setSharedBy(self::TEST_FILES_SHARING_API_USER1)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = $shareManager->createShare($share);
$this->shareManager->acceptShare($share, self::TEST_FILES_SHARING_API_USER2);
->setShareType(IShare::TYPE_USER)
->setSharedWith(self::TEST_FILES_SHARING_API_USER3)
->setSharedBy(self::TEST_FILES_SHARING_API_USER1)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = $shareManager->createShare($share);
$this->shareManager->acceptShare($share, self::TEST_FILES_SHARING_API_USER3);
->setShareType(IShare::TYPE_USER)
->setSharedWith(self::TEST_FILES_SHARING_API_USER2)
->setSharedBy(self::TEST_FILES_SHARING_API_USER1)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = $shareManager->createShare($share);
$this->shareManager->acceptShare($share, self::TEST_FILES_SHARING_API_USER2);
->setShareType(IShare::TYPE_USER)
->setSharedWith(self::TEST_FILES_SHARING_API_USER4)
->setSharedBy(self::TEST_FILES_SHARING_API_USER2)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = $shareManager->createShare($share);
$this->shareManager->acceptShare($share, self::TEST_FILES_SHARING_API_USER4);
->setShareType(IShare::TYPE_USER)
->setSharedWith(self::TEST_FILES_SHARING_API_USER4)
->setSharedBy(self::TEST_FILES_SHARING_API_USER2)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = $shareManager->createShare($share);
$this->shareManager->acceptShare($share, self::TEST_FILES_SHARING_API_USER4);
$shares = $this->shareManager->getSharesBy(self::TEST_FILES_SHARING_API_USER1, IShare::TYPE_USER, $node);
/** @var \OCP\Share\IShare[] $shares */
- $shares = array_filter($shares, function (\OCP\Share\IShare $share) {
+ $shares = array_filter($shares, function (IShare $share) {
return $share->getSharedWith() === self::TEST_FILES_SHARING_API_USER2;
});
$this->assertCount(1, $shares);
$share = $shares[0];
- $share->setPermissions(\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_SHARE);
+ $share->setPermissions(Constants::PERMISSION_READ | Constants::PERMISSION_SHARE);
$this->shareManager->updateShare($share);
$this->assertEtagsForFoldersChanged([self::TEST_FILES_SHARING_API_USER2]);
use OCA\Files_Sharing\ExpireSharesJob;
use OCP\AppFramework\Utility\ITimeFactory;
+use OCP\Constants;
use OCP\Share\IManager;
use OCP\Share\IShare;
$share->setNode($testFolder)
->setShareType(IShare::TYPE_LINK)
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setSharedBy($this->user1);
$shareManager->createShare($share);
$share->setNode($testFolder)
->setShareType(IShare::TYPE_USER)
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setSharedBy($this->user1)
->setSharedWith($this->user2);
namespace OCA\Files_Sharing\Tests\External;
use OC\Federation\CloudIdManager;
+use OCA\Files_Sharing\External\Cache;
use OCA\Files_Sharing\Tests\TestCase;
use OCP\Contacts\IManager;
use OCP\EventDispatcher\IEventDispatcher;
private $storage;
/**
- * @var \OCA\Files_Sharing\External\Cache
+ * @var Cache
*/
private $cache;
->method('search')
->willReturn([]);
- $this->cache = new \OCA\Files_Sharing\External\Cache(
+ $this->cache = new Cache(
$this->storage,
$this->cloudIdManager->getCloudId($this->remoteUser, 'http://example.com/owncloud')
);
use OCP\IUser;
use OCP\IUserManager;
use OCP\IUserSession;
+use OCP\OCS\IDiscoveryService;
use OCP\Share\IShare;
use Psr\Log\LoggerInterface;
use Test\Traits\UserTrait;
new StorageFactory(),
$this->clientService,
\OC::$server->getNotificationManager(),
- \OC::$server->query(\OCP\OCS\IDiscoveryService::class),
+ \OC::$server->query(IDiscoveryService::class),
$this->cloudFederationProviderManager,
$this->cloudFederationFactory,
$this->groupManager,
namespace OCA\Files_Sharing\Tests\External;
use OCA\Files_Sharing\External\Scanner;
+use OCA\Files_Sharing\External\Storage;
use Test\TestCase;
/**
*/
class ScannerTest extends TestCase {
protected Scanner $scanner;
- /** @var \OCA\Files_Sharing\External\Storage|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var Storage|\PHPUnit\Framework\MockObject\MockObject */
protected $storage;
/** @var \OC\Files\Cache\Cache|\PHPUnit\Framework\MockObject\MockObject */
protected $cache;
use OC\Federation\CloudId;
use OCA\Files_Sharing\External\Manager as ExternalShareManager;
+use OCA\Files_Sharing\External\Storage;
use OCP\Http\Client\IClient;
use OCP\Http\Client\IClientService;
use OCP\Http\Client\IResponse;
/**
* Dummy subclass to make it possible to access private members
*/
-class TestSharingExternalStorage extends \OCA\Files_Sharing\External\Storage {
+class TestSharingExternalStorage extends Storage {
public function getBaseUri() {
return $this->createBaseUri();
}
use OC\Files\Filesystem;
use OC\Files\View;
+use OCP\Constants;
use OCP\Share\IShare;
/**
'/test',
self::TEST_FILES_SHARING_API_USER1,
'group1',
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
$this->shareManager->acceptShare($share, self::TEST_FILES_SHARING_API_USER2);
$this->fileIds[self::TEST_FILES_SHARING_API_USER1][''] = $view1->getFileInfo('')->getId();
'/test',
self::TEST_FILES_SHARING_API_USER2,
'group2',
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
$this->shareManager->acceptShare($share, self::TEST_FILES_SHARING_API_USER3);
$share = $this->share(
'/test/sub',
self::TEST_FILES_SHARING_API_USER2,
'group3',
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
$this->shareManager->acceptShare($share, self::TEST_FILES_SHARING_API_USER4);
*/
namespace OCA\Files_Sharing\Tests;
+use OC\Files\Filesystem;
+use OCA\Files_Sharing\Helper;
+
/**
* Class HelperTest
*
* test set and get share folder
*/
public function testSetGetShareFolder(): void {
- $this->assertSame('/', \OCA\Files_Sharing\Helper::getShareFolder());
+ $this->assertSame('/', Helper::getShareFolder());
- \OCA\Files_Sharing\Helper::setShareFolder('/Shared/Folder');
+ Helper::setShareFolder('/Shared/Folder');
- $sharedFolder = \OCA\Files_Sharing\Helper::getShareFolder();
- $this->assertSame('/Shared/Folder', \OCA\Files_Sharing\Helper::getShareFolder());
- $this->assertTrue(\OC\Files\Filesystem::is_dir($sharedFolder));
+ $sharedFolder = Helper::getShareFolder();
+ $this->assertSame('/Shared/Folder', Helper::getShareFolder());
+ $this->assertTrue(Filesystem::is_dir($sharedFolder));
// cleanup
\OC::$server->getConfig()->deleteSystemValue('share_folder');
use OC\Files\Filesystem;
use OC\Files\View;
+use OCP\Constants;
use OCP\Lock\ILockingProvider;
+use OCP\Lock\LockedException;
use OCP\Share\IShare;
/**
'/foo/bar.txt',
$this->ownerUid,
$this->recipientUid,
- \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_SHARE
+ Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE | Constants::PERMISSION_SHARE
);
$this->loginAsUser($this->recipientUid);
public function testLockAsRecipient(): void {
- $this->expectException(\OCP\Lock\LockedException::class);
+ $this->expectException(LockedException::class);
$this->loginAsUser($this->ownerUid);
use OCP\AppFramework\Controller;
use OCP\AppFramework\Http;
use OCP\AppFramework\Http\JSONResponse;
+use OCP\AppFramework\Http\Response;
use OCP\Share\IManager as ShareManager;
use Test\TestCase;
}
public function testAfterControllerNoShareInfo(): void {
- $response = $this->createMock(Http\Response::class);
+ $response = $this->createMock(Response::class);
$this->assertEquals(
$response,
}
public function testAfterControllerNoJSON(): void {
- $response = $this->createMock(Http\Response::class);
+ $response = $this->createMock(Response::class);
$this->assertEquals(
$response,
public function testBeforeControllerWithSharingDisabled(): void {
- $this->expectException(\OCP\Files\NotFoundException::class);
+ $this->expectException(NotFoundException::class);
$this->expectExceptionMessage('Sharing is disabled.');
$this->appManager
namespace OCA\Files_Sharing\Tests;
use OC\Memcache\NullCache;
+use OC\Share20\Share;
use OCA\Files_Sharing\MountProvider;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\Files\IRootFolder;
$this->shareManager->expects($this->any())
->method('newShare')
->willReturnCallback(function () use ($rootFolder, $userManager) {
- return new \OC\Share20\Share($rootFolder, $userManager);
+ return new Share($rootFolder, $userManager);
});
$mounts = $this->provider->getMountsForUser($this->user, $this->loader);
$this->assertCount(4, $mounts);
$this->shareManager->expects($this->any())
->method('newShare')
->willReturnCallback(function () use ($rootFolder, $userManager) {
- return new \OC\Share20\Share($rootFolder, $userManager);
+ return new Share($rootFolder, $userManager);
});
if ($moveFails) {
*/
namespace OCA\Files_Sharing\Tests;
+use OCA\Files_Sharing\Helper;
+
abstract class PropagationTestCase extends TestCase {
/**
* @var \OC\Files\View
public static function setUpBeforeClass(): void {
parent::setUpBeforeClass();
- \OCA\Files_Sharing\Helper::registerHooks();
+ Helper::registerHooks();
}
protected function setUp(): void {
*/
namespace OCA\Files_Sharing\Tests;
+use OC\Files\Filesystem;
+use OCA\Files_Sharing\Helper;
+use OCP\Constants;
use OCP\Share\IShare;
/**
$this->filename,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_SHARE
+ Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE | Constants::PERMISSION_SHARE
);
$share2 = $this->share(
$this->filename,
self::TEST_FILES_SHARING_API_USER1,
'testGroup',
- \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_SHARE
+ Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE | Constants::PERMISSION_SHARE
);
$this->shareManager->acceptShare($share2, self::TEST_FILES_SHARING_API_USER2);
$this->shareManager->acceptShare($share2, self::TEST_FILES_SHARING_API_USER3);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $this->assertTrue(\OC\Files\Filesystem::file_exists($this->filename));
+ $this->assertTrue(Filesystem::file_exists($this->filename));
self::loginHelper(self::TEST_FILES_SHARING_API_USER3);
- $this->assertTrue(\OC\Files\Filesystem::file_exists($this->filename));
+ $this->assertTrue(Filesystem::file_exists($this->filename));
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- \OC\Files\Filesystem::unlink($this->filename);
+ Filesystem::unlink($this->filename);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
// both group share and user share should be gone
- $this->assertFalse(\OC\Files\Filesystem::file_exists($this->filename));
+ $this->assertFalse(Filesystem::file_exists($this->filename));
// for user3 nothing should change
self::loginHelper(self::TEST_FILES_SHARING_API_USER3);
- $this->assertTrue(\OC\Files\Filesystem::file_exists($this->filename));
+ $this->assertTrue(Filesystem::file_exists($this->filename));
$this->shareManager->deleteShare($share1);
$this->shareManager->deleteShare($share2);
$this->filename,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_SHARE
+ Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE | Constants::PERMISSION_SHARE
);
- \OCA\Files_Sharing\Helper::setShareFolder('/Shared/subfolder');
+ Helper::setShareFolder('/Shared/subfolder');
$share = $this->share(
IShare::TYPE_USER,
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $this->assertTrue(\OC\Files\Filesystem::file_exists($this->filename));
- $this->assertTrue(\OC\Files\Filesystem::file_exists('/Shared/subfolder/' . $this->folder));
+ $this->assertTrue(Filesystem::file_exists($this->filename));
+ $this->assertTrue(Filesystem::file_exists('/Shared/subfolder/' . $this->folder));
//cleanup
\OC::$server->getConfig()->deleteSystemValue('share_folder');
$this->markTestSkipped('TODO: Disable because fails on drone');
$this->loginHelper(self::TEST_FILES_SHARING_API_USER1);
- \OC\Files\Filesystem::file_put_contents('test.txt', 'test');
+ Filesystem::file_put_contents('test.txt', 'test');
$share = $this->share(
IShare::TYPE_GROUP,
'test.txt',
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_GROUP1,
- \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_SHARE
+ Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE | Constants::PERMISSION_SHARE
);
$this->loginHelper(self::TEST_FILES_SHARING_API_USER2);
$this->assertSame('/test.txt', $share->getTarget());
$this->assertSame(19, $share->getPermissions());
- \OC\Files\Filesystem::rename('test.txt', 'new test.txt');
+ Filesystem::rename('test.txt', 'new test.txt');
$shares = $this->shareManager->getSharedWith(self::TEST_FILES_SHARING_API_USER2, IShare::TYPE_GROUP);
$share = $shares[0];
$this->assertSame('/new test.txt', $share->getTarget());
$this->assertSame(19, $share->getPermissions());
- $share->setPermissions(\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_UPDATE);
+ $share->setPermissions(Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE);
$this->shareManager->updateShare($share);
$this->loginHelper(self::TEST_FILES_SHARING_API_USER2);
}
public function dataProviderTestFileSharePermissions() {
- $permission1 = \OCP\Constants::PERMISSION_ALL;
- $permission3 = \OCP\Constants::PERMISSION_READ;
- $permission4 = \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_UPDATE;
- $permission5 = \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_DELETE;
- $permission6 = \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_DELETE;
+ $permission1 = Constants::PERMISSION_ALL;
+ $permission3 = Constants::PERMISSION_READ;
+ $permission4 = Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE;
+ $permission5 = Constants::PERMISSION_READ | Constants::PERMISSION_DELETE;
+ $permission6 = Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE | Constants::PERMISSION_DELETE;
return [
[$permission1, false],
$this->filename,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_READ
+ Constants::PERMISSION_READ
);
$this->loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $info = \OC\Files\Filesystem::getFileInfo($this->filename);
+ $info = Filesystem::getFileInfo($this->filename);
$this->assertSame(self::TEST_FILES_SHARING_API_USER1, $info->getOwner()->getUID());
}
*/
namespace OCA\Files_Sharing\Tests;
+use OC\Files\Filesystem;
+use OC\Files\View;
use OC\Memcache\ArrayCache;
use OCA\Files_Sharing\MountProvider;
+use OCA\Files_Sharing\SharedMount;
+use OCP\Constants;
use OCP\ICacheFactory;
use OCP\IGroupManager;
use OCP\IUserManager;
+use OCP\Server;
use OCP\Share\IShare;
/**
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL);
+ Constants::PERMISSION_ALL);
$this->shareManager->acceptShare($share, self::TEST_FILES_SHARING_API_USER2);
$share->setTarget('/foo/bar' . $this->folder);
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $user2View = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+ $user2View = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
$this->assertTrue($user2View->file_exists($this->folder));
// create a local folder
$this->filename,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_SHARE
+ Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE | Constants::PERMISSION_SHARE
);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- \OC\Files\Filesystem::rename($this->filename, $this->filename . '_renamed');
+ Filesystem::rename($this->filename, $this->filename . '_renamed');
- $this->assertTrue(\OC\Files\Filesystem::file_exists($this->filename . '_renamed'));
- $this->assertFalse(\OC\Files\Filesystem::file_exists($this->filename));
+ $this->assertTrue(Filesystem::file_exists($this->filename . '_renamed'));
+ $this->assertFalse(Filesystem::file_exists($this->filename));
self::loginHelper(self::TEST_FILES_SHARING_API_USER1);
- $this->assertTrue(\OC\Files\Filesystem::file_exists($this->filename));
- $this->assertFalse(\OC\Files\Filesystem::file_exists($this->filename . '_renamed'));
+ $this->assertTrue(Filesystem::file_exists($this->filename));
+ $this->assertFalse(Filesystem::file_exists($this->filename . '_renamed'));
// rename back to original name
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- \OC\Files\Filesystem::rename($this->filename . '_renamed', $this->filename);
- $this->assertFalse(\OC\Files\Filesystem::file_exists($this->filename . '_renamed'));
- $this->assertTrue(\OC\Files\Filesystem::file_exists($this->filename));
+ Filesystem::rename($this->filename . '_renamed', $this->filename);
+ $this->assertFalse(Filesystem::file_exists($this->filename . '_renamed'));
+ $this->assertTrue(Filesystem::file_exists($this->filename));
//cleanup
$this->shareManager->deleteShare($share);
$this->filename,
self::TEST_FILES_SHARING_API_USER1,
'testGroup',
- \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_SHARE
+ Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE | Constants::PERMISSION_SHARE
);
$this->shareManager->acceptShare($share, $user1->getUID());
$this->shareManager->acceptShare($share, $user2->getUID());
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $this->assertTrue(\OC\Files\Filesystem::file_exists($this->filename));
+ $this->assertTrue(Filesystem::file_exists($this->filename));
- \OC\Files\Filesystem::rename($this->filename, 'newFileName');
+ Filesystem::rename($this->filename, 'newFileName');
- $this->assertTrue(\OC\Files\Filesystem::file_exists('newFileName'));
- $this->assertFalse(\OC\Files\Filesystem::file_exists($this->filename));
+ $this->assertTrue(Filesystem::file_exists('newFileName'));
+ $this->assertFalse(Filesystem::file_exists($this->filename));
self::loginHelper(self::TEST_FILES_SHARING_API_USER3);
- $this->assertTrue(\OC\Files\Filesystem::file_exists($this->filename));
- $this->assertFalse(\OC\Files\Filesystem::file_exists('newFileName'));
+ $this->assertTrue(Filesystem::file_exists($this->filename));
+ $this->assertFalse(Filesystem::file_exists('newFileName'));
self::loginHelper(self::TEST_FILES_SHARING_API_USER3);
- $this->assertTrue(\OC\Files\Filesystem::file_exists($this->filename));
- $this->assertFalse(\OC\Files\Filesystem::file_exists('newFileName'));
+ $this->assertTrue(Filesystem::file_exists($this->filename));
+ $this->assertFalse(Filesystem::file_exists('newFileName'));
//cleanup
self::loginHelper(self::TEST_FILES_SHARING_API_USER1);
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
'testGroup',
- \OCP\Constants::PERMISSION_READ
+ Constants::PERMISSION_READ
);
$this->shareManager->acceptShare($share, $user1->getUID());
$this->shareManager->acceptShare($share, $user2->getUID());
// Login as user 2 and verify the item exists
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $this->assertTrue(\OC\Files\Filesystem::file_exists($this->folder));
+ $this->assertTrue(Filesystem::file_exists($this->folder));
$result = $this->shareManager->getShareById($share->getFullId(), self::TEST_FILES_SHARING_API_USER2);
$this->assertNotEmpty($result);
- $this->assertEquals(\OCP\Constants::PERMISSION_READ, $result->getPermissions());
+ $this->assertEquals(Constants::PERMISSION_READ, $result->getPermissions());
// Delete the share
- $this->assertTrue(\OC\Files\Filesystem::rmdir($this->folder));
- $this->assertFalse(\OC\Files\Filesystem::file_exists($this->folder));
+ $this->assertTrue(Filesystem::rmdir($this->folder));
+ $this->assertFalse(Filesystem::file_exists($this->folder));
// Verify we do not get a share
$result = $this->shareManager->getShareById($share->getFullId(), self::TEST_FILES_SHARING_API_USER2);
// Login as user 1 again and change permissions
self::loginHelper(self::TEST_FILES_SHARING_API_USER1);
- $share->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ $share->setPermissions(Constants::PERMISSION_ALL);
$share = $this->shareManager->updateShare($share);
// Login as user 2 and verify
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $this->assertFalse(\OC\Files\Filesystem::file_exists($this->folder));
+ $this->assertFalse(Filesystem::file_exists($this->folder));
$result = $this->shareManager->getShareById($share->getFullId(), self::TEST_FILES_SHARING_API_USER2);
$this->assertEquals(0, $result->getPermissions());
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL);
+ Constants::PERMISSION_ALL);
$this->shareManager->acceptShare($share, self::TEST_FILES_SHARING_API_USER2);
$share->setTarget('/bar');
});
// hack to overwrite the cache factory, we can't use the proper "overwriteService" since the mount provider is created before this test is called
- $mountProvider = \OCP\Server::get(MountProvider::class);
+ $mountProvider = Server::get(MountProvider::class);
$reflectionClass = new \ReflectionClass($mountProvider);
$reflectionCacheFactory = $reflectionClass->getProperty('cacheFactory');
$reflectionCacheFactory->setAccessible(true);
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL);
+ Constants::PERMISSION_ALL);
$this->shareManager->acceptShare($share, self::TEST_FILES_SHARING_API_USER2);
$share->setTarget('/foobar');
$this->folder2,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL);
+ Constants::PERMISSION_ALL);
$this->shareManager->acceptShare($share2, self::TEST_FILES_SHARING_API_USER2);
$share2->setTarget('/foobar');
}
}
-class DummyTestClassSharedMount extends \OCA\Files_Sharing\SharedMount {
+class DummyTestClassSharedMount extends SharedMount {
public function __construct($storage, $mountpoint, $arguments = null, $loader = null) {
// noop
}
*/
namespace OCA\Files_Sharing\Tests;
+use OC\Files\Cache\FailedCache;
+use OC\Files\Filesystem;
+use OC\Files\Storage\FailedStorage;
+use OC\Files\Storage\Temporary;
use OC\Files\View;
use OCA\Files_Sharing\SharedStorage;
use OCA\Files_Trashbin\AppInfo\Application;
use OCP\AppFramework\Bootstrap\IBootContext;
+use OCP\Constants;
use OCP\Files\NotFoundException;
use OCP\Share\IShare;
}
}
- \OC\Files\Filesystem::getLoader()->removeStorageWrapper('oc_trashbin');
+ Filesystem::getLoader()->removeStorageWrapper('oc_trashbin');
parent::tearDown();
}
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $user2View = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+ $user2View = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
$this->assertTrue($user2View->file_exists($this->folder));
// create a local folder
// delete the local folder
/** @var \OC\Files\Storage\Storage $storage */
- [$storage, $internalPath] = \OC\Files\Filesystem::resolvePath('/' . self::TEST_FILES_SHARING_API_USER2 . '/files/localfolder');
+ [$storage, $internalPath] = Filesystem::resolvePath('/' . self::TEST_FILES_SHARING_API_USER2 . '/files/localfolder');
$storage->rmdir($internalPath);
//enforce reload of the mount points
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $user2View = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+ $user2View = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
$this->assertTrue($user2View->file_exists($this->folder));
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
$share2 = $this->share(
$this->filename,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_SHARE
+ Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE | Constants::PERMISSION_SHARE
);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
// compare file size between user1 and user2, should always be the same
- $this->assertSame($folderSize, \OC\Files\Filesystem::filesize($this->folder));
- $this->assertSame($file1Size, \OC\Files\Filesystem::filesize($this->folder . $this->filename));
- $this->assertSame($file2Size, \OC\Files\Filesystem::filesize($this->filename));
+ $this->assertSame($folderSize, Filesystem::filesize($this->folder));
+ $this->assertSame($file1Size, Filesystem::filesize($this->folder . $this->filename));
+ $this->assertSame($file2Size, Filesystem::filesize($this->filename));
//cleanup
$this->shareManager->deleteShare($share1);
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_READ
+ Constants::PERMISSION_READ
);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $this->assertTrue(\OC\Files\Filesystem::is_dir($this->folder));
+ $this->assertTrue(Filesystem::is_dir($this->folder));
// for the share root we expect:
// the read permissions (1)
// the delete permission (8), to enable unshare
- $rootInfo = \OC\Files\Filesystem::getFileInfo($this->folder);
+ $rootInfo = Filesystem::getFileInfo($this->folder);
$this->assertSame(9, $rootInfo->getPermissions());
// for the file within the shared folder we expect:
// the read permissions (1)
- $subfileInfo = \OC\Files\Filesystem::getFileInfo($this->folder . $this->filename);
+ $subfileInfo = Filesystem::getFileInfo($this->folder . $this->filename);
$this->assertSame(1, $subfileInfo->getPermissions());
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_READ
+ Constants::PERMISSION_READ
);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $user2View = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+ $user2View = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
// part file should be forbidden
$handle = $user2View->fopen($this->folder . '/test.txt.part', 'w');
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_CREATE
+ Constants::PERMISSION_READ | Constants::PERMISSION_CREATE
);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $user2View = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+ $user2View = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
// create part file allowed
$handle = $user2View->fopen($this->folder . '/test.txt.part', 'w');
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_UPDATE
+ Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE
);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $user2View = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+ $user2View = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
// create part file allowed
$handle = $user2View->fopen($this->folder . '/test.txt.part', 'w');
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_DELETE
+ Constants::PERMISSION_READ | Constants::PERMISSION_DELETE
);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $user2View = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+ $user2View = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
// part file should be forbidden
$handle = $user2View->fopen($this->folder . '/test.txt.part', 'w');
}
public function testMountSharesOtherUser(): void {
- $rootView = new \OC\Files\View('');
+ $rootView = new View('');
self::loginHelper(self::TEST_FILES_SHARING_API_USER1);
// share 2 different files with 2 different users
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
$share2 = $this->share(
IShare::TYPE_USER,
$this->filename,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER3,
- \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_SHARE
+ Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE | Constants::PERMISSION_SHARE
);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
$mountConfigManager = \OC::$server->getMountProviderCollection();
$mounts = $mountConfigManager->getMountsForUser(\OC::$server->getUserManager()->get(self::TEST_FILES_SHARING_API_USER3));
- array_walk($mounts, [\OC\Files\Filesystem::getMountManager(), 'addMount']);
+ array_walk($mounts, [Filesystem::getMountManager(), 'addMount']);
$this->assertTrue($rootView->file_exists('/' . self::TEST_FILES_SHARING_API_USER3 . '/files/' . $this->filename));
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $view = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+ $view = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
$this->assertTrue($view->file_exists($this->folder));
[$sharedStorage,] = $view->resolvePath($this->folder);
$this->assertTrue($sharedStorage->instanceOfStorage('OCA\Files_Sharing\ISharedStorage'));
- $sourceStorage = new \OC\Files\Storage\Temporary([]);
+ $sourceStorage = new Temporary([]);
$sourceStorage->file_put_contents('foo.txt', 'asd');
$sharedStorage->copyFromStorage($sourceStorage, 'foo.txt', 'bar.txt');
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $view = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+ $view = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
$this->assertTrue($view->file_exists($this->folder));
[$sharedStorage,] = $view->resolvePath($this->folder);
$this->assertTrue($sharedStorage->instanceOfStorage('OCA\Files_Sharing\ISharedStorage'));
- $sourceStorage = new \OC\Files\Storage\Temporary([]);
+ $sourceStorage = new Temporary([]);
$sourceStorage->file_put_contents('foo.txt', 'asd');
$sourceStorage->getScanner()->scan('');
public function testNameConflict(): void {
self::loginHelper(self::TEST_FILES_SHARING_API_USER1);
- $view1 = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER1 . '/files');
+ $view1 = new View('/' . self::TEST_FILES_SHARING_API_USER1 . '/files');
$view1->mkdir('foo');
self::loginHelper(self::TEST_FILES_SHARING_API_USER3);
- $view3 = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER3 . '/files');
+ $view3 = new View('/' . self::TEST_FILES_SHARING_API_USER3 . '/files');
$view3->mkdir('foo');
// share a folder with the same name from two different users to the same user
'foo',
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_GROUP1,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
$this->shareManager->acceptShare($share1, self::TEST_FILES_SHARING_API_USER2);
'foo',
self::TEST_FILES_SHARING_API_USER3,
self::TEST_FILES_SHARING_API_GROUP1,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
$this->shareManager->acceptShare($share2, self::TEST_FILES_SHARING_API_USER2);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $view2 = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+ $view2 = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
$this->assertTrue($view2->file_exists('/foo'));
$this->assertTrue($view2->file_exists('/foo (2)'));
$mount = $view2->getMount('/foo');
$this->assertInstanceOf('\OCA\Files_Sharing\SharedMount', $mount);
- /** @var \OCA\Files_Sharing\SharedStorage $storage */
+ /** @var SharedStorage $storage */
$storage = $mount->getStorage();
$this->assertEquals(self::TEST_FILES_SHARING_API_USER1, $storage->getOwner(''));
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL - \OCP\Constants::PERMISSION_DELETE
+ Constants::PERMISSION_ALL - Constants::PERMISSION_DELETE
);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $view = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+ $view = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
$this->assertTrue($view->file_exists($this->folder));
$view->file_put_contents($this->folder . '/newfile.txt', 'asd');
self::loginHelper(self::TEST_FILES_SHARING_API_USER1);
$this->assertTrue($this->view->file_exists($this->folder . '/newfile.txt'));
- $this->assertEquals(\OCP\Constants::PERMISSION_ALL - \OCP\Constants::PERMISSION_CREATE,
+ $this->assertEquals(Constants::PERMISSION_ALL - Constants::PERMISSION_CREATE,
$this->view->getFileInfo($this->folder . '/newfile.txt')->getPermissions());
$this->view->unlink($this->folder);
]);
// trigger init
- $this->assertInstanceOf(\OC\Files\Storage\FailedStorage::class, $storage->getSourceStorage());
- $this->assertInstanceOf(\OC\Files\Cache\FailedCache::class, $storage->getCache());
+ $this->assertInstanceOf(FailedStorage::class, $storage->getSourceStorage());
+ $this->assertInstanceOf(FailedCache::class, $storage->getCache());
}
public function testInitWithNotFoundSource(): void {
]);
// trigger init
- $this->assertInstanceOf(\OC\Files\Storage\FailedStorage::class, $storage->getSourceStorage());
- $this->assertInstanceOf(\OC\Files\Cache\FailedCache::class, $storage->getCache());
+ $this->assertInstanceOf(FailedStorage::class, $storage->getSourceStorage());
+ $this->assertInstanceOf(FailedCache::class, $storage->getCache());
}
}
namespace OCA\Files_Sharing\Tests;
use OC\Files\View;
+use OCP\Constants;
use OCP\Share\IShare;
use Test\Traits\UserTrait;
'/sharedfolder',
self::TEST_FILES_SHARING_API_USER2,
self::TEST_FILES_SHARING_API_USER1,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
$ownerRootInfo = $ownerView->getFileInfo('', false);
'/sharedfolder',
self::TEST_FILES_SHARING_API_USER2,
self::TEST_FILES_SHARING_API_USER1,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
$ownerRootInfo = $ownerView->getFileInfo('', false);
*/
namespace OCA\Files_Sharing\Tests;
+use OC\Files\Cache\Storage;
use OC\Files\Filesystem;
+use OC\Files\View;
+use OC\Group\Database;
use OC\User\DisplayNameCache;
use OCA\Files_Sharing\AppInfo\Application;
use OCA\Files_Sharing\External\MountProvider as ExternalMountProvider;
self::loginHelper(self::TEST_FILES_SHARING_API_USER1);
$this->data = 'foobar';
- $this->view = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER1 . '/files');
- $this->view2 = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+ $this->view = new View('/' . self::TEST_FILES_SHARING_API_USER1 . '/files');
+ $this->view2 = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
$this->shareManager = \OC::$server->getShareManager();
$this->rootFolder = \OC::$server->getRootFolder();
\OC_User::clearBackends();
\OC_User::useBackend('database');
\OC::$server->getGroupManager()->clearBackends();
- \OC::$server->getGroupManager()->addBackend(new \OC\Group\Database());
+ \OC::$server->getGroupManager()->addBackend(new Database());
parent::tearDownAfterClass();
}
}
\OC_Util::tearDownFS();
- \OC\Files\Cache\Storage::getGlobalCache()->clearCache();
+ Storage::getGlobalCache()->clearCache();
\OC::$server->getUserSession()->setUser(null);
- \OC\Files\Filesystem::tearDown();
+ Filesystem::tearDown();
\OC::$server->getUserSession()->login($user, $password);
\OC::$server->getUserFolder($user);
*/
namespace OCA\Files_Sharing\Tests;
+use OC\Files\Filesystem;
+use OCP\Constants;
use OCP\Share\IShare;
+use OCP\Util;
/**
* Class UnshareChildrenTest
protected function setUp(): void {
parent::setUp();
- \OCP\Util::connectHook('OC_Filesystem', 'post_delete', '\OCA\Files_Sharing\Hooks', 'unshareChildren');
+ Util::connectHook('OC_Filesystem', 'post_delete', '\OCA\Files_Sharing\Hooks', 'unshareChildren');
$this->folder = self::TEST_FOLDER_NAME;
$this->subfolder = '/subfolder_share_api_test';
* @medium
*/
public function testUnshareChildren(): void {
- $fileInfo2 = \OC\Files\Filesystem::getFileInfo($this->folder);
+ $fileInfo2 = Filesystem::getFileInfo($this->folder);
$this->share(
IShare::TYPE_USER,
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
$this->assertCount(1, $shares);
// move shared folder to 'localDir'
- \OC\Files\Filesystem::mkdir('localDir');
- $result = \OC\Files\Filesystem::rename($this->folder, '/localDir/' . $this->folder);
+ Filesystem::mkdir('localDir');
+ $result = Filesystem::rename($this->folder, '/localDir/' . $this->folder);
$this->assertTrue($result);
- \OC\Files\Filesystem::unlink('localDir');
+ Filesystem::unlink('localDir');
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
self::loginHelper(self::TEST_FILES_SHARING_API_USER1);
// the folder for the owner should still exists
- $this->assertTrue(\OC\Files\Filesystem::file_exists($this->folder));
+ $this->assertTrue(Filesystem::file_exists($this->folder));
}
}
*/
namespace OCA\Files_Sharing\Tests;
+use OC\Files\FileInfo;
+use OC\Files\Filesystem;
+use OC\Files\View;
+use OCA\Files_Sharing\Helper;
use OCA\Files_Trashbin\AppInfo\Application;
use OCP\AppFramework\Bootstrap\IBootContext;
+use OCP\Constants;
use OCP\Share\IShare;
/**
public static function setUpBeforeClass(): void {
parent::setUpBeforeClass();
- \OCA\Files_Sharing\Helper::registerHooks();
+ Helper::registerHooks();
}
protected function setUp(): void {
$trashbinApp = new Application();
$trashbinApp->boot($this->createMock(IBootContext::class));
- $fileinfo = \OC\Files\Filesystem::getFileInfo($this->folder);
- $this->assertTrue($fileinfo instanceof \OC\Files\FileInfo);
+ $fileinfo = Filesystem::getFileInfo($this->folder);
+ $this->assertTrue($fileinfo instanceof FileInfo);
$this->share(
IShare::TYPE_USER,
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
$this->loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $view = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+ $view = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
// check if user2 can see the shared folder
$this->assertTrue($view->file_exists($this->folder));
$this->assertCount(0, $foldersShared);
// trashbin should contain the local file but not the mount point
- $rootView = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2);
+ $rootView = new View('/' . self::TEST_FILES_SHARING_API_USER2);
$trashContent = \OCA\Files_Trashbin\Helper::getTrashFiles('/', self::TEST_FILES_SHARING_API_USER2);
$this->assertSame(1, count($trashContent));
$firstElement = reset($trashContent);
\OC::$server->getAppManager()->disableApp('files_trashbin');
}
- \OC\Files\Filesystem::getLoader()->removeStorageWrapper('oc_trashbin');
+ Filesystem::getLoader()->removeStorageWrapper('oc_trashbin');
}
public function shareFolderProvider() {
$this->loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $beforeShareRoot = \OC\Files\Filesystem::getFileInfo('');
+ $beforeShareRoot = Filesystem::getFileInfo('');
$etagBeforeShareRoot = $beforeShareRoot->getEtag();
- \OC\Files\Filesystem::mkdir($shareFolder);
+ Filesystem::mkdir($shareFolder);
- $beforeShareDir = \OC\Files\Filesystem::getFileInfo($shareFolder);
+ $beforeShareDir = Filesystem::getFileInfo($shareFolder);
$etagBeforeShareDir = $beforeShareDir->getEtag();
$this->loginHelper(self::TEST_FILES_SHARING_API_USER1);
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
$this->loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $afterShareRoot = \OC\Files\Filesystem::getFileInfo('');
+ $afterShareRoot = Filesystem::getFileInfo('');
$etagAfterShareRoot = $afterShareRoot->getEtag();
- $afterShareDir = \OC\Files\Filesystem::getFileInfo($shareFolder);
+ $afterShareDir = Filesystem::getFileInfo($shareFolder);
$etagAfterShareDir = $afterShareDir->getEtag();
$this->assertTrue(is_string($etagBeforeShareRoot));
* if a folder gets renamed all children mount points should be renamed too
*/
public function testRename(): void {
- $fileinfo = \OC\Files\Filesystem::getFileInfo($this->folder);
+ $fileinfo = Filesystem::getFileInfo($this->folder);
$share = $this->share(
IShare::TYPE_USER,
$this->folder,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
$this->loginHelper(self::TEST_FILES_SHARING_API_USER2);
// make sure that the shared folder exists
- $this->assertTrue(\OC\Files\Filesystem::file_exists($this->folder));
+ $this->assertTrue(Filesystem::file_exists($this->folder));
- \OC\Files\Filesystem::mkdir('oldTarget');
- \OC\Files\Filesystem::mkdir('oldTarget/subfolder');
- \OC\Files\Filesystem::mkdir('newTarget');
+ Filesystem::mkdir('oldTarget');
+ Filesystem::mkdir('oldTarget/subfolder');
+ Filesystem::mkdir('newTarget');
- \OC\Files\Filesystem::rename($this->folder, 'oldTarget/subfolder/' . $this->folder);
+ Filesystem::rename($this->folder, 'oldTarget/subfolder/' . $this->folder);
// re-login to make sure that the new mount points are initialized
$this->loginHelper(self::TEST_FILES_SHARING_API_USER2);
- \OC\Files\Filesystem::rename('/oldTarget', '/newTarget/oldTarget');
+ Filesystem::rename('/oldTarget', '/newTarget/oldTarget');
// re-login to make sure that the new mount points are initialized
$this->loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $this->assertTrue(\OC\Files\Filesystem::file_exists('/newTarget/oldTarget/subfolder/' . $this->folder));
+ $this->assertTrue(Filesystem::file_exists('/newTarget/oldTarget/subfolder/' . $this->folder));
// cleanup
$this->shareManager->deleteShare($share);
$this->markTestSkipped('Skipped because this is failing with S3 as primary as file id are change when moved.');
// user1 creates folder1
- $viewUser1 = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER1 . '/files');
+ $viewUser1 = new View('/' . self::TEST_FILES_SHARING_API_USER1 . '/files');
$folder1 = 'folder1';
$viewUser1->mkdir($folder1);
$folder1,
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_SHARE
+ Constants::PERMISSION_READ | Constants::PERMISSION_SHARE
);
$this->loginHelper(self::TEST_FILES_SHARING_API_USER2);
- $viewUser2 = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+ $viewUser2 = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
// Create user2 files
$folder2 = 'folder2';
$viewUser2->mkdir($folder2);
$folder2,
self::TEST_FILES_SHARING_API_USER2,
self::TEST_FILES_SHARING_API_USER3,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
// user2 shares folder2/file1 to user3
$file1Share = $this->share(
$file1,
self::TEST_FILES_SHARING_API_USER2,
self::TEST_FILES_SHARING_API_USER3,
- \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_SHARE
+ Constants::PERMISSION_READ | Constants::PERMISSION_SHARE
);
// user2 shares subfolder1 to user3
$subfolder1Share = $this->share(
$subfolder1,
self::TEST_FILES_SHARING_API_USER2,
self::TEST_FILES_SHARING_API_USER3,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
// user2 shares subfolder2/file2.txt to user3
$file2Share = $this->share(
$file2,
self::TEST_FILES_SHARING_API_USER2,
self::TEST_FILES_SHARING_API_USER3,
- \OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_SHARE
+ Constants::PERMISSION_READ | Constants::PERMISSION_SHARE
);
// user2 moves folder2 into folder1
$this->assertEquals(self::TEST_FILES_SHARING_API_USER1, $subfolder1Share->getShareOwner());
$this->assertEquals(self::TEST_FILES_SHARING_API_USER1, $file2Share->getShareOwner());
// Expect permissions to be limited by the permissions of the destination share
- $this->assertEquals(\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_SHARE, $folder2Share->getPermissions());
- $this->assertEquals(\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_SHARE, $file1Share->getPermissions());
- $this->assertEquals(\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_SHARE, $subfolder1Share->getPermissions());
- $this->assertEquals(\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_SHARE, $file2Share->getPermissions());
+ $this->assertEquals(Constants::PERMISSION_READ | Constants::PERMISSION_SHARE, $folder2Share->getPermissions());
+ $this->assertEquals(Constants::PERMISSION_READ | Constants::PERMISSION_SHARE, $file1Share->getPermissions());
+ $this->assertEquals(Constants::PERMISSION_READ | Constants::PERMISSION_SHARE, $subfolder1Share->getPermissions());
+ $this->assertEquals(Constants::PERMISSION_READ | Constants::PERMISSION_SHARE, $file2Share->getPermissions());
// user2 moves folder2 out of folder1
$viewUser2->rename($folder1 . '/' . $folder2, $folder2);
$this->assertEquals(self::TEST_FILES_SHARING_API_USER2, $subfolder1Share->getShareOwner());
$this->assertEquals(self::TEST_FILES_SHARING_API_USER2, $file2Share->getShareOwner());
// Expect permissions to not change
- $this->assertEquals(\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_SHARE, $folder2Share->getPermissions());
- $this->assertEquals(\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_SHARE, $file1Share->getPermissions());
- $this->assertEquals(\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_SHARE, $subfolder1Share->getPermissions());
- $this->assertEquals(\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_SHARE, $file2Share->getPermissions());
+ $this->assertEquals(Constants::PERMISSION_READ | Constants::PERMISSION_SHARE, $folder2Share->getPermissions());
+ $this->assertEquals(Constants::PERMISSION_READ | Constants::PERMISSION_SHARE, $file1Share->getPermissions());
+ $this->assertEquals(Constants::PERMISSION_READ | Constants::PERMISSION_SHARE, $subfolder1Share->getPermissions());
+ $this->assertEquals(Constants::PERMISSION_READ | Constants::PERMISSION_SHARE, $file2Share->getPermissions());
// cleanup
$this->shareManager->deleteShare($folder1Share);
*/
namespace OCA\Files_Sharing\Tests;
+use OC\Files\View;
+use OCP\Constants;
use OCP\Share\IShare;
/**
'container/shareddir',
self::TEST_FILES_SHARING_API_USER1,
self::TEST_FILES_SHARING_API_USER2,
- \OCP\Constants::PERMISSION_ALL
+ Constants::PERMISSION_ALL
);
$this->_share->setStatus(IShare::STATUS_ACCEPTED);
self::loginHelper(self::TEST_FILES_SHARING_API_USER2);
// retrieve the shared storage
- $secondView = new \OC\Files\View('/' . self::TEST_FILES_SHARING_API_USER2);
+ $secondView = new View('/' . self::TEST_FILES_SHARING_API_USER2);
[$this->sharedStorage, $internalPath] = $secondView->resolvePath('files/shareddir');
$this->sharedCache = $this->sharedStorage->getCache();
}
*/
namespace OCA\Files_Trashbin\BackgroundJob;
+use OC\Files\View;
use OCA\Files_Trashbin\Expiration;
use OCA\Files_Trashbin\Helper;
use OCA\Files_Trashbin\Trashbin;
\OC_Util::setupFS($user);
// Check if this user has a trashbin directory
- $view = new \OC\Files\View('/' . $user);
+ $view = new View('/' . $user);
if (!$view->is_dir('/files_trashbin/files')) {
return false;
}
*/
namespace OCA\Files_Trashbin\Command;
+use OC\Files\View;
use OCA\Files_Trashbin\Expiration;
use OCA\Files_Trashbin\Helper;
use OCA\Files_Trashbin\Trashbin;
\OC_Util::setupFS($user);
// Check if this user has a trashbin directory
- $view = new \OC\Files\View('/' . $user);
+ $view = new View('/' . $user);
if (!$view->is_dir('/files_trashbin/files')) {
return false;
}
use OC\Core\Command\Base;
use OCA\Files_Trashbin\Trash\ITrashManager;
+use OCA\Files_Trashbin\Trash\TrashItem;
use OCP\Files\IRootFolder;
use OCP\IDBConnection;
use OCP\IL10N;
$trashItemClass = get_class($trashItem);
// Check scope with exact class name for locally deleted files
- if ($scope === self::SCOPE_USER && $trashItemClass !== \OCA\Files_Trashbin\Trash\TrashItem::class) {
+ if ($scope === self::SCOPE_USER && $trashItemClass !== TrashItem::class) {
$output->writeln('Skipping <info>' . $trashItem->getName() . '</info> because it is not a user trash item', OutputInterface::VERBOSITY_VERBOSE);
continue;
}
use OCP\AppFramework\Http\Attribute\NoAdminRequired;
use OCP\AppFramework\Http\Attribute\NoCSRFRequired;
use OCP\AppFramework\Http\DataResponse;
+use OCP\AppFramework\Http\FileDisplayResponse;
use OCP\AppFramework\Utility\ITimeFactory;
use OCP\Files\Folder;
use OCP\Files\IMimeTypeDetector;
}
$f = $this->previewManager->getPreview($file, $x, $y, !$a, IPreview::MODE_FILL, $mimeType);
- $response = new Http\FileDisplayResponse($f, Http::STATUS_OK, ['Content-Type' => $f->getMimeType()]);
+ $response = new FileDisplayResponse($f, Http::STATUS_OK, ['Content-Type' => $f->getMimeType()]);
// Cache previews for 24H
$response->cacheFor(3600 * 24);
namespace OCA\Files_Trashbin;
use OC\Files\FileInfo;
+use OC\Files\View;
use OCP\Constants;
use OCP\Files\Cache\ICacheEntry;
$result = [];
$timestamp = null;
- $view = new \OC\Files\View('/' . $user . '/files_trashbin/files');
+ $view = new View('/' . $user . '/files_trashbin/files');
if (ltrim($dir, '/') !== '' && !$view->is_dir($dir)) {
throw new \Exception('Directory does not exists');
$absoluteDir = $view->getAbsolutePath($dir);
$internalPath = $mount->getInternalPath($absoluteDir);
- $extraData = \OCA\Files_Trashbin\Trashbin::getExtraData($user);
+ $extraData = Trashbin::getExtraData($user);
$dirContent = $storage->getCache()->getFolderContents($mount->getInternalPath($view->getAbsolutePath($dir)));
foreach ($dirContent as $entry) {
$entryName = $entry->getName();
$entry = \OCA\Files\Helper::formatFileInfo($i);
$entry['id'] = $i->getId();
$entry['etag'] = $entry['mtime']; // add fake etag, it is only needed to identify the preview image
- $entry['permissions'] = \OCP\Constants::PERMISSION_READ;
+ $entry['permissions'] = Constants::PERMISSION_READ;
$files[] = $entry;
}
return $files;
use OCA\Files_Trashbin\Trash\ITrashItem;
use OCA\Files_Trashbin\Trash\ITrashManager;
+use OCA\Files_Trashbin\Trashbin;
use OCP\Files\FileInfo;
use OCP\IUser;
use Sabre\DAV\Exception\Forbidden;
}
public function delete() {
- \OCA\Files_Trashbin\Trashbin::deleteAll();
+ Trashbin::deleteAll();
foreach ($this->trashManager->listTrashRoot($this->user) as $trashItem) {
$this->trashManager->removeItem($trashItem);
}
$this->deletedFiles[$normalized] = $normalized;
if ($filesPath = $view->getRelativePath($normalized)) {
$filesPath = trim($filesPath, '/');
- $result = \OCA\Files_Trashbin\Trashbin::move2trash($filesPath);
+ $result = Trashbin::move2trash($filesPath);
} else {
$result = false;
}
use OCA\Files_Trashbin\Command\Expire;
use OCA\Files_Trashbin\Events\BeforeNodeRestoredEvent;
use OCA\Files_Trashbin\Events\NodeRestoredEvent;
+use OCA\Files_Trashbin\Exceptions\CopyRecursiveException;
+use OCA\Files_Versions\Storage;
use OCP\App\IAppManager;
use OCP\AppFramework\Utility\ITimeFactory;
use OCP\EventDispatcher\Event;
use OCP\Lock\ILockingProvider;
use OCP\Lock\LockedException;
use OCP\Server;
+use OCP\Util;
use Psr\Log\LoggerInterface;
/** @template-implements IEventListener<BeforeNodeDeletedEvent> */
if ($sourceStorage->getCache()->inCache($sourceInternalPath)) {
$trashStorage->getUpdater()->renameFromStorage($sourceStorage, $sourceInternalPath, $trashInternalPath);
}
- } catch (\OCA\Files_Trashbin\Exceptions\CopyRecursiveException $e) {
+ } catch (CopyRecursiveException $e) {
$moveSuccessful = false;
if ($trashStorage->file_exists($trashInternalPath)) {
$trashStorage->unlink($trashInternalPath);
if (!$result) {
\OC::$server->get(LoggerInterface::class)->error('trash bin database couldn\'t be updated', ['app' => 'files_trashbin']);
}
- \OCP\Util::emitHook('\OCA\Files_Trashbin\Trashbin', 'post_moveToTrash', ['filePath' => Filesystem::normalizePath($file_path),
+ Util::emitHook('\OCA\Files_Trashbin\Trashbin', 'post_moveToTrash', ['filePath' => Filesystem::normalizePath($file_path),
'trashPath' => Filesystem::normalizePath(static::getTrashFilename($filename, $timestamp))]);
self::retainVersions($filename, $owner, $ownerPath, $timestamp);
$config = \OC::$server->get(IConfig::class);
$userTrashbinSize = $config->getUserValue($user, 'files_trashbin', 'trashbin_size', '-1');
if (is_numeric($userTrashbinSize) && ($userTrashbinSize > -1)) {
- return \OCP\Util::numericToNumber($userTrashbinSize);
+ return Util::numericToNumber($userTrashbinSize);
}
$systemTrashbinSize = $config->getAppValue('files_trashbin', 'trashbin_size', '-1');
if (is_numeric($systemTrashbinSize)) {
- return \OCP\Util::numericToNumber($systemTrashbinSize);
+ return Util::numericToNumber($systemTrashbinSize);
}
return -1;
}
* @param int $timestamp when the file was deleted
*/
private static function retainVersions($filename, $owner, $ownerPath, $timestamp) {
- if (\OCP\Server::get(IAppManager::class)->isEnabledForUser('files_versions') && !empty($ownerPath)) {
+ if (Server::get(IAppManager::class)->isEnabledForUser('files_versions') && !empty($ownerPath)) {
$user = OC_User::getUser();
$rootView = new View('/');
self::copy_recursive($owner . '/files_versions/' . $ownerPath, $owner . '/files_trashbin/versions/' . static::getTrashFilename(basename($ownerPath), $timestamp), $rootView);
}
self::move($rootView, $owner . '/files_versions/' . $ownerPath, $user . '/files_trashbin/versions/' . static::getTrashFilename($filename, $timestamp));
- } elseif ($versions = \OCA\Files_Versions\Storage::getVersions($owner, $ownerPath)) {
+ } elseif ($versions = Storage::getVersions($owner, $ownerPath)) {
foreach ($versions as $v) {
if ($owner !== $user) {
self::copy($rootView, $owner . '/files_versions' . $v['path'] . '.v' . $v['version'], $owner . '/files_trashbin/versions/' . static::getTrashFilename($v['name'] . '.v' . $v['version'], $timestamp));
$view->chroot('/' . $user . '/files');
$view->touch('/' . $location . '/' . $uniqueFilename, $mtime);
$view->chroot($fakeRoot);
- \OCP\Util::emitHook('\OCA\Files_Trashbin\Trashbin', 'post_restore', ['filePath' => $targetPath, 'trashPath' => $sourcePath]);
+ Util::emitHook('\OCA\Files_Trashbin\Trashbin', 'post_restore', ['filePath' => $targetPath, 'trashPath' => $sourcePath]);
$sourceNode = self::getNodeForPath($sourcePath);
$targetNode = self::getNodeForPath($targetPath);
* @return false|null
*/
private static function restoreVersions(View $view, $file, $filename, $uniqueFilename, $location, $timestamp) {
- if (\OCP\Server::get(IAppManager::class)->isEnabledForUser('files_versions')) {
+ if (Server::get(IAppManager::class)->isEnabledForUser('files_versions')) {
$user = OC_User::getUser();
$rootView = new View('/');
*/
private static function deleteVersions(View $view, $file, $filename, $timestamp, string $user): int|float {
$size = 0;
- if (\OCP\Server::get(IAppManager::class)->isEnabledForUser('files_versions')) {
+ if (Server::get(IAppManager::class)->isEnabledForUser('files_versions')) {
if ($view->is_dir('files_trashbin/versions/' . $file)) {
$size += self::calculateSize(new View('/' . $user . '/files_trashbin/versions/' . $file));
$view->unlink('files_trashbin/versions/' . $file);
$quota = PHP_INT_MAX;
}
} else {
- $quota = \OCP\Util::computerFileSize($quota);
+ $quota = Util::computerFileSize($quota);
// invalid quota
if ($quota === false) {
$quota = PHP_INT_MAX;
$availableSpace = $quota;
}
- return \OCP\Util::numericToNumber($availableSpace);
+ return Util::numericToNumber($availableSpace);
}
/**
try {
$size += self::delete($filename, $user, $timestamp);
$count++;
- } catch (\OCP\Files\NotPermittedException $e) {
+ } catch (NotPermittedException $e) {
\OC::$server->get(LoggerInterface::class)->warning('Removing "' . $filename . '" from trashbin failed.',
[
'exception' => $e,
$size += $view->filesize($pathDir);
$result = $view->copy($pathDir, $destination . '/' . $i['name']);
if (!$result) {
- throw new \OCA\Files_Trashbin\Exceptions\CopyRecursiveException();
+ throw new CopyRecursiveException();
}
$view->touch($destination . '/' . $i['name'], $view->filemtime($pathDir));
}
$size += $view->filesize($source);
$result = $view->copy($source, $destination);
if (!$result) {
- throw new \OCA\Files_Trashbin\Exceptions\CopyRecursiveException();
+ throw new CopyRecursiveException();
}
$view->touch($destination, $view->filemtime($source));
}
private static function getUniqueFilename($location, $filename, View $view) {
$ext = pathinfo($filename, PATHINFO_EXTENSION);
$name = pathinfo($filename, PATHINFO_FILENAME);
- $l = \OCP\Util::getL10N('files_trashbin');
+ $l = Util::getL10N('files_trashbin');
$location = '/' . trim($location, '/');
namespace OCA\Files_Trashbin\UserMigration;
use OCA\Files_Trashbin\AppInfo\Application;
+use OCA\Files_Trashbin\Trashbin;
use OCP\Files\Folder;
use OCP\Files\IRootFolder;
use OCP\Files\NotFoundException;
$exportDestination->copyFolder($trashbinFolder, static::PATH_FILES_FOLDER);
$originalLocations = [];
// TODO Export all extra data and bump migrator to v2
- foreach (\OCA\Files_Trashbin\Trashbin::getExtraData($uid) as $filename => $extraData) {
+ foreach (Trashbin::getExtraData($uid) as $filename => $extraData) {
$locationData = [];
foreach ($extraData as $timestamp => ['location' => $location]) {
$locationData[$timestamp] = $location;
use OCA\Files_Trashbin\Command\CleanUp;
use OCP\Files\IRootFolder;
use OCP\IDBConnection;
+use OCP\UserInterface;
use Symfony\Component\Console\Exception\InvalidOptionException;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\NullOutput;
->setMethods(['removeDeletedFiles'])
->setConstructorArgs([$this->rootFolder, $this->userManager, $this->dbConnection])
->getMock();
- $backend = $this->createMock(\OCP\UserInterface::class);
+ $backend = $this->createMock(UserInterface::class);
$backend->method('getUsers')
->with('', 500, 0)
->willReturn($backendUsers);
use OC\Files\Filesystem;
use OC\Files\Storage\Common;
use OC\Files\Storage\Temporary;
+use OC\Files\View;
use OCA\Files_Trashbin\AppInfo\Application;
use OCA\Files_Trashbin\Events\MoveToTrashEvent;
use OCA\Files_Trashbin\Storage;
use OCA\Files_Trashbin\Trash\ITrashManager;
use OCP\AppFramework\Bootstrap\IBootContext;
use OCP\AppFramework\Utility\ITimeFactory;
+use OCP\Constants;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\Files\Cache\ICache;
use OCP\Files\Folder;
// this will setup the FS
$this->loginAsUser($this->user);
- \OCA\Files_Trashbin\Storage::setupStorage();
+ Storage::setupStorage();
- $this->rootView = new \OC\Files\View('/');
- $this->userView = new \OC\Files\View('/' . $this->user . '/files/');
+ $this->rootView = new View('/');
+ $this->userView = new View('/' . $this->user . '/files/');
$this->userView->file_put_contents('test.txt', 'foo');
$this->userView->file_put_contents(static::LONG_FILENAME, 'foo');
$this->userView->file_put_contents(static::MAX_FILENAME, 'foo');
}
protected function tearDown(): void {
- \OC\Files\Filesystem::getLoader()->removeStorageWrapper('oc_trashbin');
+ Filesystem::getLoader()->removeStorageWrapper('oc_trashbin');
$this->logout();
$user = \OC::$server->getUserManager()->get($this->user);
if ($user !== null) {
*/
public function testCrossStorageDeleteFile(): void {
$storage2 = new Temporary([]);
- \OC\Files\Filesystem::mount($storage2, [], $this->user . '/files/substorage');
+ Filesystem::mount($storage2, [], $this->user . '/files/substorage');
$this->userView->file_put_contents('substorage/subfile.txt', 'foo');
$storage2->getScanner()->scan('');
*/
public function testCrossStorageDeleteFolder(): void {
$storage2 = new Temporary([]);
- \OC\Files\Filesystem::mount($storage2, [], $this->user . '/files/substorage');
+ Filesystem::mount($storage2, [], $this->user . '/files/substorage');
$this->userView->mkdir('substorage/folder');
$this->userView->file_put_contents('substorage/folder/subfile.txt', 'bar');
->setShareType(IShare::TYPE_USER)
->setSharedBy($this->user)
->setSharedWith($recipientUser)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = \OC::$server->getShareManager()->createShare($share);
\OC::$server->getShareManager()->acceptShare($share, $recipientUser);
$this->loginAsUser($recipientUser);
// delete as recipient
- $recipientView = new \OC\Files\View('/' . $recipientUser . '/files');
+ $recipientView = new View('/' . $recipientUser . '/files');
$recipientView->unlink('share/test.txt');
// rescan trash storage for both users
->setShareType(IShare::TYPE_USER)
->setSharedBy($this->user)
->setSharedWith($recipientUser)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = \OC::$server->getShareManager()->createShare($share);
\OC::$server->getShareManager()->acceptShare($share, $recipientUser);
$this->loginAsUser($recipientUser);
// delete as recipient
- $recipientView = new \OC\Files\View('/' . $recipientUser . '/files');
+ $recipientView = new View('/' . $recipientUser . '/files');
$recipientView->rmdir('share/folder');
// rescan trash storage
*/
public function testKeepFileAndVersionsWhenMovingFileBetweenStorages(): void {
$storage2 = new Temporary([]);
- \OC\Files\Filesystem::mount($storage2, [], $this->user . '/files/substorage');
+ Filesystem::mount($storage2, [], $this->user . '/files/substorage');
// trigger a version (multiple would not work because of the expire logic)
$this->userView->file_put_contents('test.txt', 'v1');
*/
public function testKeepFileAndVersionsWhenMovingFolderBetweenStorages(): void {
$storage2 = new Temporary([]);
- \OC\Files\Filesystem::mount($storage2, [], $this->user . '/files/substorage');
+ Filesystem::mount($storage2, [], $this->user . '/files/substorage');
// trigger a version (multiple would not work because of the expire logic)
$this->userView->file_put_contents('folder/inside.txt', 'v1');
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
+use OC\AllConfig;
use OC\AppFramework\Bootstrap\BootContext;
use OC\AppFramework\DependencyInjection\DIContainer;
+use OC\Files\Cache\Watcher;
+use OC\Files\Filesystem;
+use OC\Files\Storage\Local;
+use OC\Files\View;
use OCA\Files_Sharing\AppInfo\Application;
use OCA\Files_Trashbin\AppInfo\Application as TrashbinApplication;
+use OCA\Files_Trashbin\Expiration;
+use OCA\Files_Trashbin\Helper;
+use OCA\Files_Trashbin\Trashbin;
+use OCP\AppFramework\Utility\ITimeFactory;
+use OCP\Constants;
+use OCP\IConfig;
use OCP\Share\IShare;
/**
$config = \OC::$server->getConfig();
//configure trashbin
- self::$rememberRetentionObligation = $config->getSystemValue('trashbin_retention_obligation', \OCA\Files_Trashbin\Expiration::DEFAULT_RETENTION_OBLIGATION);
- /** @var \OCA\Files_Trashbin\Expiration $expiration */
- $expiration = \OC::$server->query(\OCA\Files_Trashbin\Expiration::class);
+ self::$rememberRetentionObligation = $config->getSystemValue('trashbin_retention_obligation', Expiration::DEFAULT_RETENTION_OBLIGATION);
+ /** @var Expiration $expiration */
+ $expiration = \OC::$server->query(Expiration::class);
$expiration->setRetentionObligation('auto, 2');
// register trashbin hooks
$user->delete();
}
- /** @var \OCA\Files_Trashbin\Expiration $expiration */
- $expiration = \OC::$server->query(\OCA\Files_Trashbin\Expiration::class);
+ /** @var Expiration $expiration */
+ $expiration = \OC::$server->query(Expiration::class);
$expiration->setRetentionObligation(self::$rememberRetentionObligation);
\OC_Hook::clear();
- \OC\Files\Filesystem::getLoader()->removeStorageWrapper('oc_trashbin');
+ Filesystem::getLoader()->removeStorageWrapper('oc_trashbin');
if (self::$trashBinStatus) {
\OC::$server->getAppManager()->enableApp('files_trashbin');
\OC::$server->getAppManager()->enableApp('files_trashbin');
$config = \OC::$server->getConfig();
- $mockConfig = $this->createMock(\OCP\IConfig::class);
+ $mockConfig = $this->createMock(IConfig::class);
$mockConfig
->method('getSystemValue')
->willReturnCallback(static function ($key, $default) use ($config) {
if ($key === 'filesystem_check_changes') {
- return \OC\Files\Cache\Watcher::CHECK_ONCE;
+ return Watcher::CHECK_ONCE;
} else {
return $config->getSystemValue($key, $default);
}
->willReturnCallback(static function ($appName, $key, $default = '') use ($config) {
return $config->getAppValue($appName, $key, $default);
});
- $this->overwriteService(\OC\AllConfig::class, $mockConfig);
+ $this->overwriteService(AllConfig::class, $mockConfig);
$this->trashRoot1 = '/' . self::TEST_TRASHBIN_USER1 . '/files_trashbin';
$this->trashRoot2 = '/' . self::TEST_TRASHBIN_USER2 . '/files_trashbin';
- $this->rootView = new \OC\Files\View();
+ $this->rootView = new View();
self::loginHelper(self::TEST_TRASHBIN_USER1);
}
protected function tearDown(): void {
- $this->restoreService(\OC\AllConfig::class);
+ $this->restoreService(AllConfig::class);
// disable trashbin to be able to properly clean up
\OC::$server->getAppManager()->disableApp('files_trashbin');
public function testExpireOldFiles(): void {
/** @var \OCP\AppFramework\Utility\ITimeFactory $time */
- $time = \OC::$server->query(\OCP\AppFramework\Utility\ITimeFactory::class);
+ $time = \OC::$server->query(ITimeFactory::class);
$currentTime = $time->getTime();
$expireAt = $currentTime - 2 * 24 * 60 * 60;
$expiredDate = $currentTime - 3 * 24 * 60 * 60;
// create some files
- \OC\Files\Filesystem::file_put_contents('file1.txt', 'file1');
- \OC\Files\Filesystem::file_put_contents('file2.txt', 'file2');
- \OC\Files\Filesystem::file_put_contents('file3.txt', 'file3');
+ Filesystem::file_put_contents('file1.txt', 'file1');
+ Filesystem::file_put_contents('file2.txt', 'file2');
+ Filesystem::file_put_contents('file3.txt', 'file3');
// delete them so that they end up in the trash bin
- \OC\Files\Filesystem::unlink('file1.txt');
- \OC\Files\Filesystem::unlink('file2.txt');
- \OC\Files\Filesystem::unlink('file3.txt');
+ Filesystem::unlink('file1.txt');
+ Filesystem::unlink('file2.txt');
+ Filesystem::unlink('file3.txt');
//make sure that files are in the trash bin
- $filesInTrash = OCA\Files_Trashbin\Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'name');
+ $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'name');
$this->assertSame(3, count($filesInTrash));
// every second file will get a date in the past so that it will get expired
#$this->assertSame('file2.txt', $remainingFile['name']);
// check that file1.txt and file3.txt was really deleted
- $newTrashContent = OCA\Files_Trashbin\Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1);
+ $newTrashContent = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1);
$this->assertSame(1, count($newTrashContent));
$element = reset($newTrashContent);
// TODO: failing test
$expiredDate = $currentTime - 3 * 24 * 60 * 60;
// create some files
- \OC\Files\Filesystem::mkdir($folder);
- \OC\Files\Filesystem::file_put_contents($folder . 'user1-1.txt', 'file1');
- \OC\Files\Filesystem::file_put_contents($folder . 'user1-2.txt', 'file2');
- \OC\Files\Filesystem::file_put_contents($folder . 'user1-3.txt', 'file3');
- \OC\Files\Filesystem::file_put_contents($folder . 'user1-4.txt', 'file4');
+ Filesystem::mkdir($folder);
+ Filesystem::file_put_contents($folder . 'user1-1.txt', 'file1');
+ Filesystem::file_put_contents($folder . 'user1-2.txt', 'file2');
+ Filesystem::file_put_contents($folder . 'user1-3.txt', 'file3');
+ Filesystem::file_put_contents($folder . 'user1-4.txt', 'file4');
//share user1-4.txt with user2
$node = \OC::$server->getUserFolder(self::TEST_TRASHBIN_USER1)->get($folder);
->setNode($node)
->setSharedBy(self::TEST_TRASHBIN_USER1)
->setSharedWith(self::TEST_TRASHBIN_USER2)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = \OC::$server->getShareManager()->createShare($share);
\OC::$server->getShareManager()->acceptShare($share, self::TEST_TRASHBIN_USER2);
// delete them so that they end up in the trash bin
- \OC\Files\Filesystem::unlink($folder . 'user1-1.txt');
- \OC\Files\Filesystem::unlink($folder . 'user1-2.txt');
- \OC\Files\Filesystem::unlink($folder . 'user1-3.txt');
+ Filesystem::unlink($folder . 'user1-1.txt');
+ Filesystem::unlink($folder . 'user1-2.txt');
+ Filesystem::unlink($folder . 'user1-3.txt');
- $filesInTrash = OCA\Files_Trashbin\Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'name');
+ $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'name');
$this->assertSame(3, count($filesInTrash));
// every second file will get a date in the past so that it will get expired
// login as user2
self::loginHelper(self::TEST_TRASHBIN_USER2);
- $this->assertTrue(\OC\Files\Filesystem::file_exists($folder . 'user1-4.txt'));
+ $this->assertTrue(Filesystem::file_exists($folder . 'user1-4.txt'));
// create some files
- \OC\Files\Filesystem::file_put_contents('user2-1.txt', 'file1');
- \OC\Files\Filesystem::file_put_contents('user2-2.txt', 'file2');
+ Filesystem::file_put_contents('user2-1.txt', 'file1');
+ Filesystem::file_put_contents('user2-2.txt', 'file2');
// delete them so that they end up in the trash bin
- \OC\Files\Filesystem::unlink('user2-1.txt');
- \OC\Files\Filesystem::unlink('user2-2.txt');
+ Filesystem::unlink('user2-1.txt');
+ Filesystem::unlink('user2-2.txt');
- $filesInTrashUser2 = OCA\Files_Trashbin\Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER2, 'name');
+ $filesInTrashUser2 = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER2, 'name');
$this->assertSame(2, count($filesInTrashUser2));
// every second file will get a date in the past so that it will get expired
$this->manipulateDeleteTime($filesInTrashUser2, $this->trashRoot2, $expiredDate);
- \OC\Files\Filesystem::unlink($folder . 'user1-4.txt');
+ Filesystem::unlink($folder . 'user1-4.txt');
$this->runCommands();
- $filesInTrashUser2AfterDelete = OCA\Files_Trashbin\Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER2);
+ $filesInTrashUser2AfterDelete = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER2);
// user2-1.txt should have been expired
$this->verifyArray($filesInTrashUser2AfterDelete, ['user2-2.txt', 'user1-4.txt']);
self::loginHelper(self::TEST_TRASHBIN_USER1);
// user1-1.txt and user1-3.txt should have been expired
- $filesInTrashUser1AfterDelete = OCA\Files_Trashbin\Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1);
+ $filesInTrashUser1AfterDelete = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1);
$this->verifyArray($filesInTrashUser1AfterDelete, ['user1-2.txt', 'user1-4.txt']);
}
$counter = ($counter + 1) % 2;
if ($counter === 1) {
$source = $trashRoot . '/files/' . $file['name'] . '.d' . $file['mtime'];
- $target = \OC\Files\Filesystem::normalizePath($trashRoot . '/files/' . $file['name'] . '.d' . $expireDate);
+ $target = Filesystem::normalizePath($trashRoot . '/files/' . $file['name'] . '.d' . $expireDate);
$this->rootView->rename($source, $target);
$file['mtime'] = $expireDate;
}
public function testExpireOldFilesUtilLimitsAreMet(): void {
// create some files
- \OC\Files\Filesystem::file_put_contents('file1.txt', 'file1');
- \OC\Files\Filesystem::file_put_contents('file2.txt', 'file2');
- \OC\Files\Filesystem::file_put_contents('file3.txt', 'file3');
+ Filesystem::file_put_contents('file1.txt', 'file1');
+ Filesystem::file_put_contents('file2.txt', 'file2');
+ Filesystem::file_put_contents('file3.txt', 'file3');
// delete them so that they end up in the trash bin
- \OC\Files\Filesystem::unlink('file3.txt');
+ Filesystem::unlink('file3.txt');
sleep(1); // make sure that every file has a unique mtime
- \OC\Files\Filesystem::unlink('file2.txt');
+ Filesystem::unlink('file2.txt');
sleep(1); // make sure that every file has a unique mtime
- \OC\Files\Filesystem::unlink('file1.txt');
+ Filesystem::unlink('file1.txt');
//make sure that files are in the trash bin
- $filesInTrash = OCA\Files_Trashbin\Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+ $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
$this->assertSame(3, count($filesInTrash));
$testClass = new TrashbinForTesting();
// the two oldest files (file3.txt and file2.txt) should be deleted
$this->assertSame(10, $sizeOfDeletedFiles);
- $newTrashContent = OCA\Files_Trashbin\Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1);
+ $newTrashContent = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1);
$this->assertSame(1, count($newTrashContent));
$element = reset($newTrashContent);
$this->assertSame('file1.txt', $element['name']);
$this->assertFalse($userFolder->nodeExists('file1.txt'));
- $filesInTrash = OCA\Files_Trashbin\Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+ $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
$this->assertCount(1, $filesInTrash);
/** @var \OCP\Files\FileInfo */
$trashedFile = $filesInTrash[0];
$this->assertTrue(
- OCA\Files_Trashbin\Trashbin::restore(
+ Trashbin::restore(
'file1.txt.d' . $trashedFile->getMtime(),
$trashedFile->getName(),
$trashedFile->getMtime()
$this->assertFalse($userFolder->nodeExists('folder/file1.txt'));
- $filesInTrash = OCA\Files_Trashbin\Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+ $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
$this->assertCount(1, $filesInTrash);
/** @var \OCP\Files\FileInfo */
$trashedFile = $filesInTrash[0];
$this->assertTrue(
- OCA\Files_Trashbin\Trashbin::restore(
+ Trashbin::restore(
'file1.txt.d' . $trashedFile->getMtime(),
$trashedFile->getName(),
$trashedFile->getMtime()
$this->assertFalse($userFolder->nodeExists('folder'));
- $filesInTrash = OCA\Files_Trashbin\Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+ $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
$this->assertCount(1, $filesInTrash);
/** @var \OCP\Files\FileInfo */
$trashedFolder = $filesInTrash[0];
$this->assertTrue(
- OCA\Files_Trashbin\Trashbin::restore(
+ Trashbin::restore(
'folder.d' . $trashedFolder->getMtime(),
$trashedFolder->getName(),
$trashedFolder->getMtime()
$this->assertFalse($userFolder->nodeExists('folder'));
- $filesInTrash = OCA\Files_Trashbin\Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+ $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
$this->assertCount(1, $filesInTrash);
/** @var \OCP\Files\FileInfo */
$trashedFile = $filesInTrash[0];
$this->assertTrue(
- OCA\Files_Trashbin\Trashbin::restore(
+ Trashbin::restore(
'folder.d' . $trashedFile->getMtime() . '/file1.txt',
'file1.txt',
$trashedFile->getMtime()
$this->assertFalse($userFolder->nodeExists('folder/file1.txt'));
- $filesInTrash = OCA\Files_Trashbin\Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+ $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
$this->assertCount(1, $filesInTrash);
/** @var \OCP\Files\FileInfo */
$folder->delete();
$this->assertTrue(
- OCA\Files_Trashbin\Trashbin::restore(
+ Trashbin::restore(
'file1.txt.d' . $trashedFile->getMtime(),
$trashedFile->getName(),
$trashedFile->getMtime()
$this->assertFalse($userFolder->nodeExists('file1.txt'));
- $filesInTrash = OCA\Files_Trashbin\Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+ $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
$this->assertCount(1, $filesInTrash);
/** @var \OCP\Files\FileInfo */
$file->putContent('bar');
$this->assertTrue(
- OCA\Files_Trashbin\Trashbin::restore(
+ Trashbin::restore(
'file1.txt.d' . $trashedFile->getMtime(),
$trashedFile->getName(),
$trashedFile->getMtime()
$this->assertFalse($userFolder->nodeExists('folder/file1.txt'));
- $filesInTrash = OCA\Files_Trashbin\Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+ $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
$this->assertCount(1, $filesInTrash);
/** @var \OCP\Files\FileInfo */
$file->putContent('bar');
$this->assertTrue(
- OCA\Files_Trashbin\Trashbin::restore(
+ Trashbin::restore(
'file1.txt.d' . $trashedFile->getMtime(),
$trashedFile->getName(),
$trashedFile->getMtime()
*/
public function testRestoreUnexistingFile(): void {
$this->assertFalse(
- OCA\Files_Trashbin\Trashbin::restore(
+ Trashbin::restore(
'unexist.txt.d123456',
'unexist.txt',
'123456'
$this->assertFalse($userFolder->nodeExists('folder/file1.txt'));
- $filesInTrash = OCA\Files_Trashbin\Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+ $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
$this->assertCount(1, $filesInTrash);
/** @var \OCP\Files\FileInfo */
// delete source folder
[$storage, $internalPath] = $this->rootView->resolvePath('/' . self::TEST_TRASHBIN_USER1 . '/files/folder');
- if ($storage instanceof \OC\Files\Storage\Local) {
+ if ($storage instanceof Local) {
$folderAbsPath = $storage->getSourcePath($internalPath);
// make folder read-only
chmod($folderAbsPath, 0555);
$this->assertTrue(
- OCA\Files_Trashbin\Trashbin::restore(
+ Trashbin::restore(
'file1.txt.d' . $trashedFile->getMtime(),
$trashedFile->getName(),
$trashedFile->getMtime()
\OC_Util::tearDownFS();
\OC_User::setUserId('');
- \OC\Files\Filesystem::tearDown();
+ Filesystem::tearDown();
\OC_User::setUserId($user);
\OC_Util::setupFS($user);
\OC::$server->getUserFolder($user);
// just a dummy class to make protected methods available for testing
-class TrashbinForTesting extends \OCA\Files_Trashbin\Trashbin {
+class TrashbinForTesting extends Trashbin {
/**
* @param OCP\Files\FileInfo[] $files
*/
namespace OCA\Files_Versions\BackgroundJob;
+use OC\Files\View;
use OCA\Files_Versions\Expiration;
use OCA\Files_Versions\Storage;
use OCP\AppFramework\Utility\ITimeFactory;
\OC_Util::setupFS($user);
// Check if this user has a versions directory
- $view = new \OC\Files\View('/' . $user);
+ $view = new View('/' . $user);
if (!$view->is_dir('/files_versions')) {
return false;
}
*/
namespace OCA\Files_Versions\Command;
+use OC\Files\View;
use OCA\Files_Versions\Expiration;
use OCA\Files_Versions\Storage;
use OCP\IUser;
\OC_Util::setupFS($user);
// Check if this user has a version directory
- $view = new \OC\Files\View('/' . $user);
+ $view = new View('/' . $user);
if (!$view->is_dir('/files_versions')) {
return false;
}
use OC\Files\Search\SearchComparison;
use OC\Files\Search\SearchQuery;
use OC\Files\View;
+use OC\User\NoUserException;
use OC_User;
use OCA\Files_Sharing\SharedMount;
use OCA\Files_Versions\AppInfo\Application;
use OCP\IUser;
use OCP\IUserManager;
use OCP\Lock\ILockingProvider;
+use OCP\Server;
+use OCP\Util;
use Psr\Log\LoggerInterface;
class Storage {
6 => ['intervalEndsAfter' => -1, 'step' => 604800],
];
- /** @var \OCA\Files_Versions\AppInfo\Application */
+ /** @var Application */
private static $application;
/**
$version->delete();
\OC_Hook::emit('\OCP\Versions', 'delete', ['path' => $internalPath, 'trigger' => self::DELETE_TRIGGER_RETENTION_CONSTRAINT]);
} catch (NotPermittedException $e) {
- \OCP\Server::get(LoggerInterface::class)->error("Missing permissions to delete version: {$internalPath}", ['app' => 'files_versions', 'exception' => $e]);
+ Server::get(LoggerInterface::class)->error("Missing permissions to delete version: {$internalPath}", ['app' => 'files_versions', 'exception' => $e]);
}
}
}
$user = \OC::$server->get(IUserManager::class)->get($uid);
if (is_null($user)) {
$logger->error('Backends provided no user object for ' . $uid, ['app' => 'files_versions']);
- throw new \OC\User\NoUserException('Backends provided no user object for ' . $uid);
+ throw new NoUserException('Backends provided no user object for ' . $uid);
}
\OC_Util::setupFS($uid);
$quota = Filesystem::free_space('/');
$softQuota = false;
} else {
- $quota = \OCP\Util::computerFileSize($quota);
+ $quota = Util::computerFileSize($quota);
}
// make sure that we have the current size of the version history
use OCA\Files_Versions\Db\VersionEntity;
use OCA\Files_Versions\Db\VersionsMapper;
use OCA\Files_Versions\Storage;
+use OCP\Constants;
use OCP\Files\File;
use OCP\Files\FileInfo;
use OCP\Files\Folder;
}
public function rollback(IVersion $version) {
- if (!$this->currentUserHasPermissions($version->getSourceFile(), \OCP\Constants::PERMISSION_UPDATE)) {
+ if (!$this->currentUserHasPermissions($version->getSourceFile(), Constants::PERMISSION_UPDATE)) {
throw new Forbidden('You cannot restore this version because you do not have update permissions on the source file.');
}
}
public function deleteVersion(IVersion $version): void {
- if (!$this->currentUserHasPermissions($version->getSourceFile(), \OCP\Constants::PERMISSION_DELETE)) {
+ if (!$this->currentUserHasPermissions($version->getSourceFile(), Constants::PERMISSION_DELETE)) {
throw new Forbidden('You cannot delete this version because you do not have delete permissions on the source file.');
}
}
public function setMetadataValue(Node $node, int $revision, string $key, string $value): void {
- if (!$this->currentUserHasPermissions($node, \OCP\Constants::PERMISSION_UPDATE)) {
+ if (!$this->currentUserHasPermissions($node, Constants::PERMISSION_UPDATE)) {
throw new Forbidden('You cannot update the version\'s metadata because you do not have update permissions on the source file.');
}
use OCP\Files\Folder;
use OCP\Files\IRootFolder;
use OCP\Files\Storage\IStorage;
+use OCP\UserInterface;
use Test\TestCase;
/**
->setConstructorArgs([$this->rootFolder, $this->userManager, $this->versionMapper])
->getMock();
- $backend = $this->getMockBuilder(\OCP\UserInterface::class)
+ $backend = $this->getMockBuilder(UserInterface::class)
->disableOriginalConstructor()->getMock();
$backend->expects($this->once())->method('getUsers')
->with('', 500, 0)
*/
namespace OCA\Files_Versions\Tests;
+use OC\AllConfig;
+use OC\Files\Cache\Watcher;
+use OC\Files\Filesystem;
use OC\Files\Storage\Temporary;
+use OC\Files\View;
+use OC\User\NoUserException;
+use OCA\Files_Sharing\AppInfo\Application;
use OCA\Files_Versions\Db\VersionEntity;
use OCA\Files_Versions\Db\VersionsMapper;
+use OCA\Files_Versions\Storage;
use OCA\Files_Versions\Versions\IVersionManager;
+use OCP\Constants;
use OCP\Files\IMimeTypeLoader;
use OCP\IConfig;
use OCP\IUser;
+use OCP\Server;
use OCP\Share\IShare;
+use OCP\Util;
/**
* Class Test_Files_versions
public static function setUpBeforeClass(): void {
parent::setUpBeforeClass();
- $application = new \OCA\Files_Sharing\AppInfo\Application();
+ $application = new Application();
// create test user
self::loginHelper(self::TEST_VERSIONS_USER2, true);
->method('getSystemValue')
->willReturnCallback(function ($key, $default) use ($config) {
if ($key === 'filesystem_check_changes') {
- return \OC\Files\Cache\Watcher::CHECK_ONCE;
+ return Watcher::CHECK_ONCE;
} else {
return $config->getSystemValue($key, $default);
}
});
- $this->overwriteService(\OC\AllConfig::class, $mockConfig);
+ $this->overwriteService(AllConfig::class, $mockConfig);
// clear hooks
\OC_Hook::clear();
\OC::$server->boot();
self::loginHelper(self::TEST_VERSIONS_USER);
- $this->rootView = new \OC\Files\View();
+ $this->rootView = new View();
if (!$this->rootView->file_exists(self::USERS_VERSIONS_ROOT)) {
$this->rootView->mkdir(self::USERS_VERSIONS_ROOT);
}
- $this->versionsMapper = \OCP\Server::get(VersionsMapper::class);
- $this->mimeTypeLoader = \OCP\Server::get(IMimeTypeLoader::class);
+ $this->versionsMapper = Server::get(VersionsMapper::class);
+ $this->mimeTypeLoader = Server::get(IMimeTypeLoader::class);
$this->user1 = $this->createMock(IUser::class);
$this->user1->method('getUID')
}
protected function tearDown(): void {
- $this->restoreService(\OC\AllConfig::class);
+ $this->restoreService(AllConfig::class);
if ($this->rootView) {
$this->rootView->deleteAll(self::TEST_VERSIONS_USER . '/files/');
}
public function testRename(): void {
- \OC\Files\Filesystem::file_put_contents('test.txt', 'test file');
+ Filesystem::file_put_contents('test.txt', 'test file');
$t1 = time();
// second version is two weeks older, this way we make sure that no
$this->rootView->file_put_contents($v2, 'version2');
// execute rename hook of versions app
- \OC\Files\Filesystem::rename('test.txt', 'test2.txt');
+ Filesystem::rename('test.txt', 'test2.txt');
$this->runCommands();
}
public function testRenameInSharedFolder(): void {
- \OC\Files\Filesystem::mkdir('folder1');
- \OC\Files\Filesystem::mkdir('folder1/folder2');
- \OC\Files\Filesystem::file_put_contents('folder1/test.txt', 'test file');
+ Filesystem::mkdir('folder1');
+ Filesystem::mkdir('folder1/folder2');
+ Filesystem::file_put_contents('folder1/test.txt', 'test file');
$t1 = time();
// second version is two weeks older, this way we make sure that no
->setShareType(IShare::TYPE_USER)
->setSharedBy(self::TEST_VERSIONS_USER)
->setSharedWith(self::TEST_VERSIONS_USER2)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = \OC::$server->getShareManager()->createShare($share);
\OC::$server->getShareManager()->acceptShare($share, self::TEST_VERSIONS_USER2);
self::loginHelper(self::TEST_VERSIONS_USER2);
- $this->assertTrue(\OC\Files\Filesystem::file_exists('folder1/test.txt'));
+ $this->assertTrue(Filesystem::file_exists('folder1/test.txt'));
// execute rename hook of versions app
- \OC\Files\Filesystem::rename('/folder1/test.txt', '/folder1/folder2/test.txt');
+ Filesystem::rename('/folder1/test.txt', '/folder1/folder2/test.txt');
$this->runCommands();
}
public function testMoveFolder(): void {
- \OC\Files\Filesystem::mkdir('folder1');
- \OC\Files\Filesystem::mkdir('folder2');
- \OC\Files\Filesystem::file_put_contents('folder1/test.txt', 'test file');
+ Filesystem::mkdir('folder1');
+ Filesystem::mkdir('folder2');
+ Filesystem::file_put_contents('folder1/test.txt', 'test file');
$t1 = time();
// second version is two weeks older, this way we make sure that no
$this->rootView->file_put_contents($v2, 'version2');
// execute rename hook of versions app
- \OC\Files\Filesystem::rename('folder1', 'folder2/folder1');
+ Filesystem::rename('folder1', 'folder2/folder1');
$this->runCommands();
public function testMoveFileIntoSharedFolderAsRecipient(): void {
- \OC\Files\Filesystem::mkdir('folder1');
- $fileInfo = \OC\Files\Filesystem::getFileInfo('folder1');
+ Filesystem::mkdir('folder1');
+ $fileInfo = Filesystem::getFileInfo('folder1');
$node = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER)->get('folder1');
$share = \OC::$server->getShareManager()->newShare();
->setShareType(IShare::TYPE_USER)
->setSharedBy(self::TEST_VERSIONS_USER)
->setSharedWith(self::TEST_VERSIONS_USER2)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = \OC::$server->getShareManager()->createShare($share);
\OC::$server->getShareManager()->acceptShare($share, self::TEST_VERSIONS_USER2);
self::loginHelper(self::TEST_VERSIONS_USER2);
$versionsFolder2 = '/' . self::TEST_VERSIONS_USER2 . '/files_versions';
- \OC\Files\Filesystem::file_put_contents('test.txt', 'test file');
+ Filesystem::file_put_contents('test.txt', 'test file');
$t1 = time();
// second version is two weeks older, this way we make sure that no
$this->rootView->file_put_contents($v2, 'version2');
// move file into the shared folder as recipient
- \OC\Files\Filesystem::rename('/test.txt', '/folder1/test.txt');
+ Filesystem::rename('/test.txt', '/folder1/test.txt');
$this->assertFalse($this->rootView->file_exists($v1));
$this->assertFalse($this->rootView->file_exists($v2));
}
public function testMoveFolderIntoSharedFolderAsRecipient(): void {
- \OC\Files\Filesystem::mkdir('folder1');
+ Filesystem::mkdir('folder1');
$node = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER)->get('folder1');
$share = \OC::$server->getShareManager()->newShare();
->setShareType(IShare::TYPE_USER)
->setSharedBy(self::TEST_VERSIONS_USER)
->setSharedWith(self::TEST_VERSIONS_USER2)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = \OC::$server->getShareManager()->createShare($share);
\OC::$server->getShareManager()->acceptShare($share, self::TEST_VERSIONS_USER2);
self::loginHelper(self::TEST_VERSIONS_USER2);
$versionsFolder2 = '/' . self::TEST_VERSIONS_USER2 . '/files_versions';
- \OC\Files\Filesystem::mkdir('folder2');
- \OC\Files\Filesystem::file_put_contents('folder2/test.txt', 'test file');
+ Filesystem::mkdir('folder2');
+ Filesystem::file_put_contents('folder2/test.txt', 'test file');
$t1 = time();
// second version is two weeks older, this way we make sure that no
$this->rootView->file_put_contents($v2, 'version2');
// move file into the shared folder as recipient
- \OC\Files\Filesystem::rename('/folder2', '/folder1/folder2');
+ Filesystem::rename('/folder2', '/folder1/folder2');
$this->assertFalse($this->rootView->file_exists($v1));
$this->assertFalse($this->rootView->file_exists($v2));
}
public function testRenameSharedFile(): void {
- \OC\Files\Filesystem::file_put_contents('test.txt', 'test file');
+ Filesystem::file_put_contents('test.txt', 'test file');
$t1 = time();
// second version is two weeks older, this way we make sure that no
->setShareType(IShare::TYPE_USER)
->setSharedBy(self::TEST_VERSIONS_USER)
->setSharedWith(self::TEST_VERSIONS_USER2)
- ->setPermissions(\OCP\Constants::PERMISSION_READ | \OCP\Constants::PERMISSION_UPDATE | \OCP\Constants::PERMISSION_SHARE);
+ ->setPermissions(Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE | Constants::PERMISSION_SHARE);
$share = \OC::$server->getShareManager()->createShare($share);
\OC::$server->getShareManager()->acceptShare($share, self::TEST_VERSIONS_USER2);
self::loginHelper(self::TEST_VERSIONS_USER2);
- $this->assertTrue(\OC\Files\Filesystem::file_exists('test.txt'));
+ $this->assertTrue(Filesystem::file_exists('test.txt'));
// execute rename hook of versions app
- \OC\Files\Filesystem::rename('test.txt', 'test2.txt');
+ Filesystem::rename('test.txt', 'test2.txt');
self::loginHelper(self::TEST_VERSIONS_USER);
}
public function testCopy(): void {
- \OC\Files\Filesystem::file_put_contents('test.txt', 'test file');
+ Filesystem::file_put_contents('test.txt', 'test file');
$t1 = time();
// second version is two weeks older, this way we make sure that no
$this->rootView->file_put_contents($v2, 'version2');
// execute copy hook of versions app
- \OC\Files\Filesystem::copy('test.txt', 'test2.txt');
+ Filesystem::copy('test.txt', 'test2.txt');
$this->runCommands();
$this->rootView->file_put_contents($v2, 'version2');
// execute copy hook of versions app
- $versions = \OCA\Files_Versions\Storage::getVersions(self::TEST_VERSIONS_USER, '/subfolder/test.txt');
+ $versions = Storage::getVersions(self::TEST_VERSIONS_USER, '/subfolder/test.txt');
$this->assertCount(2, $versions);
*/
public function testGetVersionsEmptyFile(): void {
// execute copy hook of versions app
- $versions = \OCA\Files_Versions\Storage::getVersions(self::TEST_VERSIONS_USER, '');
+ $versions = Storage::getVersions(self::TEST_VERSIONS_USER, '');
$this->assertCount(0, $versions);
- $versions = \OCA\Files_Versions\Storage::getVersions(self::TEST_VERSIONS_USER, null);
+ $versions = Storage::getVersions(self::TEST_VERSIONS_USER, null);
$this->assertCount(0, $versions);
}
// needed to have a FS setup (the background job does this)
\OC_Util::setupFS(self::TEST_VERSIONS_USER);
- $this->assertFalse(\OCA\Files_Versions\Storage::expire('/void/unexist.txt', self::TEST_VERSIONS_USER));
+ $this->assertFalse(Storage::expire('/void/unexist.txt', self::TEST_VERSIONS_USER));
}
public function testExpireNonexistingUser(): void {
- $this->expectException(\OC\User\NoUserException::class);
+ $this->expectException(NoUserException::class);
$this->logout();
// needed to have a FS setup (the background job does this)
\OC_Util::setupFS(self::TEST_VERSIONS_USER);
- \OC\Files\Filesystem::file_put_contents('test.txt', 'test file');
+ Filesystem::file_put_contents('test.txt', 'test file');
- $this->assertFalse(\OCA\Files_Versions\Storage::expire('test.txt', 'unexist'));
+ $this->assertFalse(Storage::expire('test.txt', 'unexist'));
}
public function testRestoreSameStorage(): void {
- \OC\Files\Filesystem::mkdir('sub');
+ Filesystem::mkdir('sub');
$this->doTestRestore();
}
public function testRestoreCrossStorage(): void {
$storage2 = new Temporary([]);
- \OC\Files\Filesystem::mount($storage2, [], self::TEST_VERSIONS_USER . '/files/sub');
+ Filesystem::mount($storage2, [], self::TEST_VERSIONS_USER . '/files/sub');
$this->doTestRestore();
}
->setShareType(IShare::TYPE_USER)
->setSharedBy(self::TEST_VERSIONS_USER)
->setSharedWith(self::TEST_VERSIONS_USER2)
- ->setPermissions(\OCP\Constants::PERMISSION_READ);
+ ->setPermissions(Constants::PERMISSION_READ);
$share = \OC::$server->getShareManager()->createShare($share);
\OC::$server->getShareManager()->acceptShare($share, self::TEST_VERSIONS_USER2);
$versions = $this->createAndCheckVersions(
- \OC\Files\Filesystem::getView(),
+ Filesystem::getView(),
'folder/test.txt'
);
$firstVersion = current($versions);
- $this->assertFalse(\OCA\Files_Versions\Storage::rollback('folder/test.txt', $firstVersion['version'], $this->user2), 'Revert did not happen');
+ $this->assertFalse(Storage::rollback('folder/test.txt', $firstVersion['version'], $this->user2), 'Revert did not happen');
$this->loginAsUser(self::TEST_VERSIONS_USER);
->setShareType(IShare::TYPE_USER)
->setSharedBy(self::TEST_VERSIONS_USER)
->setSharedWith(self::TEST_VERSIONS_USER2)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = \OC::$server->getShareManager()->createShare($share);
$shareManager = \OC::$server->getShareManager();
$shareManager->acceptShare($share, self::TEST_VERSIONS_USER2);
$shareManager->moveShare($share, self::TEST_VERSIONS_USER2);
$versions = $this->createAndCheckVersions(
- \OC\Files\Filesystem::getView(),
+ Filesystem::getView(),
'folder/test.txt'
);
$firstVersion = current($versions);
- $this->assertTrue(\OCA\Files_Versions\Storage::rollback('folder/test.txt', $firstVersion['version'], $this->user1));
+ $this->assertTrue(Storage::rollback('folder/test.txt', $firstVersion['version'], $this->user1));
$this->loginAsUser(self::TEST_VERSIONS_USER);
}
);
- \OCP\Util::connectHook(
+ Util::connectHook(
'\OCP\Versions',
$hookName,
$eventHandler,
$versionEntity->setMetadata([]);
$this->versionsMapper->insert($versionEntity);
- $oldVersions = \OCA\Files_Versions\Storage::getVersions(
+ $oldVersions = Storage::getVersions(
self::TEST_VERSIONS_USER, '/sub/test.txt'
);
$params = [];
$this->connectMockHooks('rollback', $params);
- $versionManager = \OCP\Server::get(IVersionManager::class);
+ $versionManager = Server::get(IVersionManager::class);
$versions = $versionManager->getVersionsForFile($this->user1, $info1);
$version = array_filter($versions, function ($version) use ($t2) {
return $version->getRevisionId() === $t2;
'Restored file has mtime from version'
);
- $newVersions = \OCA\Files_Versions\Storage::getVersions(
+ $newVersions = Storage::getVersions(
self::TEST_VERSIONS_USER, '/sub/test.txt'
);
$this->loginAsUser(self::TEST_VERSIONS_USER);
$this->createAndCheckVersions(
- \OC\Files\Filesystem::getView(),
+ Filesystem::getView(),
'test.txt'
);
}
public function testStoreVersionAsRecipient(): void {
$this->loginAsUser(self::TEST_VERSIONS_USER);
- \OC\Files\Filesystem::mkdir('folder');
- \OC\Files\Filesystem::file_put_contents('folder/test.txt', 'test file');
+ Filesystem::mkdir('folder');
+ Filesystem::file_put_contents('folder/test.txt', 'test file');
$node = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER)->get('folder');
$share = \OC::$server->getShareManager()->newShare();
->setShareType(IShare::TYPE_USER)
->setSharedBy(self::TEST_VERSIONS_USER)
->setSharedWith(self::TEST_VERSIONS_USER2)
- ->setPermissions(\OCP\Constants::PERMISSION_ALL);
+ ->setPermissions(Constants::PERMISSION_ALL);
$share = \OC::$server->getShareManager()->createShare($share);
\OC::$server->getShareManager()->acceptShare($share, self::TEST_VERSIONS_USER2);
$this->loginAsUser(self::TEST_VERSIONS_USER2);
$this->createAndCheckVersions(
- \OC\Files\Filesystem::getView(),
+ Filesystem::getView(),
'folder/test.txt'
);
// needed to make the hooks fire
\OC_Util::setupFS(self::TEST_VERSIONS_USER);
- $userView = new \OC\Files\View('/' . self::TEST_VERSIONS_USER . '/files');
+ $userView = new View('/' . self::TEST_VERSIONS_USER . '/files');
$this->createAndCheckVersions(
$userView,
'test.txt'
* @param \OC\Files\View $view
* @param string $path
*/
- private function createAndCheckVersions(\OC\Files\View $view, $path) {
+ private function createAndCheckVersions(View $view, $path) {
$view->file_put_contents($path, 'test file');
$view->file_put_contents($path, 'version 1');
$view->file_put_contents($path, 'version 2');
[$rootStorage,] = $this->rootView->resolvePath(self::TEST_VERSIONS_USER . '/files_versions');
$rootStorage->getScanner()->scan('files_versions');
- $versions = \OCA\Files_Versions\Storage::getVersions(
+ $versions = Storage::getVersions(
self::TEST_VERSIONS_USER, '/' . $path
);
\OC_Util::tearDownFS();
\OC_User::setUserId('');
- \OC\Files\Filesystem::tearDown();
+ Filesystem::tearDown();
\OC_User::setUserId($user);
\OC_Util::setupFS($user);
\OC::$server->getUserFolder($user);
}
// extend the original class to make it possible to test protected methods
-class VersionStorageToTest extends \OCA\Files_Versions\Storage {
+class VersionStorageToTest extends Storage {
/**
* @param integer $time
use OCA\OAuth2\Db\AccessToken;
use OCA\OAuth2\Db\AccessTokenMapper;
+use OCA\OAuth2\Exceptions\AccessTokenNotFoundException;
use OCP\AppFramework\Utility\ITimeFactory;
use Test\TestCase;
public function testDeleteByClientId(): void {
- $this->expectException(\OCA\OAuth2\Exceptions\AccessTokenNotFoundException::class);
+ $this->expectException(AccessTokenNotFoundException::class);
$this->accessTokenMapper->deleteByClientId(1234);
$token = new AccessToken();
use OCA\OAuth2\Db\Client;
use OCA\OAuth2\Db\ClientMapper;
+use OCA\OAuth2\Exceptions\ClientNotFoundException;
use Test\TestCase;
/**
}
public function testGetByIdentifierNotExisting(): void {
- $this->expectException(\OCA\OAuth2\Exceptions\ClientNotFoundException::class);
+ $this->expectException(ClientNotFoundException::class);
$this->clientMapper->getByIdentifier('MyTotallyNotExistingClient');
}
}
public function testGetByUidNotExisting(): void {
- $this->expectException(\OCA\OAuth2\Exceptions\ClientNotFoundException::class);
+ $this->expectException(ClientNotFoundException::class);
$this->clientMapper->getByUid(1234);
}
use OCP\Security\Events\GenerateSecurePasswordEvent;
use OCP\Security\ISecureRandom;
use OCP\User\Backend\ISetDisplayNameBackend;
+use OCP\Util;
use Psr\Log\LoggerInterface;
/**
if (is_numeric($quota)) {
$quota = (float)$quota;
} else {
- $quota = \OCP\Util::computerFileSize($quota);
+ $quota = Util::computerFileSize($quota);
}
if ($quota === false) {
throw new OCSException($this->l10n->t('Invalid quota value: %1$s', [$value]), 101);
if ($maxQuota !== -1 && $quota > $maxQuota) {
throw new OCSException($this->l10n->t('Invalid quota value. %1$s is exceeding the maximum quota', [$value]), 101);
}
- $quota = \OCP\Util::humanFileSize($quota);
+ $quota = Util::humanFileSize($quota);
}
}
// no else block because quota can be set to 'none' in previous if
use OCP\IRequest;
use OCP\IUser;
use OCP\IUserSession;
+use OCP\Server;
use OCP\Settings\IManager;
use PHPUnit\Framework\MockObject\MockObject;
use Test\TestCase;
$this->l10n = $this->createMock(IL10N::class);
$this->settingManager = $this->createMock(IManager::class);
$this->groupManager = $this->createMock(IGroupManager::class);
- $this->appManager = \OCP\Server::get(IAppManager::class);
+ $this->appManager = Server::get(IAppManager::class);
}
/**
namespace OCA\Provisioning_API\Tests\Controller;
use OCA\Provisioning_API\Controller\AppsController;
+use OCA\Provisioning_API\Tests\TestCase;
use OCP\App\IAppManager;
+use OCP\AppFramework\OCS\OCSException;
use OCP\IRequest;
use OCP\IUserSession;
*
* @package OCA\Provisioning_API\Tests
*/
-class AppsControllerTest extends \OCA\Provisioning_API\Tests\TestCase {
+class AppsControllerTest extends TestCase {
/** @var IAppManager */
private $appManager;
/** @var AppsController */
public function testGetAppInfoOnBadAppID(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(998);
$this->api->getAppInfo('not_provisioning_api');
public function testGetAppsInvalidFilter(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(101);
$this->api->getApps('foo');
use OC\User\NoUserException;
use OCA\Provisioning_API\Controller\GroupsController;
use OCP\Accounts\IAccountManager;
+use OCP\AppFramework\OCS\OCSException;
use OCP\Group\ISubAdmin;
use OCP\IConfig;
use OCP\IRequest;
public function testGetGroupAsIrrelevantSubadmin(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(403);
$group = $this->createGroup('group');
public function testGetGroupNonExisting(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('The requested group could not be found');
$this->expectExceptionCode(404);
public function testGetSubAdminsOfGroupsNotExists(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Group does not exist');
$this->expectExceptionCode(101);
public function testAddGroupEmptyGroup(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Invalid group name');
$this->expectExceptionCode(101);
public function testAddGroupExistingGroup(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(102);
$this->groupManager
public function testDeleteGroupNonExisting(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(101);
$this->api->deleteGroup('NonExistingGroup');
public function testDeleteAdminGroup(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(102);
$this->groupManager
public function testAddUserAlreadyExisting(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(102);
$this->userManager
public function testAddUserNonExistingGroup(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Group NonExistingGroup does not exist');
$this->expectExceptionCode(104);
public function testAddUserExistingGroupNonExistingGroup(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Group NonExistingGroup does not exist');
$this->expectExceptionCode(104);
public function testAddUserFailedToGenerateUserID(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Could not create non-existing user ID');
$this->expectExceptionCode(111);
public function testAddUserEmailRequired(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Required email address was not provided');
$this->expectExceptionCode(110);
public function testAddUserUnsuccessful(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Bad request');
$this->expectExceptionCode(101);
public function testAddUserAsSubAdminNoGroup(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('No group specified (required for sub-admins)');
$this->expectExceptionCode(106);
public function testAddUserAsSubAdminValidGroupNotSubAdmin(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Insufficient privileges for group ExistingGroup');
$this->expectExceptionCode(105);
public function testGetUserTargetDoesNotExist(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('User does not exist');
$this->expectExceptionCode(404);
public function testGetUserDataAsSubAdminAndUserIsNotAccessible(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(998);
$loggedInUser = $this->getMockBuilder(IUser::class)
}
public function testEditUserRegularUserSelfEditChangeEmailInvalid(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(101);
$loggedInUser = $this->getMockBuilder(IUser::class)
public function testEditUserRegularUserSelfEditChangeQuota(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(113);
$loggedInUser = $this->getMockBuilder(IUser::class)
public function testEditUserAdminUserSelfEditChangeInvalidQuota(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Invalid quota value: ABC');
$this->expectExceptionCode(101);
* @dataProvider dataEditUserSelfEditChangeLanguageButForced
*/
public function testEditUserSelfEditChangeLanguageButForced($forced): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->config->expects($this->any())
->method('getSystemValue')
* @dataProvider dataEditUserSelfEditChangeLanguageButForced
*/
public function testEditUserAdminEditChangeLanguageInvalidLanguage(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->l10nFactory->expects($this->once())
public function testEditUserSubadminUserInaccessible(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(998);
$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
public function testDeleteUserNotExistingUser(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(998);
$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
public function testDeleteUserSelf(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(101);
$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
public function testDeleteUnsuccessfulUserAsAdmin(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(101);
$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
public function testDeleteUnsuccessfulUserAsSubadmin(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(101);
$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
public function testDeleteUserAsSubAdminAndUserIsNotAccessible(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(998);
$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
public function testGetUsersGroupsTargetUserNotExisting(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(998);
$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
public function testGetUsersGroupsForSubAdminUserAndUserIsInaccessible(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(998);
$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
public function testAddToGroupWithTargetGroupNotExisting(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(102);
$this->groupManager->expects($this->once())
public function testAddToGroupWithNoGroupSpecified(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(101);
$this->api->addToGroup('TargetUser');
public function testAddToGroupWithTargetUserNotExisting(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(103);
$targetGroup = $this->createMock(IGroup::class);
public function testAddToGroupNoSubadmin(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(104);
$targetUser = $this->createMock(IUser::class);
public function testRemoveFromGroupWithNoTargetGroup(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(101);
$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
public function testRemoveFromGroupWithEmptyTargetGroup(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(101);
$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
public function testRemoveFromGroupWithNotExistingTargetGroup(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(102);
$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
public function testRemoveFromGroupWithNotExistingTargetUser(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(103);
$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
public function testRemoveFromGroupWithoutPermission(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(104);
$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
public function testRemoveFromGroupAsAdminFromAdmin(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Cannot remove yourself from the admin group');
$this->expectExceptionCode(105);
public function testRemoveFromGroupAsSubAdminFromSubAdmin(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Cannot remove yourself from this group as you are a sub-admin');
$this->expectExceptionCode(105);
public function testRemoveFromGroupAsSubAdminFromLastSubAdminGroup(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Not viable to remove user from the last group you are sub-admin of');
$this->expectExceptionCode(105);
public function testAddSubAdminWithNotExistingTargetUser(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('User does not exist');
$this->expectExceptionCode(101);
public function testAddSubAdminWithNotExistingTargetGroup(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Group does not exist');
$this->expectExceptionCode(102);
public function testAddSubAdminToAdminGroup(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Cannot create sub-admins for admin group');
$this->expectExceptionCode(103);
public function testRemoveSubAdminNotExistingTargetUser(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('User does not exist');
$this->expectExceptionCode(101);
public function testRemoveSubAdminNotExistingTargetGroup(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Group does not exist');
$this->expectExceptionCode(101);
public function testRemoveSubAdminFromNotASubadmin(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('User is not a sub-admin of this group');
$this->expectExceptionCode(102);
public function testGetUserSubAdminGroupsNotExistingTargetUser(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('User does not exist');
$this->expectExceptionCode(404);
public function testGetCurrentUserNotLoggedIn(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->userSession->expects($this->once())->method('getUser')
public function testResendWelcomeMessageWithNotExistingTargetUser(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(998);
$this->userManager
public function testResendWelcomeMessageAsSubAdminAndUserIsNotAccessible(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionCode(998);
$loggedInUser = $this->getMockBuilder(IUser::class)
public function testResendWelcomeMessageNoEmail(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Email address not available');
$this->expectExceptionCode(101);
public function testResendWelcomeMessageNullEmail(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Email address not available');
$this->expectExceptionCode(101);
public function testResendWelcomeMessageFailed(): void {
- $this->expectException(\OCP\AppFramework\OCS\OCSException::class);
+ $this->expectException(OCSException::class);
$this->expectExceptionMessage('Sending email failed');
$this->expectExceptionCode(102);
use OCP\Files\SimpleFS\ISimpleFolder;
use OCP\Http\Client\IClientService;
use OCP\IConfig;
+use OCP\IGroup;
use OCP\IL10N;
use OCP\INavigationManager;
use OCP\IRequest;
use OCP\IURLGenerator;
use OCP\L10N\IFactory;
+use OCP\Util;
use Psr\Log\LoggerInterface;
#[OpenAPI(scope: OpenAPI::SCOPE_IGNORE)]
$templateResponse = new TemplateResponse('settings', 'settings/empty', ['pageTitle' => $this->l10n->t('Settings')]);
$templateResponse->setContentSecurityPolicy($policy);
- \OCP\Util::addStyle('settings', 'settings');
- \OCP\Util::addScript('settings', 'vue-settings-apps-users-management');
+ Util::addStyle('settings', 'settings');
+ Util::addScript('settings', 'vue-settings-apps-users-management');
return $templateResponse;
}
$groupsList = [];
foreach ($groups as $group) {
$groupItem = $groupManager->get($group);
- if ($groupItem instanceof \OCP\IGroup) {
+ if ($groupItem instanceof IGroup) {
$groupsList[] = $groupManager->get($group);
}
}
use OC\Group\Manager as GroupManager;
use OC\User\Session;
+use OCA\Encryption\KeyManager;
+use OCA\Encryption\Recovery;
use OCP\App\IAppManager;
use OCP\AppFramework\Controller;
use OCP\AppFramework\Http\Attribute\BruteForceProtection;
use OCP\IUser;
use OCP\IUserManager;
use OCP\IUserSession;
+use OCP\Server;
class ChangePasswordController extends Controller {
private ?string $userId;
if ($this->appManager->isEnabledForUser('encryption')) {
//handle the recovery case
- $keyManager = \OCP\Server::get(\OCA\Encryption\KeyManager::class);
- $recovery = \OCP\Server::get(\OCA\Encryption\Recovery::class);
+ $keyManager = Server::get(KeyManager::class);
+ $recovery = Server::get(Recovery::class);
$recoveryAdminEnabled = $recovery->isRecoveryKeyEnabled();
$validRecoveryPassword = false;
use OC\AppFramework\Http;
use OC\Encryption\Exceptions\ModuleDoesNotExistsException;
use OC\ForbiddenException;
+use OC\Group\MetaData;
use OC\KnownUser\KnownUserService;
use OC\Security\IdentityProof\Manager;
use OC\User\Manager as UserManager;
use OCP\IUserSession;
use OCP\L10N\IFactory;
use OCP\Mail\IMailer;
+use OCP\Util;
use function in_array;
#[OpenAPI(scope: OpenAPI::SCOPE_IGNORE)]
\OC::$server->getNavigationManager()->setActiveEntry('core_users');
/* SORT OPTION: SORT_USERCOUNT or SORT_GROUPNAME */
- $sortGroupsBy = \OC\Group\MetaData::SORT_USERCOUNT;
+ $sortGroupsBy = MetaData::SORT_USERCOUNT;
$isLDAPUsed = false;
if ($this->config->getSystemValueBool('sort_groups_by_name', false)) {
- $sortGroupsBy = \OC\Group\MetaData::SORT_GROUPNAME;
+ $sortGroupsBy = MetaData::SORT_GROUPNAME;
} else {
if ($this->appManager->isEnabledForUser('user_ldap')) {
$isLDAPUsed =
$this->groupManager->isBackendUsed('\OCA\User_LDAP\Group_Proxy');
if ($isLDAPUsed) {
// LDAP user count can be slow, so we sort by group name here
- $sortGroupsBy = \OC\Group\MetaData::SORT_GROUPNAME;
+ $sortGroupsBy = MetaData::SORT_GROUPNAME;
}
}
}
$canChangePassword = $this->canAdminChangeUserPasswords();
/* GROUPS */
- $groupsInfo = new \OC\Group\MetaData(
+ $groupsInfo = new MetaData(
$uid,
$isAdmin,
$isDelegatedAdmin,
$languages = $this->l10nFactory->getLanguages();
/** Using LDAP or admins (system config) can enfore sorting by group name, in this case the frontend setting is overwritten */
- $forceSortGroupByName = $sortGroupsBy === \OC\Group\MetaData::SORT_GROUPNAME;
+ $forceSortGroupByName = $sortGroupsBy === MetaData::SORT_GROUPNAME;
/* FINAL DATA */
$serverData = [];
$serverData['isAdmin'] = $isAdmin;
$serverData['isDelegatedAdmin'] = $isDelegatedAdmin;
$serverData['sortGroups'] = $forceSortGroupByName
- ? \OC\Group\MetaData::SORT_GROUPNAME
- : (int)$this->config->getAppValue('core', 'group.sortBy', (string)\OC\Group\MetaData::SORT_USERCOUNT);
+ ? MetaData::SORT_GROUPNAME
+ : (int)$this->config->getAppValue('core', 'group.sortBy', (string)MetaData::SORT_USERCOUNT);
$serverData['forceSortGroupByName'] = $forceSortGroupByName;
$serverData['quotaPreset'] = $quotaPreset;
$serverData['allowUnlimitedQuota'] = $allowUnlimitedQuota;
$this->initialState->provideInitialState('usersSettings', $serverData);
- \OCP\Util::addStyle('settings', 'settings');
- \OCP\Util::addScript('settings', 'vue-settings-apps-users-management');
+ Util::addStyle('settings', 'settings');
+ Util::addScript('settings', 'vue-settings-apps-users-management');
return new TemplateResponse('settings', 'settings/empty', ['pageTitle' => $this->l10n->t('Settings')]);
}
use OCP\IBinaryFinder;
use OCP\IConfig;
use OCP\IL10N;
+use OCP\Server;
use OCP\Settings\IDelegatedSettings;
class Mail implements IDelegatedSettings {
public function getForm() {
$parameters = [
// Mail
- 'sendmail_is_available' => (bool)\OCP\Server::get(IBinaryFinder::class)->findBinaryPath('sendmail'),
+ 'sendmail_is_available' => (bool)Server::get(IBinaryFinder::class)->findBinaryPath('sendmail'),
'mail_domain' => $this->config->getSystemValue('mail_domain', ''),
'mail_from_address' => $this->config->getSystemValue('mail_from_address', ''),
'mail_smtpmode' => $this->config->getSystemValue('mail_smtpmode', ''),
$this->initialState->provideInitialState('sharingDocumentation', $this->urlGenerator->linkToDocs('admin-sharing'));
$this->initialState->provideInitialState('sharingSettings', $parameters);
- \OCP\Util::addScript($this->appName, 'vue-settings-admin-sharing');
+ Util::addScript($this->appName, 'vue-settings-admin-sharing');
return new TemplateResponse($this->appName, 'settings/admin/sharing', [], '');
}
*/
namespace OCA\Settings\SetupChecks;
+use OC\Memcache\Memcached;
use OCP\IConfig;
use OCP\IL10N;
use OCP\IURLGenerator;
$memcacheLockingClass = $this->config->getSystemValue('memcache.locking', null);
$memcacheLocalClass = $this->config->getSystemValue('memcache.local', null);
$caches = array_filter([$memcacheDistributedClass,$memcacheLockingClass,$memcacheLocalClass]);
- if (in_array(\OC\Memcache\Memcached::class, array_map(fn (string $class) => ltrim($class, '\\'), $caches))) {
+ if (in_array(Memcached::class, array_map(fn (string $class) => ltrim($class, '\\'), $caches))) {
// wrong PHP module is installed
if (extension_loaded('memcache') && !extension_loaded('memcached')) {
return SetupResult::warning(
use OCP\Accounts\IAccountManager;
use OCP\IAvatarManager;
use OCP\IL10N;
+use OCP\Image;
use OCP\IUser;
use OCP\UserMigration\IExportDestination;
use OCP\UserMigration\IImportSource;
$output->writeln('Importing avatar from ' . $importPath . '…');
$stream = $importSource->getFileAsStream($importPath);
- $image = new \OCP\Image();
+ $image = new Image();
$image->loadFromFileHandle($stream);
try {
use OCP\IUser;
use OCP\IUserManager;
use OCP\IUserSession;
+use OCP\Server;
use OCP\Settings\IDeclarativeManager;
use OCP\Settings\IManager;
use PHPUnit\Framework\MockObject\MockObject;
$this->initialState,
);
- $user = \OCP\Server::get(IUserManager::class)->createUser($this->adminUid, 'mylongrandompassword');
+ $user = Server::get(IUserManager::class)->createUser($this->adminUid, 'mylongrandompassword');
\OC_User::setUserId($user->getUID());
- \OCP\Server::get(IGroupManager::class)->createGroup('admin')->addUser($user);
+ Server::get(IGroupManager::class)->createGroup('admin')->addUser($user);
}
protected function tearDown(): void {
- \OCP\Server::get(IUserManager::class)
+ Server::get(IUserManager::class)
->get($this->adminUid)
->delete();
\OC_User::setUserId(null);
- \OCP\Server::get(IUserSession::class)->setUser(null);
+ Server::get(IUserSession::class)->setUser(null);
parent::tearDown();
}
use OC\Mail\EMailTemplate;
use OC\Mail\Message;
+use OCA\Settings\Mailer\NewUserMailHelper;
use OCP\AppFramework\Utility\ITimeFactory;
use OCP\Defaults;
use OCP\IConfig;
private $config;
/** @var ICrypto|\PHPUnit\Framework\MockObject\MockObject */
private $crypto;
- /** @var \OCA\Settings\Mailer\NewUserMailHelper */
+ /** @var NewUserMailHelper */
private $newUserMailHelper;
protected function setUp(): void {
return $this->l10n;
});
- $this->newUserMailHelper = new \OCA\Settings\Mailer\NewUserMailHelper(
+ $this->newUserMailHelper = new NewUserMailHelper(
$this->defaults,
$this->urlGenerator,
$this->l10nFactory,
public function testBeforeControllerAsUserWithExemption(): void {
- $this->expectException(\OC\AppFramework\Middleware\Security\Exceptions\NotAdminException::class);
+ $this->expectException(NotAdminException::class);
$this->reflector
->expects($this->exactly(2))
use OCP\IBinaryFinder;
use OCP\IConfig;
use OCP\IL10N;
+use OCP\Server;
use Test\TestCase;
class MailTest extends TestCase {
'settings',
'settings/admin/additional-mail',
[
- 'sendmail_is_available' => (bool)\OCP\Server::get(IBinaryFinder::class)->findBinaryPath('sendmail'),
+ 'sendmail_is_available' => (bool)Server::get(IBinaryFinder::class)->findBinaryPath('sendmail'),
'mail_domain' => 'mx.nextcloud.com',
'mail_from_address' => 'no-reply@nextcloud.com',
'mail_smtpmode' => 'smtp',
use OCP\IDBConnection;
use OCP\IL10N;
use OCP\IUrlGenerator;
+use OCP\Server;
use OCP\SetupCheck\SetupResult;
use Test\TestCase;
$this->l10n = $this->getMockBuilder(IL10N::class)->getMock();
$this->urlGenerator = $this->getMockBuilder(IUrlGenerator::class)->getMock();
- $this->connection = \OCP\Server::get(IDBConnection::class);
+ $this->connection = Server::get(IDBConnection::class);
$this->check = new SupportedDatabase(
$this->l10n,
$this->urlGenerator,
- \OCP\Server::get(IDBConnection::class)
+ Server::get(IDBConnection::class)
);
}
use OCP\Share\IManager as IShareManager;
use OCP\Share\IShare;
use OCP\Share\IShareProviderWithNotification;
+use OCP\Util;
use Psr\Log\LoggerInterface;
/**
]
);
}
- $message->setFrom([\OCP\Util::getDefaultEmailAddress($instanceName) => $senderName]);
+ $message->setFrom([Util::getDefaultEmailAddress($instanceName) => $senderName]);
// The "Reply-To" is set to the sharer if an mail address is configured
// also the default footer contains a "Do not reply" which needs to be adjusted.
]
);
}
- $message->setFrom([\OCP\Util::getDefaultEmailAddress($instanceName) => $senderName]);
+ $message->setFrom([Util::getDefaultEmailAddress($instanceName) => $senderName]);
// The "Reply-To" is set to the sharer if an mail address is configured
// also the default footer contains a "Do not reply" which needs to be adjusted.
]
);
}
- $message->setFrom([\OCP\Util::getDefaultEmailAddress($instanceName) => $senderName]);
+ $message->setFrom([Util::getDefaultEmailAddress($instanceName) => $senderName]);
if ($this->settingsManager->replyToInitiator() && $initiatorEmailAddress !== null) {
$message->setReplyTo([$initiatorEmailAddress => $initiatorDisplayName]);
$emailTemplate->addFooter($instanceName . ' - ' . $this->defaults->getSlogan());
$instanceName
]
);
- $message->setFrom([\OCP\Util::getDefaultEmailAddress($instanceName) => $senderName]);
+ $message->setFrom([Util::getDefaultEmailAddress($instanceName) => $senderName]);
$message->setTo([$initiatorEMailAddress => $initiatorDisplayName]);
$message->useTemplate($emailTemplate);
$this->mailer->send($message);
->from('share')
->where(
$qb->expr()->orX(
- $qb->expr()->eq('share_type', $qb->createNamedParameter(\OCP\Share\IShare::TYPE_EMAIL))
+ $qb->expr()->eq('share_type', $qb->createNamedParameter(IShare::TYPE_EMAIL))
)
);
use DateTime;
use OC\Mail\Message;
+use OC\Share20\Share;
use OCA\ShareByMail\Settings\SettingsManager;
use OCA\ShareByMail\ShareByMailProvider;
use OCP\Activity\IManager as IActivityManager;
+use OCP\Constants;
use OCP\Defaults;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\Files\File;
use OCP\Security\IHasher;
use OCP\Security\ISecureRandom;
use OCP\Security\PasswordContext;
+use OCP\Server;
+use OCP\Share\Exceptions\ShareNotFound;
use OCP\Share\IAttributes;
use OCP\Share\IManager;
use OCP\Share\IShare;
+use OCP\Util;
use PHPUnit\Framework\MockObject\MockObject;
use Psr\Log\LoggerInterface;
use Test\TestCase;
protected function setUp(): void {
parent::setUp();
- $this->connection = \OCP\Server::get(IDBConnection::class);
+ $this->connection = Server::get(IDBConnection::class);
$this->l = $this->getMockBuilder(IL10N::class)->getMock();
$this->l->method('t')
public function testGetShareByIdFailed(): void {
- $this->expectException(\OCP\Share\Exceptions\ShareNotFound::class);
+ $this->expectException(ShareNotFound::class);
$instance = $this->getInstance(['createShareObject']);
public function testGetShareByTokenFailed(): void {
- $this->expectException(\OCP\Share\Exceptions\ShareNotFound::class);
+ $this->expectException(ShareNotFound::class);
$itemSource = 11;
public function testGetRawShareFailed(): void {
- $this->expectException(\OCP\Share\Exceptions\ShareNotFound::class);
+ $this->expectException(ShareNotFound::class);
$itemSource = 11;
$itemType = 'file';
$this->shareManager->expects($this->any())
->method('newShare')
- ->willReturn(new \OC\Share20\Share($rootFolder, $userManager));
+ ->willReturn(new Share($rootFolder, $userManager));
$provider = $this->getInstance(['sendMailNotification', 'createShareActivity']);
$this->mailer->expects($this->any())->method('validateMailAddress')->willReturn(true);
$share1->setSharedWith('user@server.com')
->setSharedBy($u1->getUID())
->setShareOwner($u1->getUID())
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file1);
$provider->create($share1);
$share2->setSharedWith('user@server.com')
->setSharedBy($u2->getUID())
->setShareOwner($u1->getUID())
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($file2);
$provider->create($share2);
$this->shareManager->expects($this->any())
->method('newShare')
- ->willReturn(new \OC\Share20\Share($rootFolder, $userManager));
+ ->willReturn(new Share($rootFolder, $userManager));
$provider = $this->getInstance(['sendMailNotification', 'createShareActivity']);
$this->mailer->expects($this->any())->method('validateMailAddress')->willReturn(true);
$share1->setSharedWith('user@server.com')
->setSharedBy($u1->getUID())
->setShareOwner($u1->getUID())
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($folder);
$share1 = $provider->create($share1);
$share2->setSharedWith('user2@server.com')
->setSharedBy($u2->getUID())
->setShareOwner($u1->getUID())
- ->setPermissions(\OCP\Constants::PERMISSION_READ)
+ ->setPermissions(Constants::PERMISSION_READ)
->setNode($folder);
$share2 = $provider->create($share2);
->expects($this->once())
->method('setFrom')
->with([
- \OCP\Util::getDefaultEmailAddress('UnitTestCloud') => 'Mrs. Owner User via UnitTestCloud'
+ Util::getDefaultEmailAddress('UnitTestCloud') => 'Mrs. Owner User via UnitTestCloud'
]);
$user
->expects($this->once())
->expects($this->once())
->method('setFrom')
->with([
- \OCP\Util::getDefaultEmailAddress('UnitTestCloud') => 'Mrs. Owner User via UnitTestCloud'
+ Util::getDefaultEmailAddress('UnitTestCloud') => 'Mrs. Owner User via UnitTestCloud'
]);
$user
->expects($this->once())
->expects($this->once())
->method('setFrom')
->with([
- \OCP\Util::getDefaultEmailAddress('UnitTestCloud') => 'Mrs. Owner User via UnitTestCloud'
+ Util::getDefaultEmailAddress('UnitTestCloud') => 'Mrs. Owner User via UnitTestCloud'
]);
$user
->expects($this->once())
->expects($this->once())
->method('setFrom')
->with([
- \OCP\Util::getDefaultEmailAddress('UnitTestCloud') => 'Mr. Initiator User via UnitTestCloud'
+ Util::getDefaultEmailAddress('UnitTestCloud') => 'Mr. Initiator User via UnitTestCloud'
]);
$message
->expects($this->never())
->expects($this->once())
->method('setFrom')
->with([
- \OCP\Util::getDefaultEmailAddress('UnitTestCloud') => 'UnitTestCloud'
+ Util::getDefaultEmailAddress('UnitTestCloud') => 'UnitTestCloud'
]);
// Since replyToInitiator is false, we never get the initiator email address
$user
->expects($this->once())
->method('setFrom')
->with([
- \OCP\Util::getDefaultEmailAddress('UnitTestCloud') => 'UnitTestCloud'
+ Util::getDefaultEmailAddress('UnitTestCloud') => 'UnitTestCloud'
]);
$message
->expects($this->never())
use OCP\EventDispatcher\IEventDispatcher;
use OCP\SystemTag\ManagerEvent;
use OCP\SystemTag\MapperEvent;
+use OCP\Util;
class Application extends App implements IBootstrap {
public const APP_ID = 'systemtags';
$dispatcher->addListener(
LoadAdditionalScriptsEvent::class,
function (): void {
- \OCP\Util::addScript('core', 'systemtags');
- \OCP\Util::addInitScript(self::APP_ID, 'init');
+ Util::addScript('core', 'systemtags');
+ Util::addInitScript(self::APP_ID, 'init');
}
);
$managerListener = function (ManagerEvent $event) use ($context): void {
- /** @var \OCA\SystemTags\Activity\Listener $listener */
+ /** @var Listener $listener */
$listener = $context->getServerContainer()->query(Listener::class);
$listener->event($event);
};
$dispatcher->addListener(ManagerEvent::EVENT_UPDATE, $managerListener);
$mapperListener = function (MapperEvent $event) use ($context): void {
- /** @var \OCA\SystemTags\Activity\Listener $listener */
+ /** @var Listener $listener */
$listener = $context->getServerContainer()->query(Listener::class);
$listener->mapperEvent($event);
};
use OCP\AppFramework\Http\TemplateResponse;
use OCP\Settings\ISettings;
+use OCP\Util;
class Admin implements ISettings {
* @return TemplateResponse
*/
public function getForm() {
- \OCP\Util::addScript('systemtags', 'admin');
+ Util::addScript('systemtags', 'admin');
return new TemplateResponse('systemtags', 'admin', [], '');
}
*/
namespace OCA\Testing;
+use OC\User\Database;
+
/**
* Alternative home user backend.
*
* ],
* ]
*/
-class AlternativeHomeUserBackend extends \OC\User\Database {
+class AlternativeHomeUserBackend extends Database {
public function __construct() {
parent::__construct();
}
use OCP\AppFramework\Http\Attribute\BruteForceProtection;
use OCP\AppFramework\Http\Attribute\NoCSRFRequired;
use OCP\AppFramework\Http\Attribute\PublicPage;
+use OCP\AppFramework\Http\ContentSecurityPolicy;
use OCP\AppFramework\Http\DataDisplayResponse;
use OCP\AppFramework\Http\DataResponse;
use OCP\AppFramework\Http\FileDisplayResponse;
}
$response = new FileDisplayResponse($file);
- $csp = new Http\ContentSecurityPolicy();
+ $csp = new ContentSecurityPolicy();
$csp->allowInlineStyle();
$response->setContentSecurityPolicy($csp);
$response->cacheFor(3600);
use OCP\AppFramework\Http\FileDisplayResponse;
use OCP\AppFramework\Http\JSONResponse;
use OCP\AppFramework\Http\NotFoundResponse;
+use OCP\AppFramework\Http\Response;
use OCP\AppFramework\OCS\OCSBadRequestException;
use OCP\AppFramework\OCS\OCSForbiddenException;
use OCP\AppFramework\OCSController;
*/
#[NoAdminRequired]
#[NoCSRFRequired]
- public function getBackground(): Http\Response {
+ public function getBackground(): Response {
$file = $this->backgroundService->getBackground();
if ($file !== null) {
$response = new FileDisplayResponse($file, Http::STATUS_OK, ['Content-Type' => $file->getMimeType()]);
use OCP\EventDispatcher\IEventListener;
use OCP\IConfig;
use OCP\IUserSession;
+use OCP\Util;
use Psr\Container\ContainerInterface;
/** @template-implements IEventListener<BeforeTemplateRenderedEvent|BeforeLoginTemplateRenderedEvent> */
$this->themeInjectionService->injectHeaders();
// Making sure to inject just after core
- \OCP\Util::addScript('theming', 'theming', 'core');
+ Util::addScript('theming', 'theming', 'core');
}
}
use OCA\Theming\Jobs\MigrateBackgroundImages;
use OCP\BackgroundJob\IJobList;
use OCP\Migration\IOutput;
+use OCP\Migration\IRepairStep;
-class InitBackgroundImagesMigration implements \OCP\Migration\IRepairStep {
+class InitBackgroundImagesMigration implements IRepairStep {
private IJobList $jobList;
use OCP\BackgroundJob\IJobList;
use OCP\IAppConfig;
use OCP\IDBConnection;
+use OCP\Migration\IMigrationStep;
use OCP\Migration\IOutput;
// This can only be executed once because `background_color` is again used with Nextcloud 30,
// so this part only works when updating -> Nextcloud 29 -> 30
-class Version2006Date20240905111627 implements \OCP\Migration\IMigrationStep {
+class Version2006Date20240905111627 implements IMigrationStep {
public function __construct(
private IJobList $jobList,
use OCP\Files\SimpleFS\ISimpleFolder;
use OCP\IAppConfig;
use OCP\IConfig;
+use OCP\Image;
use OCP\Lock\LockedException;
use OCP\PreConditionNotMetException;
use RuntimeException;
public function recalculateMeanColor(?string $userId = null): void {
$userId = $userId ?? $this->getUserId();
- $image = new \OCP\Image();
+ $image = new Image();
$handle = $this->getAppDataFolder($userId)->getFile('background.jpg')->read();
if ($handle === false || $image->loadFromFileHandle($handle) === false) {
throw new InvalidArgumentException('Invalid image file');
* @return string|null The fallback background color - if any
*/
public function setGlobalBackground($path): ?string {
- $image = new \OCP\Image();
+ $image = new Image();
$handle = is_resource($path) ? $path : fopen($path, 'rb');
if ($handle && $image->loadFromFileHandle($handle) !== false) {
* Calculate mean color of an given image
* It only takes the upper part into account so that a matching text color can be derived for the app menu
*/
- private function calculateMeanColor(\OCP\Image $image): false|string {
+ private function calculateMeanColor(Image $image): false|string {
/**
* Small helper to ensure one channel is returned as 8byte hex
*/
};
}
- $tempImage = new \OCP\Image();
+ $tempImage = new Image();
// Crop to only analyze top bar
$resource = $image->cropNew(0, 0, $image->width(), min(max(50, (int)($image->height() * 0.125)), $image->height()));
use OCA\Theming\ThemingDefaults;
use OCP\App\IAppManager;
use OCP\AppFramework\Http;
+use OCP\AppFramework\Http\ContentSecurityPolicy;
use OCP\AppFramework\Http\DataResponse;
+use OCP\AppFramework\Http\FileDisplayResponse;
+use OCP\AppFramework\Http\JSONResponse;
+use OCP\AppFramework\Http\NotFoundResponse;
use OCP\AppFramework\Services\IAppConfig;
use OCP\AppFramework\Utility\ITimeFactory;
use OCP\Files\NotFoundException;
->with($this->equalTo('logo'))
->willThrowException(new NotFoundException());
- $expected = new Http\NotFoundResponse();
+ $expected = new NotFoundResponse();
$this->assertEquals($expected, $this->themingController->getImage('logo'));
}
->with('theming', 'logoMime', '')
->willReturn('text/svg');
- @$expected = new Http\FileDisplayResponse($file);
+ @$expected = new FileDisplayResponse($file);
$expected->cacheFor(3600);
$expected->addHeader('Content-Type', 'text/svg');
$expected->addHeader('Content-Disposition', 'attachment; filename="logo"');
- $csp = new Http\ContentSecurityPolicy();
+ $csp = new ContentSecurityPolicy();
$csp->allowInlineStyle();
$expected->setContentSecurityPolicy($csp);
@$this->assertEquals($expected, $this->themingController->getImage('logo'));
$this->imageManager->method('getImage')
->with($this->equalTo('background'))
->willThrowException(new NotFoundException());
- $expected = new Http\NotFoundResponse();
+ $expected = new NotFoundResponse();
$this->assertEquals($expected, $this->themingController->getImage('background'));
}
->with('theming', 'backgroundMime', '')
->willReturn('image/png');
- @$expected = new Http\FileDisplayResponse($file);
+ @$expected = new FileDisplayResponse($file);
$expected->cacheFor(3600);
$expected->addHeader('Content-Type', 'image/png');
$expected->addHeader('Content-Disposition', 'attachment; filename="background"');
- $csp = new Http\ContentSecurityPolicy();
+ $csp = new ContentSecurityPolicy();
$csp->allowInlineStyle();
$expected->setContentSecurityPolicy($csp);
@$this->assertEquals($expected, $this->themingController->getImage('background'));
['theming.Icon.getTouchIcon', ['app' => 'core'], 'touchicon'],
['theming.Icon.getFavicon', ['app' => 'core'], 'favicon'],
]);
- $response = new Http\JSONResponse([
+ $response = new JSONResponse([
'name' => 'Nextcloud',
'start_url' => 'localhost',
'icons' =>
public function testGetImageUnset(): void {
- $this->expectException(\OCP\Files\NotFoundException::class);
+ $this->expectException(NotFoundException::class);
$this->config->expects($this->once())
->method('getAppValue')->with('theming', 'logoMime', false)
public function testGetCachedImageNotFound(): void {
- $this->expectException(\OCP\Files\NotFoundException::class);
+ $this->expectException(NotFoundException::class);
$folder = $this->setupCacheFolder();
$folder->expects($this->once())
->method('getFile')
->with('filename')
- ->will($this->throwException(new \OCP\Files\NotFoundException()));
+ ->will($this->throwException(new NotFoundException()));
$image = $this->imageManager->getCachedImage('filename');
}
namespace OCA\Theming\Tests\Service;
use OC\Route\Router;
+use OC\URLGenerator;
use OCA\Theming\ImageManager;
use OCA\Theming\ITheme;
use OCA\Theming\Themes\DyslexiaFont;
$cacheFactory = $this->createMock(ICacheFactory::class);
$request = $this->createMock(IRequest::class);
$router = $this->createMock(Router::class);
- $this->urlGenerator = new \OC\URLGenerator(
+ $this->urlGenerator = new URLGenerator(
$this->config,
$userSession,
$cacheFactory,
use OCP\Files\SimpleFS\ISimpleFile;
use OCP\Files\SimpleFS\ISimpleFolder;
use OCP\IConfig;
+use OCP\Server;
use OCP\ServerVersion;
use PHPUnit\Framework\MockObject\MockObject;
use Test\TestCase;
parent::setUp();
$this->config = $this->createMock(IConfig::class);
$this->appData = $this->createMock(IAppData::class);
- $this->appManager = \OCP\Server::get(IAppManager::class);
+ $this->appManager = Server::get(IAppManager::class);
$this->imageManager = $this->createMock(ImageManager::class);
$this->util = new Util($this->createMock(ServerVersion::class), $this->config, $this->appManager, $this->appData, $this->imageManager);
}
public function dataGetAppIcon() {
return [
- ['user_ldap', \OCP\Server::get(IAppManager::class)->getAppPath('user_ldap') . '/img/app.svg'],
+ ['user_ldap', Server::get(IAppManager::class)->getAppPath('user_ldap') . '/img/app.svg'],
['noapplikethis', \OC::$SERVERROOT . '/core/img/logo/logo.svg'],
- ['comments', \OCP\Server::get(IAppManager::class)->getAppPath('comments') . '/img/comments.svg'],
+ ['comments', Server::get(IAppManager::class)->getAppPath('comments') . '/img/comments.svg'],
];
}
namespace OCA\TwoFactorBackupCodes\Tests\Service;
use OCA\TwoFactorBackupCodes\Service\BackupCodeStorage;
+use OCP\IUser;
use OCP\Notification\IManager;
use OCP\Notification\INotification;
use Test\TestCase;
}
public function testSimpleWorkFlow(): void {
- $user = $this->getMockBuilder(\OCP\IUser::class)->getMock();
+ $user = $this->getMockBuilder(IUser::class)->getMock();
$user->expects($this->any())
->method('getUID')
->willReturn($this->testUID);
use OCP\AppFramework\Http\TemplateResponse;
use OCP\AppFramework\Services\IInitialState;
use OCP\IRequest;
+use OCP\Util;
#[OpenAPI(scope: OpenAPI::SCOPE_IGNORE)]
class ChangelogController extends Controller {
'text' => $changes,
]);
- \OCP\Util::addScript($this->appName, 'view-changelog-page');
+ Util::addScript($this->appName, 'view-changelog-page');
return new TemplateResponse($this->appName, 'empty');
}
}
use OCP\EventDispatcher\Event;
use OCP\EventDispatcher\IEventListener;
use OCP\IAppConfig;
+use OCP\Util;
use Psr\Log\LoggerInterface;
/** @template-implements IEventListener<BeforeTemplateRenderedEvent> */
return;
}
- \OCP\Util::addInitScript(Application::APP_NAME, 'init');
+ Util::addInitScript(Application::APP_NAME, 'init');
}
}
namespace OCA\UpdateNotification\Migration;
use OCA\UpdateNotification\BackgroundJob\ResetToken;
+use OCA\UpdateNotification\Notification\BackgroundJob;
+use OCA\UpdateNotification\ResetTokenBackgroundJob;
use OCP\BackgroundJob\IJobList;
use OCP\Migration\IOutput;
use OCP\Migration\SimpleMigrationStep;
* This class was renamed so it is now unknow but we still need to remove it
* @psalm-suppress UndefinedClass, InvalidArgument
*/
- $hasOldResetToken = $this->joblist->has(\OCA\UpdateNotification\ResetTokenBackgroundJob::class, null);
+ $hasOldResetToken = $this->joblist->has(ResetTokenBackgroundJob::class, null);
$hasNewResetToken = $this->joblist->has(ResetToken::class, null);
if ($hasOldResetToken) {
/**
* @psalm-suppress UndefinedClass, InvalidArgument
*/
- $this->joblist->remove(\OCA\UpdateNotification\ResetTokenBackgroundJob::class);
+ $this->joblist->remove(ResetTokenBackgroundJob::class);
if (!$hasNewResetToken) {
$this->joblist->add(ResetToken::class);
}
* Remove the "has updates" background job, the new one is automatically started from the info.xml
* @psalm-suppress UndefinedClass, InvalidArgument
*/
- if ($this->joblist->has(\OCA\UpdateNotification\Notification\BackgroundJob::class, null)) {
+ if ($this->joblist->has(BackgroundJob::class, null)) {
/**
* @psalm-suppress UndefinedClass, InvalidArgument
*/
- $this->joblist->remove(\OCA\UpdateNotification\Notification\BackgroundJob::class);
+ $this->joblist->remove(BackgroundJob::class);
}
}
}
use OCP\Notification\INotification;
use OCP\Notification\INotifier;
use OCP\Notification\UnknownNotificationException;
+use OCP\Server;
use OCP\Util;
class Notifier implements INotifier {
}
protected function getAppInfo($appId, $languageCode) {
- return \OCP\Server::get(IAppManager::class)->getAppInfo($appId, false, $languageCode);
+ return Server::get(IAppManager::class)->getAppInfo($appId, false, $languageCode);
}
}
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
-
use OCA\User_LDAP\Mapping\GroupMapping;
use OCA\User_LDAP\Mapping\UserMapping;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\Server;
use OCP\User\Events\BeforeUserIdUnassignedEvent;
use OCP\User\Events\UserIdUnassignedEvent;
+use OCP\Util;
// Check user and app status
\OC_JSON::checkAdminUser();
}
if ($mapping === null || !$result) {
- $l = \OCP\Util::getL10N('user_ldap');
+ $l = Util::getL10N('user_ldap');
throw new \Exception($l->t('Failed to clear the mappings.'));
}
\OC_JSON::success();
<?php
+use OCA\User_LDAP\Helper;
+use OCP\Util;
+
/**
* SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
\OC_JSON::callCheck();
$prefix = (string)$_POST['ldap_serverconfig_chooser'];
-$helper = new \OCA\User_LDAP\Helper(\OC::$server->getConfig(), \OC::$server->getDatabaseConnection());
+$helper = new Helper(\OC::$server->getConfig(), \OC::$server->getDatabaseConnection());
if ($helper->deleteServerConfiguration($prefix)) {
\OC_JSON::success();
} else {
- $l = \OCP\Util::getL10N('user_ldap');
+ $l = Util::getL10N('user_ldap');
\OC_JSON::error(['message' => $l->t('Failed to delete the server configuration')]);
}
<?php
+use OCA\User_LDAP\LDAP;
+
/**
* SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
\OC_JSON::callCheck();
$prefix = (string)$_POST['ldap_serverconfig_chooser'];
-$ldapWrapper = new OCA\User_LDAP\LDAP();
+$ldapWrapper = new LDAP();
$connection = new \OCA\User_LDAP\Connection($ldapWrapper, $prefix);
$configuration = $connection->getConfiguration();
if (isset($configuration['ldap_agent_password']) && $configuration['ldap_agent_password'] !== '') {
<?php
+use OCA\User_LDAP\Configuration;
+use OCA\User_LDAP\Helper;
+
/**
* SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
\OC_JSON::checkAppEnabled('user_ldap');
\OC_JSON::callCheck();
-$helper = new \OCA\User_LDAP\Helper(\OC::$server->getConfig(), \OC::$server->getDatabaseConnection());
+$helper = new Helper(\OC::$server->getConfig(), \OC::$server->getDatabaseConnection());
$serverConnections = $helper->getServerConfigurationPrefixes();
sort($serverConnections);
$lk = array_pop($serverConnections);
$resultData = ['configPrefix' => $nk];
-$newConfig = new \OCA\User_LDAP\Configuration($nk, false);
+$newConfig = new Configuration($nk, false);
if (isset($_POST['copyConfig'])) {
- $originalConfig = new \OCA\User_LDAP\Configuration($_POST['copyConfig']);
+ $originalConfig = new Configuration($_POST['copyConfig']);
$newConfig->setConfiguration($originalConfig->getConfiguration());
} else {
- $configuration = new \OCA\User_LDAP\Configuration($nk, false);
+ $configuration = new Configuration($nk, false);
$newConfig->setConfiguration($configuration->getDefaults());
$resultData['defaults'] = $configuration->getDefaults();
}
<?php
+use OCA\User_LDAP\LDAP;
+
/**
* SPDX-FileCopyrightText: 2018-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
}
}
-$ldapWrapper = new OCA\User_LDAP\LDAP();
+$ldapWrapper = new LDAP();
$connection = new \OCA\User_LDAP\Connection($ldapWrapper, $prefix);
$connection->setConfiguration($_POST);
$connection->saveConfiguration();
<?php
+use OCA\User_LDAP\LDAP;
+use OCP\Util;
+
/**
* SPDX-FileCopyrightText: 2017-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
\OC_JSON::checkAppEnabled('user_ldap');
\OC_JSON::callCheck();
-$l = \OCP\Util::getL10N('user_ldap');
+$l = Util::getL10N('user_ldap');
-$ldapWrapper = new OCA\User_LDAP\LDAP();
+$ldapWrapper = new LDAP();
$connection = new \OCA\User_LDAP\Connection($ldapWrapper, $_POST['ldap_serverconfig_chooser']);
<?php
+use OCA\User_LDAP\AccessFactory;
+use OCA\User_LDAP\Configuration;
+use OCA\User_LDAP\LDAP;
+use OCA\User_LDAP\Wizard;
+use OCP\Util;
+
/**
* SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
\OC_JSON::checkAppEnabled('user_ldap');
\OC_JSON::callCheck();
-$l = \OCP\Util::getL10N('user_ldap');
+$l = Util::getL10N('user_ldap');
if (!isset($_POST['action'])) {
\OC_JSON::error(['message' => $l->t('No action specified')]);
}
$prefix = (string)$_POST['ldap_serverconfig_chooser'];
-$ldapWrapper = new \OCA\User_LDAP\LDAP();
-$configuration = new \OCA\User_LDAP\Configuration($prefix);
+$ldapWrapper = new LDAP();
+$configuration = new Configuration($prefix);
$con = new \OCA\User_LDAP\Connection($ldapWrapper, $prefix, null);
$con->setConfiguration($configuration->getConfiguration());
$con->ldapConfigurationActive = (string)true;
$con->setIgnoreValidation(true);
-$factory = \OC::$server->get(\OCA\User_LDAP\AccessFactory::class);
+$factory = \OC::$server->get(AccessFactory::class);
$access = $factory->get($con);
-$wizard = new \OCA\User_LDAP\Wizard($configuration, $ldapWrapper, $access);
+$wizard = new Wizard($configuration, $ldapWrapper, $access);
switch ($action) {
case 'guessPortAndTLS':
declare(strict_types=1);
+use OCA\User_LDAP\AppInfo\Application;
+use OCP\AppFramework\App;
+
/**
* SPDX-FileCopyrightText: 2017-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
$this->create('user_ldap_ajax_wizard', 'apps/user_ldap/ajax/wizard.php')
->actionInclude('user_ldap/ajax/wizard.php');
-$application = new \OCP\AppFramework\App('user_ldap');
+$application = new App('user_ldap');
$application->registerRoutes($this, [
'ocs' => [
['name' => 'ConfigAPI#create', 'url' => '/api/v1/config', 'verb' => 'POST'],
]
]);
-/** @var \OCA\User_LDAP\AppInfo\Application $application */
-$application = \OC::$server->query(\OCA\User_LDAP\AppInfo\Application::class);
+/** @var Application $application */
+$application = \OC::$server->query(Application::class);
$application->registerRoutes($this, [
'routes' => [
['name' => 'renewPassword#tryRenewPassword', 'url' => '/renewpassword', 'verb' => 'POST'],
use OCP\IConfig;
use OCP\IUserManager;
use OCP\User\Events\UserIdAssignedEvent;
+use OCP\Util;
use Psr\Log\LoggerInterface;
use function strlen;
use function substr;
return false;
}
//LDAP attributes are not case sensitive
- $result = \OCP\Util::mb_array_change_key_case(
+ $result = Util::mb_array_change_key_case(
$this->invokeLDAPMethod('getAttributes', $er), MB_CASE_LOWER, 'UTF-8');
return $result;
return @$this->invokeLDAPMethod('exopPasswd', $userDN, '', $password) ||
@$this->invokeLDAPMethod('modReplace', $userDN, $password);
} catch (ConstraintViolationException $e) {
- throw new HintException('Password change rejected.', \OCP\Util::getL10N('user_ldap')->t('Password change rejected. Hint: ') . $e->getMessage(), (int)$e->getCode());
+ throw new HintException('Password change rejected.', Util::getL10N('user_ldap')->t('Password change rejected. Hint: ') . $e->getMessage(), (int)$e->getCode());
}
}
if (!is_array($item)) {
continue;
}
- $item = \OCP\Util::mb_array_change_key_case($item, MB_CASE_LOWER, 'UTF-8');
+ $item = Util::mb_array_change_key_case($item, MB_CASE_LOWER, 'UTF-8');
foreach ($attr as $key) {
if (isset($item[$key])) {
if (is_array($item[$key]) && isset($item[$key]['count'])) {
use OCP\Notification\IManager as INotificationManager;
use OCP\Share\IManager as IShareManager;
use OCP\User\Events\PostLoginEvent;
+use OCP\Util;
use Psr\Container\ContainerInterface;
use Psr\Log\LoggerInterface;
$context->injectFn(Closure::fromCallable([$this, 'registerBackendDependents']));
- \OCP\Util::connectHook(
+ Util::connectHook(
'\OCA\Files_Sharing\API\Server2Server',
'preLoginNameUsedAsUserName',
'\OCA\User_LDAP\Helper',
*/
namespace OCA\User_LDAP;
+use OCP\Server;
use Psr\Log\LoggerInterface;
/**
return [strtolower($attribute)];
}
if ($value !== self::AVATAR_PREFIX_DEFAULT) {
- \OCP\Server::get(LoggerInterface::class)->warning('Invalid config value to ldapUserAvatarRule; falling back to default.');
+ Server::get(LoggerInterface::class)->warning('Invalid config value to ldapUserAvatarRule; falling back to default.');
}
return $defaultAttributes;
}
*/
namespace OCA\User_LDAP;
+use OC\Files\Filesystem;
+
/**
* @brief wraps around static Nextcloud core methods
*/
* @return bool
*/
public function isLoaded() {
- return \OC\Files\Filesystem::$loaded;
+ return Filesystem::$loaded;
}
/**
namespace OCA\User_LDAP;
use OCP\GroupInterface;
+use OCP\Server;
use Psr\Log\LoggerInterface;
class GroupPluginManager {
foreach ($this->which as $action => $v) {
if ((bool)($respondToActions & $action)) {
$this->which[$action] = $plugin;
- \OCP\Server::get(LoggerInterface::class)->debug('Registered action ' . $action . ' to plugin ' . get_class($plugin), ['app' => 'user_ldap']);
+ Server::get(LoggerInterface::class)->debug('Registered action ' . $action . ' to plugin ' . get_class($plugin), ['app' => 'user_ldap']);
}
}
}
use OCP\IConfig;
use OCP\IUserManager;
-class Group_Proxy extends Proxy implements \OCP\GroupInterface, IGroupLDAP, IGetDisplayNameBackend, INamedBackend, IDeleteGroupBackend, IBatchMethodsBackend, IIsAdminBackend {
+class Group_Proxy extends Proxy implements GroupInterface, IGroupLDAP, IGetDisplayNameBackend, INamedBackend, IDeleteGroupBackend, IBatchMethodsBackend, IIsAdminBackend {
private $backends = [];
private ?Group_LDAP $refBackend = null;
private Helper $helper;
use OCA\User_LDAP\User_Proxy;
use OCP\AppFramework\Utility\ITimeFactory;
use OCP\BackgroundJob\TimedJob;
+use OCP\Server;
/**
* Class CleanUp
if (isset($arguments['mapping'])) {
$this->mapping = $arguments['mapping'];
} else {
- $this->mapping = \OCP\Server::get(UserMapping::class);
+ $this->mapping = Server::get(UserMapping::class);
}
if (isset($arguments['deletedUsersIndex'])) {
use OCA\User_LDAP\Exceptions\ConstraintViolationException;
use OCP\IConfig;
use OCP\Profiler\IProfiler;
+use OCP\Server;
use Psr\Log\LoggerInterface;
class LDAP implements ILDAPWrapper {
$profiler->add($this->dataCollector);
}
- $this->logger = \OCP\Server::get(LoggerInterface::class);
+ $this->logger = Server::get(LoggerInterface::class);
}
/**
use OCP\DB\IPreparedStatement;
use OCP\DB\QueryBuilder\IQueryBuilder;
use OCP\IDBConnection;
+use OCP\Server;
use Psr\Log\LoggerInterface;
/**
/**
* @param \OCP\IDBConnection $dbc
*/
- public function __construct(\OCP\IDBConnection $dbc) {
+ public function __construct(IDBConnection $dbc) {
$this->dbc = $dbc;
}
*/
public function map($fdn, $name, $uuid) {
if (mb_strlen($fdn) > 4000) {
- \OCP\Server::get(LoggerInterface::class)->error(
+ Server::get(LoggerInterface::class)->error(
'Cannot map, because the DN exceeds 4000 characters: {dn}',
[
'app' => 'user_ldap',
/**
* @param IFactory $l10nFactory
*/
- public function __construct(\OCP\L10N\IFactory $l10nFactory) {
+ public function __construct(IFactory $l10nFactory) {
$this->l10nFactory = $l10nFactory;
}
* property array
* @param string $dn the DN of the user
* @param string $uid the internal (owncloud) username
- * @return \OCA\User_LDAP\User\User
+ * @return User
*/
private function createAndCache($dn, $uid) {
$this->checkAccess();
/**
* creates and returns an instance of OfflineUser for the specified user
* @param string $id
- * @return \OCA\User_LDAP\User\OfflineUser
+ * @return OfflineUser
*/
public function getDeletedUser($id) {
return new OfflineUser(
/**
* @brief returns a User object by its Nextcloud username
* @param string $id the DN or username of the user
- * @return \OCA\User_LDAP\User\User|\OCA\User_LDAP\User\OfflineUser|null
+ * @return User|OfflineUser|null
*/
protected function createInstancyByUserName($id) {
//most likely a uid. Check whether it is a deleted user
/**
* @brief returns a User object by its DN or Nextcloud username
* @param string $id the DN or username of the user
- * @return \OCA\User_LDAP\User\User|\OCA\User_LDAP\User\OfflineUser|null
+ * @return User|OfflineUser|null
* @throws \Exception when connection could not be established
*/
public function get($id) {
*/
protected $db;
/**
- * @var \OCA\User_LDAP\Mapping\UserMapping
+ * @var UserMapping
*/
protected $mapping;
/** @var IManager */
use OCP\IUserManager;
use OCP\Notification\IManager as INotificationManager;
use OCP\Server;
+use OCP\Util;
use Psr\Log\LoggerInterface;
/**
$this->notificationManager = $notificationManager;
$this->birthdateParser = new BirthdateParserService();
- \OCP\Util::connectHook('OC_User', 'post_login', $this, 'handlePasswordExpiry');
+ Util::connectHook('OC_User', 'post_login', $this, 'handlePasswordExpiry');
}
/**
//User Profile Field - Phone number
$attr = strtolower($this->connection->ldapAttributePhone);
if (!empty($attr)) { // attribute configured
- $profileValues[\OCP\Accounts\IAccountManager::PROPERTY_PHONE]
+ $profileValues[IAccountManager::PROPERTY_PHONE]
= $ldapEntry[$attr][0] ?? '';
}
//User Profile Field - website
$cutPosition = strpos($ldapEntry[$attr][0], ' ');
if ($cutPosition) {
// drop appended label
- $profileValues[\OCP\Accounts\IAccountManager::PROPERTY_WEBSITE]
+ $profileValues[IAccountManager::PROPERTY_WEBSITE]
= substr($ldapEntry[$attr][0], 0, $cutPosition);
} else {
- $profileValues[\OCP\Accounts\IAccountManager::PROPERTY_WEBSITE]
+ $profileValues[IAccountManager::PROPERTY_WEBSITE]
= $ldapEntry[$attr][0];
}
} elseif (!empty($attr)) { // configured, but not defined
- $profileValues[\OCP\Accounts\IAccountManager::PROPERTY_WEBSITE] = '';
+ $profileValues[IAccountManager::PROPERTY_WEBSITE] = '';
}
//User Profile Field - Address
$attr = strtolower($this->connection->ldapAttributeAddress);
if (isset($ldapEntry[$attr])) {
if (str_contains($ldapEntry[$attr][0], '$')) {
// basic format conversion from postalAddress syntax to commata delimited
- $profileValues[\OCP\Accounts\IAccountManager::PROPERTY_ADDRESS]
+ $profileValues[IAccountManager::PROPERTY_ADDRESS]
= str_replace('$', ', ', $ldapEntry[$attr][0]);
} else {
- $profileValues[\OCP\Accounts\IAccountManager::PROPERTY_ADDRESS]
+ $profileValues[IAccountManager::PROPERTY_ADDRESS]
= $ldapEntry[$attr][0];
}
} elseif (!empty($attr)) { // configured, but not defined
- $profileValues[\OCP\Accounts\IAccountManager::PROPERTY_ADDRESS] = '';
+ $profileValues[IAccountManager::PROPERTY_ADDRESS] = '';
}
//User Profile Field - Twitter
$attr = strtolower($this->connection->ldapAttributeTwitter);
if (!empty($attr)) {
- $profileValues[\OCP\Accounts\IAccountManager::PROPERTY_TWITTER]
+ $profileValues[IAccountManager::PROPERTY_TWITTER]
= $ldapEntry[$attr][0] ?? '';
}
//User Profile Field - fediverse
$attr = strtolower($this->connection->ldapAttributeFediverse);
if (!empty($attr)) {
- $profileValues[\OCP\Accounts\IAccountManager::PROPERTY_FEDIVERSE]
+ $profileValues[IAccountManager::PROPERTY_FEDIVERSE]
= $ldapEntry[$attr][0] ?? '';
}
//User Profile Field - organisation
$attr = strtolower($this->connection->ldapAttributeOrganisation);
if (!empty($attr)) {
- $profileValues[\OCP\Accounts\IAccountManager::PROPERTY_ORGANISATION]
+ $profileValues[IAccountManager::PROPERTY_ORGANISATION]
= $ldapEntry[$attr][0] ?? '';
}
//User Profile Field - role
$attr = strtolower($this->connection->ldapAttributeRole);
if (!empty($attr)) {
- $profileValues[\OCP\Accounts\IAccountManager::PROPERTY_ROLE]
+ $profileValues[IAccountManager::PROPERTY_ROLE]
= $ldapEntry[$attr][0] ?? '';
}
//User Profile Field - headline
$attr = strtolower($this->connection->ldapAttributeHeadline);
if (!empty($attr)) {
- $profileValues[\OCP\Accounts\IAccountManager::PROPERTY_HEADLINE]
+ $profileValues[IAccountManager::PROPERTY_HEADLINE]
= $ldapEntry[$attr][0] ?? '';
}
//User Profile Field - biography
if (isset($ldapEntry[$attr])) {
if (str_contains($ldapEntry[$attr][0], '\r')) {
// convert line endings
- $profileValues[\OCP\Accounts\IAccountManager::PROPERTY_BIOGRAPHY]
+ $profileValues[IAccountManager::PROPERTY_BIOGRAPHY]
= str_replace(["\r\n","\r"], "\n", $ldapEntry[$attr][0]);
} else {
- $profileValues[\OCP\Accounts\IAccountManager::PROPERTY_BIOGRAPHY]
+ $profileValues[IAccountManager::PROPERTY_BIOGRAPHY]
= $ldapEntry[$attr][0];
}
} elseif (!empty($attr)) { // configured, but not defined
- $profileValues[\OCP\Accounts\IAccountManager::PROPERTY_BIOGRAPHY] = '';
+ $profileValues[IAccountManager::PROPERTY_BIOGRAPHY] = '';
}
//User Profile Field - birthday
$attr = strtolower($this->connection->ldapAttributeBirthDate);
$value = $ldapEntry[$attr][0];
try {
$birthdate = $this->birthdateParser->parseBirthdate($value);
- $profileValues[\OCP\Accounts\IAccountManager::PROPERTY_BIRTHDATE]
+ $profileValues[IAccountManager::PROPERTY_BIRTHDATE]
= $birthdate->format('Y-m-d');
} catch (InvalidArgumentException $e) {
// Invalid date -> just skip the property
//User Profile Field - pronouns
$attr = strtolower($this->connection->ldapAttributePronouns);
if (!empty($attr)) {
- $profileValues[\OCP\Accounts\IAccountManager::PROPERTY_PRONOUNS]
+ $profileValues[IAccountManager::PROPERTY_PRONOUNS]
= $ldapEntry[$attr][0] ?? '';
}
// check for changed data and cache just for TTL checking
// system must be postponed after the login. It is to ensure
// external mounts are mounted properly (e.g. with login
// credentials from the session).
- \OCP\Util::connectHook('OC_User', 'post_login', $this, 'updateAvatarPostLogin');
+ Util::connectHook('OC_User', 'post_login', $this, 'updateAvatarPostLogin');
break;
}
}
namespace OCA\User_LDAP;
use OC\User\Backend;
+use OCP\Server;
use Psr\Log\LoggerInterface;
class UserPluginManager {
foreach ($this->which as $action => $v) {
if (is_int($action) && (bool)($respondToActions & $action)) {
$this->which[$action] = $plugin;
- \OCP\Server::get(LoggerInterface::class)->debug('Registered action ' . $action . ' to plugin ' . get_class($plugin), ['app' => 'user_ldap']);
+ Server::get(LoggerInterface::class)->debug('Registered action ' . $action . ' to plugin ' . get_class($plugin), ['app' => 'user_ldap']);
}
}
if (method_exists($plugin, 'deleteUser')) {
$this->which['deleteUser'] = $plugin;
- \OCP\Server::get(LoggerInterface::class)->debug('Registered action deleteUser to plugin ' . get_class($plugin), ['app' => 'user_ldap']);
+ Server::get(LoggerInterface::class)->debug('Registered action deleteUser to plugin ' . get_class($plugin), ['app' => 'user_ldap']);
}
}
/**
* checks whether a user is still available on LDAP
*
- * @param string|\OCA\User_LDAP\User\User $user either the Nextcloud user
- * name or an instance of that user
+ * @param string|User $user either the Nextcloud user
+ * name or an instance of that user
* @throws \Exception
* @throws \OC\ServerNotAvailableException
*/
/**
* 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
+ * @param string|User $user either the Nextcloud user
+ * name or an instance of that user
*/
public function userExistsOnLDAP($user, bool $ignoreCache = false): bool {
$id = ($user instanceof User) ? $user->getUsername() : $user;
use OC\ServerNotAvailableException;
use OCP\IL10N;
use OCP\L10N\IFactory as IL10NFactory;
+use OCP\Util;
use Psr\Log\LoggerInterface;
class Wizard extends LDAPUtility {
}
// strtolower on all keys for proper comparison
- $result = \OCP\Util::mb_array_change_key_case($result);
+ $result = Util::mb_array_change_key_case($result);
$attribute = strtolower($attribute);
if (isset($result[$attribute])) {
foreach ($result[$attribute] as $key => $val) {
*/
namespace OCA\User_LDAP\Tests;
+use OC\ServerNotAvailableException;
use OCA\User_LDAP\Access;
use OCA\User_LDAP\Connection;
use OCA\User_LDAP\Exceptions\ConstraintViolationException;
use OCA\User_LDAP\User\OfflineUser;
use OCA\User_LDAP\User\User;
use OCP\EventDispatcher\IEventDispatcher;
+use OCP\HintException;
use OCP\IAppConfig;
use OCP\IAvatarManager;
use OCP\IConfig;
$this->connection
->expects($this->once())
->method('getConnectionResource')
- ->willThrowException(new \OC\ServerNotAvailableException('Connection to LDAP server could not be established'));
+ ->willThrowException(new ServerNotAvailableException('Connection to LDAP server could not be established'));
$this->ldap
->expects($this->never())
->method('isResource');
- $this->expectException(\OC\ServerNotAvailableException::class);
+ $this->expectException(ServerNotAvailableException::class);
$this->expectExceptionMessage('Connection to LDAP server could not be established');
$this->access->setPassword('CN=foo', 'MyPassword');
}
public function testSetPasswordWithRejectedChange(): void {
- $this->expectException(\OCP\HintException::class);
+ $this->expectException(HintException::class);
$this->expectExceptionMessage('Password change rejected.');
$this->connection
*/
namespace OCA\User_LDAP\Tests;
+use OC\ServerNotAvailableException;
use OCA\User_LDAP\Connection;
use OCA\User_LDAP\ILDAPWrapper;
* @package OCA\User_LDAP\Tests
*/
class ConnectionTest extends \Test\TestCase {
- /** @var \OCA\User_LDAP\ILDAPWrapper|\PHPUnit\Framework\MockObject\MockObject */
+ /** @var ILDAPWrapper|\PHPUnit\Framework\MockObject\MockObject */
protected $ldap;
/** @var Connection */
->willReturnCallback(function () use (&$isThrown) {
if (!$isThrown) {
$isThrown = true;
- throw new \OC\ServerNotAvailableException();
+ throw new ServerNotAvailableException();
}
return true;
});
try {
$this->assertFalse($this->connection->bind(), 'Connection::bind() should not return true with invalid credentials.');
- } catch (\OC\ServerNotAvailableException $e) {
+ } catch (ServerNotAvailableException $e) {
$this->fail('Failed asserting that exception of type "OC\ServerNotAvailableException" is not thrown.');
}
}
->method('startTls')
->willReturn(false);
- $this->expectException(\OC\ServerNotAvailableException::class);
+ $this->expectException(ServerNotAvailableException::class);
$this->expectExceptionMessage('Start TLS failed, when connecting to LDAP host ' . $host . '.');
$this->connection->init();
use OCA\User_LDAP\User\Manager;
use OCA\User_LDAP\UserPluginManager;
use OCP\IAvatarManager;
+use OCP\Image;
+use OCP\Server;
use OCP\Share\IManager;
use Psr\Log\LoggerInterface;
*/
public function init() {
\OC::$server->registerService(UserPluginManager::class, function () {
- return new \OCA\User_LDAP\UserPluginManager();
+ return new UserPluginManager();
});
\OC::$server->registerService(GroupPluginManager::class, function () {
- return new \OCA\User_LDAP\GroupPluginManager();
+ return new GroupPluginManager();
});
$this->initLDAPWrapper();
new FilesystemHelper(),
\OC::$server->get(LoggerInterface::class),
\OC::$server->get(IAvatarManager::class),
- new \OCP\Image(),
+ new Image(),
\OC::$server->getUserManager(),
\OC::$server->getNotificationManager(),
\OC::$server->get(IManager::class)
* initializes the Access test instance
*/
protected function initAccess() {
- $this->access = new Access($this->connection, $this->ldap, $this->userManager, $this->helper, \OC::$server->getConfig(), \OCP\Server::get(LoggerInterface::class));
+ $this->access = new Access($this->connection, $this->ldap, $this->userManager, $this->helper, \OC::$server->getConfig(), Server::get(LoggerInterface::class));
}
/**
/** @var string */
private $ldapHost;
- /** @var \OCA\User_LDAP\LDAP */
+ /** @var LDAP */
private $ldap;
/** @var bool */
*/
namespace OCA\User_LDAP\Tests;
+use OC\Config;
use OC\User\Manager;
use OCA\User_LDAP\Access;
use OCA\User_LDAP\Connection;
use OCA\User_LDAP\Group_LDAP;
+use OCA\User_LDAP\Helper;
use OCA\User_LDAP\IGroupLDAP;
use OCA\User_LDAP\IUserLDAP;
+use OCA\User_LDAP\LDAPProviderFactory;
use OCA\User_LDAP\User_LDAP;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\ICacheFactory;
private function getServerMock(IUserLDAP $userBackend, IGroupLDAP $groupBackend) {
$server = $this->getMockBuilder('OC\Server')
->setMethods(['getUserManager', 'getBackends', 'getGroupManager'])
- ->setConstructorArgs(['', new \OC\Config(\OC::$configDir)])
+ ->setConstructorArgs(['', new Config(\OC::$configDir)])
->getMock();
$server->expects($this->any())
->method('getUserManager')
}
private function getLDAPProvider(IServerContainer $serverContainer) {
- $factory = new \OCA\User_LDAP\LDAPProviderFactory($serverContainer);
+ $factory = new LDAPProviderFactory($serverContainer);
return $factory->getLDAPProvider();
}
$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
- $helper = new \OCA\User_LDAP\Helper(\OC::$server->getConfig(), \OC::$server->getDatabaseConnection());
+ $helper = new Helper(\OC::$server->getConfig(), \OC::$server->getDatabaseConnection());
$ldapProvider = $this->getLDAPProvider($server);
$this->assertEquals(
$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
- $helper = new \OCA\User_LDAP\Helper(\OC::$server->getConfig(), \OC::$server->getDatabaseConnection());
+ $helper = new Helper(\OC::$server->getConfig(), \OC::$server->getDatabaseConnection());
$ldapProvider = $this->getLDAPProvider($server);
$this->assertEquals(
use OCP\IDBConnection;
abstract class AbstractMappingTest extends \Test\TestCase {
- abstract public function getMapper(\OCP\IDBConnection $dbMock);
+ abstract public function getMapper(IDBConnection $dbMock);
/**
* kiss test on isColNameValid
/**
* calls map() on the given mapper and asserts result for true
- * @param \OCA\User_LDAP\Mapping\AbstractMapping $mapper
+ * @param AbstractMapping $mapper
* @param array $data
*/
protected function mapEntries($mapper, $data) {
namespace OCA\User_LDAP\Tests\Mapping;
use OCA\User_LDAP\Mapping\GroupMapping;
+use OCP\IDBConnection;
/**
* Class GroupMappingTest
* @package OCA\User_LDAP\Tests\Mapping
*/
class GroupMappingTest extends AbstractMappingTest {
- public function getMapper(\OCP\IDBConnection $dbMock) {
+ public function getMapper(IDBConnection $dbMock) {
return new GroupMapping($dbMock);
}
}
namespace OCA\User_LDAP\Tests\Mapping;
use OCA\User_LDAP\Mapping\UserMapping;
+use OCP\IDBConnection;
use OCP\Support\Subscription\IAssertion;
/**
* @package OCA\User_LDAP\Tests\Mapping
*/
class UserMappingTest extends AbstractMappingTest {
- public function getMapper(\OCP\IDBConnection $dbMock) {
+ public function getMapper(IDBConnection $dbMock) {
return new UserMapping($dbMock, $this->createMock(IAssertion::class));
}
}
use OCP\IUserManager;
use OCP\Notification\IManager as INotificationManager;
use OCP\Notification\INotification;
+use OCP\Util;
use Psr\Log\LoggerInterface;
/**
->method('notify');
\OC_Hook::clear();//disconnect irrelevant hooks
- \OCP\Util::connectHook('OC_User', 'post_login', $this->user, 'handlePasswordExpiry');
+ Util::connectHook('OC_User', 'post_login', $this->user, 'handlePasswordExpiry');
/** @noinspection PhpUnhandledExceptionInspection */
\OC_Hook::emit('OC_User', 'post_login', ['uid' => $this->uid]);
}
->method('notify');
\OC_Hook::clear();//disconnect irrelevant hooks
- \OCP\Util::connectHook('OC_User', 'post_login', $this->user, 'handlePasswordExpiry');
+ Util::connectHook('OC_User', 'post_login', $this->user, 'handlePasswordExpiry');
/** @noinspection PhpUnhandledExceptionInspection */
\OC_Hook::emit('OC_User', 'post_login', ['uid' => $this->uid]);
}
public function testSetPasswordInvalid(): void {
- $this->expectException(\OCP\HintException::class);
+ $this->expectException(HintException::class);
$this->expectExceptionMessage('Password fails quality checking policy');
$this->prepareAccessForSetPassword($this->access);
public function testSetDisplayNameErrorWithPlugin(): void {
- $this->expectException(\OCP\HintException::class);
+ $this->expectException(HintException::class);
$newDisplayName = 'J. Baker';
$this->pluginManager->expects($this->once())
use OCP\EventDispatcher\IEventListener;
use OCP\IInitialStateService;
use OCP\IUserSession;
+use OCP\Util;
/** @template-implements IEventListener<BeforeTemplateRenderedEvent> */
class BeforeTemplateRenderedListener implements IEventListener {
return ['profileEnabled' => $this->profileManager->isProfileEnabled($user)];
});
- \OCP\Util::addScript('user_status', 'menu');
- \OCP\Util::addStyle('user_status', 'user-status-menu');
+ Util::addScript('user_status', 'menu');
+ Util::addStyle('user_status', 'user-status-menu');
}
}
namespace OCA\WebhookListeners\BackgroundJobs;
+use OCA\AppAPI\PublicFunctions;
use OCA\WebhookListeners\Db\AuthMethod;
use OCA\WebhookListeners\Db\WebhookListenerMapper;
use OCP\App\IAppManager;
use OCP\BackgroundJob\QueuedJob;
use OCP\Http\Client\IClientService;
use OCP\ICertificateManager;
+use OCP\Server;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\NotFoundExceptionInterface;
use Psr\Log\LoggerInterface;
throw new RuntimeException('AppAPI is disabled or not installed.');
}
try {
- $appApiFunctions = \OCP\Server::get(\OCA\AppAPI\PublicFunctions::class);
+ $appApiFunctions = Server::get(PublicFunctions::class);
} catch (ContainerExceptionInterface|NotFoundExceptionInterface) {
throw new RuntimeException('Could not get AppAPI public functions.');
}
use OCP\AppFramework\Db\Entity;
use OCP\Security\ICrypto;
+use OCP\Server;
/**
* @method void setUserId(?string $userId)
?ICrypto $crypto = null,
) {
if ($crypto === null) {
- $crypto = \OCP\Server::get(ICrypto::class);
+ $crypto = Server::get(ICrypto::class);
}
$this->crypto = $crypto;
$this->addType('appId', 'string');
use OCP\Files\Events\Node\NodeWrittenEvent;
use OCP\ICacheFactory;
use OCP\IDBConnection;
+use OCP\Server;
use OCP\User\Events\UserCreatedEvent;
use Test\TestCase;
protected function setUp(): void {
parent::setUp();
- $this->connection = \OCP\Server::get(IDBConnection::class);
- $this->cacheFactory = \OCP\Server::get(ICacheFactory::class);
+ $this->connection = Server::get(IDBConnection::class);
+ $this->cacheFactory = Server::get(ICacheFactory::class);
$this->pruneTables();
$this->mapper = new WebhookListenerMapper(
*/
namespace OCA\WorkflowEngine\Tests\Check;
+use OCA\WorkflowEngine\Check\AbstractStringCheck;
use OCP\IL10N;
class AbstractStringCheckTest extends \Test\TestCase {
public function testExecuteStringCheck($operation, $checkValue, $actualValue, $expected): void {
$check = $this->getCheckMock();
- /** @var \OCA\WorkflowEngine\Check\AbstractStringCheck $check */
+ /** @var AbstractStringCheck $check */
$this->assertEquals($expected, $this->invokePrivate($check, 'executeStringCheck', [$operation, $checkValue, $actualValue]));
}
public function testValidateCheck($operator, $value): void {
$check = $this->getCheckMock();
- /** @var \OCA\WorkflowEngine\Check\AbstractStringCheck $check */
+ /** @var AbstractStringCheck $check */
$check->validateCheck($operator, $value);
$this->addToAssertionCount(1);
$check = $this->getCheckMock();
try {
- /** @var \OCA\WorkflowEngine\Check\AbstractStringCheck $check */
+ /** @var AbstractStringCheck $check */
$check->validateCheck($operator, $value);
} catch (\UnexpectedValueException $e) {
$this->assertEquals($exceptionCode, $e->getCode());
*/
namespace OCA\WorkflowEngine\Tests\Check;
+use OCA\WorkflowEngine\Check\RequestRemoteAddress;
use OCP\IL10N;
use OCP\IRequest;
* @param bool $expected
*/
public function testExecuteCheckMatchesIPv4($value, $ip, $expected): void {
- $check = new \OCA\WorkflowEngine\Check\RequestRemoteAddress($this->getL10NMock(), $this->request);
+ $check = new RequestRemoteAddress($this->getL10NMock(), $this->request);
$this->request->expects($this->once())
->method('getRemoteAddress')
* @param bool $expected
*/
public function testExecuteCheckNotMatchesIPv4($value, $ip, $expected): void {
- $check = new \OCA\WorkflowEngine\Check\RequestRemoteAddress($this->getL10NMock(), $this->request);
+ $check = new RequestRemoteAddress($this->getL10NMock(), $this->request);
$this->request->expects($this->once())
->method('getRemoteAddress')
* @param bool $expected
*/
public function testExecuteCheckMatchesIPv6($value, $ip, $expected): void {
- $check = new \OCA\WorkflowEngine\Check\RequestRemoteAddress($this->getL10NMock(), $this->request);
+ $check = new RequestRemoteAddress($this->getL10NMock(), $this->request);
$this->request->expects($this->once())
->method('getRemoteAddress')
* @param bool $expected
*/
public function testExecuteCheckNotMatchesIPv6($value, $ip, $expected): void {
- $check = new \OCA\WorkflowEngine\Check\RequestRemoteAddress($this->getL10NMock(), $this->request);
+ $check = new RequestRemoteAddress($this->getL10NMock(), $this->request);
$this->request->expects($this->once())
->method('getRemoteAddress')
*/
namespace OCA\WorkflowEngine\Tests\Check;
+use OCA\WorkflowEngine\Check\RequestTime;
use OCP\IL10N;
class RequestTimeTest extends \Test\TestCase {
* @param bool $expected
*/
public function testExecuteCheckIn($value, $timestamp, $expected): void {
- $check = new \OCA\WorkflowEngine\Check\RequestTime($this->getL10NMock(), $this->timeFactory);
+ $check = new RequestTime($this->getL10NMock(), $this->timeFactory);
$this->timeFactory->expects($this->once())
->method('getTime')
* @param bool $expected
*/
public function testExecuteCheckNotIn($value, $timestamp, $expected): void {
- $check = new \OCA\WorkflowEngine\Check\RequestTime($this->getL10NMock(), $this->timeFactory);
+ $check = new RequestTime($this->getL10NMock(), $this->timeFactory);
$this->timeFactory->expects($this->once())
->method('getTime')
* @param string $value
*/
public function testValidateCheck($operator, $value): void {
- $check = new \OCA\WorkflowEngine\Check\RequestTime($this->getL10NMock(), $this->timeFactory);
+ $check = new RequestTime($this->getL10NMock(), $this->timeFactory);
$check->validateCheck($operator, $value);
$this->addToAssertionCount(1);
}
* @param string $exceptionMessage
*/
public function testValidateCheckInvalid($operator, $value, $exceptionCode, $exceptionMessage): void {
- $check = new \OCA\WorkflowEngine\Check\RequestTime($this->getL10NMock(), $this->timeFactory);
+ $check = new RequestTime($this->getL10NMock(), $this->timeFactory);
try {
$check->validateCheck($operator, $value);
*/
namespace OCA\WorkflowEngine\Tests\Check;
+use OCA\WorkflowEngine\Check\AbstractStringCheck;
use OCA\WorkflowEngine\Check\RequestUserAgent;
use OCP\IL10N;
use OCP\IRequest;
->method('getHeader')
->willReturn($actualValue);
- /** @var \OCA\WorkflowEngine\Check\AbstractStringCheck $check */
+ /** @var AbstractStringCheck $check */
$this->assertEquals($expected, $this->check->executeCheck($operation, $checkValue));
}
}
projects / nextcloud-server.git / commitdiff