Initial commit

extensions/lock/src/Events/DiscussionWasLocked.php

@@ -0,0 +1,27 @@
+<?php namespace Flarum\Lock\Events;
+
+use Flarum\Core\Discussions\Discussion;
+use Flarum\Core\Users\User;
+
+class DiscussionWasLocked
+{
+    /**
+     * @var Discussion
+     */
+    public $discussion;
+
+    /**
+     * @var User
+     */
+    public $user;
+
+    /**
+     * @param Discussion $discussion
+     * @param User $user
+     */
+    public function __construct(Discussion $discussion, User $user)
+    {
+        $this->discussion = $discussion;
+        $this->user = $user;
+    }
+}

extensions/lock/src/Events/DiscussionWasUnlocked.php

@@ -0,0 +1,27 @@
+<?php namespace Flarum\Lock\Events;
+
+use Flarum\Core\Discussions\Discussion;
+use Flarum\Core\Users\User;
+
+class DiscussionWasUnlocked
+{
+    /**
+     * @var Discussion
+     */
+    public $discussion;
+
+    /**
+     * @var User
+     */
+    public $user;
+
+    /**
+     * @param Discussion $discussion
+     * @param User $user
+     */
+    public function __construct(Discussion $discussion, User $user)
+    {
+        $this->discussion = $discussion;
+        $this->user = $user;
+    }
+}

extensions/lock/src/Extension.php

@@ -0,0 +1,16 @@
+<?php namespace Flarum\Lock;
+
+use Flarum\Support\Extension as BaseExtension;
+use Illuminate\Contracts\Events\Dispatcher;
+
+class Extension extends BaseExtension
+{
+    public function boot(Dispatcher $events)
+    {
+        $events->subscribe('Flarum\Lock\Listeners\AddClientAssets');
+        $events->subscribe('Flarum\Lock\Listeners\AddApiAttributes');
+        $events->subscribe('Flarum\Lock\Listeners\PersistData');
+        $events->subscribe('Flarum\Lock\Listeners\NotifyDiscussionLocked');
+        $events->subscribe('Flarum\Lock\Listeners\ConfigurePermissions');
+    }
+}

extensions/lock/src/Gambits/LockGambit.php

@@ -0,0 +1,14 @@
+<?php namespace Flarum\Lock\Gambits;
+
+use Flarum\Core\Search\Search;
+use Flarum\Core\Search\RegexGambit;
+
+class LockGambit extends RegexGambit
+{
+    protected $pattern = 'is:locked';
+
+    protected function conditions(Search $search, array $matches, $negate)
+    {
+        $search->getQuery()->where('is_locked', ! $negate);
+    }
+}

extensions/lock/src/Listeners/AddApiAttributes.php

@@ -0,0 +1,21 @@
+<?php namespace Flarum\Lock\Listeners;
+
+use Flarum\Events\ApiAttributes;
+use Illuminate\Contracts\Events\Dispatcher;
+use Flarum\Api\Serializers\DiscussionSerializer;
+
+class AddApiAttributes
+{
+    public function subscribe(Dispatcher $events)
+    {
+        $events->listen(ApiAttributes::class, [$this, 'addAttributes']);
+    }
+
+    public function addAttributes(ApiAttributes $event)
+    {
+        if ($event->serializer instanceof DiscussionSerializer) {
+            $event->attributes['isLocked'] = (bool) $event->model->is_locked;
+            $event->attributes['canLock'] = (bool) $event->model->can($event->actor, 'lock');
+        }
+    }
+}

extensions/lock/src/Listeners/AddClientAssets.php

