.gitlab-ci.yml

@@ -9,6 +9,7 @@ stages:
   - prepare
   - review
   - deploy:staging
+  - qa
   - deploy:canary
   - deploy:production
 
@@ -127,6 +128,17 @@ review:stop:
       - master
       - test/gitlab-ci
 
+qa:manual:
+  stage: qa
+  script:
+    - echo "Manually approved"
+  when: manual
+  only:
+    refs:
+      - master
+      - test/gitlab-ci
+  allow_failure: false
+
 staging:fpm:
   stage: deploy:staging
   image: minds/ci:latest

Api/Factory.php

@@ -171,8 +171,9 @@ class Factory
     /**
      * Builds an API response
      * @param array $data
+     * @return true
      */
-    public static function response($data = [])
+    public static function response($data = []): bool
     {
         $data = array_merge([
             'status' => 'success', //should success be assumed?
@@ -184,6 +185,8 @@ class Factory
 
         header('Content-type: application/json');
         echo json_encode($data);
+
+        return true;
     }
 
     /**

Controllers/api/v2/subscriptions/incoming.php

+<?php
+
+namespace Minds\Controllers\api\v2\subscriptions;
+
+use Minds\Api\Factory;
+use Minds\Core\Di\Di;
+use Minds\Core\Session;
+use Minds\Interfaces;
+
+/**
+ * Incoming subscritions
+ */
+class incoming implements Interfaces\Api
+{
+    public function get($pages): bool
+    {
+        if (!isset($pages[0])) {
+            return $this->getSingle($pages[0]);
+        } else {
+            return $this->getList($pages[0]);
+        }
+    }
+    
+    /**
+     * Return a single request
+     * @param string $subscriberGuid
+     * @return void
+     */
+    private function getSingle(string $subscriberGuid): bool
+    {
+        // Return a single request
+        $manager = Di::_()->get('Subscriptions\Requests\Manager');
+        
+        // Construct URN on the fly
+        $urn = "urn:subscription-request:" . implode('-', [ Session::getLoggedInUserGuid(), $subscriberGuid ]);
+        
+        $request = $manager->get($urn);
+
+        if (!$request || $request->getPublisherGuid() != Session::getLoggedInUserGuid()) {
+            return Factory::response([
+                'status' => 'error',
+                'message' => 'Not found',
+            ]);
+        }
+
+        return Factory::response([
+            'request' => $request->export(),
+        ]);
+    }
+
+    /**
+     * Return a list of subscription requests
+     * @return bool
+     */
+    private function getList(): bool
+    {
+        // Return a list of subscription requests
+        $manager = Di::_()->get('Subscriptions\Requests\Manager');
+
+        $requests = $manager->getIncomingList(Session::getLoggedInUserGuid(), []);
+        
+        return Factory::response([
+            'requests' => Factory::exportable($requests),
+            'next' => $requests->getPagingToken(),
+        ]);
+    }
+
+    public function post($pages)
+    {
+        // Void
+        return Factory::response([]);
+    }
+
+    public function put($pages)
+    {
+        // Accept / Deny
+        $manager = Di::_()->get('Subscriptions\Requests\Manager');
+        
+        // Construct URN on the fly
+        $subscriberGuid = $pages[0];
+        $urn = "urn:subscription-request:" . implode('-', [ Session::getLoggedInUserGuid(), $subscriberGuid ]);
+        
+        $request = $manager->get($urn);
+        
+        if (!$request || $request->getPublisherGuid() != Session::getLoggedInUserGuid()) {
+            return Factory::response([
+                'status' => 'error',
+                'message' => 'Not found',
+            ]);
+        }
+
+        try {
+            switch ($pages[1]) {
+                case "accept":
+                    $manager->accept($request);
+                    break;
+                case "decline":
+                    $manager->decline($request);
+                    break;
+            }
+        } catch (\Exception $e) {
+            return Factory::response([
+                'status' => 'error',
+                'message' => $e->getMessage(),
+            ]);
+        }
+
+        return Factory::response([]);
+    }
+
+    public function delete($pages)
+    {
+        // Void
+        return Factory::response([]);
+    }
+}

Controllers/api/v2/subscriptions/outgoing.php

+<?php
+
+namespace Minds\Controllers\api\v2\subscriptions;
+
+use Minds\Api\Factory;
+use Minds\Core\Di\Di;
+use Minds\Core\Session;
+use Minds\Core\Subscriptions\Requests\SubscriptionRequest;
+use Minds\Entities\Factory as EntitiesFactory;
+use Minds\Interfaces;
+
+/**
+ * Outgoing subscritions
+ */
+class outgoing implements Interfaces\Api
+{
+    public function get($pages): bool
+    {
+        if (isset($pages[0])) {
+            return $this->getSingle($pages[0]);
+        } else {
+            return $this->getList();
+        }
+    }
+
+    /**
+     * Return a single request
+     * @param string $publisherGuid
+     * @return void
+     */
+    private function getSingle(string $publisherGuid): bool
+    {
+        // Return a single request
+        $manager = Di::_()->get('Subscriptions\Requests\Manager');
+        
+        // Construct URN on the fly
+        $urn = "urn:subscription-request:" . implode('-', [ $publisherGuid, Session::getLoggedInUserGuid() ]);
+        
+        $request = $manager->get($urn);
+
+        if (!$request || $request->getSubscriberGuid() != Session::getLoggedInUserGuid()) {
+            return Factory::response([
+                'status' => 'error',
+                'message' => 'Not found',
+            ]);
+        }
+
+        return Factory::response([
+            'request' => $request->export(),
+        ]);
+    }
+
+    /**
+     * Return a list of subscription requests
+     * @return bool
+     */
+    private function getList(): bool
+    {
+        return Factory::response([
+            'requests' => [],
+            'next' => null,
+        ]);
+    }
+
+    public function post($pages)
+    {
+        // Void
+        return Factory::response([]);
+    }
+
+    public function put($pages)
+    {
+        // Make a subscription request
+        $manager = Di::_()->get('Subscriptions\Requests\Manager');
+
+        $request = new SubscriptionRequest();
+        $request->setPublisherGuid($pages[0])
+            ->setSubscriberGuid(Session::getLoggedInUserGuid());
+
+        try {
+            $manager->add($request);
+        } catch (\Exception $e) {
+            return Factory::response([
+                'status' => 'error',
+                'message' => $e->getMessage(),
+            ]);
+        }
+
+        return Factory::response([]);
+    }
+
+    public function delete($pages)
+    {
+        // Delete a subscription request
+        return Factory::response([]);
+    }
+}

Core/Provisioner/Provisioners/cassandra-provision.cql

@@ -1448,6 +1448,14 @@ CREATE TABLE minds.email_campaign_logs (
 
 ALTER TABLE minds.views ADD owner_guid text;
 
+CREATE TABLE minds.subscription_requests (
+    publisher_guid bigint,
+    subscriber_guid bigint,
+    timestamp timestamp,
+    declined boolean,
+    PRIMARY KEY (publisher_guid, subscriber_guid)
+);
+
 CREATE TABLE minds.pro (
     user_guid bigint,
     domain text,

Core/Subscriptions/Manager.php

@@ -94,14 +94,19 @@ class Manager
     /**
      * Subscribe to a publisher
      * @param User $publisher
+     * @param bool $force
      * @return Subscription
      */
-    public function subscribe($publisher)
+    public function subscribe($publisher, bool $force = false): ?Subscription
     {
         $subscription = new Subscription();
         $subscription->setSubscriberGuid($this->subscriber->getGuid())
             ->setPublisherGuid($publisher->getGuid());
 
+        if ($publisher->getMode() === 2 && !$force) {
+            throw new RequiresSubscriptionRequestException();
+        }
+
         if ($this->getSubscriptionsCount() >= static::MAX_SUBSCRIPTIONS) {
             $this->sendNotificationDelegate->onMaxSubscriptions($subscription);
             throw new TooManySubscriptionsException();

Core/Subscriptions/Provider.php

@@ -14,5 +14,8 @@ class Provider extends DiProvider
         $this->di->bind('Subscriptions\Manager', function ($di) {
             return new Manager();
         }, [ 'useFactory'=>false ]);
+        $this->di->bind('Subscriptions\Requests\Manager', function ($di) {
+            return new Requests\Manager();
+        }, [ 'useFactory'=>false ]);
     }
 }

Core/Subscriptions/Requests/Delegates/NotificationsDelegate.php

+<?php
+namespace Minds\Core\Subscriptions\Requests\Delegates;
+
+use Minds\Core\Di\Di;
+use Minds\Core\Events\EventsDispatcher;
+use Minds\Core\Subscriptions\Requests\SubscriptionRequest;
+
+class NotificationsDelegate
+{
+    /** @var EventsDispatcher */
+    private $eventsDispatcher;
+
+    public function __construct($eventsDispatcher = null)
+    {
+        $this->eventsDispatcher = $eventsDispatcher ?: Di::_()->get('EventsDispatcher');
+    }
+
+    /**
+     * Called when subscription request is made
+     * @param SubscriptionRequest $subscriptionRequest
+     * @return void
+     */
+    public function onAdd(SubscriptionRequest $subscriptionRequest): void
+    {
+        $this->eventsDispatcher->trigger('notification', 'all', [
+            'to' => [ $subscriptionRequest->getPublisherGuid() ],
+            'entity' => $subscriptionRequest->getSubscriberGuid(),
+            'notification_view' => 'subscription_request_received',
+            'from' => $subscriptionRequest->getSubscriberGuid(),
+            'params' => [],
+        ]);
+    }
+
+    /**
+     * Called when subscription request is accepted
+     * @param SubscriptionRequest $subscriptionRequest
+     * @return void
+     */
+    public function onAccept(SubscriptionRequest $subscriptionRequest): void
+    {
+        $this->eventsDispatcher->trigger('notification', 'all', [
+            'to' => [ $subscriptionRequest->getSubscriberGuid() ],
+            'entity' => $subscriptionRequest->getPublisherGuid(),
+            'notification_view' => 'subscription_request_accepted',
+            'from' => $subscriptionRequest->getPublisherGuid(),
+            'params' => [],
+        ]);
+    }
+
+    /**
+     * Called when subscription request is declined
+     * @param SubscriptionRequest $subscriptionRequest
+     * @return void
+     */
+    public function onDecline(SubscriptionRequest $subscriptionRequest): void
+    {
+        $this->eventsDispatcher->trigger('notification', 'all', [
+            'to' => [ $subscriptionRequest->getSubscriberGuid() ],
+            'entity' => $subscriptionRequest->getPublisherGuid(),
+            'notification_view' => 'subscription_request_declined',
+            'from' => $subscriptionRequest->getPublisherGuid(),
+            'params' => [],
+        ]);
+    }
+}

Core/Subscriptions/Requests/Delegates/SubscriptionsDelegate.php

+<?php
+namespace Minds\Core\Subscriptions\Requests\Delegates;
+
+use Minds\Core\Di\Di;
+use Minds\Core\EntitiesBuilder;
+use Minds\Core\Subscriptions\Manager as SubscriptionsManager;
+use Minds\Core\Subscriptions\Requests\SubscriptionRequest;
+
+class SubscriptionsDelegate
+{
+    /** @var SubscriptionsManager */
+    private $subscriptionsManager;
+
+    /** @var EntitiesBuilder */
+    private $entitiesBuilder;
+
+    public function __construct($subscriptionsManager = null, $entitiesBuilder = null)
+    {
+        $this->subscriptionsManager = $subscriptionsManager ?? Di::_()->get('Subscriptions\Manager');
+        $this->entitiesBuilder = $entitiesBuilder ?? Di::_()->get('EntitiesBuilder');
+    }
+
+    /**
+     * Called when subscription request is accepted
+     * @param SubscriptionRequest $subscriptionRequest
+     * @return void
+     */
+    public function onAccept(SubscriptionRequest $subscriptionRequest): void
+    {
+        $subscriber = $this->entitiesBuilder->single($subscriptionRequest->getSubscriberGuid());
+        $publisher = $this->entitiesBuilder->single($subscriptionRequest->getPublisherGuid());
+
+        $this->subscriptionsManager->setSubscriber($subscriber);
+        $this->subscriptionsManager->subscribe($publisher, true);
+    }
+}

Core/Subscriptions/Requests/Manager.php

+<?php
+/**
+ * Subscriptions Requests Manager
+ */
+namespace Minds\Core\Subscriptions\Requests;
+
+use Minds\Core\Subscriptions\Requests\Delegates\NotificationsDelegate;
+use Minds\Core\Subscriptions\Requests\Delegates\SubscriptionsDelegate;
+use Minds\Core\EntitiesBuilder;
+use Minds\Core\Di\Di;
+use Minds\Common\Repository\Response;
+use Minds\Entities\User;
+
+class Manager
+{
+    /** @var Repository */
+    private $repository;
+
+    /** @var NotificationsDelegate */
+    private $notificationsDelegate;
+
+    /** @var SubscriptionsDelegate */
+    private $subscriptionsDelegate;
+
+    /** @var EntitiesBuilder */
+    private $entitiesBuilder;
+
+    public function __construct($repository = null, $notificationsDelegate = null, $subscriptionsDelegate = null, $entitiesBuilder = null)
+    {
+        $this->repository = $repository ?? new Repository();
+        $this->notificationsDelegate = $notificationsDelegate ?? new NotificationsDelegate;
+        $this->subscriptionsDelegate = $subscriptionsDelegate ?? new SubscriptionsDelegate;
+        $this->entitiesBuilder = $entitiesBuilder ?? Di::_()->get('EntitiesBuilder');
+    }
+
+    /**
+     * Return a list of incoming subscription requests
+     * @param string $userGuid
+     * @param array $opts
+     * @return Response
+     */
+    public function getIncomingList(string $userGuid, array $opts = []): Response
+    {
+        $opts = array_merge([
+            'hydrate' => true,
+        ], $opts);
+
+        $opts['publisher_guid'] = $user_guid;
+        $response = $this->repository->getList($opts);
+
+        if ($opts['hydrate']) {
+            foreach ($response as $i => $request) {
+                $request->setSubscriber($this->entitiesBuilder->single($request->getSubscriberGuid()));
+            }
+        }
+
+        return $response;
+    }
+
+    /**
+     * Return a subscription request
+     * @param string $urn
+     * @return SubscriptionRequest
+     */
+    public function get(string $urn): ?SubscriptionRequest
+    {
+        return $this->repository->get($urn);
+    }
+
+    /**
+     * Add a subscription request
+     * @param SubscriptionRequest $subscriptionRequest
+     * @return bool
+     */
+    public function add(SubscriptionRequest $subscriptionRequest): bool
+    {
+        // Check if exists
+        $existing = $this->get($subscriptionRequest->getUrn());
+        if ($existing) {
+            throw new SubscriptionRequestExistsException();
+        }
+
+        // Check if the user exists
+        $publisher = $this->entitiesBuilder->single($subscriptionRequest->getPublisherGuid());
+        if (!$publisher || !$publisher instanceof User) {
+            throw new SubscriptionRequestChannelDoesntExist();
+        }
+
+        $this->repository->add($subscriptionRequest);
+
+        $this->notificationsDelegate->onAdd($subscriptionRequest);
+
+        return true;
+    }
+
+    /**
+     * Accept a subscription request
+     * @param SubscriptionRequest $subscriptionRequest
+     * @return bool
+     */
+    public function accept(SubscriptionRequest $subscriptionRequest): bool
+    {
+        // Check if exists
+        $existing = $this->get($subscriptionRequest->getUrn());
+        if (!$existing) {
+            throw new SubscriptionRequestDoesntExistException();
+        }
+
+        if ($existing->isDeclined()) {
+            throw new SubscriptionRequestAlreadyCompletedException();
+        }
+    
+        $this->repository->delete($subscriptionRequest);
+
+        $this->notificationsDelegate->onAccept($subscriptionRequest);
+        $this->subscriptionsDelegate->onAccept($subscriptionRequest);
+
+        return true;
+    }
+
+    /**
+     * Decline a subscription request
+     * @param SubscriptionRequest $subscriptionRequest
+     * @return bool
+     */
+    public function decline(SubscriptionRequest $subscriptionRequest): bool
+    {
+        // Check if exists
+        $existing = $this->get($subscriptionRequest->getUrn());
+        if (!$existing) {
+            throw new SubscriptionRequestDoesntExistException();
+        }
+
+        if ($existing->isDeclined()) {
+            throw new SubscriptionRequestAlreadyCompletedException();
+        }
+
+        $subscriptionRequest->setDeclined(true);
+        $this->repository->update($subscriptionRequest);
+
+        $this->notificationsDelegate->onDecline($subscriptionRequest);
+
+        return true;
+    }
+}

Core/Subscriptions/Requests/Repository.php

+<?php
+/**
+ * Subscriptions Requests Repository
+ */
+namespace Minds\Core\Subscriptions\Requests;
+
+use Minds\Core\Di\Di;
+use Minds\Core\Data\Cassandra\Client;
+use Minds\Core\Data\Cassandra\Prepared;
+use Minds\Common\Repository\Response;
+use Minds\Common\Urn;
+use Cassandra\Timestamp;
+use Cassandra\Bigint;
+
+class Repository
+{
+    /** @var Client */
+    private $db;
+
+    public function __construct($db = null)
+    {
+        $this->db = $db ?? Di::_()->get('Database\Cassandra\Cql');
+    }
+ 
+    /**
+     * Return a list of subscription requests
+     * @param array $opts
+     * @return Response
+     */
+    public function getList(array $opts = []): Response
+    {
+        $opts = array_merge([
+            'publisher_guid' => null,
+            'show_declined' => false,
+            'limit' => 5000,
+            'token' => '',
+        ], $opts);
+
+        if (!$opts['publisher_guid']) {
+            throw new \Exception('publisher_guid not set');
+        }
+
+        $prepared = new Prepared\Custom();
+        $prepared->query(
+            "SELECT * FROM subscription_requests
+            WHERE publisher_guid = ?",
+            [
+                new Bigint($opts['publisher_guid']),
+            ]
+        );
+        $result = $this->db->request($prepared);
+        $response = new Response;
+
+        foreach ($result as $row) {
+            $subscriptionRequest = new SubscriptionRequest();
+            $subscriptionRequest
+                ->setPublisherGuid((string) $row['publisher_guid'])
+                ->setSubscriberGuid((string) $row['subscriber_guid'])
+                ->setTimestampMs((int) $row['timestamp']->time())
+                ->setDeclined((bool) $row['declined']);
+
+            if ($subscriptionRequest->isDeclined() && !$opts['show_declined']) {
+                continue;
+            }
+    
+            $response[] = $subscriptionRequest;
+        }
+
+        return $response;
+    }
+
+    /**
+     * Return a single subscription request from a urn
+     * @param string $urn
+     * @return SubscriptionRequest
+     */
+    public function get(string $urn): ?SubscriptionRequest
+    {
+        $urn = new Urn($urn);
+        list($publisherGuid, $subscriberGuid) = explode('-', $urn->getNss());
+ 
+        $prepared = new Prepared\Custom();
+        $prepared->query(
+            "SELECT * FROM subscription_requests
+            WHERE publisher_guid = ?
+            AND subscriber_guid = ?",
+            [
+                new Bigint($publisherGuid),
+                new Bigint($subscriberGuid),
+            ]
+        );
+        $result = $this->db->request($prepared);
+
+        if (!$result) {
+            return null;
+        }
+
+        $row = $result[0];
+
+        if (!$row) {
+            return null;
+        }
+
+        $subscriptionRequest = new SubscriptionRequest();
+        $subscriptionRequest
+                ->setPublisherGuid((string) $row['publisher_guid'])
+                ->setSubscriberGuid((string) $row['subscriber_guid'])
+                ->setTimestampMs((int) $row['timestamp']->time())
+                ->setDeclined((bool) $row['declined']);
+
+        return $subscriptionRequest;
+    }
+
+    /**
+     * Add a subscription request
+     * @param SubscriptionRequest $subscriptionRequest
+     * @return bool
+     */
+    public function add(SubscriptionRequest $subscriptionRequest): bool
+    {
+        $statement = "INSERT INTO subscription_requests
+            (publisher_guid, subscriber_guid, timestamp)
+            VALUES
+            (?, ?, ?)
+            IF NOT EXISTS";
+        $values = [
+            new Bigint($subscriptionRequest->getPublisherGuid()),
+            new Bigint($subscriptionRequest->getSubscriberGuid()),
+            new Timestamp($subscriptionRequest->getTimestampMs() ?? round(microtime(true) * 1000)),
+        ];
+
+        $prepared = new Prepared\Custom();
+        $prepared->query($statement, $values);
+
+        return (bool) $this->db->request($prepared);
+    }
+
+    /**
+     * Update a subscription request
+     * @param SubscriptionRequest $subscriptionRequest
+     * @param array $fields
+     * @return bool
+     */
+    public function update(SubscriptionRequest $subscriptionRequest, array $field = []): bool
+    {
+        $statement = "UPDATE subscription_requests
+            SET declined = ?
+            WHERE publisher_guid = ?
+            AND subscriber_guid = ?";
+        $values = [
+            $subscriptionRequest->isDeclined(),
+            new Bigint($subscriptionRequest->getPublisherGuid()),
+            new Bigint($subscriptionRequest->getSubscriberGuid()),
+        ];
+
+        $prepared = new Prepared\Custom();
+        $prepared->query($statement, $values);
+
+        return (bool) $this->db->request($prepared);
+    }
+
+    /**
+     * Delete a subscription request
+     * @param SubscriptionRequest $subscriptionRequest
+     * @return bool
+     */
+    public function delete(SubscriptionRequest $subscriptionRequest): bool
+    {
+        $statement = "DELETE FROM subscription_requests
+            WHERE publisher_guid = ?
+            AND subscriber_guid = ?";
+        $values = [
+            new Bigint($subscriptionRequest->getPublisherGuid()),
+            new Bigint($subscriptionRequest->getSubscriberGuid()),
+        ];
+
+        $prepared = new Prepared\Custom();
+        $prepared->query($statement, $values);
+
+        return (bool) $this->db->request($prepared);
+    }
+}

Core/Subscriptions/Requests/SubscriptionRequest.php

+<?php
+/**
+ * SubscriptionRequest Model
+ */
+namespace Minds\Core\Subscriptions\Requests;
+
+use Minds\Entities\User;
+use Minds\Traits\MagicAttributes;
+
+/**
+ * @method SubscriptionRequest setPublisherGuid(string $publisherGuid)
+ * @method string getPublisherGuid()
+ * @method SubscriptionRequest setPublisher(User $user)
+ * @method User getPublisher()
+ * @method SubscriptionRequest setSubscriberGuid(string $subscriberGuid)
+ * @method string getSubscriberGuid()
+ * @method SubscriptionRequest setSubscriber(User $subscriber)
+ * @method User getSubscriber()
+ * @method SubscriptionRequest setDeclined(bool $declined)
+ * @method bool getDeclined()
+ * @method SubscriptionRequest setTimestampMs(int $timestampMs)
+ * @method int getTimestampMs()
+ */
+class SubscriptionRequest
+{
+    use MagicAttributes;
+
+    /** @var string */
+    private $publisherGuid;
+
+    /** @var User */
+    private $publisher;
+
+    /** @var string */
+    private $subscriberGuid;
+
+    /** @var User */
+    private $subscriber;
+
+    /** @var bool */
+    private $declined = false;
+
+    /** @var int */
+    private $timestampMs;
+
+    /**
+     * @return string
+     */
+    public function getUrn(): string
+    {
+        return "urn:subscription-request:" . implode('-', [ $this->publisherGuid, $this->subscriberGuid ]);
+    }
+
+    /**
+     * Export
+     * @return array
+     */
+    public function export(): array
+    {
+        return [
+            'publisher_guid' => (string) $this->publisherGuid,
+            'publisher' => $this->publisher ? $this->publisher->export() : null,
+            'subscriber_guid' => (string) $this->subscriberGuid,
+            'subscriber' => $this->subscriber ? $this->subscriber->export() : null,
+            'declined' => (bool) $this->declined,
+            'timestamp_ms' => $this->timestampMs,
+            'timestamp_sec' => round($this->timestampMs / 1000),
+        ];
+    }
+}

Core/Subscriptions/Requests/SubscriptionRequestAlreadyCompletedException.php

+<?php
+namespace Minds\Core\Subscriptions\Requests;
+
+use Exception;
+
+class SubscriptionRequestAlreadyCompletedException extends Exception
+{
+    /** @var string */
+    protected $message = "A subscription request was accepted/declined but has already been actioned.";
+}

Core/Subscriptions/Requests/SubscriptionRequestChannelDoesntExist.php

+<?php
+namespace Minds\Core\Subscriptions\Requests;
+
+use Exception;
+
+class SubscriptionRequestChannelDoesntExist extends Exception
+{
+    /** @var string */
+    protected $message = "A subscription request was made to a channel that doesnt exist";
+}

Core/Subscriptions/Requests/SubscriptionRequestDoesntExistException.php

+<?php
+namespace Minds\Core\Subscriptions\Requests;
+
+use Exception;
+
+class SubscriptionRequestDoesntExistException extends Exception
+{
+    /** @var string */
+    protected $message = "A subscription request currently does not exist, but was interacted with";
+}

Core/Subscriptions/Requests/SubscriptionRequestExistsException.php

+<?php
+namespace Minds\Core\Subscriptions\Requests;
+
+use Exception;
+
+class SubscriptionRequestExistsException extends Exception
+{
+    /** @var string */
+    protected $message = "A subscription request already exists but tried to be created.";
+}

Spec/Core/Subscriptions/Requests/Delegates/SubscriptionsDelegateSpec.php

+<?php
+
+namespace Spec\Minds\Core\Subscriptions\Requests\Delegates;
+
+use Minds\Core\Subscriptions\Requests\Delegates\SubscriptionsDelegate;
+use PhpSpec\ObjectBehavior;
+use Prophecy\Argument;
+
+class SubscriptionsDelegateSpec extends ObjectBehavior
+{
+    public function it_is_initializable()
+    {
+        $this->shouldHaveType(SubscriptionsDelegate::class);
+    }
+}

Spec/Core/Subscriptions/Requests/ManagerSpec.php

+<?php
+
+namespace Spec\Minds\Core\Subscriptions\Requests;
+
+use Minds\Core\Subscriptions\Requests\Manager;
+use Minds\Core\Subscriptions\Requests\Repository;
+use Minds\Core\Subscriptions\Requests\SubscriptionRequest;
+use Minds\Core\Subscriptions\Requests\Delegates;
+use Minds\Core\EntitiesBuilder;
+use Minds\Entities\User;
+use PhpSpec\ObjectBehavior;
+use Prophecy\Argument;
+
+class ManagerSpec extends ObjectBehavior
+{
+    private $repository;
+    private $notificationsDelegate;
+    private $subscriptionsDelegate;
+    private $entitiesBuilder;
+
+    public function let(
+        Repository $repository,
+        Delegates\NotificationsDelegate $notificationsDelegate,
+        Delegates\SubscriptionsDelegate $subscriptionsDelegate,
+        EntitiesBuilder $entitiesBuilder
+    ) {
+        $this->beConstructedWith($repository, $notificationsDelegate, $subscriptionsDelegate, $entitiesBuilder);
+        $this->repository = $repository;
+        $this->notificationsDelegate = $notificationsDelegate;
+        $this->subscriptionsDelegate = $subscriptionsDelegate;
+        $this->entitiesBuilder = $entitiesBuilder;
+    }
+
+    public function it_is_initializable()
+    {
+        $this->shouldHaveType(Manager::class);
+    }
+
+    public function it_should_add_a_request()
+    {
+        $subscriptionRequest = new SubscriptionRequest();
+        $subscriptionRequest->setPublisherGuid(123)
+            ->setSubscriberGuid(456);
+
+        $this->entitiesBuilder->single(123)
+            ->willReturn(new User);
+        
+        $this->repository->get("urn:subscription-request:123-456")
+            ->willReturn(null);
+
+        $this->repository->add($subscriptionRequest)
+            ->willReturn(true);
+
+        $this->notificationsDelegate->onAdd($subscriptionRequest)
+            ->shouldBeCalled();
+
+        $this->add($subscriptionRequest)
+            ->shouldBe(true);
+    }
+
+    public function it_should_accept_a_request()
+    {
+        $subscriptionRequest = new SubscriptionRequest();
+        $subscriptionRequest->setPublisherGuid(123)
+            ->setSubscriberGuid(456);
+        
+        $this->repository->get("urn:subscription-request:123-456")
+            ->willReturn($subscriptionRequest);
+
+        $this->repository->delete(Argument::any())
+            ->willReturn(true);
+
+        $this->notificationsDelegate->onAccept($subscriptionRequest)
+            ->shouldBeCalled();
+
+        $this->subscriptionsDelegate->onAccept($subscriptionRequest)
+            ->shouldBeCalled();
+
+        $this->accept($subscriptionRequest)
+            ->shouldBe(true);
+    }
+
+    public function it_should_decline_a_request()
+    {
+        $subscriptionRequest = new SubscriptionRequest();
+        $subscriptionRequest->setPublisherGuid(123)
+            ->setSubscriberGuid(456);
+        
+        $this->repository->get("urn:subscription-request:123-456")
+            ->willReturn($subscriptionRequest);
+
+        $this->repository->update(Argument::that(function ($sr) {
+            return $sr->isDeclined() === true;
+        }))
+            ->willReturn(true);
+
+        $this->notificationsDelegate->onDecline($subscriptionRequest)
+            ->shouldBeCalled();
+
+        $this->decline($subscriptionRequest)
+            ->shouldBe(true);
+    }
+}

Spec/Core/Subscriptions/Requests/RepositorySpec.php

+<?php
+
+namespace Spec\Minds\Core\Subscriptions\Requests;
+
+use Minds\Core\Subscriptions\Requests\Repository;
+use Minds\Core\Subscriptions\Requests\SubscriptionRequest;
+use Minds\Core\Data\Cassandra\Client;
+use Spec\Minds\Mocks\Cassandra\Rows;
+use Cassandra\Timestamp;
+use Cassandra\Bigint;
+use Cassandra\Boolean;
+use PhpSpec\ObjectBehavior;
+use Prophecy\Argument;
+
+class RepositorySpec extends ObjectBehavior
+{
+    private $db;
+
+    public function let(Client $db)
+    {
+        $this->beConstructedWith($db);
+        $this->db = $db;
+    }
+
+    public function it_is_initializable()
+    {
+        $this->shouldHaveType(Repository::class);
+    }
+
+    public function it_should_get_a_request_from_a_urn()
+    {
+        $this->db->request(Argument::that(function ($prepared) {
+            $query = $prepared->build();
+            return $query['values'][0]->value() == '123'
+                && $query['values'][1]->value() == '456';
+        }))
+            ->willReturn(new Rows([
+                [
+                    'publisher_guid' => '123',
+                    'subscriber_guid' => '456',
+                    'timestamp' => new Timestamp(time()),
+                    'declined' => null,
+                ]
+                ], 'next-page-token'));
+
+        $subscriptionRequest = $this->get("urn:subscription-request:123-456");
+        $subscriptionRequest->getPublisherGuid()
+            ->shouldBe('123');
+        $subscriptionRequest->getSubscriberGuid()
+            ->shouldBe('456');
+    }
+
+    public function it_should_get_a_list_of_requests()
+    {
+        $this->db->request(Argument::that(function ($prepared) {
+            $query = $prepared->build();
+            return $query['values'][0]->value() == '123';
+        }))
+            ->willReturn(new Rows([
+                [
+                    'publisher_guid' => new Bigint(123),
+                    'subscriber_guid' => new Bigint(456),
+                    'timestamp' => new Timestamp(time()),
+                    'declined' => null,
+                ],
+                [
+                    'publisher_guid' => new Bigint('1789'),
+                    'subscriber_guid' => new Bigint('1123'),
+                    'timestamp' => new Timestamp(time()),
+                    'declined' => true,
+                ]
+                ], 'next-page-token'));
+
+        $response = $this->getList([
+            'publisher_guid' => '123',
+            'show_declined' => true,
+        ]);
+        $response[0]->getPublisherGuid()
+            ->shouldBe('123');
+        $response[0]->getSubscriberGuid()
+            ->shouldBe('456');
+        $response[1]->getPublisherGuid()
+            ->shouldBe('1789');
+        $response[1]->getSubscriberGuid()
+            ->shouldBe('1123');
+        $response[1]->isDeclined()
+            ->shouldBe(true);
+    }
+
+    public function it_should_add_to_repository()
+    {
+        $subscriptionRequest = new SubscriptionRequest();
+        $subscriptionRequest->setPublisherGuid('123')
+            ->setSubscriberGuid('456')
+            ->setTimestampMs(1568711904123);
+
+        $this->db->request(Argument::that(function ($prepared) {
+            $values = $prepared->build()['values'];
+            return $values[0]->value() === '123'
+                && $values[1]->value() === '456'
+                && $values[2]->time() === 1568711904123;
+        }))
+            ->willReturn(true);
+        
+        $this->add($subscriptionRequest)
+            ->shouldReturn(true);
+    }
+
+    public function it_should_update_a_request()
+    {
+        $subscriptionRequest = new SubscriptionRequest();
+        $subscriptionRequest->setPublisherGuid('123')
+            ->setSubscriberGuid('456')
+            ->setDeclined(true);
+
+        $this->db->request(Argument::that(function ($prepared) {
+            $values = $prepared->build()['values'];
+            return $values[0] == true
+                && $values[1]->value() === '123'
+                && $values[2]->value() === '456';
+        }))
+            ->willReturn(true);
+        
+        $this->update($subscriptionRequest)
+            ->shouldReturn(true);
+    }
+
+    public function it_should_delete_a_request()
+    {
+        $subscriptionRequest = new SubscriptionRequest();
+        $subscriptionRequest->setPublisherGuid('123')
+            ->setSubscriberGuid('456');
+
+        $this->db->request(Argument::that(function ($prepared) {
+            $values = $prepared->build()['values'];
+            return $values[0]->value() === '123'
+                && $values[1]->value() === '456';
+        }))
+            ->willReturn(true);
+        
+        $this->delete($subscriptionRequest)
+            ->shouldReturn(true);
+    }
+}