FederatedEventService::confirmRequiredCondition() - Code Metrics - Inspection of "Circles 22" - nextcloud/circles - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#551)

by Maxence

created 2021-02-25 15:12 UTC

FederatedEventService::confirmRequiredCondition() B

↳ Parent: FederatedEventService

Complexity

Conditions	10
Paths	9

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	29
rs	7.6666
c	0
b	0
f	0
cc	10
nc	9
nop	3

How to fix Complexity

<?php

declare(strict_types=1);


/**
 * 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]>
 * @copyright 2021
 * @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 daita\MySmallPhpTools\ActivityPub\Nextcloud\nc21\NC21Signature;
use daita\MySmallPhpTools\Exceptions\RequestNetworkException;
use daita\MySmallPhpTools\Exceptions\SignatoryException;
use daita\MySmallPhpTools\Model\Nextcloud\nc21\NC21Request;
use daita\MySmallPhpTools\Model\Request;
use daita\MySmallPhpTools\Model\SimpleDataStore;
use daita\MySmallPhpTools\Traits\Nextcloud\nc21\TNC21Request;
use daita\MySmallPhpTools\Traits\TStringTools;
use OC;
use OCA\Circles\Db\MemberRequest;
use OCA\Circles\Db\RemoteRequest;
use OCA\Circles\Db\RemoteWrapperRequest;
use OCA\Circles\Exceptions\FederatedEventDSyncException;
use OCA\Circles\Exceptions\FederatedEventException;
use OCA\Circles\Exceptions\FederatedItemException;
use OCA\Circles\Exceptions\InitiatorNotConfirmedException;
use OCA\Circles\Exceptions\JsonException;
use OCA\Circles\Exceptions\ModelException;
use OCA\Circles\Exceptions\OwnerNotFoundException;
use OCA\Circles\Exceptions\RemoteNotFoundException;
use OCA\Circles\Exceptions\RemoteResourceNotFoundException;
use OCA\Circles\Exceptions\UnknownRemoteException;
use OCA\Circles\IFederatedItem;
use OCA\Circles\IFederatedItemAsyncProcess;
use OCA\Circles\IFederatedItemCircleCheckNotRequired;
use OCA\Circles\IFederatedItemDataRequestOnly;
use OCA\Circles\IFederatedItemInitiatorCheckNotRequired;
use OCA\Circles\IFederatedItemInitiatorMembershipNotRequired;
use OCA\Circles\IFederatedItemInitiatorMustBeLocal;
use OCA\Circles\IFederatedItemLimitedToInstanceWithMembership;
use OCA\Circles\IFederatedItemMemberCheckNotRequired;
use OCA\Circles\IFederatedItemMemberEmpty;
use OCA\Circles\IFederatedItemMemberOptional;
use OCA\Circles\IFederatedItemMemberRequired;
use OCA\Circles\Model\Circle;
use OCA\Circles\Model\Federated\FederatedEvent;
use OCA\Circles\Model\Federated\RemoteInstance;
use OCA\Circles\Model\Federated\RemoteWrapper;
use OCA\Circles\Model\GlobalScale\GSWrapper;
use OCA\Circles\Model\Member;
use OCP\IL10N;
use ReflectionClass;
use ReflectionException;


/**
 * Class FederatedEventService
 *
 * @package OCA\Circles\Service
 */
class FederatedEventService extends NC21Signature {


	use TNC21Request;
	use TStringTools;


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

	/** @var RemoteWrapperRequest */
	private $remoteWrapperRequest;

	/** @var RemoteRequest */
	private $remoteRequest;

	/** @var MemberRequest */
	private $memberRequest;

	/** @var RemoteUpstreamService */
	private $remoteUpstreamService;

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

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


