Re-structured the app code to be feature based rather than code type based

app/Actions/Activity.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace BookStack\Actions;
+
+use BookStack\Auth\User;
+use BookStack\Model;
+
+/**
+ * @property string  key
+ * @property \User   user
+ * @property \Entity entity
+ * @property string  extra
+ */
+class Activity extends Model
+{
+
+    /**
+     * Get the entity for this activity.
+     */
+    public function entity()
+    {
+        if ($this->entity_type === '') {
+            $this->entity_type = null;
+        }
+        return $this->morphTo('entity');
+    }
+
+    /**
+     * Get the user this activity relates to.
+     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
+     */
+    public function user()
+    {
+        return $this->belongsTo(User::class);
+    }
+
+    /**
+     * Returns text from the language files, Looks up by using the
+     * activity key.
+     */
+    public function getText()
+    {
+        return trans('activities.' . $this->key);
+    }
+
+    /**
+     * Checks if another Activity matches the general information of another.
+     * @param $activityB
+     * @return bool
+     */
+    public function isSimilarTo($activityB)
+    {
+        return [$this->key, $this->entity_type, $this->entity_id] === [$activityB->key, $activityB->entity_type, $activityB->entity_id];
+    }
+}

app/Actions/ActivityService.php

@@ -0,0 +1,174 @@
+<?php namespace BookStack\Actions;
+
+use BookStack\Actions\Activity;
+use BookStack\Auth\Permissions\PermissionService;
+use BookStack\Entities\Entity;
+use Session;
+
+class ActivityService
+{
+    protected $activity;
+    protected $user;
+    protected $permissionService;
+
+    /**
+     * ActivityService constructor.
+     * @param \BookStack\Actions\Activity $activity
+     * @param PermissionService $permissionService
+     */
+    public function __construct(Activity $activity, PermissionService $permissionService)
+    {
+        $this->activity = $activity;
+        $this->permissionService = $permissionService;
+        $this->user = user();
+    }
+
+    /**
+     * Add activity data to database.
+     * @param Entity $entity
+     * @param        $activityKey
+     * @param int $bookId
+     * @param bool $extra
+     */
+    public function add(Entity $entity, $activityKey, $bookId = 0, $extra = false)
+    {
+        $activity = $this->activity->newInstance();
+        $activity->user_id = $this->user->id;
+        $activity->book_id = $bookId;
+        $activity->key = strtolower($activityKey);
+        if ($extra !== false) {
+            $activity->extra = $extra;
+        }
+        $entity->activity()->save($activity);
+        $this->setNotification($activityKey);
+    }
+
+    /**
+     * Adds a activity history with a message & without binding to a entity.
+     * @param            $activityKey
+     * @param int $bookId
+     * @param bool|false $extra
+     */
+    public function addMessage($activityKey, $bookId = 0, $extra = false)
+    {
+        $this->activity->user_id = $this->user->id;
+        $this->activity->book_id = $bookId;
+        $this->activity->key = strtolower($activityKey);
+        if ($extra !== false) {
+            $this->activity->extra = $extra;
+        }
+        $this->activity->save();
+        $this->setNotification($activityKey);
+    }
+
+
+    /**
+     * Removes the entity attachment from each of its activities
+     * and instead uses the 'extra' field with the entities name.
+     * Used when an entity is deleted.
+     * @param Entity $entity
+     * @return mixed
+     */
+    public function removeEntity(Entity $entity)
+    {
+        $activities = $entity->activity;
+        foreach ($activities as $activity) {
+            $activity->extra = $entity->name;
+            $activity->entity_id = 0;
+            $activity->entity_type = null;
+            $activity->save();
+        }
+        return $activities;
+    }
+
+    /**
+     * Gets the latest activity.
+     * @param int $count
+     * @param int $page
+     * @return array
+     */
+    public function latest($count = 20, $page = 0)
+    {
+        $activityList = $this->permissionService
+            ->filterRestrictedEntityRelations($this->activity, 'activities', 'entity_id', 'entity_type')
+            ->orderBy('created_at', 'desc')->with('user', 'entity')->skip($count * $page)->take($count)->get();
+
+        return $this->filterSimilar($activityList);
+    }
+
+    /**
+     * Gets the latest activity for an entity, Filtering out similar
+     * items to prevent a message activity list.
+     * @param Entity $entity
+     * @param int $count
+     * @param int $page
+     * @return array
+     */
+    public function entityActivity($entity, $count = 20, $page = 0)
+    {
+        if ($entity->isA('book')) {
+            $query = $this->activity->where('book_id', '=', $entity->id);
+        } else {
+            $query = $this->activity->where('entity_type', '=', get_class($entity))
+                ->where('entity_id', '=', $entity->id);
+        }
+        
+        $activity = $this->permissionService
+            ->filterRestrictedEntityRelations($query, 'activities', 'entity_id', 'entity_type')
+            ->orderBy('created_at', 'desc')->with(['entity', 'user.avatar'])->skip($count * $page)->take($count)->get();
+
+        return $this->filterSimilar($activity);
+    }
+
+    /**
+     * Get latest activity for a user, Filtering out similar
+     * items.
+     * @param $user
+     * @param int $count
+     * @param int $page
+     * @return array
+     */
+    public function userActivity($user, $count = 20, $page = 0)
+    {
+        $activityList = $this->permissionService
+            ->filterRestrictedEntityRelations($this->activity, 'activities', 'entity_id', 'entity_type')
+            ->orderBy('created_at', 'desc')->where('user_id', '=', $user->id)->skip($count * $page)->take($count)->get();
+        return $this->filterSimilar($activityList);
+    }
+
+    /**
+     * Filters out similar activity.
+     * @param Activity[] $activities
+     * @return array
+     */
+    protected function filterSimilar($activities)
+    {
+        $newActivity = [];
+        $previousItem = false;
+        foreach ($activities as $activityItem) {
+            if ($previousItem === false) {
+                $previousItem = $activityItem;
+                $newActivity[] = $activityItem;
+                continue;
+            }
+            if (!$activityItem->isSimilarTo($previousItem)) {
+                $newActivity[] = $activityItem;
+            }
+            $previousItem = $activityItem;
+        }
+        return $newActivity;
+    }
+
+    /**
+     * Flashes a notification message to the session if an appropriate message is available.
+     * @param $activityKey
+     */
+    protected function setNotification($activityKey)
+    {
+        $notificationTextKey = 'activities.' . $activityKey . '_notification';
+        if (trans()->has($notificationTextKey)) {
+            $message = trans($notificationTextKey);
+            Session::flash('success', $message);
+        }
+    }
+}

