migrate therinaldos.com data

wedding-pics/lib/private/Notification/Action.php

@@ -0,0 +1,172 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Joas Schilling <coding@schilljs.com>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Notification;
+
+use OCP\Notification\IAction;
+
+class Action implements IAction {
+	/** @var string */
+	protected $label;
+
+	/** @var string */
+	protected $labelParsed;
+
+	/** @var string */
+	protected $link;
+
+	/** @var string */
+	protected $requestType;
+
+	/** @var string */
+	protected $icon;
+
+	/** @var bool */
+	protected $primary;
+
+	public function __construct() {
+		$this->label = '';
+		$this->labelParsed = '';
+		$this->link = '';
+		$this->requestType = '';
+		$this->primary = false;
+	}
+
+	/**
+	 * @param string $label
+	 * @return $this
+	 * @throws \InvalidArgumentException if the label is invalid
+	 * @since 8.2.0
+	 */
+	public function setLabel(string $label): IAction {
+		if ($label === '' || isset($label[32])) {
+			throw new \InvalidArgumentException('The given label is invalid');
+		}
+		$this->label = $label;
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 * @since 8.2.0
+	 */
+	public function getLabel(): string {
+		return $this->label;
+	}
+
+	/**
+	 * @param string $label
+	 * @return $this
+	 * @throws \InvalidArgumentException if the label is invalid
+	 * @since 8.2.0
+	 */
+	public function setParsedLabel(string $label): IAction {
+		if ($label === '') {
+			throw new \InvalidArgumentException('The given parsed label is invalid');
+		}
+		$this->labelParsed = $label;
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 * @since 8.2.0
+	 */
+	public function getParsedLabel(): string {
+		return $this->labelParsed;
+	}
+
+	/**
+	 * @param $primary bool
+	 * @return $this
+	 * @since 9.0.0
+	 */
+	public function setPrimary(bool $primary): IAction {
+		$this->primary = $primary;
+		return $this;
+	}
+
+	/**
+	 * @return bool
+	 * @since 9.0.0
+	 */
+	public function isPrimary(): bool {
+		return $this->primary;
+	}
+
+	/**
+	 * @param string $link
+	 * @param string $requestType
+	 * @return $this
+	 * @throws \InvalidArgumentException if the link is invalid
+	 * @since 8.2.0
+	 */
+	public function setLink(string $link, string $requestType): IAction {
+		if ($link === '' || isset($link[256])) {
+			throw new \InvalidArgumentException('The given link is invalid');
+		}
+		if (!in_array($requestType, [
+			self::TYPE_GET,
+			self::TYPE_POST,
+			self::TYPE_PUT,
+			self::TYPE_DELETE,
+			self::TYPE_WEB,
+		], true)) {
+			throw new \InvalidArgumentException('The given request type is invalid');
+		}
+		$this->link = $link;
+		$this->requestType = $requestType;
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 * @since 8.2.0
+	 */
+	public function getLink(): string {
+		return $this->link;
+	}
+
+	/**
+	 * @return string
+	 * @since 8.2.0
+	 */
+	public function getRequestType(): string {
+		return $this->requestType;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isValid(): bool {
+		return $this->label !== '' && $this->link !== '';
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isValidParsed(): bool {
+		return $this->labelParsed !== '' && $this->link !== '';
+	}
+}

wedding-pics/lib/private/Notification/Manager.php

@@ -0,0 +1,427 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Joas Schilling <coding@schilljs.com>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Notification;
+
+use OC\AppFramework\Bootstrap\Coordinator;
+use OCP\ICache;
+use OCP\ICacheFactory;
+use OCP\IUserManager;
+use OCP\Notification\AlreadyProcessedException;
+use OCP\Notification\IApp;
+use OCP\Notification\IDeferrableApp;
+use OCP\Notification\IDismissableNotifier;
+use OCP\Notification\IManager;
+use OCP\Notification\INotification;
+use OCP\Notification\INotifier;
+use OCP\RichObjectStrings\IValidator;
+use OCP\Support\Subscription\IRegistry;
+use Psr\Container\ContainerExceptionInterface;
+use Psr\Log\LoggerInterface;
+
+class Manager implements IManager {
+	/** @var IValidator */
+	protected $validator;
+	/** @var IUserManager */
+	private $userManager;
+	/** @var ICache */
+	protected $cache;
+	/** @var IRegistry */
+	protected $subscription;
+	/** @var LoggerInterface */
+	protected $logger;
+	/** @var Coordinator */
+	private $coordinator;
+
+	/** @var IApp[] */
+	protected $apps;
+	/** @var string[] */
+	protected $appClasses;
+
+	/** @var INotifier[] */
+	protected $notifiers;
+	/** @var string[] */
+	protected $notifierClasses;
+
+	/** @var bool */
+	protected $preparingPushNotification;
+	/** @var bool */
+	protected $deferPushing;
+	/** @var bool */
+	private $parsedRegistrationContext;
+
+	public function __construct(IValidator $validator,
+		IUserManager $userManager,
+		ICacheFactory $cacheFactory,
+		IRegistry $subscription,
+		LoggerInterface $logger,
+		Coordinator $coordinator) {
+		$this->validator = $validator;
+		$this->userManager = $userManager;
+		$this->cache = $cacheFactory->createDistributed('notifications');
+		$this->subscription = $subscription;
+		$this->logger = $logger;
+		$this->coordinator = $coordinator;
+
+		$this->apps = [];
+		$this->notifiers = [];
+		$this->appClasses = [];
+		$this->notifierClasses = [];
+		$this->preparingPushNotification = false;
+		$this->deferPushing = false;
+		$this->parsedRegistrationContext = false;
+	}
+	/**
+	 * @param string $appClass The service must implement IApp, otherwise a
+	 *                          \InvalidArgumentException is thrown later
+	 * @since 17.0.0
+	 */
+	public function registerApp(string $appClass): void {
+		$this->appClasses[] = $appClass;
+	}
+
+	/**
+	 * @param \Closure $service The service must implement INotifier, otherwise a
+	 *                          \InvalidArgumentException is thrown later
+	 * @param \Closure $info    An array with the keys 'id' and 'name' containing
+	 *                          the app id and the app name
+	 * @deprecated 17.0.0 use registerNotifierService instead.
+	 * @since 8.2.0 - Parameter $info was added in 9.0.0
+	 */
+	public function registerNotifier(\Closure $service, \Closure $info) {
+		$infoData = $info();
+		$exception = new \InvalidArgumentException(
+			'Notifier ' . $infoData['name'] . ' (id: ' . $infoData['id'] . ') is not considered because it is using the old way to register.'
+		);
+		$this->logger->error($exception->getMessage(), ['exception' => $exception]);
+	}
+
+	/**
+	 * @param string $notifierService The service must implement INotifier, otherwise a
+	 *                          \InvalidArgumentException is thrown later
+	 * @since 17.0.0
+	 */
+	public function registerNotifierService(string $notifierService): void {
+		$this->notifierClasses[] = $notifierService;
+	}
+
+	/**
+	 * @return IApp[]
+	 */
+	protected function getApps(): array {
+		if (empty($this->appClasses)) {
+			return $this->apps;
+		}
+
+		foreach ($this->appClasses as $appClass) {
+			try {
+				$app = \OC::$server->get($appClass);
+			} catch (ContainerExceptionInterface $e) {
+				$this->logger->error('Failed to load notification app class: ' . $appClass, [
+					'exception' => $e,
+					'app' => 'notifications',
+				]);
+				continue;
+			}
+
+			if (!($app instanceof IApp)) {
+				$this->logger->error('Notification app class ' . $appClass . ' is not implementing ' . IApp::class, [
+					'app' => 'notifications',
+				]);
+				continue;
+			}
+
+			$this->apps[] = $app;
+		}
+
+		$this->appClasses = [];
+
+		return $this->apps;
+	}
+
+	/**
+	 * @return INotifier[]
+	 */
+	public function getNotifiers(): array {
+		if (!$this->parsedRegistrationContext) {
+			$notifierServices = $this->coordinator->getRegistrationContext()->getNotifierServices();
+			foreach ($notifierServices as $notifierService) {
+				try {
+					$notifier = \OC::$server->get($notifierService->getService());
+				} catch (ContainerExceptionInterface $e) {
+					$this->logger->error('Failed to load notification notifier class: ' . $notifierService->getService(), [
+						'exception' => $e,
+						'app' => 'notifications',
+					]);
+					continue;
+				}
+
+				if (!($notifier instanceof INotifier)) {
+					$this->logger->error('Notification notifier class ' . $notifierService->getService() . ' is not implementing ' . INotifier::class, [
+						'app' => 'notifications',
+					]);
+					continue;
+				}
+
+				$this->notifiers[] = $notifier;
+			}
+
+			$this->parsedRegistrationContext = true;
+		}
+
+		if (empty($this->notifierClasses)) {
+			return $this->notifiers;
+		}
+
+		foreach ($this->notifierClasses as $notifierClass) {
+			try {
+				$notifier = \OC::$server->get($notifierClass);
+			} catch (ContainerExceptionInterface $e) {
+				$this->logger->error('Failed to load notification notifier class: ' . $notifierClass, [
+					'exception' => $e,
+					'app' => 'notifications',
+				]);
+				continue;
+			}
+
+			if (!($notifier instanceof INotifier)) {
+				$this->logger->error('Notification notifier class ' . $notifierClass . ' is not implementing ' . INotifier::class, [
+					'app' => 'notifications',
+				]);
+				continue;
+			}
+
+			$this->notifiers[] = $notifier;
+		}
+
+		$this->notifierClasses = [];
+
+		return $this->notifiers;
+	}
+
+	/**
+	 * @return INotification
+	 * @since 8.2.0
+	 */
+	public function createNotification(): INotification {
+		return new Notification($this->validator);
+	}
+
+	/**
+	 * @return bool
+	 * @since 8.2.0
+	 */
+	public function hasNotifiers(): bool {
+		return !empty($this->notifiers) || !empty($this->notifierClasses);
+	}
+
+	/**
+	 * @param bool $preparingPushNotification
+	 * @since 14.0.0
+	 */
+	public function setPreparingPushNotification(bool $preparingPushNotification): void {
+		$this->preparingPushNotification = $preparingPushNotification;
+	}
+
+	/**
+	 * @return bool
+	 * @since 14.0.0
+	 */
+	public function isPreparingPushNotification(): bool {
+		return $this->preparingPushNotification;
+	}
+
+	/**
+	 * The calling app should only "flush" when it got returned true on the defer call
+	 * @return bool
+	 * @since 20.0.0
+	 */
+	public function defer(): bool {
+		$alreadyDeferring = $this->deferPushing;
+		$this->deferPushing = true;
+
+		$apps = $this->getApps();
+
+		foreach ($apps as $app) {
+			if ($app instanceof IDeferrableApp) {
+				$app->defer();
+			}
+		}
+
+		return !$alreadyDeferring;
+	}
+
+	/**
+	 * @since 20.0.0
+	 */
+	public function flush(): void {
+		$apps = $this->getApps();
+
+		foreach ($apps as $app) {
+			if (!$app instanceof IDeferrableApp) {
+				continue;
+			}
+
+			try {
+				$app->flush();
+			} catch (\InvalidArgumentException $e) {
+			}
+		}
+
+		$this->deferPushing = false;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function isFairUseOfFreePushService(): bool {
+		$pushAllowed = $this->cache->get('push_fair_use');
+		if ($pushAllowed === null) {
+			/**
+			 * We want to keep offering our push notification service for free, but large
+			 * users overload our infrastructure. For this reason we have to rate-limit the
+			 * use of push notifications. If you need this feature, consider using Nextcloud Enterprise.
+			 */
+			$isFairUse = $this->subscription->delegateHasValidSubscription() || $this->userManager->countSeenUsers() < 1000;
+			$pushAllowed = $isFairUse ? 'yes' : 'no';
+			$this->cache->set('push_fair_use', $pushAllowed, 3600);
+		}
+		return $pushAllowed === 'yes';
+	}
+
+	/**
+	 * @param INotification $notification
+	 * @throws \InvalidArgumentException When the notification is not valid
+	 * @since 8.2.0
+	 */
+	public function notify(INotification $notification): void {
+		if (!$notification->isValid()) {
+			throw new \InvalidArgumentException('The given notification is invalid');
+		}
+
+		$apps = $this->getApps();
+
+		foreach ($apps as $app) {
+			try {
+				$app->notify($notification);
+			} catch (\InvalidArgumentException $e) {
+			}
+		}
+	}
+
+	/**
+	 * Identifier of the notifier, only use [a-z0-9_]
+	 *
+	 * @return string
+	 * @since 17.0.0
+	 */
+	public function getID(): string {
+		return 'core';
+	}
+
+	/**
+	 * Human readable name describing the notifier
+	 *
+	 * @return string
+	 * @since 17.0.0
+	 */
+	public function getName(): string {
+		return 'core';
+	}
+
+	/**
+	 * @param INotification $notification
+	 * @param string $languageCode The code of the language that should be used to prepare the notification
+	 * @return INotification
+	 * @throws \InvalidArgumentException When the notification was not prepared by a notifier
+	 * @throws AlreadyProcessedException When the notification is not needed anymore and should be deleted
+	 * @since 8.2.0
+	 */
+	public function prepare(INotification $notification, string $languageCode): INotification {
+		$notifiers = $this->getNotifiers();
+
+		foreach ($notifiers as $notifier) {
+			try {
+				$notification = $notifier->prepare($notification, $languageCode);
+			} catch (\InvalidArgumentException $e) {
+				continue;
+			} catch (AlreadyProcessedException $e) {
+				$this->markProcessed($notification);
+				throw new \InvalidArgumentException('The given notification has been processed');
+			}
+
+			if (!$notification->isValidParsed()) {
+				throw new \InvalidArgumentException('The given notification has not been handled');
+			}
+		}
+
+		if (!$notification->isValidParsed()) {
+			throw new \InvalidArgumentException('The given notification has not been handled');
+		}
+
+		return $notification;
+	}
+
+	/**
+	 * @param INotification $notification
+	 */
+	public function markProcessed(INotification $notification): void {
+		$apps = $this->getApps();
+
+		foreach ($apps as $app) {
+			$app->markProcessed($notification);
+		}
+	}
+
+	/**
+	 * @param INotification $notification
+	 * @return int
+	 */
+	public function getCount(INotification $notification): int {
+		$apps = $this->getApps();
+
+		$count = 0;
+		foreach ($apps as $app) {
+			$count += $app->getCount($notification);
+		}
+
+		return $count;
+	}
+
+	public function dismissNotification(INotification $notification): void {
+		$notifiers = $this->getNotifiers();
+
+		foreach ($notifiers as $notifier) {
+			if ($notifier instanceof IDismissableNotifier) {
+				try {
+					$notifier->dismissNotification($notification);
+				} catch (\InvalidArgumentException $e) {
+					continue;
+				}
+			}
+		}
+	}
+}

wedding-pics/lib/private/Notification/Notification.php

@@ -0,0 +1,610 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * @copyright Copyright (c) 2016, ownCloud, Inc.
+ *
+ * @author Joas Schilling <coding@schilljs.com>
+ * @author Morris Jobke <hey@morrisjobke.de>
+ * @author Roeland Jago Douma <roeland@famdouma.nl>
+ *
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License, version 3,
+ * along with this program. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+namespace OC\Notification;
+
+use OCP\Notification\IAction;
+use OCP\Notification\INotification;
+use OCP\RichObjectStrings\InvalidObjectExeption;
+use OCP\RichObjectStrings\IValidator;
+
+class Notification implements INotification {
+	/** @var IValidator */
+	protected $richValidator;
+
+	/** @var string */
+	protected $app;
+
+	/** @var string */
+	protected $user;
+
+	/** @var \DateTime */
+	protected $dateTime;
+
+	/** @var string */
+	protected $objectType;
+
+	/** @var string */
+	protected $objectId;
+
+	/** @var string */
+	protected $subject;
+
+	/** @var array */
+	protected $subjectParameters;
+
+	/** @var string */
+	protected $subjectParsed;
+
+	/** @var string */
+	protected $subjectRich;
+
+	/** @var array */
+	protected $subjectRichParameters;
+
+	/** @var string */
+	protected $message;
+
+	/** @var array */
+	protected $messageParameters;
+
+	/** @var string */
+	protected $messageParsed;
+
+	/** @var string */
+	protected $messageRich;
+
+	/** @var array */
+	protected $messageRichParameters;
+
+	/** @var string */
+	protected $link;
+
+	/** @var string */
+	protected $icon;
+
+	/** @var array */
+	protected $actions;
+
+	/** @var array */
+	protected $actionsParsed;
+
+	/** @var bool */
+	protected $hasPrimaryAction;
+
+	/** @var bool */
+	protected $hasPrimaryParsedAction;
+
+	public function __construct(IValidator $richValidator) {
+		$this->richValidator = $richValidator;
+		$this->app = '';
+		$this->user = '';
+		$this->dateTime = new \DateTime();
+		$this->dateTime->setTimestamp(0);
+		$this->objectType = '';
+		$this->objectId = '';
+		$this->subject = '';
+		$this->subjectParameters = [];
+		$this->subjectParsed = '';
+		$this->subjectRich = '';
+		$this->subjectRichParameters = [];
+		$this->message = '';
+		$this->messageParameters = [];
+		$this->messageParsed = '';
+		$this->messageRich = '';
+		$this->messageRichParameters = [];
+		$this->link = '';
+		$this->icon = '';
+		$this->actions = [];
+		$this->actionsParsed = [];
+	}
+
+	/**
+	 * @param string $app
+	 * @return $this
+	 * @throws \InvalidArgumentException if the app id is invalid
+	 * @since 8.2.0
+	 */
+	public function setApp(string $app): INotification {
+		if ($app === '' || isset($app[32])) {
+			throw new \InvalidArgumentException('The given app name is invalid');
+		}
+		$this->app = $app;
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 * @since 8.2.0
+	 */
+	public function getApp(): string {
+		return $this->app;
+	}
+
+	/**
+	 * @param string $user
+	 * @return $this
+	 * @throws \InvalidArgumentException if the user id is invalid
+	 * @since 8.2.0
+	 */
+	public function setUser(string $user): INotification {
+		if ($user === '' || isset($user[64])) {
+			throw new \InvalidArgumentException('The given user id is invalid');
+		}
+		$this->user = $user;
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 * @since 8.2.0
+	 */
+	public function getUser(): string {
+		return $this->user;
+	}
+
+	/**
+	 * @param \DateTime $dateTime
+	 * @return $this
+	 * @throws \InvalidArgumentException if the $dateTime is invalid
+	 * @since 9.0.0
+	 */
+	public function setDateTime(\DateTime $dateTime): INotification {
+		if ($dateTime->getTimestamp() === 0) {
+			throw new \InvalidArgumentException('The given date time is invalid');
+		}
+		$this->dateTime = $dateTime;
+		return $this;
+	}
+
+	/**
+	 * @return \DateTime
+	 * @since 9.0.0
+	 */
+	public function getDateTime(): \DateTime {
+		return $this->dateTime;
+	}
+
+	/**
+	 * @param string $type
+	 * @param string $id
+	 * @return $this
+	 * @throws \InvalidArgumentException if the object type or id is invalid
+	 * @since 8.2.0 - 9.0.0: Type of $id changed to string
+	 */
+	public function setObject(string $type, string $id): INotification {
+		if ($type === '' || isset($type[64])) {
+			throw new \InvalidArgumentException('The given object type is invalid');
+		}
+		$this->objectType = $type;
+
+		if ($id === '' || isset($id[64])) {
+			throw new \InvalidArgumentException('The given object id is invalid');
+		}
+		$this->objectId = $id;
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 * @since 8.2.0
+	 */
+	public function getObjectType(): string {
+		return $this->objectType;
+	}
+
+	/**
+	 * @return string
+	 * @since 8.2.0 - 9.0.0: Return type changed to string
+	 */
+	public function getObjectId(): string {
+		return $this->objectId;
+	}
+
+	/**
+	 * @param string $subject
+	 * @param array $parameters
+	 * @return $this
+	 * @throws \InvalidArgumentException if the subject or parameters are invalid
+	 * @since 8.2.0
+	 */
+	public function setSubject(string $subject, array $parameters = []): INotification {
+		if ($subject === '' || isset($subject[64])) {
+			throw new \InvalidArgumentException('The given subject is invalid');
+		}
+
+		$this->subject = $subject;
+		$this->subjectParameters = $parameters;
+
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 * @since 8.2.0
+	 */
+	public function getSubject(): string {
+		return $this->subject;
+	}
+
+	/**
+	 * @return array
+	 * @since 8.2.0
+	 */
+	public function getSubjectParameters(): array {
+		return $this->subjectParameters;
+	}
+
+	/**
+	 * @param string $subject
+	 * @return $this
+	 * @throws \InvalidArgumentException if the subject is invalid
+	 * @since 8.2.0
+	 */
+	public function setParsedSubject(string $subject): INotification {
+		if ($subject === '') {
+			throw new \InvalidArgumentException('The given parsed subject is invalid');
+		}
+		$this->subjectParsed = $subject;
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 * @since 8.2.0
+	 */
+	public function getParsedSubject(): string {
+		return $this->subjectParsed;
+	}
+
+	/**
+	 * @param string $subject
+	 * @param array $parameters
+	 * @return $this
+	 * @throws \InvalidArgumentException if the subject or parameters are invalid
+	 * @since 11.0.0
+	 */
+	public function setRichSubject(string $subject, array $parameters = []): INotification {
+		if ($subject === '') {
+			throw new \InvalidArgumentException('The given parsed subject is invalid');
+		}
+
+		$this->subjectRich = $subject;
+		$this->subjectRichParameters = $parameters;
+
+		if ($this->subjectParsed === '') {
+			$this->subjectParsed = $this->richToParsed($subject, $parameters);
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @throws \InvalidArgumentException if a parameter has no name or no type
+	 */
+	private function richToParsed(string $message, array $parameters): string {
+		$placeholders = [];
+		$replacements = [];
+		foreach ($parameters as $placeholder => $parameter) {
+			$placeholders[] = '{' . $placeholder . '}';
+			foreach (['name','type'] as $requiredField) {
+				if (!isset($parameter[$requiredField]) || !is_string($parameter[$requiredField])) {
+					throw new \InvalidArgumentException("Invalid rich object, {$requiredField} field is missing");
+				}
+			}
+			if ($parameter['type'] === 'user') {
+				$replacements[] = '@' . $parameter['name'];
+			} elseif ($parameter['type'] === 'file') {
+				$replacements[] = $parameter['path'] ?? $parameter['name'];
+			} else {
+				$replacements[] = $parameter['name'];
+			}
+		}
+		return str_replace($placeholders, $replacements, $message);
+	}
+
+	/**
+	 * @return string
+	 * @since 11.0.0
+	 */
+	public function getRichSubject(): string {
+		return $this->subjectRich;
+	}
+
+	/**
+	 * @return array[]
+	 * @since 11.0.0
+	 */
+	public function getRichSubjectParameters(): array {
+		return $this->subjectRichParameters;
+	}
+
+	/**
+	 * @param string $message
+	 * @param array $parameters
+	 * @return $this
+	 * @throws \InvalidArgumentException if the message or parameters are invalid
+	 * @since 8.2.0
+	 */
+	public function setMessage(string $message, array $parameters = []): INotification {
+		if ($message === '' || isset($message[64])) {
+			throw new \InvalidArgumentException('The given message is invalid');
+		}
+
+		$this->message = $message;
+		$this->messageParameters = $parameters;
+
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 * @since 8.2.0
+	 */
+	public function getMessage(): string {
+		return $this->message;
+	}
+
+	/**
+	 * @return array
+	 * @since 8.2.0
+	 */
+	public function getMessageParameters(): array {
+		return $this->messageParameters;
+	}
+
+	/**
+	 * @param string $message
+	 * @return $this
+	 * @throws \InvalidArgumentException if the message is invalid
+	 * @since 8.2.0
+	 */
+	public function setParsedMessage(string $message): INotification {
+		if ($message === '') {
+			throw new \InvalidArgumentException('The given parsed message is invalid');
+		}
+		$this->messageParsed = $message;
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 * @since 8.2.0
+	 */
+	public function getParsedMessage(): string {
+		return $this->messageParsed;
+	}
+
+	/**
+	 * @param string $message
+	 * @param array $parameters
+	 * @return $this
+	 * @throws \InvalidArgumentException if the message or parameters are invalid
+	 * @since 11.0.0
+	 */
+	public function setRichMessage(string $message, array $parameters = []): INotification {
+		if ($message === '') {
+			throw new \InvalidArgumentException('The given parsed message is invalid');
+		}
+
+		$this->messageRich = $message;
+		$this->messageRichParameters = $parameters;
+
+		if ($this->messageParsed === '') {
+			$this->messageParsed = $this->richToParsed($message, $parameters);
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 * @since 11.0.0
+	 */
+	public function getRichMessage(): string {
+		return $this->messageRich;
+	}
+
+	/**
+	 * @return array[]
+	 * @since 11.0.0
+	 */
+	public function getRichMessageParameters(): array {
+		return $this->messageRichParameters;
+	}
+
+	/**
+	 * @param string $link
+	 * @return $this
+	 * @throws \InvalidArgumentException if the link is invalid
+	 * @since 8.2.0
+	 */
+	public function setLink(string $link): INotification {
+		if ($link === '' || isset($link[4000])) {
+			throw new \InvalidArgumentException('The given link is invalid');
+		}
+		$this->link = $link;
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 * @since 8.2.0
+	 */
+	public function getLink(): string {
+		return $this->link;
+	}
+
+	/**
+	 * @param string $icon
+	 * @return $this
+	 * @throws \InvalidArgumentException if the icon is invalid
+	 * @since 11.0.0
+	 */
+	public function setIcon(string $icon): INotification {
+		if ($icon === '' || isset($icon[4000])) {
+			throw new \InvalidArgumentException('The given icon is invalid');
+		}
+		$this->icon = $icon;
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 * @since 11.0.0
+	 */
+	public function getIcon(): string {
+		return $this->icon;
+	}
+
+	/**
+	 * @return IAction
+	 * @since 8.2.0
+	 */
+	public function createAction(): IAction {
+		return new Action();
+	}
+
+	/**
+	 * @param IAction $action
+	 * @return $this
+	 * @throws \InvalidArgumentException if the action is invalid
+	 * @since 8.2.0
+	 */
+	public function addAction(IAction $action): INotification {
+		if (!$action->isValid()) {
+			throw new \InvalidArgumentException('The given action is invalid');
+		}
+
+		if ($action->isPrimary()) {
+			if ($this->hasPrimaryAction) {
+				throw new \InvalidArgumentException('The notification already has a primary action');
+			}
+
+			$this->hasPrimaryAction = true;
+		}
+
+		$this->actions[] = $action;
+		return $this;
+	}
+
+	/**
+	 * @return IAction[]
+	 * @since 8.2.0
+	 */
+	public function getActions(): array {
+		return $this->actions;
+	}
+
+	/**
+	 * @param IAction $action
+	 * @return $this
+	 * @throws \InvalidArgumentException if the action is invalid
+	 * @since 8.2.0
+	 */
+	public function addParsedAction(IAction $action): INotification {
+		if (!$action->isValidParsed()) {
+			throw new \InvalidArgumentException('The given parsed action is invalid');
+		}
+
+		if ($action->isPrimary()) {
+			if ($this->hasPrimaryParsedAction) {
+				throw new \InvalidArgumentException('The notification already has a primary action');
+			}
+
+			$this->hasPrimaryParsedAction = true;
+
+			// Make sure the primary action is always the first one
+			array_unshift($this->actionsParsed, $action);
+		} else {
+			$this->actionsParsed[] = $action;
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @return IAction[]
+	 * @since 8.2.0
+	 */
+	public function getParsedActions(): array {
+		return $this->actionsParsed;
+	}
+
+	/**
+	 * @return bool
+	 * @since 8.2.0
+	 */
+	public function isValid(): bool {
+		return
+			$this->isValidCommon()
+			&&
+			$this->getSubject() !== ''
+		;
+	}
+
+	/**
+	 * @return bool
+	 * @since 8.2.0
+	 */
+	public function isValidParsed(): bool {
+		if ($this->getRichSubject() !== '' || !empty($this->getRichSubjectParameters())) {
+			try {
+				$this->richValidator->validate($this->getRichSubject(), $this->getRichSubjectParameters());
+			} catch (InvalidObjectExeption $e) {
+				return false;
+			}
+		}
+
+		if ($this->getRichMessage() !== '' || !empty($this->getRichMessageParameters())) {
+			try {
+				$this->richValidator->validate($this->getRichMessage(), $this->getRichMessageParameters());
+			} catch (InvalidObjectExeption $e) {
+				return false;
+			}
+		}
+
+		return
+			$this->isValidCommon()
+			&&
+			$this->getParsedSubject() !== ''
+		;
+	}
+
+	protected function isValidCommon(): bool {
+		return
+			$this->getApp() !== ''
+			&&
+			$this->getUser() !== ''
+			&&
+			$this->getDateTime()->getTimestamp() !== 0
+			&&
+			$this->getObjectType() !== ''
+			&&
+			$this->getObjectId() !== ''
+		;
+	}
+}