CirclesService::detailsCircleLinkedGroups() - Code Metrics - Inspection of "Federated Circles & Global Scale" - nextcloud/circles - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#362)

by Maxence

created 2020-02-02 12:28 UTC

CirclesService::detailsCircleLinkedGroups() A

↳ Parent: CirclesService

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	11
rs	9.9
cc	2
nc	2
nop	1

<?php
/**
 * Circles - Bring cloud-users closer together.
 *
 * This file is licensed under the Affero General Public License version 3 or
 * later. See the COPYING file.
 *
 * @author Maxence Lange <[email protected]>
 * @author Vinicius Cubas Brand <[email protected]>
 * @author Daniel Tygel <[email protected]>
 *
 * @copyright 2017
 * @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\Circles\Service;


use Exception;
use OC;
use OCA\Circles\AppInfo\Application;
use OCA\Circles\Db\CircleProviderRequest;
use OCA\Circles\Db\CirclesRequest;
use OCA\Circles\Db\FederatedLinksRequest;
use OCA\Circles\Db\MembersRequest;
use OCA\Circles\Db\SharesRequest;
use OCA\Circles\Exceptions\CircleAlreadyExistsException;
use OCA\Circles\Exceptions\CircleDoesNotExistException;
use OCA\Circles\Exceptions\CircleTypeDisabledException;
use OCA\Circles\Exceptions\FederatedCircleNotAllowedException;
use OCA\Circles\Exceptions\MemberDoesNotExistException;
use OCA\Circles\Exceptions\MemberIsNotModeratorException;
use OCA\Circles\Exceptions\MemberIsNotOwnerException;
use OCA\Circles\Exceptions\MembersLimitException;
use OCA\Circles\Model\Circle;
use OCA\Circles\Model\GlobalScale\GSEvent;
use OCA\Circles\Model\Member;
use OCP\IGroupManager;
use OCP\IL10N;

class CirclesService {

	/** @var string */
	private $userId;

	/** @var IL10N */
	private $l10n;

	/** @var IGroupManager */
	private $groupManager;

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

	/** @var CirclesRequest */
	private $circlesRequest;

	/** @var MembersRequest */
	private $membersRequest;

	/** @var SharesRequest */
	private $sharesRequest;

	/** @var FederatedLinksRequest */
	private $federatedLinksRequest;

	/** @var GSUpstreamService */
	private $gsUpstreamService;

	/** @var EventsService */
	private $eventsService;

	/** @var CircleProviderRequest */
	private $circleProviderRequest;

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


	/**
	 * CirclesService constructor.
	 *
	 * @param string $userId
	 * @param IL10N $l10n
	 * @param IGroupManager $groupManager
	 * @param ConfigService $configService
	 * @param CirclesRequest $circlesRequest
	 * @param MembersRequest $membersRequest
	 * @param SharesRequest $sharesRequest
	 * @param FederatedLinksRequest $federatedLinksRequest
	 * @param GSUpstreamService $gsUpstreamService
	 * @param EventsService $eventsService
	 * @param CircleProviderRequest $circleProviderRequest
	 * @param MiscService $miscService
	 */
	public function __construct(
		$userId,
		IL10N $l10n,
		IGroupManager $groupManager,
		ConfigService $configService,
		CirclesRequest $circlesRequest,
		MembersRequest $membersRequest,
		SharesRequest $sharesRequest,
		FederatedLinksRequest $federatedLinksRequest,
		GSUpstreamService $gsUpstreamService,
		EventsService $eventsService,
		CircleProviderRequest $circleProviderRequest,
		MiscService $miscService
	) {
		$this->userId = $userId;
		$this->l10n = $l10n;
		$this->groupManager = $groupManager;
		$this->configService = $configService;
		$this->circlesRequest = $circlesRequest;
		$this->membersRequest = $membersRequest;
		$this->sharesRequest = $sharesRequest;
		$this->federatedLinksRequest = $federatedLinksRequest;
		$this->gsUpstreamService = $gsUpstreamService;
		$this->eventsService = $eventsService;
		$this->circleProviderRequest = $circleProviderRequest;
		$this->miscService = $miscService;
	}


	/**
	 * Create circle using this->userId as owner
	 *
	 * @param int|string $type
	 * @param string $name
	 *
	 * @return Circle
	 * @throws CircleTypeDisabledException
	 * @throws Exception
	 */
	public function createCircle($type, $name) {
		$type = $this->convertTypeStringToBitValue($type);
		$type = (int)$type;

		if ($type === '') {

			throw new CircleTypeDisabledException(
				$this->l10n->t('You need a specify a type of circle')
			);
		}

		if (!$this->configService->isCircleAllowed($type)) {
			throw new CircleTypeDisabledException(
				$this->l10n->t('You cannot create this type of circle')
			);
		}

		$circle = new Circle($type, $name);

//		try {
		$circle->generateUniqueId();
		// TODO: check uniqueness !!
		// TODO: check uniqueness !!
		// TODO: check uniqueness !!
		// TODO: check uniqueness !!
//		$this->circlesRequest->createCircle($circle, $this->userId);

		$owner = new Member($this->userId, Member::TYPE_USER);
		$owner->setCircleId($circle->getUniqueId())
			  ->setLevel(Member::LEVEL_OWNER)
			  ->setStatus(Member::STATUS_MEMBER);
		$circle->setOwner($owner)
			   ->setViewer($owner);

//			$this->membersRequest->createMember($circle->getOwner());

		$event = new GSevent(GSEvent::CIRCLE_CREATE, true);
		$event->setCircle($circle);
		$this->gsUpstreamService->newEvent($event);

//		} catch (CircleAlreadyExistsException $e) {
//			throw $e;
//		}

//		$this->eventsService->onCircleCreation($circle);

		return $circle;
	}


	/**
	 * list Circles depends on type (or all) and name (parts) and minimum level.
	 *
	 * @param string $userId
	 * @param mixed $type
	 * @param string $name
	 * @param int $level
	 *
	 * @param bool $forceAll
	 *
	 * @return Circle[]
	 * @throws CircleTypeDisabledException
	 * @throws Exception
	 */
	public function listCircles($userId, $type, $name = '', $level = 0, $forceAll = false) {
		$type = $this->convertTypeStringToBitValue($type);

		if ($userId === '') {
			throw new Exception('UserID cannot be null');
		}

		if (!$this->configService->isCircleAllowed((int)$type)) {
			throw new CircleTypeDisabledException(
				$this->l10n->t('You cannot display this type of circle')
			);
		}

		$data = [];
		$result = $this->circlesRequest->getCircles($userId, $type, $name, $level, $forceAll);
		foreach ($result as $item) {
			$data[] = $item;
		}

		return $data;
	}


	/**
	 * returns details on circle and its members if this->userId is a member itself.
	 *
	 * @param string $circleUniqueId
	 * @param bool $forceAll
	 *
	 * @return Circle
	 * @throws Exception
	 */
	public function detailsCircle($circleUniqueId, $forceAll = false) {

		try {
			$circle = $this->circlesRequest->getCircle($circleUniqueId, $this->userId, '', $forceAll);
			if ($this->viewerIsAdmin()
				|| $circle->getHigherViewer()
						  ->isLevel(Member::LEVEL_MEMBER)
				|| $forceAll === true
			) {
				$this->detailsCircleMembers($circle);
				$this->detailsCircleLinkedGroups($circle);
				$this->detailsCircleFederatedCircles($circle);
			}
		} catch (Exception $e) {
			throw $e;
		}

		return $circle;
	}


	/**
	 * get the Members list and add the result to the Circle.
	 *
	 * @param Circle $circle
	 *
	 * @throws Exception
	 */
	private function detailsCircleMembers(Circle &$circle) {
		if ($this->viewerIsAdmin()) {
			$members = $this->membersRequest->forceGetMembers($circle->getUniqueId(), 0);
		} else {
			$members = $this->membersRequest->getMembers(
				$circle->getUniqueId(), $circle->getHigherViewer()
			);
		}

		$circle->setMembers($members);
	}


	/**
	 * get the Linked Group list and add the result to the Circle.
	 *
	 * @param Circle $circle
	 *
	 * @throws MemberDoesNotExistException
	 */
	private function detailsCircleLinkedGroups(Circle &$circle) {
		$groups = [];
		if ($this->configService->isLinkedGroupsAllowed()) {
			$groups =
				$this->membersRequest->getGroupsFromCircle(
					$circle->getUniqueId(), $circle->getHigherViewer()
				);
		}

		$circle->setGroups($groups);
	}


	/**
	 * get the Federated Circles list and add the result to the Circle.
	 *
	 * @param Circle $circle
	 */
	private function detailsCircleFederatedCircles(Circle &$circle) {
		$links = [];

		try {
			if ($this->configService->isFederatedCirclesAllowed()) {
				$circle->hasToBeFederated();
				$links = $this->federatedLinksRequest->getLinksFromCircle($circle->getUniqueId());
			}
		} catch (FederatedCircleNotAllowedException $e) {

		}

		$circle->setLinks($links);
	}


	/**
	 * save new settings if current user is admin.
	 *
	 * @param string $circleUniqueId
	 * @param array $settings
	 *
	 * @return Circle
	 * @throws Exception
	 */
	public function settingsCircle($circleUniqueId, $settings) {

		try {
			$circle = $this->circlesRequest->getCircle($circleUniqueId, $this->userId);
			$this->hasToBeOwner($circle->getHigherViewer());

			if (!$this->viewerIsAdmin()) {
				$settings['members_limit'] = $circle->getSetting('members_limit');
			}

			$ak = array_keys($settings);
			foreach ($ak AS $k) {
				$circle->setSetting($k, $settings[$k]);
			}

			$this->circlesRequest->updateCircle($circle, $this->userId);

			$this->eventsService->onSettingsChange($circle);
		} catch (Exception $e) {
			throw $e;
		}

		return $circle;
	}


	/**
	 * Join a circle.
	 *
	 * @param string $circleUniqueId
	 *
	 * @return null|Member
	 * @throws Exception
	 */
	public function joinCircle($circleUniqueId) {
		try {
			$circle = $this->circlesRequest->getCircle($circleUniqueId, $this->userId);
			$member = $this->membersRequest->getFreshNewMember(
				$circleUniqueId, $this->userId, Member::TYPE_USER, ''
			);

			$event = new GSevent(GSEvent::MEMBER_JOIN);
			$event->setCircle($circle);
			$event->setMember($member);
			$this->gsUpstreamService->newEvent($event);
		} catch (Exception $e) {
			throw $e;
		}

		return $member;
	}


	/**
	 * Leave a circle.
	 *
	 * @param string $circleUniqueId
	 *
	 * @return null|Member
	 * @throws Exception
	 */
	public function leaveCircle($circleUniqueId) {
		$circle = $this->circlesRequest->getCircle($circleUniqueId, $this->userId);
		$member = $circle->getViewer();

		$event = new GSevent(GSEvent::MEMBER_LEAVE);
		$event->setCircle($circle);
		$event->setMember($member);
		$this->gsUpstreamService->newEvent($event);

		return $member;
	}


	/**
	 * destroy a circle.
	 *
	 * @param string $circleUniqueId
	 *
	 * @throws CircleDoesNotExistException
	 * @throws MemberIsNotModeratorException
	 * @throws MemberIsNotOwnerException
	 */
	public function removeCircle($circleUniqueId) {
		$circle = $this->circlesRequest->getCircle($circleUniqueId, $this->userId);

		$this->hasToBeOwner($circle->getHigherViewer());

		$this->eventsService->onCircleDestruction($circle);

		$this->membersRequest->removeAllFromCircle($circleUniqueId);
		$this->circlesRequest->destroyCircle($circleUniqueId);
	}


	/**
	 * @param $circleName
	 *
	 * @return Circle|null
	 * @throws CircleDoesNotExistException
	 */
	public function infoCircleByName($circleName) {
		return $this->circlesRequest->forceGetCircleByName($circleName);
	}


	/**
	 * When a user is removed.
	 * Before deleting a user from the cloud, we assign a new owner to his Circles.
	 * Remove the Circle if it has no admin.
	 *
	 * @param string $userId
	 */
	public function onUserRemoved($userId) {
		$circles = $this->circlesRequest->getCircles($userId, 0, '', Member::LEVEL_OWNER);

		foreach ($circles as $circle) {

			$members =
				$this->membersRequest->forceGetMembers($circle->getUniqueId(), Member::LEVEL_ADMIN);

			if (sizeof($members) === 1) {
				$this->circlesRequest->destroyCircle($circle->getUniqueId());
				continue;
			}

			$this->switchOlderAdminToOwner($circle, $members);
		}
	}


	/**
	 * switchOlderAdminToOwner();
	 *
	 * @param Circle $circle
	 * @param Member[] $members
	 */
	private function switchOlderAdminToOwner(Circle $circle, $members) {

		foreach ($members as $member) {
			if ($member->getLevel() === Member::LEVEL_ADMIN) {
				$member->setLevel(Member::LEVEL_OWNER);
				$this->membersRequest->updateMember($member);
				$this->eventsService->onMemberOwner($circle, $member);

				return;
			}
		}

	}


	/**
	 * Convert a Type in String to its Bit Value
	 *
	 * @param string $type
	 *
	 * @return int|mixed
	 */
	public function convertTypeStringToBitValue($type) {
		$strings = [
			'personal' => Circle::CIRCLES_PERSONAL,
			'secret'   => Circle::CIRCLES_SECRET,
			'closed'   => Circle::CIRCLES_CLOSED,
			'public'   => Circle::CIRCLES_PUBLIC,
			'all'      => Circle::CIRCLES_ALL
		];

		if (!key_exists(strtolower($type), $strings)) {
			return $type;
		}

		return $strings[strtolower($type)];
	}


	/**
	 * getCircleIcon()
	 *
	 * Return the right imagePath for a type of circle.
	 *
	 * @param string $type
	 * @param bool $png
	 *
	 * @return string
	 */
	public static function getCircleIcon($type, $png = false) {

		$ext = '.svg';
		if ($png === true) {
			$ext = '.png';
		}

		$urlGen = OC::$server->getURLGenerator();
		switch ($type) {
			case Circle::CIRCLES_PERSONAL:
				return $urlGen->getAbsoluteURL(
					$urlGen->imagePath(Application::APP_NAME, 'personal' . $ext)
				);
			case Circle::CIRCLES_CLOSED:
				return $urlGen->getAbsoluteURL(
					$urlGen->imagePath(Application::APP_NAME, 'closed' . $ext)
				);
			case Circle::CIRCLES_SECRET:
				return $urlGen->getAbsoluteURL(
					$urlGen->imagePath(Application::APP_NAME, 'secret' . $ext)
				);
			case Circle::CIRCLES_PUBLIC:
				return $urlGen->getAbsoluteURL(
					$urlGen->imagePath(Application::APP_NAME, 'black_circle' . $ext)
				);
		}

		return $urlGen->getAbsoluteURL(
			$urlGen->imagePath(Application::APP_NAME, 'black_circle' . $ext)
		);
	}


	/**
	 * @param string $circleUniqueIds
	 * @param int $limit
	 * @param int $offset
	 *
	 * @return array
	 */
	public function getFilesForCircles($circleUniqueIds, $limit = -1, $offset = 0) {
		if (!is_array($circleUniqueIds)) {
			$circleUniqueIds = [$circleUniqueIds];
		}

		$objectIds = $this->circleProviderRequest->getFilesForCircles(
			$this->userId, $circleUniqueIds, $limit, $offset
		);

		return $objectIds;
	}


	/**
	 * @param Circle $circle
	 *
	 * @throws MembersLimitException
	 */
	public function checkThatCircleIsNotFull(Circle $circle) {

		$members = $this->membersRequest->forceGetMembers(
			$circle->getUniqueId(), Member::LEVEL_MEMBER, true
		);

		$limit = $circle->getSetting('members_limit');
		if ($limit === -1) {
			return;
		}
		if ($limit === 0 || $limit === '' || $limit === null) {
			$limit = $this->configService->getAppValue(ConfigService::CIRCLES_MEMBERS_LIMIT);
		}

		if (sizeof($members) >= $limit) {
			throw new MembersLimitException(
				'This circle already reach its limit on the number of members'
			);
		}

	}

	/**
	 * @return bool
	 */
	public function viewerIsAdmin() {
		if ($this->userId === '') {
			return false;
		}

		return ($this->groupManager->isAdmin($this->userId));
	}


	/**
	 * should be moved.
	 *
	 * @param Member $member
	 *
	 * @throws MemberIsNotOwnerException
	 */
	public function hasToBeOwner(Member $member) {

		if (!$this->groupManager->isAdmin($this->userId)
			&& $member->getLevel() < Member::LEVEL_OWNER) {
			throw new MemberIsNotOwnerException(
				$this->l10n->t('This member is not the owner of the circle')
			);
		}
	}


	/**
	 * should be moved.
	 *
	 * @param Member $member
	 *
	 * @throws MemberIsNotOwnerException
	 */
	public function hasToBeAdmin(Member $member) {

		if (!$this->groupManager->isAdmin($member->getUserId())
			&& $member->getLevel() < Member::LEVEL_ADMIN) {
			throw new MemberIsNotOwnerException(
				$this->l10n->t('This member is not an admin of the circle')
			);
		}
	}
}