app/Actions/Comment.php

@@ -0,0 +1,45 @@
+<?php namespace BookStack\Actions;
+
+use BookStack\Ownable;
+
+class Comment extends Ownable
+{
+    protected $fillable = ['text', 'html', 'parent_id'];
+    protected $appends = ['created', 'updated'];
+
+    /**
+     * Get the entity that this comment belongs to
+     * @return \Illuminate\Database\Eloquent\Relations\MorphTo
+     */
+    public function entity()
+    {
+        return $this->morphTo('entity');
+    }
+
+    /**
+     * Check if a comment has been updated since creation.
+     * @return bool
+     */
+    public function isUpdated()
+    {
+        return $this->updated_at->timestamp > $this->created_at->timestamp;
+    }
+
+    /**
+     * Get created date as a relative diff.
+     * @return mixed
+     */
+    public function getCreatedAttribute()
+    {
+        return $this->created_at->diffForHumans();
+    }
+
+    /**
+     * Get updated date as a relative diff.
+     * @return mixed
+     */
+    public function getUpdatedAttribute()
+    {
+        return $this->updated_at->diffForHumans();
+    }
+}

app/Actions/CommentRepo.php

@@ -0,0 +1,90 @@
+<?php namespace BookStack\Actions;
+
+use BookStack\Actions\Comment;
+use BookStack\Entities\Entity;
+
+/**
+ * Class CommentRepo
+ * @package BookStack\Repos
+ */
+class CommentRepo
+{
+
+    /**
+     * @var \BookStack\Actions\Comment $comment
+     */
+    protected $comment;
+
+    /**
+     * CommentRepo constructor.
+     * @param \BookStack\Actions\Comment $comment
+     */
+    public function __construct(Comment $comment)
+    {
+        $this->comment = $comment;
+    }
+
+    /**
+     * Get a comment by ID.
+     * @param $id
+     * @return \BookStack\Actions\Comment|\Illuminate\Database\Eloquent\Model
+     */
+    public function getById($id)
+    {
+        return $this->comment->newQuery()->findOrFail($id);
+    }
+
+    /**
+     * Create a new comment on an entity.
+     * @param \BookStack\Entities\Entity $entity
+     * @param array $data
+     * @return \BookStack\Actions\Comment
+     */
+    public function create(Entity $entity, $data = [])
+    {
+        $userId = user()->id;
+        $comment = $this->comment->newInstance($data);
+        $comment->created_by = $userId;
+        $comment->updated_by = $userId;
+        $comment->local_id = $this->getNextLocalId($entity);
+        $entity->comments()->save($comment);
+        return $comment;
+    }
+
+    /**
+     * Update an existing comment.
+     * @param \BookStack\Actions\Comment $comment
+     * @param array $input
+     * @return mixed
+     */
+    public function update($comment, $input)
+    {
+        $comment->updated_by = user()->id;
+        $comment->update($input);
+        return $comment;
+    }
+
+    /**
+     * Delete a comment from the system.
+     * @param \BookStack\Actions\Comment $comment
+     * @return mixed
+     */
+    public function delete($comment)
+    {
+        return $comment->delete();
+    }
+
+    /**
+     * Get the next local ID relative to the linked entity.
+     * @param \BookStack\Entities\Entity $entity
+     * @return int
+     */
+    protected function getNextLocalId(Entity $entity)
+    {
+        $comments = $entity->comments(false)->orderBy('local_id', 'desc')->first();
+        if ($comments === null) {
+            return 1;
+        }
+        return $comments->local_id + 1;
+    }
+}