@@ -0,0 +1,39 @@
+<?php namespace Flarum\Lock\Listeners;
+
+use Flarum\Events\RegisterLocales;
+use Flarum\Events\BuildClientView;
+use Illuminate\Contracts\Events\Dispatcher;
+
+class AddClientAssets
+{
+    public function subscribe(Dispatcher $events)
+    {
+        $events->listen(RegisterLocales::class, [$this, 'addLocale']);
+        $events->listen(BuildClientView::class, [$this, 'addAssets']);
+    }
+
+    public function addLocale(RegisterLocales $event)
+    {
+        $event->addTranslations('en', __DIR__.'/../../locale/en.yml');
+    }
+
+    public function addAssets(BuildClientView $event)
+    {
+        $event->forumAssets([
+            __DIR__.'/../../js/forum/dist/extension.js',
+            __DIR__.'/../../less/forum/extension.less'
+        ]);
+
+        $event->forumBootstrapper('lock/main');
+
+        $event->forumTranslations([
+            'lock.discussion_locked_notification',
+            'lock.discussion_locked_post',
+            'lock.discussion_unlocked_post',
+            'lock.notify_discussion_locked',
+            'lock.locked',
+            'lock.lock',
+            'lock.unlock'
+        ]);
+    }
+}

extensions/lock/src/Listeners/ConfigurePermissions.php

@@ -0,0 +1,23 @@
+<?php namespace Flarum\Lock\Listeners;
+
+use Flarum\Events\ModelAllow;
+use Flarum\Core\Discussions\Discussion;
+
+class ConfigurePermissions
+{
+    public function subscribe($events)
+    {
+        $events->listen(ModelAllow::class, [$this, 'allowDiscussionPermissions'], 10);
+    }
+
+    public function allowDiscussionPermissions(ModelAllow $event)
+    {
+        if ($event->model instanceof Discussion &&
+            $event->model->is_locked &&
+            $event->action === 'reply') {
+            if (! $event->model->can($event->actor, 'lock')) {
+                return false;
+            }
+        }
+    }
+}

extensions/lock/src/Listeners/NotifyDiscussionLocked.php

@@ -0,0 +1,71 @@
+<?php namespace Flarum\Lock\Listeners;
+
+use Flarum\Events\RegisterPostTypes;
+use Flarum\Events\RegisterNotificationTypes;
+use Flarum\Lock\Posts\DiscussionLockedPost;
+use Flarum\Lock\Notifications\DiscussionLockedBlueprint;
+use Flarum\Lock\Events\DiscussionWasLocked;
+use Flarum\Lock\Events\DiscussionWasUnlocked;
+use Flarum\Core\Notifications\NotificationSyncer;
+use Flarum\Core\Discussions\Discussion;
+use Flarum\Core\Users\User;
+use Illuminate\Contracts\Events\Dispatcher;
+
+class NotifyDiscussionLocked
+{
+    protected $notifications;
+
+    public function __construct(NotificationSyncer $notifications)
+    {
+        $this->notifications = $notifications;
+    }
+
+    public function subscribe(Dispatcher $events)
+    {
+        $events->listen(RegisterPostTypes::class, [$this, 'registerPostType']);
+        $events->listen(RegisterNotificationTypes::class, [$this, 'registerNotificationType']);
+        $events->listen(DiscussionWasLocked::class, [$this, 'whenDiscussionWasLocked']);
+        $events->listen(DiscussionWasUnlocked::class, [$this, 'whenDiscussionWasUnlocked']);
+    }
+
+    public function registerPostType(RegisterPostTypes $event)
+    {
+        $event->register('Flarum\Lock\Posts\DiscussionLockedPost');
+    }
+
+    public function registerNotificationType(RegisterNotificationTypes $event)
+    {
+        $event->register(
+            'Flarum\Lock\Notifications\DiscussionLockedBlueprint',
+            'Flarum\Api\Serializers\DiscussionBasicSerializer',
+            ['alert']
+        );
+    }
+
+    public function whenDiscussionWasLocked(DiscussionWasLocked $event)
+    {
+        $this->stickyChanged($event->discussion, $event->user, true);
+    }
+
+    public function whenDiscussionWasUnlocked(DiscussionWasUnlocked $event)
+    {
+        $this->stickyChanged($event->discussion, $event->user, false);
+    }
+
+    protected function stickyChanged(Discussion $discussion, User $user, $isLocked)
+    {
+        $post = DiscussionLockedPost::reply(
+            $discussion->id,
+            $user->id,
+            $isLocked
+        );
+
+        $post = $discussion->mergePost($post);
+
+        if ($discussion->start_user_id !== $user->id) {
+            $notification = new DiscussionLockedBlueprint($post);
+
+            $this->notifications->sync($notification, $post->exists ? [$discussion->startUser] : []);
+        }
+    }
+}