	/**
	 * FederatedEventService constructor.
	 *
	 * @param IL10N $l10n
	 * @param RemoteWrapperRequest $remoteWrapperRequest
	 * @param RemoteRequest $remoteRequest
	 * @param MemberRequest $memberRequest
	 * @param RemoteUpstreamService $remoteUpstreamService
	 * @param ConfigService $configService
	 */
	public function __construct(
		IL10N $l10n, RemoteWrapperRequest $remoteWrapperRequest, RemoteRequest $remoteRequest,
		MemberRequest $memberRequest, RemoteUpstreamService $remoteUpstreamService,
		ConfigService $configService
	) {
		$this->l10n = $l10n;
		$this->remoteWrapperRequest = $remoteWrapperRequest;
		$this->remoteRequest = $remoteRequest;
		$this->memberRequest = $memberRequest;
		$this->remoteUpstreamService = $remoteUpstreamService;
		$this->configService = $configService;
	}


	/**
	 * Called when creating a new Event.
	 * This method will manage the event locally and upstream the payload if needed.
	 *
	 * @param FederatedEvent $event
	 *
	 * @return SimpleDataStore
	 * @throws InitiatorNotConfirmedException
	 * @throws OwnerNotFoundException
	 * @throws FederatedEventException
	 * @throws RequestNetworkException
	 * @throws RemoteNotFoundException
	 * @throws RemoteResourceNotFoundException
	 * @throws UnknownRemoteException
	 * @throws SignatoryException
	 * @throws FederatedItemException
	 * @throws FederatedEventDSyncException
	 */
	public function newEvent(FederatedEvent $event): SimpleDataStore {
		$event->setSource($this->configService->getLocalInstance());

		try {
			$federatedItem = $this->getFederatedItem($event, false);
		} catch (FederatedEventException $e) {
			$this->e($e);
			throw $e;
		}

		$this->confirmInitiator($event, true);
		if ($this->configService->isLocalInstance($event->getCircle()->getInstance())) {
			$event->setIncomingOrigin($event->getCircle()->getInstance());

			try {
				$federatedItem->verify($event);
				$reading = $event->getReadingOutcome();
				$reading->s('translated', $this->l10n->t($reading->g('message'), $reading->gArray('params')));
			} catch (FederatedItemException $e) {
				throw new FederatedItemException($this->l10n->t($e->getMessage(), $e->getParams()));
			}

			if ($event->isDataRequestOnly()) {
				return $event->getDataOutcome();
			}

			if (!$event->isAsync()) {
				$federatedItem->manage($event);
			}

			$this->initBroadcast($event);
		} else {
			$this->remoteUpstreamService->confirmEvent($event);
			if ($event->isDataRequestOnly()) {
				return $event->getDataOutcome();
			}

			if (!$event->isAsync()) {
				$federatedItem->manage($event);
			}
		}

		return $event->getOutcome();
	}


	/**
	 * This confirmation is optional, method is just here to avoid going too far away on the process
	 *
	 * @param FederatedEvent $event
	 * @param bool $local
	 *
	 * @throws InitiatorNotConfirmedException
	 */
	public function confirmInitiator(FederatedEvent $event, bool $local = false): void {
		if ($event->canBypass(FederatedEvent::BYPASS_INITIATORCHECK)) {
			return;
		}

		$circle = $event->getCircle();
		if (!$circle->hasInitiator()) {
			throw new InitiatorNotConfirmedException('Initiator does not exist');
		}

		if ($local) {
			if (!$this->configService->isLocalInstance($circle->getInitiator()->getInstance())) {
				throw new InitiatorNotConfirmedException(
					'Initiator is not from the instance at the origin of the request'
				);
			}
		} else {
			if ($circle->getInitiator()->getInstance() !== $event->getIncomingOrigin()) {
				throw new InitiatorNotConfirmedException(
					'Initiator must belong to the instance at the origin of the request'
				);
			}
		}

		if (!$event->canBypass(FederatedEvent::BYPASS_INITIATORMEMBERSHIP)
			&& $circle->getInitiator()->getLevel() < Member::LEVEL_MEMBER) {
			throw new InitiatorNotConfirmedException('Initiator must be a member of the Circle');
		}
	}