app/Actions/Tag.php

@@ -0,0 +1,21 @@
+<?php namespace BookStack\Actions;
+
+use BookStack\Model;
+
+/**
+ * Class Attribute
+ * @package BookStack
+ */
+class Tag extends Model
+{
+    protected $fillable = ['name', 'value', 'order'];
+
+    /**
+     * Get the entity that this tag belongs to
+     * @return \Illuminate\Database\Eloquent\Relations\MorphTo
+     */
+    public function entity()
+    {
+        return $this->morphTo('entity');
+    }
+}

app/Actions/TagRepo.php

@@ -0,0 +1,140 @@
+<?php namespace BookStack\Actions;
+
+use BookStack\Entities\Entity;
+use BookStack\Auth\Permissions\PermissionService;
+
+/**
+ * Class TagRepo
+ * @package BookStack\Repos
+ */
+class TagRepo
+{
+
+    protected $tag;
+    protected $entity;
+    protected $permissionService;
+
+    /**
+     * TagRepo constructor.
+     * @param \BookStack\Actions\Tag $attr
+     * @param \BookStack\Entities\Entity $ent
+     * @param \BookStack\Auth\Permissions\PermissionService $ps
+     */
+    public function __construct(Tag $attr, Entity $ent, PermissionService $ps)
+    {
+        $this->tag = $attr;
+        $this->entity = $ent;
+        $this->permissionService = $ps;
+    }
+
+    /**
+     * Get an entity instance of its particular type.
+     * @param $entityType
+     * @param $entityId
+     * @param string $action
+     * @return \Illuminate\Database\Eloquent\Model|null|static
+     */
+    public function getEntity($entityType, $entityId, $action = 'view')
+    {
+        $entityInstance = $this->entity->getEntityInstance($entityType);
+        $searchQuery = $entityInstance->where('id', '=', $entityId)->with('tags');
+        $searchQuery = $this->permissionService->enforceEntityRestrictions($entityType, $searchQuery, $action);
+        return $searchQuery->first();
+    }
+
+    /**
+     * Get all tags for a particular entity.
+     * @param string $entityType
+     * @param int $entityId
+     * @return mixed
+     */
+    public function getForEntity($entityType, $entityId)
+    {
+        $entity = $this->getEntity($entityType, $entityId);
+        if ($entity === null) {
+            return collect();
+        }
+
+        return $entity->tags;
+    }
+
+    /**
+     * Get tag name suggestions from scanning existing tag names.
+     * If no search term is given the 50 most popular tag names are provided.
+     * @param $searchTerm
+     * @return array
+     */
+    public function getNameSuggestions($searchTerm = false)
+    {
+        $query = $this->tag->select('*', \DB::raw('count(*) as count'))->groupBy('name');
+
+        if ($searchTerm) {
+            $query = $query->where('name', 'LIKE', $searchTerm . '%')->orderBy('name', 'desc');
+        } else {
+            $query = $query->orderBy('count', 'desc')->take(50);
+        }
+
+        $query = $this->permissionService->filterRestrictedEntityRelations($query, 'tags', 'entity_id', 'entity_type');
+        return $query->get(['name'])->pluck('name');
+    }
+
+    /**
+     * Get tag value suggestions from scanning existing tag values.
+     * If no search is given the 50 most popular values are provided.
+     * Passing a tagName will only find values for a tags with a particular name.
+     * @param $searchTerm
+     * @param $tagName
+     * @return array
+     */
+    public function getValueSuggestions($searchTerm = false, $tagName = false)
+    {
+        $query = $this->tag->select('*', \DB::raw('count(*) as count'))->groupBy('value');
+
+        if ($searchTerm) {
+            $query = $query->where('value', 'LIKE', $searchTerm . '%')->orderBy('value', 'desc');
+        } else {
+            $query = $query->orderBy('count', 'desc')->take(50);
+        }
+
+        if ($tagName !== false) {
+            $query = $query->where('name', '=', $tagName);
+        }
+
+        $query = $this->permissionService->filterRestrictedEntityRelations($query, 'tags', 'entity_id', 'entity_type');
+        return $query->get(['value'])->pluck('value');
+    }
+
+    /**
+     * Save an array of tags to an entity
+     * @param \BookStack\Entities\Entity $entity
+     * @param array $tags
+     * @return array|\Illuminate\Database\Eloquent\Collection
+     */
+    public function saveTagsToEntity(Entity $entity, $tags = [])
+    {
+        $entity->tags()->delete();
+        $newTags = [];
+        foreach ($tags as $tag) {
+            if (trim($tag['name']) === '') {
+                continue;
+            }
+            $newTags[] = $this->newInstanceFromInput($tag);
+        }
+
+        return $entity->tags()->saveMany($newTags);
+    }
+
+    /**
+     * Create a new Tag instance from user input.
+     * @param $input
+     * @return \BookStack\Actions\Tag
+     */
+    protected function newInstanceFromInput($input)
+    {
+        $name = trim($input['name']);
+        $value = isset($input['value']) ? trim($input['value']) : '';
+        // Any other modification or cleanup required can go here
+        $values = ['name' => $name, 'value' => $value];
+        return $this->tag->newInstance($values);
+    }
+}

