OCA\Files_FullTextSearch\Service\GroupFoldersService

Complexity

Total Complexity

14

Size/Duplication

Total Lines	185
Duplicated Lines	8.65 %

Coupling/Cohesion

Components	2
Dependencies	4

Importance

Changes	2
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	16	16	1
A	initGroupSharesForUser()	0	9	2
A	getFileSource()	0	11	2
B	updateDocumentAccess()	0	29	2
A	getShareUsers()	0	8	2
A	getMountPoint()	0	12	3
A	getMountPoints()	0	14	2

<?php
/**
 * Files_FullTextSearch - Index the content of your files
 *
 * This file is licensed under the Affero General Public License version 3 or
 * later. See the COPYING file.
 *
 * @author Maxence Lange <maxence@artificial-owl.com>
 * @copyright 2018
 * @license GNU AGPL version 3 or any later version
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */


namespace OCA\Files_FullTextSearch\Service;


use OCA\Files_FullTextSearch\Exceptions\FileIsNotIndexableException;
use OCA\Files_FullTextSearch\Exceptions\KnownFileSourceException;
use OCA\Files_FullTextSearch\Model\FilesDocument;
use OCA\Files_FullTextSearch\Model\MountPoint;
use OCA\GroupFolders\Folder\FolderManager;
use OCA\GroupFolders\Mount\MountProvider;
use OCP\App;
use OCP\Files\IRootFolder;
use OCP\Files\Node;
use OCP\Files\Storage\IStorageFactory;
use OCP\IUserManager;
use OCP\Share\IManager;

class GroupFoldersService {


	const DOCUMENT_SOURCE = 'group_folders';

	/** @var IRootFolder */
	private $rootFolder;

	/** @var IUserManager */
	private $userManager;

	/** @var IManager */
	private $shareManager;

	/** @var FolderManager */
	private $folderManager;

	/** @var LocalFilesService */
	private $localFilesService;

	/** @var ConfigService */
	private $configService;

	/** @var MiscService */
	private $miscService;


	/** @var MountPoint[] */
	private $groupFolders = [];


	/**
	 * ExternalFilesService constructor.
	 *
	 * @param IRootFolder $rootFolder
	 * @param IUserManager $userManager
	 * @param IManager $shareManager
	 * @param FolderManager $folderManager
	 * @param LocalFilesService $localFilesService
	 * @param ConfigService $configService
	 * @param MiscService $miscService
	 */
	public function __construct(

This method seems to be duplicated in your project.

		IRootFolder $rootFolder, IUserManager $userManager, IManager $shareManager,
		FolderManager $folderManager, LocalFilesService $localFilesService,
		ConfigService $configService,
		MiscService $miscService
	) {
		$this->rootFolder = $rootFolder;
		$this->userManager = $userManager;
		$this->shareManager = $shareManager;
		$this->folderManager = $folderManager;

		$this->localFilesService = $localFilesService;

		$this->configService = $configService;
		$this->miscService = $miscService;
	}


	/**
	 * @param string $userId
	 */
	public function initGroupSharesForUser($userId) {
		$this->groupFolders = [];
		if (!App::isEnabled('groupfolders')) {
			return;
		}


		$this->groupFolders = $this->getMountPoints($userId);
	}


	/**
	 * @param Node $file
	 *
	 * @param string $source
	 *
	 * @throws KnownFileSourceException
	 */
	public function getFileSource(Node $file, &$source) {

		try {
			$this->getMountPoint($file);
		} catch (FileIsNotIndexableException $e) {
			return;
		}

		$source = self::DOCUMENT_SOURCE;
		throw new KnownFileSourceException();
	}


	/**
	 * @param FilesDocument $document
	 * @param Node $file
	 */
	public function updateDocumentAccess(FilesDocument &$document, Node $file) {

The parameter $file is not used and could be removed.

		if ($document->getSource() !== self::DOCUMENT_SOURCE) {
			return;
		}

//		try {

49% of this comment could be valid code. Did you maybe forget this after debugging?

//			$mount = $this->getGroupFolderMount($file);
//		} catch (FileIsNotIndexableException $e) {
//			return;
//		}

		$access = $document->getAccess();
		echo json_encode($access);
//		if ($this->isMountFullGlobal($mount)) {

63% of this comment could be valid code. Did you maybe forget this after debugging?

//			$access->addUsers(['__all']);
//		} else {
//			$access->addUsers($mount->getUsers());
//			$access->addGroups($mount->getGroups());
////		 	$access->addCircles($mount->getCircles());
//		}
//
//		// twist 'n tweak.
//		if (!$mount->isGlobal()) {
//			$access->setOwnerId($mount->getUsers()[0]);
//		}

		$document->setAccess($access);
	}


	/**
	 * @param FilesDocument $document
	 * @param array $users
	 */
	public function getShareUsers(FilesDocument $document, &$users) {

		if ($document->getSource() !== self::DOCUMENT_SOURCE) {
			return;
		}

		$this->localFilesService->getSharedUsersFromAccess($document->getAccess(), $users);
	}


	/**
	 * @param Node $file
	 *
	 * @return MountPoint
	 * @throws FileIsNotIndexableException
	 */
	private function getMountPoint(Node $file) {

		foreach ($this->groupFolders as $mount) {
			echo '######    ' . $file->getPath() . '  ' . $mount->getPath() . "\n";
			if (strpos($file->getPath(), $mount->getPath()) === 0) {
				return $mount;
			}
		}

		throw new FileIsNotIndexableException();

	}


	/**
	 * @param string $userId
	 *
	 * @return MountPoint[]
	 */
	private function getMountPoints($userId) {

		$mountPoints = [];
		$mounts = $this->folderManager->getAllFolders();
		foreach ($mounts as $path => $mount) {
			$mountPoint = new MountPoint();
			$mountPoint->setId($mount['id'])
					   ->setPath('/' . $userId . '/files/' . $mount['mount_point'])
					   ->setGroups(array_keys($mount['applicable']['groups']));
			$mountPoints[] = $mountPoint;
		}

		return $mountPoints;
	}


}