extensions/lock/src/Listeners/PersistData.php

@@ -0,0 +1,36 @@
+<?php namespace Flarum\Lock\Listeners;
+
+use Flarum\Lock\Events\DiscussionWasLocked;
+use Flarum\Lock\Events\DiscussionWasUnlocked;
+use Flarum\Events\DiscussionWillBeSaved;
+
+class PersistData
+{
+    public function subscribe($events)
+    {
+        $events->listen(DiscussionWillBeSaved::class, [$this, 'whenDiscussionWillBeSaved']);
+    }
+
+    public function whenDiscussionWillBeSaved(DiscussionWillBeSaved $event)
+    {
+        if (isset($event->data['attributes']['isLocked'])) {
+            $isLocked = (bool) $event->data['attributes']['isLocked'];
+            $discussion = $event->discussion;
+            $actor = $event->actor;
+
+            $discussion->assertCan($actor, 'lock');
+
+            if ((bool) $discussion->is_locked === $isLocked) {
+                return;
+            }
+
+            $discussion->is_locked = $isLocked;
+
+            $discussion->raise(
+                $discussion->is_locked
+                    ? new DiscussionWasLocked($discussion, $actor)
+                    : new DiscussionWasUnlocked($discussion, $actor)
+            );
+        }
+    }
+}

extensions/lock/src/Notifications/DiscussionLockedBlueprint.php

@@ -0,0 +1,39 @@
+<?php namespace Flarum\Lock\Notifications;
+
+use Flarum\Sticky\Posts\DiscussionLockedPost;
+use Flarum\Core\Notifications\Blueprint;
+
+class DiscussionLockedBlueprint implements Blueprint
+{
+    protected $post;
+
+    public function __construct(DiscussionLockedPost $post)
+    {
+        $this->post = $post;
+    }
+
+    public function getSender()
+    {
+        return $this->post->user;
+    }
+
+    public function getSubject()
+    {
+        return $this->post->discussion;
+    }
+
+    public function getData()
+    {
+        return ['postNumber' => (int) $this->post->number];
+    }
+
+    public static function getType()
+    {
+        return 'discussionLocked';
+    }
+
+    public static function getSubjectModel()
+    {
+        return 'Flarum\Core\Discussions\Discussion';
+    }
+}

extensions/lock/src/Posts/DiscussionLockedPost.php

@@ -0,0 +1,64 @@
+<?php namespace Flarum\Lock\Posts;
+
+use Flarum\Core\Posts\Post;
+use Flarum\Core\Posts\EventPost;
+use Flarum\Core\Posts\MergeablePost;
+
+class DiscussionLockedPost extends EventPost implements MergeablePost
+{
+    public static $type = 'discussionLocked';
+
+    public function saveAfter(Post $previous)
+    {
+        // If the previous post is another 'discussion locked' post, and it's
+        // by the same user, then we can merge this post into it. If we find
+        // that we've in fact reverted the locked status, delete it. Otherwise,
+        // update its content.
+        if ($previous instanceof static && $this->user_id === $previous->user_id) {
+            if ($previous->content['locked'] != $this->content['locked']) {
+                $previous->delete();
+            } else {
+                $previous->content = $this->content;
+
+                $previous->save();
+            }
+
+            return $previous;
+        }
+
+        $this->save();
+
+        return $this;
+    }
+
+    /**
+     * Create a new instance in reply to a discussion.
+     *
+     * @param integer $discussionId
+     * @param integer $userId
+     * @param boolean $isLocked
+     * @return static
+     */
+    public static function reply($discussionId, $userId, $isLocked)
+    {
+        $post = new static;
+
+        $post->content       = static::buildContent($isLocked);
+        $post->time          = time();
+        $post->discussion_id = $discussionId;
+        $post->user_id       = $userId;
+
+        return $post;
+    }
+
+    /**
+     * Build the content attribute.
+     *
+     * @param boolean $isLocked Whether or not the discussion is stickied.
+     * @return array
+     */
+    public static function buildContent($isLocked)
+    {
+        return ['locked' => (bool) $isLocked];
+    }
+}