	/**
	 * @param FederatedEvent $event
	 * @param bool $checkLocalOnly
	 *
	 * @return IFederatedItem
	 * @throws FederatedEventException
	 */
	public function getFederatedItem(FederatedEvent $event, bool $checkLocalOnly = true): IFederatedItem {
		$class = $event->getClass();
		try {
			$test = new ReflectionClass($class);
		} catch (ReflectionException $e) {
			throw new FederatedEventException('ReflectionException with ' . $class . ': ' . $e->getMessage());
		}

		if (!in_array(IFederatedItem::class, $test->getInterfaceNames())) {
			throw new FederatedEventException($class . ' does not implements IFederatedItem');
		}

		$item = OC::$server->get($class);
		if (!($item instanceof IFederatedItem)) {
			throw new FederatedEventException($class . ' not an IFederatedItem');
		}

		$this->setFederatedEventBypass($event, $item);
		$this->confirmRequiredCondition($event, $item, $checkLocalOnly);
		$this->configureEvent($event, $item);

		return $item;
	}


	/**
	 * Some event might need to bypass some checks
	 *
	 * @param FederatedEvent $event
	 * @param IFederatedItem $item
	 */
	private function setFederatedEventBypass(FederatedEvent $event, IFederatedItem $item) {
		if ($item instanceof IFederatedItemCircleCheckNotRequired) {
			$event->bypass(FederatedEvent::BYPASS_LOCALCIRCLECHECK);
		}
		if ($item instanceof IFederatedItemMemberCheckNotRequired) {
			$event->bypass(FederatedEvent::BYPASS_LOCALMEMBERCHECK);
		}
		if ($item instanceof IFederatedItemInitiatorCheckNotRequired) {
			$event->bypass(FederatedEvent::BYPASS_INITIATORCHECK);
		}
		if ($item instanceof IFederatedItemInitiatorMembershipNotRequired) {
			$event->bypass(FederatedEvent::BYPASS_INITIATORMEMBERSHIP);
		}
	}

	/**
	 * Some event might require additional check
	 *
	 * @param FederatedEvent $event
	 * @param IFederatedItem $item
	 * @param bool $checkLocalOnly
	 *
	 * @throws FederatedEventException
	 */
	private function confirmRequiredCondition(
		FederatedEvent $event,
		IFederatedItem $item,
		bool $checkLocalOnly = true
	) {
		if (!$event->hasCircle()) {
			throw new FederatedEventException('FederatedEvent has no Circle linked');
		}

		// TODO: enforce IFederatedItemMemberEmpty if no member
		if ($item instanceof IFederatedItemMemberEmpty) {
			$event->setMember(null);
		}

		if ($item instanceof IFederatedItemMemberRequired && !$event->hasMember()) {
			throw new FederatedEventException('FederatedEvent has no Member linked');
		}
		if ($event->hasMember()
			&& !($item instanceof IFederatedItemMemberRequired)
			&& !($item instanceof IFederatedItemMemberOptional)) {
			throw new FederatedEventException(
				get_class($item)
				. ' does not implements IFederatedItemMemberOptional nor IFederatedItemMemberRequired'
			);
		}
		if ($item instanceof IFederatedItemInitiatorMustBeLocal && $checkLocalOnly) {
			throw new FederatedEventException('FederatedItem must be executed locally');
		}
	}


	/**
	 * @param FederatedEvent $event
	 * @param IFederatedItem $item
	 */
	private function configureEvent(FederatedEvent $event, IFederatedItem $item) {
		if ($item instanceof IFederatedItemAsyncProcess) {
			$event->setAsync(true);
		}
		if ($item instanceof IFederatedItemLimitedToInstanceWithMembership) {
			$event->setLimitedToInstanceWithMember(true);
		}
		if ($item instanceof IFederatedItemDataRequestOnly) {
			$event->setDataRequestOnly(true);
		}
	}


