Api/Exportable.php

@@ -8,6 +8,9 @@
 
 namespace Minds\Api;
 
+use Minds\Core\Di\Di;
+use Minds\Core\Session;
+
 class Exportable implements \JsonSerializable
 {
     /** @var array */
@@ -100,6 +103,13 @@ class Exportable implements \JsonSerializable
 
             $exported = $item->export(...$this->exportArgs);
 
+            if ($item && Di::_()->get('Features\Manager')->has('permissions')) {
+                $permissionsManager = Di::_()->get('Permissions\Manager');
+                $permissions = $permissionsManager->getList(['user_guid' => Session::getLoggedinUser(),
+                                                            'entities' => [$item]]);
+                $exported['permissions'] = $permissions->export();
+            }
+
             // Shims
             // TODO: Maybe allow customization via classes? i.e. JavascriptGuidShim, ExceptionShim, etc
 
@@ -126,8 +136,6 @@ class Exportable implements \JsonSerializable
                 $exported[$exception] = $item->{$exception};
             }
 
-            //
-
             $output[$key] = $exported;
         }
 

Api/Factory.php

@@ -211,15 +211,23 @@ class Factory
      */
     public static function exportable($entities, $exceptions = [], $exportContext = false)
     {
+        $permissionsManager = Di::_()->get('Permissions\Manager');
         if (!$entities) {
             return [];
         }
+       
         foreach ($entities as $k => $entity) {
             if ($exportContext && method_exists($entity, 'setExportContext')) {
                 $entity->setExportContext($exportContext);
             }
 
             $entities[$k] = $entity->export();
+            //Calculate new permissions object with the entities
+            if ($entity && Di::_()->get('Features\Manager')->has('permissions')) {
+                $permissions = $permissionsManager->getList(['user_guid' => Session::getLoggedinUser(),
+                                                            'entities' => [$entity]]);
+                $entities[$k]['permissions'] = $permissions->export();
+            }
             $entities[$k]['guid'] = (string) $entities[$k]['guid']; //javascript doesn't like long numbers..
             if (isset($entities[$k]['ownerObj']['guid'])) {
                 $entities[$k]['ownerObj']['guid'] = (string) $entity->ownerObj['guid'];

Controllers/api/v2/permissions/comments.php

@@ -7,7 +7,6 @@ use Minds\Core\Di\Di;
 use Minds\Interfaces;
 use Minds\Core\Entities\Actions\Save;
 use Minds\Core\Session;
-use Minds\Core\Permissions\Permissions;
 use Minds\Core\Permissions\Entities\EntityPermissions;
 
 class comments implements Interfaces\Api

Controllers/api/v2/permissions/schema.php

+<?php
+
+namespace Minds\Controllers\api\v2\permissions;
+
+use Minds\Api\Factory;
+use Minds\Core\Di\Di;
+use Minds\Interfaces;
+use Minds\Core\Entities\Actions\Save;
+use Minds\Core\Session;
+use Minds\Core\Permissions\Roles\Roles;
+use Minds\Core\Permissions\Roles\Flags;
+
+class schema implements Interfaces\Api
+{
+    public function get($pages)
+    {
+        $response = [
+           'roles' => Roles::toArray(),
+           'flags' => Flags::toArray()
+        ];
+        return Factory::response($response);
+    }
+
+    public function post($pages)
+    {
+        // TODO: Implement put() method.
+    }
+
+    public function put($pages)
+    {
+        // TODO: Implement put() method.
+    }
+
+    public function delete($pages)
+    {
+        // TODO: Implement put() method.
+    }
+}

Core/Feeds/FeedSyncEntity.php

@@ -22,6 +22,10 @@ use Minds\Traits\MagicAttributes;
  * @method FeedSyncEntity setTimestamp(int $timestamp)
  * @method string getUrn()
  * @method FeedSyncEntity setUrn(string $urn)
+ * @method int getAccessId()
+ * @method FeedSyncEntity setAccessId(int $accessId)
+ * @method string getType()
+ * @method FeedSyncEntity setType(string $type)
  */
 class FeedSyncEntity implements JsonSerializable
 {
@@ -36,12 +40,26 @@ class FeedSyncEntity implements JsonSerializable
     /** @var int */
     protected $timestamp;
 
+    /** @var int */
+    protected $accessId;
+
     /** @var string */
     protected $urn;
 
     /** @var Entity */
     protected $entity;
 
+    public function setEntity($entity)
+    {
+        $this->entity = $entity;
+        $this->accessId = $entity->getAccessId();
+        $this->type = $entity->getType();
+        return $this;
+    }
+
+    /** @var type */
+    public $type;
+
     /**
      * Export to public API
      * @return array
@@ -51,8 +69,10 @@ class FeedSyncEntity implements JsonSerializable
         return [
             'guid' => (string) $this->guid,
             'owner_guid' =>  (string) $this->ownerGuid,
+            'access_id' => $this->accessId,
             'timestamp' => $this->timestamp,
             'urn' => $this->urn,
+            'type' => $this->type,
             'entity' => $this->entity ? $this->entity->export() : null,
         ];
     }

Core/Feeds/Top/Manager.php

@@ -150,6 +150,8 @@ class Manager
             $feedSyncEntities[] = (new FeedSyncEntity())
                 ->setGuid((string) $scoredGuid->getGuid())
                 ->setOwnerGuid((string) $ownerGuid)
+                ->setAccessId($scoredGuid->getAccessId())
+                ->setType($scoredGuid->getType())
                 ->setUrn(new Urn($urn))
                 ->setTimestamp($scoredGuid->getTimestamp());
 
@@ -180,6 +182,8 @@ class Manager
                 $entities[] = (new FeedSyncEntity)
                                 ->setGuid($entity->getGuid())
                                 ->setOwnerGuid($entity->getOwnerGuid())
+                                ->setAccessId($entity->getAccessId())
+                                ->setType($scoredGuid->getType())
                                 ->setUrn($entity->getUrn())
                                 ->setEntity($entity);
             }

Core/Feeds/Top/Repository.php

@@ -408,6 +408,7 @@ class Repository
                 ->setGuid($doc['_source'][$this->getSourceField($opts['type'])])
                 ->setType($doc['_type'])
                 ->setScore($algorithm->fetchScore($doc))
+                ->setAccessId($doc['_source']['access_id'])
                 ->setOwnerGuid($doc['_source']['owner_guid'])
                 ->setTimestamp($doc['_source']['@timestamp']);
         }

Core/Feeds/Top/ScoredGuid.php

@@ -21,6 +21,8 @@ use Minds\Traits\MagicAttributes;
  * @method ScoredGuid setTimestamp(int $timestamp)
  * @method string getType()
  * @method ScoredGuid setType(string $type)
+ * @method int getAccessId()
+ * @method ScoredGuid setAccessId(int $accessId)
  */
 class ScoredGuid
 {
@@ -41,6 +43,9 @@ class ScoredGuid
     /** @var int */
     protected $timestamp;
 
+    /** @var int */
+    protected $accessId;
+
     /**
      * @param $score
      * @return $this

Core/Permissions/Delegates/BaseRoleCalculator.php

@@ -12,7 +12,7 @@ abstract class BaseRoleCalculator
     /** @var User */
     protected $user;
 
-    public function __construct(User $user, Roles $roles = null)
+    public function __construct(User $user = null, Roles $roles = null)
     {
         $this->roles = $roles ?: new Roles();
         $this->user = $user;

Core/Permissions/Delegates/ChannelRoleCalculator.php

@@ -5,12 +5,25 @@ namespace Minds\Core\Permissions\Delegates;
 use Minds\Traits\MagicAttributes;
 use Minds\Core\Permissions\Roles\Roles;
 use Minds\Core\Permissions\Roles\Role;
+use Minds\Entities\User;
+use Minds\Common\ChannelMode;
+use Minds\Core\Di\Di;
+use Minds\Core\EntitiesBuilder;
+use Minds\Entities\Factory as EntitiesFactory;
 
 class ChannelRoleCalculator extends BaseRoleCalculator
 {
     use MagicAttributes;
 
     private $channels = [];
+    /** @var EntitiesBuilder */
+    private $entitiesBuilder;
+
+    public function __construct(User $user = null, Roles $roles, EntitiesBuilder $entitiesBuilder = null)
+    {
+        parent::__construct($user, $roles);
+        $this->entitiesBuilder = $entitiesBuilder ?: Di::_()->get('EntitiesBuilder');
+    }
 
     /**
      * Retrieves permissions for an entity relative to the user's role in a channel
@@ -23,19 +36,84 @@ class ChannelRoleCalculator extends BaseRoleCalculator
      */
     public function calculate($entity): Role
     {
-        if (isset($this->channels[$entity->getOwnerGUID()])) {
-            return $this->channels[$entity->getOwnerGUID()];
+        if (isset($this->channels[$entity->getOwnerGuid()])) {
+            return $this->channels[$entity->getOwnerGuid()];
         }
         $role = null;
-        if ($entity->getOwnerGUID() === $this->user->getGUID()) {
+        $channel = $this->getChannelForEntity($entity);
+        if ($this->user === null) {
+            $role = $this->getChannelNonSubscriberRole($channel);
+        } elseif ($entity->getOwnerGuid() === $this->user->getGuid()) {
             $role = $this->roles->getRole(Roles::ROLE_CHANNEL_OWNER);
-        } elseif ($this->user->isSubscribed($entity->getOwnerGUID())) {
-            $role = $this->roles->getRole(Roles::ROLE_CHANNEL_SUBSCRIBER);
+        } elseif ($this->user->isSubscribed($channel->getGuid())) {
+            $role = $this->getChannelSubscriberRole($channel);
         } else {
-            $role = $this->roles->getRole(Roles::ROLE_CHANNEL_NON_SUBSCRIBER);
+            $role = $this->getChannelNonSubscriberRole($channel);
         }
-        $this->channels[$entity->getOwnerGUID()] = $role;
+        $this->channels[$channel->getGuid()] = $role;
 
         return $role;
     }
+
+    /**
+     * Gets the channel user object for a given entity
+     * Return the denormalized version
+     * Or look it up in cassandra / entities cache
+     * @param entity
+     * @return user
+     */
+    protected function getChannelForEntity($entity) : User
+    {
+        if ($entity->getType() === 'user') {
+            return $entity;
+        } elseif (method_exists($entity, 'getOwnerObj')) {
+            return $this->entitiesBuilder->build($entity->getOwnerObj());
+        } else {
+            return $this->entitiesBuilder->single($entity->getOwnerGuid());
+        }
+    }
+
+
+    /**
+     * Gets a subscriber's role based on channel mode
+     * @param User
+     * @return Role
+     */
+    protected function getChannelSubscriberRole(User $channel) : Role
+    {
+        switch ($channel->getMode()) {
+            case ChannelMode::CLOSED:
+                return $this->roles->getRole(Roles::ROLE_CLOSED_CHANNEL_SUBSCRIBER);
+            case ChannelMode::MODERATED:
+                return $this->roles->getRole(Roles::ROLE_MODERATED_CHANNEL_SUBSCRIBER);
+            case ChannelMode::OPEN:
+                return $this->roles->getRole(Roles::ROLE_OPEN_CHANNEL_SUBSCRIBER);
+        }
+    }
+
+    /**
+     * Gets a non-subscriber's role based on channel mode
+     * @param User
+     * @return Role
+     */
+    protected function getChannelNonSubscriberRole(User $channel) : Role
+    {
+        switch ($channel->getMode()) {
+            case ChannelMode::CLOSED:
+                if ($this->user === null) {
+                    return $this->roles->getRole(Roles::ROLE_LOGGED_OUT_CLOSED);
+                }
+                return $this->roles->getRole(Roles::ROLE_CLOSED_CHANNEL_NON_SUBSCRIBER);
+            case ChannelMode::MODERATED:
+                if ($this->user === null) {
+                    return $this->roles->getRole(Roles::ROLE_LOGGED_OUT);
+                }
+                return $this->roles->getRole(Roles::ROLE_MODERATED_CHANNEL_NON_SUBSCRIBER);
+            case ChannelMode::OPEN:
+                if ($this->user === null) {
+                    return $this->roles->getRole(Roles::ROLE_LOGGED_OUT);
+                }
+                return $this->roles->getRole(Roles::ROLE_OPEN_CHANNEL_NON_SUBSCRIBER);
+        }
+    }
 }

Core/Permissions/Delegates/GroupRoleCalculator.php

@@ -8,6 +8,7 @@ use Minds\Core\Permissions\Roles\Role;
 use Minds\Core\EntitiesBuilder;
 use Minds\Entities\User;
 use Minds\Core\Permissions\Roles\Roles;
+use Minds\Entities\Group;
 
 class GroupRoleCalculator extends BaseRoleCalculator
 {
@@ -18,7 +19,8 @@ class GroupRoleCalculator extends BaseRoleCalculator
     /** @var array */
     private $groups = [];
 
-    public function __construct(User $user, Roles $roles, EntitiesBuilder $entitiesBuilder = null)
+
+    public function __construct(User $user = null, Roles $roles, EntitiesBuilder $entitiesBuilder = null)
     {
         parent::__construct($user, $roles);
         $this->entitiesBuilder = $entitiesBuilder ?: Di::_()->get('EntitiesBuilder');
@@ -38,9 +40,16 @@ class GroupRoleCalculator extends BaseRoleCalculator
         if (isset($this->groups[$entity->getAccessId()])) {
             return $this->groups[$entity->getAccessId()];
         }
-        $group = $this->entitiesBuilder->single($entity->getAccessId());
+        if ($entity->getType() === 'group') {
+            $group = $entity;
+        } else {
+            $group = $this->entitiesBuilder->single($entity->getAccessId());
+        }
+
         $role = null;
-        if ($group->isCreator($this->user)) {
+        if ($this->user === null) {
+            $role = $this->getGroupNonSubscriberRole($group);
+        } elseif ($group->isCreator($this->user)) {
             $role = $this->roles->getRole(Roles::ROLE_GROUP_OWNER);
         } elseif ($group->isOwner($this->user)) {
             $role = $this->roles->getRole(Roles::ROLE_GROUP_ADMIN);
@@ -49,12 +58,48 @@ class GroupRoleCalculator extends BaseRoleCalculator
         } elseif ($group->isModerator($this->user)) {
             $role = $this->roles->getRole(Roles::ROLE_GROUP_MODERATOR);
         } elseif ($group->isMember($this->user)) {
-            $role = $this->roles->getRole(Roles::ROLE_GROUP_SUBSCRIBER);
+            $role = $this->getGroupSubscriberRole($group);
         } else {
-            $role = $this->roles->getRole(Roles::ROLE_GROUP_NON_SUBSCRIBER);
+            $role = $this->getGroupNonSubscriberRole($group);
         }
-        $this->groups[$entity->getAccessId()] = $role;
+        
+        $this->groups[$group->getGuid()] = $role;
 
         return $role;
     }
+
+
+    /**
+    * Gets a subscriber's role based on group mode
+    * @param Group
+    * @return Role
+    */
+    protected function getGroupSubscriberRole(Group $group) : Role
+    {
+        if ($group->isPublic()) {
+            return $this->roles->getRole(Roles::ROLE_OPEN_GROUP_SUBSCRIBER);
+        } else {
+            return $this->roles->getRole(Roles::ROLE_CLOSED_GROUP_SUBSCRIBER);
+        }
+    }
+
+    /**
+     * Gets a non-subscriber's role based on channel mode
+     * @param Group
+     * @return Role
+     */
+    protected function getGroupNonSubscriberRole(Group $group) : Role
+    {
+        if ($group->isPublic()) {
+            if ($this->user === null) {
+                $this->roles->getRole(Roles::ROLE_LOGGED_OUT);
+            }
+            return $this->roles->getRole(Roles::ROLE_OPEN_GROUP_NON_SUBSCRIBER);
+        } else {
+            if ($this->user === null) {
+                $this->roles->getRole(Roles::ROLE_LOGGED_OUT_CLOSED);
+            }
+            return $this->roles->getRole(Roles::ROLE_CLOSED_GROUP_NON_SUBSCRIBER);
+        }
+    }
 }

Core/Permissions/Entities/Manager.php

@@ -6,6 +6,7 @@ use Minds\Core\Di\Di;
 use Minds\Core\EntitiesBuilder;
 use Minds\Core\Data\Call;
 use Minds\Core\Entities\Actions\Save;
+use Minds\Core\Permissions\Entities\EntityPermissions;
 
 /*
 * Manager for managing entity specific permissions

Core/Permissions/Manager.php

@@ -3,16 +3,20 @@
 namespace Minds\Core\Permissions;
 
 use Minds\Core\Di\Di;
+use Minds\Core\Permissions\Permissions;
+use Minds\Core\EntitiesBuilder;
+use Minds\Core\Permissions\Roles\Roles;
 
 /*
 * Manager for managing role based permissions
 */
+
 class Manager
 {
-    /** @var EntityBuilder */
-    private $entityBuilder;
+    /** @var EntitiesBuilder */
+    private $entitiesBuilder;
 
-    public function __construct($entityBuilder = null)
+    public function __construct($entitiesBuilder = null)
     {
         $this->entitiesBuilder = $entitiesBuilder ?: Di::_()->get('EntitiesBuilder');
     }
@@ -33,23 +37,34 @@ class Manager
         $opts = array_merge([
             'user_guid' => null,
             'guids' => [],
+            'entities' => [],
         ], $opts);
 
         if ($opts['user_guid'] === null) {
             throw new \InvalidArgumentException('user_guid is required');
         }
 
+        $guids = $opts['guids'] ?: array_map(function ($item) {
+            return $item['guid'];
+        }, $opts['entities']);
+
         $user = $this->entitiesBuilder->single($opts['user_guid']);
-        $entities = $this->entitiesBuilder->get($opts);
+        $entities = $this->entitiesBuilder->get(['guids' => $guids]);
 
-        if ($user->getType() !== 'user') {
+        if (!$user) {
+            throw new \InvalidArgumentException('User does not exist');
+        }
+
+        if ($user && $user->getType() !== 'user') {
             throw new \InvalidArgumentException('Entity is not a user');
         }
 
+        $entities = array_merge($entities, $opts['entities']);
+
         $roles = new Roles();
 
         /** @var Permissions */
-        $permissions = new Permissions($user, null, $entitiesBuilder);
+        $permissions = new Permissions($user, $roles, $this->entitiesBuilder);
         if (is_array($entities)) {
             $permissions->calculate($entities);
         }

Core/Permissions/Permissions.php

@@ -34,22 +34,27 @@ class Permissions implements \JsonSerializable
     /** @var EntitiesBuilder */
     private $entitiesBuilder;
 
-    public function __construct(User $user, Roles $roles = null, EntitiesBuilder $entitiesBuilder = null)
+    public function __construct(User $user = null, Roles $roles = null, EntitiesBuilder $entitiesBuilder = null)
     {
         $this->entitiesBuilder = $entitiesBuilder ?: Di::_()->get('EntitiesBuilder');
         $this->roles = $roles ?: new Roles();
         $this->user = $user;
-        $this->isAdmin = $user->isAdmin();
-        $this->isBanned = $user->isBanned();
         $this->groups = [];
         $this->channels = [];
         $this->entities = [];
+        $this->roles = $roles ?: new Roles();
+        $this->user = $user;
+        if ($this->user) {
+            $this->isAdmin =  $user->isAdmin();
+            $this->isBanned = $user->isBanned();
+            $this->channels[$user->getGuid()] = $user;
+        }
         $this->entitiesBuilder = $entitiesBuilder ?: Di::_()->get('EntitiesBuilder');
-        $this->channels[$user->getGUID()] = $user;
-        $this->channelRoleCalculator = new ChannelRoleCalculator($this->user, $this->roles);
+        $this->channelRoleCalculator = new ChannelRoleCalculator($this->user, $this->roles, $entitiesBuilder);
         $this->groupRoleCalculator = new GroupRoleCalculator($this->user, $this->roles, $entitiesBuilder);
     }
 
+
     /**
      * Permissions are user aware. This bomb function is to keep the user from being changed after instantiation.
      *
@@ -72,16 +77,24 @@ class Permissions implements \JsonSerializable
     public function calculate(array $entities = []): void
     {
         foreach ($entities as $entity) {
-            $this->entities[$entity->getGUID()] = $this->getRoleForEntity($entity);
+            if ($entity) {
+                $this->entities[$entity->getGuid()] = $this->getRoleForEntity($entity);
+            }
         }
     }
 
     private function getRoleForEntity($entity): Role
     {
         $role = null;
-        //Access id is the best way to determine what the parent entity is
-        //Any of the access flags are a channel
-        //Anything else is a group guid
+
+        //Permissions for specific channels and groups
+        if ($entity->getType() === 'user') {
+            return $this->channelRoleCalculator->calculate($entity);
+        } elseif ($entity->getType() === 'group') {
+            return $this->groupRoleCalculator->calculate($entity);
+        }
+
+        //Permissions for entities belonging to groups or channels
         switch ($entity->getAccessId()) {
             case Access::UNLISTED:
             case Access::LOGGED_IN:
@@ -100,6 +113,22 @@ class Permissions implements \JsonSerializable
             $role = $this->roles->getRole(Roles::ROLE_BANNED);
         }
 
+        //Permissions for any entity a user owns
+        //Filtering out banned users and closed channels and groupos
+        if ($this->user && $entity->getOwnerGuid() === $this->user->getGuid()) {
+            switch ($role->getName()) {
+                //If a user has any of these roles, they can no longer interact with their own content
+                case Roles::ROLE_CLOSED_CHANNEL_NON_SUBSCRIBER:
+                case Roles::ROLE_CLOSED_GROUP_NON_SUBSCRIBER:
+                case Roles::ROLE_BANNED:
+                    return $role;
+                default:
+                    //Else they own the entity and can edit/delete, etc
+                    return $this->roles->getRole(Roles::ROLE_ENTITY_OWNER);
+
+            }
+        }
+
         return $role;
     }
 
@@ -111,7 +140,9 @@ class Permissions implements \JsonSerializable
     public function export(): array
     {
         $export = [];
-        $export['user'] = $this->user->export();
+        if ($this->user) {
+            $export['user'] = $this->user->export();
+        }
         $export['channels'] = $this->getChannels();
         $export['groups'] = $this->getGroups();
         $export['entities'] = $this->entities;

Core/Permissions/Roles/AdminRole.php

@@ -7,6 +7,28 @@ class AdminRole extends BaseRole
     public function __construct()
     {
         parent::__construct(Roles::ROLE_ADMIN);
-        $this->addPermission(Roles::FLAG_APPOINT_ADMIN);
+        $this->addPermission(Flags::FLAG_APPOINT_ADMIN);
+        $this->addPermission(Flags::FLAG_CREATE_POST);
+        $this->addPermission(Flags::FLAG_EDIT_CHANNEL);
+        $this->addPermission(Flags::FLAG_EDIT_POST);
+        $this->addPermission(Flags::FLAG_DELETE_CHANNEL);
+        $this->addPermission(Flags::FLAG_DELETE_POST);
+        $this->addPermission(Flags::FLAG_APPOINT_MODERATOR);
+        $this->addPermission(Flags::FLAG_APPROVE_SUBSCRIBER);
+        $this->addPermission(Flags::FLAG_SUBSCRIBE);
+        $this->addPermission(Flags::FLAG_VIEW);
+        $this->addPermission(Flags::FLAG_VOTE);
+        $this->addPermission(Flags::FLAG_CREATE_COMMENT);
+        $this->addPermission(Flags::FLAG_EDIT_COMMENT);
+        $this->addPermission(Flags::FLAG_DELETE_COMMENT);
+        $this->addPermission(Flags::FLAG_REMIND);
+        $this->addPermission(Flags::FLAG_WIRE);
+        $this->addPermission(Flags::FLAG_MESSAGE);
+        $this->addPermission(Flags::FLAG_INVITE);
+        $this->addPermission(Flags::FLAG_CREATE_GROUP);
+        $this->addPermission(Flags::FLAG_EDIT_GROUP);
+        $this->addPermission(Flags::FLAG_DELETE_GROUP);
+        $this->addPermission(Flags::FLAG_JOIN);
+        $this->addPermission(Flags::FLAG_JOIN_GATHERING);
     }
 }

Core/Permissions/Roles/BannedRole.php

@@ -7,5 +7,6 @@ class BannedRole extends BaseRole
     public function __construct()
     {
         parent::__construct(Roles::ROLE_BANNED);
+        //No permissions for banned users
     }
 }

Core/Permissions/Roles/ChannelAdminRole.php

@@ -7,5 +7,22 @@ class ChannelAdminRole extends BaseRole
     public function __construct()
     {
         parent::__construct(Roles::ROLE_CHANNEL_ADMIN);
+        $this->addPermission(Flags::FLAG_APPOINT_ADMIN);
+        $this->addPermission(Flags::FLAG_CREATE_POST);
+        $this->addPermission(Flags::FLAG_EDIT_CHANNEL);
+        $this->addPermission(Flags::FLAG_EDIT_POST);
+        $this->addPermission(Flags::FLAG_DELETE_POST);
+        $this->addPermission(Flags::FLAG_APPOINT_MODERATOR);
+        $this->addPermission(Flags::FLAG_APPROVE_SUBSCRIBER);
+        $this->addPermission(Flags::FLAG_SUBSCRIBE);
+        $this->addPermission(Flags::FLAG_VIEW);
+        $this->addPermission(Flags::FLAG_VOTE);
+        $this->addPermission(Flags::FLAG_CREATE_COMMENT);
+        $this->addPermission(Flags::FLAG_EDIT_COMMENT);
+        $this->addPermission(Flags::FLAG_DELETE_COMMENT);
+        $this->addPermission(Flags::FLAG_REMIND);
+        $this->addPermission(Flags::FLAG_WIRE);
+        $this->addPermission(Flags::FLAG_MESSAGE);
+        $this->addPermission(Flags::FLAG_INVITE);
     }
 }

Core/Permissions/Roles/ChannelModeratorRole.php

@@ -7,5 +7,21 @@ class ChannelModeratorRole extends BaseRole
     public function __construct()
     {
         parent::__construct(Roles::ROLE_CHANNEL_MODERATOR);
+        $this->addPermission(Flags::FLAG_CREATE_POST);
+        $this->addPermission(Flags::FLAG_EDIT_CHANNEL);
+        $this->addPermission(Flags::FLAG_EDIT_POST);
+        $this->addPermission(Flags::FLAG_DELETE_POST);
+        $this->addPermission(Flags::FLAG_APPOINT_MODERATOR);
+        $this->addPermission(Flags::FLAG_APPROVE_SUBSCRIBER);
+        $this->addPermission(Flags::FLAG_SUBSCRIBE);
+        $this->addPermission(Flags::FLAG_VIEW);
+        $this->addPermission(Flags::FLAG_VOTE);
+        $this->addPermission(Flags::FLAG_CREATE_COMMENT);
+        $this->addPermission(Flags::FLAG_EDIT_COMMENT);
+        $this->addPermission(Flags::FLAG_DELETE_COMMENT);
+        $this->addPermission(Flags::FLAG_REMIND);
+        $this->addPermission(Flags::FLAG_WIRE);
+        $this->addPermission(Flags::FLAG_MESSAGE);
+        $this->addPermission(Flags::FLAG_INVITE);
     }
 }

Core/Permissions/Roles/ChannelOwnerRole.php

@@ -7,5 +7,24 @@ class ChannelOwnerRole extends BaseRole
     public function __construct()
     {
         parent::__construct(Roles::ROLE_CHANNEL_OWNER);
+        $this->addPermission(Flags::FLAG_APPOINT_ADMIN);
+        $this->addPermission(Flags::FLAG_CREATE_POST);
+        $this->addPermission(Flags::FLAG_EDIT_CHANNEL);
+        $this->addPermission(Flags::FLAG_EDIT_POST);
+        $this->addPermission(Flags::FLAG_DELETE_CHANNEL);
+        $this->addPermission(Flags::FLAG_DELETE_POST);
+        $this->addPermission(Flags::FLAG_APPOINT_MODERATOR);
+        $this->addPermission(Flags::FLAG_APPROVE_SUBSCRIBER);
+        $this->addPermission(Flags::FLAG_SUBSCRIBE);
+        $this->addPermission(Flags::FLAG_VIEW);
+        $this->addPermission(Flags::FLAG_VOTE);
+        $this->addPermission(Flags::FLAG_CREATE_COMMENT);
+        $this->addPermission(Flags::FLAG_EDIT_COMMENT);
+        $this->addPermission(Flags::FLAG_DELETE_COMMENT);
+        $this->addPermission(Flags::FLAG_REMIND);
+        $this->addPermission(Flags::FLAG_WIRE);
+        $this->addPermission(Flags::FLAG_TAG);
+        $this->addPermission(Flags::FLAG_MESSAGE);
+        $this->addPermission(Flags::FLAG_INVITE);
     }
 }

Core/Permissions/Roles/GroupSubscriberRole.php → Core/Permissions/Roles/ClosedChannelNonSubscriberRole.php

@@ -2,10 +2,11 @@
 
 namespace Minds\Core\Permissions\Roles;
 
-class GroupSubscriberRole extends BaseRole
+class ClosedChannelNonSubscriberRole extends BaseRole
 {
     public function __construct()
     {
-        parent::__construct(Roles::ROLE_GROUP_SUBSCRIBER);
+        parent::__construct(Roles::ROLE_CLOSED_CHANNEL_NON_SUBSCRIBER);
+        //No permissions for closed channel non subscribers
     }
 }