app/Actions/View.php

@@ -0,0 +1,18 @@
+<?php namespace BookStack\Actions;
+
+use BookStack\Model;
+
+class View extends Model
+{
+
+    protected $fillable = ['user_id', 'views'];
+
+    /**
+     * Get all owning viewable models.
+     * @return \Illuminate\Database\Eloquent\Relations\MorphTo
+     */
+    public function viewable()
+    {
+        return $this->morphTo();
+    }
+}

app/Actions/ViewService.php

@@ -0,0 +1,109 @@
+<?php namespace BookStack\Actions;
+
+use BookStack\Auth\Permissions\PermissionService;
+use BookStack\Entities\Entity;
+
+class ViewService
+{
+    protected $view;
+    protected $permissionService;
+
+    /**
+     * ViewService constructor.
+     * @param \BookStack\Actions\View $view
+     * @param \BookStack\Auth\Permissions\PermissionService $permissionService
+     */
+    public function __construct(View $view, PermissionService $permissionService)
+    {
+        $this->view = $view;
+        $this->permissionService = $permissionService;
+    }
+
+    /**
+     * Add a view to the given entity.
+     * @param Entity $entity
+     * @return int
+     */
+    public function add(Entity $entity)
+    {
+        $user = user();
+        if ($user === null || $user->isDefault()) {
+            return 0;
+        }
+        $view = $entity->views()->where('user_id', '=', $user->id)->first();
+        // Add view if model exists
+        if ($view) {
+            $view->increment('views');
+            return $view->views;
+        }
+
+        // Otherwise create new view count
+        $entity->views()->save($this->view->create([
+            'user_id' => $user->id,
+            'views' => 1
+        ]));
+
+        return 1;
+    }
+
+    /**
+     * Get the entities with the most views.
+     * @param int $count
+     * @param int $page
+     * @param Entity|false|array $filterModel
+     * @param string $action - used for permission checking
+     * @return
+     */
+    public function getPopular($count = 10, $page = 0, $filterModel = false, $action = 'view')
+    {
+        // TODO - Standardise input filter
+        $skipCount = $count * $page;
+        $query = $this->permissionService->filterRestrictedEntityRelations($this->view, 'views', 'viewable_id', 'viewable_type', $action)
+            ->select('*', 'viewable_id', 'viewable_type', \DB::raw('SUM(views) as view_count'))
+            ->groupBy('viewable_id', 'viewable_type')
+            ->orderBy('view_count', 'desc');
+
+        if ($filterModel && is_array($filterModel)) {
+            $query->whereIn('viewable_type', $filterModel);
+        } else if ($filterModel) {
+            $query->where('viewable_type', '=', $filterModel->getMorphClass());
+        }
+
+        return $query->with('viewable')->skip($skipCount)->take($count)->get()->pluck('viewable');
+    }
+
+    /**
+     * Get all recently viewed entities for the current user.
+     * @param int $count
+     * @param int $page
+     * @param Entity|bool $filterModel
+     * @return mixed
+     */
+    public function getUserRecentlyViewed($count = 10, $page = 0, $filterModel = false)
+    {
+        $user = user();
+        if ($user === null || $user->isDefault()) {
+            return collect();
+        }
+
+        $query = $this->permissionService
+            ->filterRestrictedEntityRelations($this->view, 'views', 'viewable_id', 'viewable_type');
+
+        if ($filterModel) {
+            $query = $query->where('viewable_type', '=', $filterModel->getMorphClass());
+        }
+        $query = $query->where('user_id', '=', $user->id);
+
+        $viewables = $query->with('viewable')->orderBy('updated_at', 'desc')
+            ->skip($count * $page)->take($count)->get()->pluck('viewable');
+        return $viewables;
+    }
+
+    /**
+     * Reset all view counts by deleting all views.
+     */
+    public function resetAll()
+    {
+        $this->view->truncate();
+    }
+}