	/**
	 * async the process, generate a local request that will be closed.
	 *
	 * @param FederatedEvent $event
	 * @param array $filter
	 */
	public function initBroadcast(FederatedEvent $event, array $filter = []): void {
		$instances = array_diff($this->getInstances($event), $filter);
		if (empty($instances)) {
			return;
		}

		$wrapper = new RemoteWrapper();
		$wrapper->setEvent($event);
		$wrapper->setToken($this->uuid());
		$wrapper->setCreation(time());
		$wrapper->setSeverity($event->getSeverity());

		foreach ($instances as $instance) {
			$wrapper->setInstance($instance);
			$this->remoteWrapperRequest->create($wrapper);
		}

		$request = new NC21Request('', Request::TYPE_POST);
		$this->configService->configureRequest(
			$request, 'circles.RemoteWrapper.asyncBroadcast', ['token' => $wrapper->getToken()]
		);

		$event->setWrapperToken($wrapper->getToken());

		try {
			$this->doRequest($request);
		} catch (RequestNetworkException $e) {
			$this->e($e, ['wrapper' => $wrapper]);
		}
	}


	/**
	 * @param FederatedEvent $event
	 * @param Circle|null $circle
	 * // TODO: use of $circle ??
	 *
	 * @return array
	 */
	public function getInstances(FederatedEvent $event, ?Circle $circle = null): array {
		$local = $this->configService->getLocalInstance();
		$instances = $this->remoteRequest->getOutgoingRecipient($circle);

		$instances = array_map(
			function(RemoteInstance $instance): string {
				return $instance->getInstance();
			}, $instances
		);

		if ($event->isLimitedToInstanceWithMember()) {
			$instances =
				array_intersect(
					$instances, $this->memberRequest->getMemberInstances($event->getCircle()->getId())
				);
		}

		$instances = array_merge([$local], $instances);

		if ($event->isAsync()) {
			return $instances;
		}

		return array_values(
			array_diff($instances, array_merge($this->configService->getTrustedDomains(), [$local]))
		);
	}


	/**
	 * @param array $current
	 */
	private function updateGlobalScaleInstances(array $current): void {

//		$known = $this->remoteRequest->getFromType(RemoteInstance::TYPE_GLOBAL_SCALE);
	}

	/**
	 * @return array
	 */
	private function getRemoteInstances(): array {
		return [];
	}


	/**
	 * should be used to manage results from events, like sending mails on user creation
	 *
	 * @param string $token
	 */
	public function manageResults(string $token): void {
		try {
			$wrappers = $this->remoteWrapperRequest->getByToken($token);
		} catch (JsonException | ModelException $e) {
			return;
		}

		$event = null;
		$events = [];
		foreach ($wrappers as $wrapper) {
			if ($wrapper->getStatus() !== GSWrapper::STATUS_DONE) {
				return;
			}

			$events[$wrapper->getInstance()] = $event = $wrapper->getEvent();
		}

		if ($event === null) {
			return;
		}

		try {
			$gs = $this->getFederatedItem($event, false);
			$gs->result($events);
		} catch (FederatedEventException $e) {

		}
	}

}