1		<?php
2		/**
3		* Circles - Bring cloud-users closer together.
4		*
5		* This file is licensed under the Affero General Public License version 3 or
6		* later. See the COPYING file.
7		*
8		* @author Maxence Lange <[email protected]>
9		* @author Vinicius Cubas Brand <[email protected]>
10		* @author Daniel Tygel <[email protected]>
11		*
12		* @copyright 2017
13		* @license GNU AGPL version 3 or any later version
14		*
15		* This program is free software: you can redistribute it and/or modify
16		* it under the terms of the GNU Affero General Public License as
17		* published by the Free Software Foundation, either version 3 of the
18		* License, or (at your option) any later version.
19		*
20		* This program is distributed in the hope that it will be useful,
21		* but WITHOUT ANY WARRANTY; without even the implied warranty of
22		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23		* GNU Affero General Public License for more details.
24		*
25		* You should have received a copy of the GNU Affero General Public License
26		* along with this program. If not, see <http://www.gnu.org/licenses/>.
27		*
28		*/
29
30		namespace OCA\Circles\Service;
31
32
33		use Exception;
34		use OC;
35		use OCA\Circles\AppInfo\Application;
36		use OCA\Circles\Db\CircleProviderRequest;
37		use OCA\Circles\Db\CirclesRequest;
38		use OCA\Circles\Db\FederatedLinksRequest;
39		use OCA\Circles\Db\MembersRequest;
40		use OCA\Circles\Db\SharesRequest;
41		use OCA\Circles\Exceptions\CircleAlreadyExistsException;
42		use OCA\Circles\Exceptions\CircleDoesNotExistException;
43		use OCA\Circles\Exceptions\CircleTypeDisabledException;
44		use OCA\Circles\Exceptions\FederatedCircleNotAllowedException;
45		use OCA\Circles\Exceptions\MemberDoesNotExistException;
46		use OCA\Circles\Exceptions\MemberIsNotModeratorException;
47		use OCA\Circles\Exceptions\MemberIsNotOwnerException;
48		use OCA\Circles\Exceptions\MembersLimitException;
49		use OCA\Circles\Model\Circle;
50		use OCA\Circles\Model\GlobalScale\GSEvent;
51		use OCA\Circles\Model\Member;
52		use OCP\IGroupManager;
53		use OCP\IL10N;
54
55		class CirclesService {
56
57		/** @var string */
58		private $userId;
59
60		/** @var IL10N */
61		private $l10n;
62
63		/** @var IGroupManager */
64		private $groupManager;
65
66		/** @var ConfigService */
67		private $configService;
68
69		/** @var CirclesRequest */
70		private $circlesRequest;
71
72		/** @var MembersRequest */
73		private $membersRequest;
74
75		/** @var SharesRequest */
76		private $sharesRequest;
77
78		/** @var FederatedLinksRequest */
79		private $federatedLinksRequest;
80
81		/** @var GSUpstreamService */
82		private $gsUpstreamService;
83
84		/** @var EventsService */
85		private $eventsService;
86
87		/** @var CircleProviderRequest */
88		private $circleProviderRequest;
89
90		/** @var MiscService */
91		private $miscService;
92
93
94		/**
95		* CirclesService constructor.
96		*
97		* @param string $userId
98		* @param IL10N $l10n
99		* @param IGroupManager $groupManager
100		* @param ConfigService $configService
101		* @param CirclesRequest $circlesRequest
102		* @param MembersRequest $membersRequest
103		* @param SharesRequest $sharesRequest
104		* @param FederatedLinksRequest $federatedLinksRequest
105		* @param GSUpstreamService $gsUpstreamService
106		* @param EventsService $eventsService
107		* @param CircleProviderRequest $circleProviderRequest
108		* @param MiscService $miscService
109		*/
110	View Code Duplication	public function __construct(
111		$userId,
112		IL10N $l10n,
113		IGroupManager $groupManager,
114		ConfigService $configService,
115		CirclesRequest $circlesRequest,
116		MembersRequest $membersRequest,
117		SharesRequest $sharesRequest,
118		FederatedLinksRequest $federatedLinksRequest,
119		GSUpstreamService $gsUpstreamService,
120		EventsService $eventsService,
121		CircleProviderRequest $circleProviderRequest,
122		MiscService $miscService
123		) {
124		$this->userId = $userId;
125		$this->l10n = $l10n;
126		$this->groupManager = $groupManager;
127		$this->configService = $configService;
128		$this->circlesRequest = $circlesRequest;
129		$this->membersRequest = $membersRequest;
130		$this->sharesRequest = $sharesRequest;
131		$this->federatedLinksRequest = $federatedLinksRequest;
132		$this->gsUpstreamService = $gsUpstreamService;
133		$this->eventsService = $eventsService;
134		$this->circleProviderRequest = $circleProviderRequest;
135		$this->miscService = $miscService;
136		}
137
138
139		/**
140		* Create circle using this->userId as owner
141		*
142		* @param int\|string $type
143		* @param string $name
144		*
145		* @return Circle
146		* @throws CircleTypeDisabledException
147		* @throws Exception
148		*/
149		public function createCircle($type, $name) {
150		$type = $this->convertTypeStringToBitValue($type);
151		$type = (int)$type;
152
153		if ($type === '') {
		0 ignored issues – show Unused Code Bug introduced 2017-07-28 02:28 UTC by Report Bug Copy Issue Report The strict comparison `===` seems to always evaluate to `false` as the types of `$type` (`integer`) and `''` (`string`) can never be identical. Maybe you want to use a loose comparison `==` instead? Loading history...
154		throw new CircleTypeDisabledException(
155		$this->l10n->t('You need a specify a type of circle')
156		);
157		}
158
159		if (!$this->configService->isCircleAllowed($type)) {
160		throw new CircleTypeDisabledException(
161		$this->l10n->t('You cannot create this type of circle')
162		);
163		}
164
165		$circle = new Circle($type, $name);
166
167		// try {
168		$circle->generateUniqueId();
169		// TODO: check uniqueness !!
170		// TODO: check uniqueness !!
171		// TODO: check uniqueness !!
172		// TODO: check uniqueness !!
173		// $this->circlesRequest->createCircle($circle, $this->userId);
174
175		$owner = new Member($this->userId, Member::TYPE_USER);
176		$owner->setCircleId($circle->getUniqueId())
177		->setLevel(Member::LEVEL_OWNER)
178		->setStatus(Member::STATUS_MEMBER);
179		$circle->setOwner($owner)
180		->setViewer($owner);
181
182		// $this->membersRequest->createMember($circle->getOwner());
183
184		$event = new GSevent(GSEvent::CIRCLE_CREATE, true);
185		$event->setCircle($circle);
186		$this->gsUpstreamService->newEvent($event);
187
188		// } catch (CircleAlreadyExistsException $e) {
189		// throw $e;
190		// }
191
192		// $this->eventsService->onCircleCreation($circle);
193
194		return $circle;
195		}
196
197
198		/**
199		* list Circles depends on type (or all) and name (parts) and minimum level.
200		*
201		* @param string $userId
202		* @param mixed $type
203		* @param string $name
204		* @param int $level
205		*
206		* @param bool $forceAll
207		*
208		* @return Circle[]
209		* @throws CircleTypeDisabledException
210		* @throws Exception
211		*/
212		public function listCircles($userId, $type, $name = '', $level = 0, $forceAll = false) {
213		$type = $this->convertTypeStringToBitValue($type);
214
215		if ($userId === '') {
216		throw new Exception('UserID cannot be null');
217		}
218
219		if (!$this->configService->isCircleAllowed((int)$type)) {
220		throw new CircleTypeDisabledException(
221		$this->l10n->t('You cannot display this type of circle')
222		);
223		}
224
225		$data = [];
226		$result = $this->circlesRequest->getCircles($userId, $type, $name, $level, $forceAll);
227		foreach ($result as $item) {
228		$data[] = $item;
229		}
230
231		return $data;
232		}
233
234
235		/**
236		* returns details on circle and its members if this->userId is a member itself.
237		*
238		* @param string $circleUniqueId
239		* @param bool $forceAll
240		*
241		* @return Circle
242		* @throws Exception
243		*/
244		public function detailsCircle($circleUniqueId, $forceAll = false) {
245
246		try {
247		$circle = $this->circlesRequest->getCircle($circleUniqueId, $this->userId, '', $forceAll);
248		if ($this->viewerIsAdmin()
249		\|\| $circle->getHigherViewer()
250		->isLevel(Member::LEVEL_MEMBER)
251		\|\| $forceAll === true
252		) {
253		$this->detailsCircleMembers($circle);
254		$this->detailsCircleLinkedGroups($circle);
255		$this->detailsCircleFederatedCircles($circle);
256		}
257		} catch (Exception $e) {
258		throw $e;
259		}
260
261		return $circle;
262		}
263
264
265		/**
266		* get the Members list and add the result to the Circle.
267		*
268		* @param Circle $circle
269		*
270		* @throws Exception
271		*/
272		private function detailsCircleMembers(Circle &$circle) {
273		if ($this->viewerIsAdmin()) {
274		$members = $this->membersRequest->forceGetMembers($circle->getUniqueId(), 0);
275		} else {
276		$members = $this->membersRequest->getMembers(
277		$circle->getUniqueId(), $circle->getHigherViewer()
278		);
279		}
280
281		$circle->setMembers($members);
282		}
283
284
285		/**
286		* get the Linked Group list and add the result to the Circle.
287		*
288		* @param Circle $circle
289		*
290		* @throws MemberDoesNotExistException
291		*/
292		private function detailsCircleLinkedGroups(Circle &$circle) {
293		$groups = [];
294		if ($this->configService->isLinkedGroupsAllowed()) {
295		$groups =
296		$this->membersRequest->getGroupsFromCircle(
297		$circle->getUniqueId(), $circle->getHigherViewer()
298		);
299		}
300
301		$circle->setGroups($groups);
302		}
303
304
305		/**
306		* get the Federated Circles list and add the result to the Circle.
307		*
308		* @param Circle $circle
309		*/
310		private function detailsCircleFederatedCircles(Circle &$circle) {
311		$links = [];
312
313		try {
314		if ($this->configService->isFederatedCirclesAllowed()) {
315		$circle->hasToBeFederated();
316		$links = $this->federatedLinksRequest->getLinksFromCircle($circle->getUniqueId());
317		}
318		} catch (FederatedCircleNotAllowedException $e) {
		0 ignored issues – show Coding Style Comprehensibility introduced 2017-07-05 22:18 UTC by Report Bug Copy Issue Report Consider adding a comment why this CATCH block is empty. Loading history...
319		}
320
321		$circle->setLinks($links);
322		}
323
324
325		/**
326		* save new settings if current user is admin.
327		*
328		* @param string $circleUniqueId
329		* @param array $settings
330		*
331		* @return Circle
332		* @throws Exception
333		*/
334		public function settingsCircle($circleUniqueId, $settings) {
335
336		try {
337		$circle = $this->circlesRequest->getCircle($circleUniqueId, $this->userId);
338		$this->hasToBeOwner($circle->getHigherViewer());
339
340		if (!$this->viewerIsAdmin()) {
341		$settings['members_limit'] = $circle->getSetting('members_limit');
342		}
343
344		$ak = array_keys($settings);
345		foreach ($ak AS $k) {
346		$circle->setSetting($k, $settings[$k]);
347		}
348
349		$this->circlesRequest->updateCircle($circle, $this->userId);
350
351		$this->eventsService->onSettingsChange($circle);
352		} catch (Exception $e) {
353		throw $e;
354		}
355
356		return $circle;
357		}
358
359
360		/**
361		* Join a circle.
362		*
363		* @param string $circleUniqueId
364		*
365		* @return null\|Member
366		* @throws Exception
367		*/
368		public function joinCircle($circleUniqueId) {
369		try {
370		$circle = $this->circlesRequest->getCircle($circleUniqueId, $this->userId);
371		$member = $this->membersRequest->getFreshNewMember(
372		$circleUniqueId, $this->userId, Member::TYPE_USER, ''
373		);
374
375		$event = new GSevent(GSEvent::MEMBER_JOIN);
376		$event->setCircle($circle);
377		$event->setMember($member);
378		$this->gsUpstreamService->newEvent($event);
379		} catch (Exception $e) {
380		throw $e;
381		}
382
383		return $member;
384		}
385
386
387		/**
388		* Leave a circle.
389		*
390		* @param string $circleUniqueId
391		*
392		* @return null\|Member
393		* @throws Exception
394		*/
395		public function leaveCircle($circleUniqueId) {
396		$circle = $this->circlesRequest->getCircle($circleUniqueId, $this->userId);
397		$member = $circle->getViewer();
398
399		$event = new GSevent(GSEvent::MEMBER_LEAVE);
400		$event->setCircle($circle);
401		$event->setMember($member);
402		$this->gsUpstreamService->newEvent($event);
403
404		return $member;
405		}
406
407
408		/**
409		* destroy a circle.
410		*
411		* @param string $circleUniqueId
412		*
413		* @throws CircleDoesNotExistException
414		* @throws MemberIsNotModeratorException
415		* @throws MemberIsNotOwnerException
416		*/
417		public function removeCircle($circleUniqueId) {
418		$circle = $this->circlesRequest->getCircle($circleUniqueId, $this->userId);
419
420		$this->hasToBeOwner($circle->getHigherViewer());
421
422		$this->eventsService->onCircleDestruction($circle);
423
424		$this->membersRequest->removeAllFromCircle($circleUniqueId);
425		$this->circlesRequest->destroyCircle($circleUniqueId);
426		}
427
428
429		/**
430		* @param $circleName
431		*
432		* @return Circle\|null
433		* @throws CircleDoesNotExistException
434		*/
435		public function infoCircleByName($circleName) {
436		return $this->circlesRequest->forceGetCircleByName($circleName);
437		}
438
439
440		/**
441		* When a user is removed.
442		* Before deleting a user from the cloud, we assign a new owner to his Circles.
443		* Remove the Circle if it has no admin.
444		*
445		* @param string $userId
446		*/
447		public function onUserRemoved($userId) {
448		$circles = $this->circlesRequest->getCircles($userId, 0, '', Member::LEVEL_OWNER);
449
450		foreach ($circles as $circle) {
451
452		$members =
453		$this->membersRequest->forceGetMembers($circle->getUniqueId(), Member::LEVEL_ADMIN);
454
455		if (sizeof($members) === 1) {
456		$this->circlesRequest->destroyCircle($circle->getUniqueId());
457		continue;
458		}
459
460		$this->switchOlderAdminToOwner($circle, $members);
461		}
462		}
463
464
465		/**
466		* switchOlderAdminToOwner();
467		*
468		* @param Circle $circle
469		* @param Member[] $members
470		*/
471		private function switchOlderAdminToOwner(Circle $circle, $members) {
472
473		foreach ($members as $member) {
474		if ($member->getLevel() === Member::LEVEL_ADMIN) {
475		$member->setLevel(Member::LEVEL_OWNER);
476		$this->membersRequest->updateMember($member);
477		$this->eventsService->onMemberOwner($circle, $member);
478
479		return;
480		}
481		}
482
483		}
484
485
486		/**
487		* Convert a Type in String to its Bit Value
488		*
489		* @param string $type
490		*
491		* @return int\|mixed
492		*/
493		public function convertTypeStringToBitValue($type) {
494		$strings = [
495		'personal' => Circle::CIRCLES_PERSONAL,
496		'secret' => Circle::CIRCLES_SECRET,
497		'closed' => Circle::CIRCLES_CLOSED,
498		'public' => Circle::CIRCLES_PUBLIC,
499		'all' => Circle::CIRCLES_ALL
500		];
501
502		if (!key_exists(strtolower($type), $strings)) {
503		return $type;
504		}
505
506		return $strings[strtolower($type)];
507		}
508
509
510		/**
511		* getCircleIcon()
512		*
513		* Return the right imagePath for a type of circle.
514		*
515		* @param string $type
516		* @param bool $png
517		*
518		* @return string
519		*/
520		public static function getCircleIcon($type, $png = false) {
521
522		$ext = '.svg';
523		if ($png === true) {
524		$ext = '.png';
525		}
526
527		$urlGen = OC::$server->getURLGenerator();
528		switch ($type) {
529		case Circle::CIRCLES_PERSONAL:
530		return $urlGen->getAbsoluteURL(
531		$urlGen->imagePath(Application::APP_NAME, 'personal' . $ext)
532		);
533		case Circle::CIRCLES_CLOSED:
534		return $urlGen->getAbsoluteURL(
535		$urlGen->imagePath(Application::APP_NAME, 'closed' . $ext)
536		);
537		case Circle::CIRCLES_SECRET:
538		return $urlGen->getAbsoluteURL(
539		$urlGen->imagePath(Application::APP_NAME, 'secret' . $ext)
540		);
541		case Circle::CIRCLES_PUBLIC:
542		return $urlGen->getAbsoluteURL(
543		$urlGen->imagePath(Application::APP_NAME, 'black_circle' . $ext)
544		);
545		}
546
547		return $urlGen->getAbsoluteURL(
548		$urlGen->imagePath(Application::APP_NAME, 'black_circle' . $ext)
549		);
550		}
551
552
553		/**
554		* @param string $circleUniqueIds
555		* @param int $limit
556		* @param int $offset
557		*
558		* @return array
559		*/
560		public function getFilesForCircles($circleUniqueIds, $limit = -1, $offset = 0) {
561		if (!is_array($circleUniqueIds)) {
562		$circleUniqueIds = [$circleUniqueIds];
563		}
564
565		$objectIds = $this->circleProviderRequest->getFilesForCircles(
566		$this->userId, $circleUniqueIds, $limit, $offset
567		);
568
569		return $objectIds;
570		}
571
572
573		/**
574		* @param Circle $circle
575		*
576		* @throws MembersLimitException
577		*/
578		public function checkThatCircleIsNotFull(Circle $circle) {
579
580		$members = $this->membersRequest->forceGetMembers(
581		$circle->getUniqueId(), Member::LEVEL_MEMBER, true
582		);
583
584		$limit = $circle->getSetting('members_limit');
585		if ($limit === -1) {
586		return;
587		}
588		if ($limit === 0 \|\| $limit === '' \|\| $limit === null) {
589		$limit = $this->configService->getAppValue(ConfigService::CIRCLES_MEMBERS_LIMIT);
590		}
591
592		if (sizeof($members) >= $limit) {
593		throw new MembersLimitException(
594		'This circle already reach its limit on the number of members'
595		);
596		}
597
598		}
599
600		/**
601		* @return bool
602		*/
603		public function viewerIsAdmin() {
604		if ($this->userId === '') {
605		return false;
606		}
607
608		return ($this->groupManager->isAdmin($this->userId));
609		}
610
611
612		/**
613		* should be moved.
614		*
615		* @param Member $member
616		*
617		* @throws MemberIsNotOwnerException
618		*/
619	View Code Duplication	public function hasToBeOwner(Member $member) {
		0 ignored issues – show Duplication introduced 2018-08-01 10:01 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
620		if (!$this->groupManager->isAdmin($this->userId)
621		&& $member->getLevel() < Member::LEVEL_OWNER) {
622		throw new MemberIsNotOwnerException(
623		$this->l10n->t('This member is not the owner of the circle')
624		);
625		}
626		}
627
628
629		/**
630		* should be moved.
631		*
632		* @param Member $member
633		*
634		* @throws MemberIsNotOwnerException
635		*/
636	View Code Duplication	public function hasToBeAdmin(Member $member) {
		0 ignored issues – show Duplication introduced 2018-08-01 10:01 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
637		if (!$this->groupManager->isAdmin($member->getUserId())
638		&& $member->getLevel() < Member::LEVEL_ADMIN) {
639		throw new MemberIsNotOwnerException(
640		$this->l10n->t('This member is not an admin of the circle')
641		);
642		}
643		}
644		}
645

nextcloud / circles

Pull Request — master (#362)

CirclesService::detailsCircleLinkedGroups() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like