1			<?php
2
3			declare(strict_types=1);
4
5
6			/**
7			* Circles - Bring cloud-users closer together.
8			*
9			* This file is licensed under the Affero General Public License version 3 or
10			* later. See the COPYING file.
11			*
12			* @author Maxence Lange <[email protected]>
13			* @copyright 2021
14			* @license GNU AGPL version 3 or any later version
15			*
16			* This program is free software: you can redistribute it and/or modify
17			* it under the terms of the GNU Affero General Public License as
18			* published by the Free Software Foundation, either version 3 of the
19			* License, or (at your option) any later version.
20			*
21			* This program is distributed in the hope that it will be useful,
22			* but WITHOUT ANY WARRANTY; without even the implied warranty of
23			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24			* GNU Affero General Public License for more details.
25			*
26			* You should have received a copy of the GNU Affero General Public License
27			* along with this program. If not, see <http://www.gnu.org/licenses/>.
28			*
29			*/
30
31			namespace OCA\Circles\Service;
32
33
34			use daita\MySmallPhpTools\ActivityPub\Nextcloud\nc21\NC21Signature;
35			use daita\MySmallPhpTools\Exceptions\RequestNetworkException;
36			use daita\MySmallPhpTools\Exceptions\SignatoryException;
37			use daita\MySmallPhpTools\Model\Nextcloud\nc21\NC21Request;
38			use daita\MySmallPhpTools\Model\Request;
39			use daita\MySmallPhpTools\Model\SimpleDataStore;
40			use daita\MySmallPhpTools\Traits\Nextcloud\nc21\TNC21Request;
41			use daita\MySmallPhpTools\Traits\TStringTools;
42			use OC;
43			use OCA\Circles\Db\MemberRequest;
44			use OCA\Circles\Db\RemoteRequest;
45			use OCA\Circles\Db\RemoteWrapperRequest;
46			use OCA\Circles\Exceptions\FederatedEventDSyncException;
47			use OCA\Circles\Exceptions\FederatedEventException;
48			use OCA\Circles\Exceptions\FederatedItemException;
49			use OCA\Circles\Exceptions\InitiatorNotConfirmedException;
50			use OCA\Circles\Exceptions\JsonException;
51			use OCA\Circles\Exceptions\ModelException;
52			use OCA\Circles\Exceptions\OwnerNotFoundException;
53			use OCA\Circles\Exceptions\RemoteNotFoundException;
54			use OCA\Circles\Exceptions\RemoteResourceNotFoundException;
55			use OCA\Circles\Exceptions\UnknownRemoteException;
56			use OCA\Circles\IFederatedItem;
57			use OCA\Circles\IFederatedItemAsyncProcess;
58			use OCA\Circles\IFederatedItemCircleCheckNotRequired;
59			use OCA\Circles\IFederatedItemDataRequestOnly;
60			use OCA\Circles\IFederatedItemInitiatorCheckNotRequired;
61			use OCA\Circles\IFederatedItemInitiatorMembershipNotRequired;
62			use OCA\Circles\IFederatedItemInitiatorMustBeLocal;
63			use OCA\Circles\IFederatedItemLimitedToInstanceWithMembership;
64			use OCA\Circles\IFederatedItemMemberCheckNotRequired;
65			use OCA\Circles\IFederatedItemMemberEmpty;
66			use OCA\Circles\IFederatedItemMemberOptional;
67			use OCA\Circles\IFederatedItemMemberRequired;
68			use OCA\Circles\Model\Circle;
69			use OCA\Circles\Model\Federated\FederatedEvent;
70			use OCA\Circles\Model\Federated\RemoteInstance;
71			use OCA\Circles\Model\Federated\RemoteWrapper;
72			use OCA\Circles\Model\GlobalScale\GSWrapper;
73			use OCA\Circles\Model\Member;
74			use OCP\IL10N;
75			use ReflectionClass;
76			use ReflectionException;
77
78
79			/**
80			* Class FederatedEventService
81			*
82			* @package OCA\Circles\Service
83			*/
84			class FederatedEventService extends NC21Signature {
85
86
87			use TNC21Request;
88			use TStringTools;
89
90
91			/** @var IL10N */
92			private $l10n;
93
94			/** @var RemoteWrapperRequest */
95			private $remoteWrapperRequest;
96
97			/** @var RemoteRequest */
98			private $remoteRequest;
99
100			/** @var MemberRequest */
101			private $memberRequest;
102
103			/** @var RemoteUpstreamService */
104			private $remoteUpstreamService;
105
106			/** @var ConfigService */
107			private $configService;
108
109			/** @var MiscService */
110			private $miscService;
111
112
113			/**
114			* FederatedEventService constructor.
115			*
116			* @param IL10N $l10n
117			* @param RemoteWrapperRequest $remoteWrapperRequest
118			* @param RemoteRequest $remoteRequest
119			* @param MemberRequest $memberRequest
120			* @param RemoteUpstreamService $remoteUpstreamService
121			* @param ConfigService $configService
122			*/
123			public function __construct(
124			IL10N $l10n, RemoteWrapperRequest $remoteWrapperRequest, RemoteRequest $remoteRequest,
125			MemberRequest $memberRequest, RemoteUpstreamService $remoteUpstreamService,
126			ConfigService $configService
127			) {
128			$this->l10n = $l10n;
129			$this->remoteWrapperRequest = $remoteWrapperRequest;
130			$this->remoteRequest = $remoteRequest;
131			$this->memberRequest = $memberRequest;
132			$this->remoteUpstreamService = $remoteUpstreamService;
133			$this->configService = $configService;
134			}
135
136
137			/**
138			* Called when creating a new Event.
139			* This method will manage the event locally and upstream the payload if needed.
140			*
141			* @param FederatedEvent $event
142			*
143			* @return SimpleDataStore
144			* @throws InitiatorNotConfirmedException
145			* @throws OwnerNotFoundException
146			* @throws FederatedEventException
147			* @throws RequestNetworkException
148			* @throws RemoteNotFoundException
149			* @throws RemoteResourceNotFoundException
150			* @throws UnknownRemoteException
151			* @throws SignatoryException
152			* @throws FederatedItemException
153			* @throws FederatedEventDSyncException
154			*/
155			public function newEvent(FederatedEvent $event): SimpleDataStore {
156			$event->setSource($this->configService->getLocalInstance());
157
158			try {
159			$federatedItem = $this->getFederatedItem($event, false);
160			} catch (FederatedEventException $e) {
161			$this->e($e);
162			throw $e;
163			}
164
165			$this->confirmInitiator($event, true);
166			if ($this->configService->isLocalInstance($event->getCircle()->getInstance())) {
167			$event->setIncomingOrigin($event->getCircle()->getInstance());
168
169			try {
170			$federatedItem->verify($event);
171			$reading = $event->getReadingOutcome();
172			$reading->s('translated', $this->l10n->t($reading->g('message'), $reading->gArray('params')));
173			} catch (FederatedItemException $e) {
174			throw new FederatedItemException($this->l10n->t($e->getMessage(), $e->getParams()));
175			}
176
177			if ($event->isDataRequestOnly()) {
178			return $event->getDataOutcome();
179			}
180
181			if (!$event->isAsync()) {
182			$federatedItem->manage($event);
183			}
184
185			$this->initBroadcast($event);
186			} else {
187			$this->remoteUpstreamService->confirmEvent($event);
188			if ($event->isDataRequestOnly()) {
189			return $event->getDataOutcome();
190			}
191
192			if (!$event->isAsync()) {
193			$federatedItem->manage($event);
194			}
195			}
196
197			return $event->getOutcome();
198			}
199
200
201			/**
202			* This confirmation is optional, method is just here to avoid going too far away on the process
203			*
204			* @param FederatedEvent $event
205			* @param bool $local
206			*
207			* @throws InitiatorNotConfirmedException
208			*/
209			public function confirmInitiator(FederatedEvent $event, bool $local = false): void {
210			if ($event->canBypass(FederatedEvent::BYPASS_INITIATORCHECK)) {
211			return;
212			}
213
214			$circle = $event->getCircle();
215			if (!$circle->hasInitiator()) {
216			throw new InitiatorNotConfirmedException('Initiator does not exist');
217			}
218
219			if ($local) {
220			if (!$this->configService->isLocalInstance($circle->getInitiator()->getInstance())) {
221			throw new InitiatorNotConfirmedException(
222			'Initiator is not from the instance at the origin of the request'
223			);
224			}
225			} else {
226			if ($circle->getInitiator()->getInstance() !== $event->getIncomingOrigin()) {
227			throw new InitiatorNotConfirmedException(
228			'Initiator must belong to the instance at the origin of the request'
229			);
230			}
231			}
232
233			if (!$event->canBypass(FederatedEvent::BYPASS_INITIATORMEMBERSHIP)
234			&& $circle->getInitiator()->getLevel() < Member::LEVEL_MEMBER) {
235			throw new InitiatorNotConfirmedException('Initiator must be a member of the Circle');
236			}
237			}
238
239
240			/**
241			* @param FederatedEvent $event
242			* @param bool $checkLocalOnly
243			*
244			* @return IFederatedItem
245			* @throws FederatedEventException
246			*/
247			public function getFederatedItem(FederatedEvent $event, bool $checkLocalOnly = true): IFederatedItem {
248			$class = $event->getClass();
249			try {
250			$test = new ReflectionClass($class);
251			} catch (ReflectionException $e) {
252			throw new FederatedEventException('ReflectionException with ' . $class . ': ' . $e->getMessage());
253			}
254
255			if (!in_array(IFederatedItem::class, $test->getInterfaceNames())) {
256			throw new FederatedEventException($class . ' does not implements IFederatedItem');
257			}
258
259			$item = OC::$server->get($class);
260			if (!($item instanceof IFederatedItem)) {
261			throw new FederatedEventException($class . ' not an IFederatedItem');
262			}
263
264			$this->setFederatedEventBypass($event, $item);
265			$this->confirmRequiredCondition($event, $item, $checkLocalOnly);
266			$this->configureEvent($event, $item);
267
268			return $item;
269			}
270
271
272			/**
273			* Some event might need to bypass some checks
274			*
275			* @param FederatedEvent $event
276			* @param IFederatedItem $item
277			*/
278			private function setFederatedEventBypass(FederatedEvent $event, IFederatedItem $item) {
279			if ($item instanceof IFederatedItemCircleCheckNotRequired) {
280			$event->bypass(FederatedEvent::BYPASS_LOCALCIRCLECHECK);
281			}
282			if ($item instanceof IFederatedItemMemberCheckNotRequired) {
283			$event->bypass(FederatedEvent::BYPASS_LOCALMEMBERCHECK);
284			}
285			if ($item instanceof IFederatedItemInitiatorCheckNotRequired) {
286			$event->bypass(FederatedEvent::BYPASS_INITIATORCHECK);
287			}
288			if ($item instanceof IFederatedItemInitiatorMembershipNotRequired) {
289			$event->bypass(FederatedEvent::BYPASS_INITIATORMEMBERSHIP);
290			}
291			}
292
293			/**
294			* Some event might require additional check
295			*
296			* @param FederatedEvent $event
297			* @param IFederatedItem $item
298			* @param bool $checkLocalOnly
299			*
300			* @throws FederatedEventException
301			*/
302			private function confirmRequiredCondition(
303			FederatedEvent $event,
304			IFederatedItem $item,
305			bool $checkLocalOnly = true
306			) {
307			if (!$event->hasCircle()) {
308			throw new FederatedEventException('FederatedEvent has no Circle linked');
309			}
310
311			// TODO: enforce IFederatedItemMemberEmpty if no member
312			if ($item instanceof IFederatedItemMemberEmpty) {
313			$event->setMember(null);
314			}
315
316			if ($item instanceof IFederatedItemMemberRequired && !$event->hasMember()) {
317			throw new FederatedEventException('FederatedEvent has no Member linked');
318			}
319			if ($event->hasMember()
320			&& !($item instanceof IFederatedItemMemberRequired)
321			&& !($item instanceof IFederatedItemMemberOptional)) {
322			throw new FederatedEventException(
323			get_class($item)
324			. ' does not implements IFederatedItemMemberOptional nor IFederatedItemMemberRequired'
325			);
326			}
327			if ($item instanceof IFederatedItemInitiatorMustBeLocal && $checkLocalOnly) {
328			throw new FederatedEventException('FederatedItem must be executed locally');
329			}
330			}
331
332
333			/**
334			* @param FederatedEvent $event
335			* @param IFederatedItem $item
336			*/
337			private function configureEvent(FederatedEvent $event, IFederatedItem $item) {
338			if ($item instanceof IFederatedItemAsyncProcess) {
339			$event->setAsync(true);
340			}
341			if ($item instanceof IFederatedItemLimitedToInstanceWithMembership) {
342			$event->setLimitedToInstanceWithMember(true);
343			}
344			if ($item instanceof IFederatedItemDataRequestOnly) {
345			$event->setDataRequestOnly(true);
346			}
347			}
348
349
350			/**
351			* async the process, generate a local request that will be closed.
352			*
353			* @param FederatedEvent $event
354			* @param array $filter
355			*/
356			public function initBroadcast(FederatedEvent $event, array $filter = []): void {
357			$instances = array_diff($this->getInstances($event), $filter);
358			if (empty($instances)) {
359			return;
360			}
361
362			$wrapper = new RemoteWrapper();
363			$wrapper->setEvent($event);
364			$wrapper->setToken($this->uuid());
365			$wrapper->setCreation(time());
366			$wrapper->setSeverity($event->getSeverity());
367
368			foreach ($instances as $instance) {
369			$wrapper->setInstance($instance);
370			$this->remoteWrapperRequest->create($wrapper);
371			}
372
373			$request = new NC21Request('', Request::TYPE_POST);
374			$this->configService->configureRequest(
375			$request, 'circles.RemoteWrapper.asyncBroadcast', ['token' => $wrapper->getToken()]
376			);
377
378			$event->setWrapperToken($wrapper->getToken());
379
380			try {
381			$this->doRequest($request);
382			} catch (RequestNetworkException $e) {
383			$this->e($e, ['wrapper' => $wrapper]);
384			}
385			}
386
387
388			/**
389			* @param FederatedEvent $event
390			* @param Circle\|null $circle
391			* // TODO: use of $circle ??
392			*
393			* @return array
394			*/
395			public function getInstances(FederatedEvent $event, ?Circle $circle = null): array {
396			$local = $this->configService->getLocalInstance();
397			$instances = $this->remoteRequest->getOutgoingRecipient($circle);
398
399			$instances = array_map(
400			function(RemoteInstance $instance): string {
401			return $instance->getInstance();
402			}, $instances
403			);
404
405			if ($event->isLimitedToInstanceWithMember()) {
406			$instances =
407			array_intersect(
408			$instances, $this->memberRequest->getMemberInstances($event->getCircle()->getId())
409			);
410			}
411
412			$instances = array_merge([$local], $instances);
413
414			if ($event->isAsync()) {
415			return $instances;
416			}
417
418			return array_values(
419			array_diff($instances, array_merge($this->configService->getTrustedDomains(), [$local]))
420			);
421			}
422
423
424			/**
425			* @param array $current
426			*/
427			private function updateGlobalScaleInstances(array $current): void {
			0 ignored issues – show Unused Code introduced 2021-01-29 12:47 UTC by Report Bug Copy Issue Report The parameter `$current` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
428			// $known = $this->remoteRequest->getFromType(RemoteInstance::TYPE_GLOBAL_SCALE);
429			}
430
431			/**
432			* @return array
433			*/
434			private function getRemoteInstances(): array {
435			return [];
436			}
437
438
439			/**
440			* should be used to manage results from events, like sending mails on user creation
441			*
442			* @param string $token
443			*/
444			public function manageResults(string $token): void {
445			try {
446			$wrappers = $this->remoteWrapperRequest->getByToken($token);
447			} catch (JsonException \| ModelException $e) {
448			return;
449			}
450
451			$event = null;
452			$events = [];
453			foreach ($wrappers as $wrapper) {
454			if ($wrapper->getStatus() !== GSWrapper::STATUS_DONE) {
455			return;
456			}
457
458			$events[$wrapper->getInstance()] = $event = $wrapper->getEvent();
459			}
460
461			if ($event === null) {
462			return;
463			}
464
465			try {
466			$gs = $this->getFederatedItem($event, false);
467			$gs->result($events);
468			} catch (FederatedEventException $e) {
			0 ignored issues – show Coding Style Comprehensibility introduced 2021-02-11 13:42 UTC by Report Bug Copy Issue Report Consider adding a comment why this CATCH block is empty. Loading history...
469			}
470			}
471
472			}
473
474

nextcloud / circles

Pull Request — master (#551)

FederatedEventService::confirmRequiredCondition() B

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like