<?php namespace BookStack\Entities;
-use BookStack\Entities\Book;
-use BookStack\Entities\Bookshelf;
-use BookStack\Entities\Chapter;
-use BookStack\Entities\Entity;
-use BookStack\Entities\Page;
-use BookStack\Entities\SearchTerm;
use BookStack\Auth\Permissions\PermissionService;
use Illuminate\Database\Connection;
+use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
use Illuminate\Database\Query\Builder;
use Illuminate\Database\Query\JoinClause;
use Illuminate\Support\Collection;
+use Illuminate\Support\Str;
class SearchService
{
+ /**
+ * @var SearchTerm
+ */
protected $searchTerm;
- protected $bookshelf;
- protected $book;
- protected $chapter;
- protected $page;
+
+ /**
+ * @var EntityProvider
+ */
+ protected $entityProvider;
+
+ /**
+ * @var Connection
+ */
protected $db;
- protected $permissionService;
/**
- * @var Entity[]
+ * @var PermissionService
*/
- protected $entities;
+ protected $permissionService;
+
/**
* Acceptable operators to be used in a query
/**
* SearchService constructor.
- * @param SearchTerm $searchTerm
- * @param Bookshelf $bookshelf
- * @param \BookStack\Entities\Book $book
- * @param \BookStack\Entities\Chapter $chapter
- * @param Page $page
- * @param Connection $db
- * @param PermissionService $permissionService
*/
- public function __construct(SearchTerm $searchTerm, Bookshelf $bookshelf, Book $book, Chapter $chapter, Page $page, Connection $db, PermissionService $permissionService)
+ public function __construct(SearchTerm $searchTerm, EntityProvider $entityProvider, Connection $db, PermissionService $permissionService)
{
$this->searchTerm = $searchTerm;
- $this->bookshelf = $bookshelf;
- $this->book = $book;
- $this->chapter = $chapter;
- $this->page = $page;
+ $this->entityProvider = $entityProvider;
$this->db = $db;
- $this->entities = [
- 'bookshelf' => $this->bookshelf,
- 'page' => $this->page,
- 'chapter' => $this->chapter,
- 'book' => $this->book
- ];
$this->permissionService = $permissionService;
}
/**
* Set the database connection
- * @param Connection $connection
*/
public function setConnection(Connection $connection)
{
/**
* Search all entities in the system.
- * @param string $searchString
- * @param string $entityType
- * @param int $page
- * @param int $count - Count of each entity to search, Total returned could can be larger and not guaranteed.
- * @param string $action
- * @return array[int, Collection];
+ * The provided count is for each entity to search,
+ * Total returned could can be larger and not guaranteed.
*/
- public function searchEntities($searchString, $entityType = 'all', $page = 1, $count = 20, $action = 'view')
+ public function searchEntities(SearchOptions $searchOpts, string $entityType = 'all', int $page = 1, int $count = 20, string $action = 'view'): array
{
- $terms = $this->parseSearchString($searchString);
- $entityTypes = array_keys($this->entities);
+ $entityTypes = array_keys($this->entityProvider->all());
$entityTypesToSearch = $entityTypes;
if ($entityType !== 'all') {
$entityTypesToSearch = $entityType;
- } else if (isset($terms['filters']['type'])) {
- $entityTypesToSearch = explode('|', $terms['filters']['type']);
+ } else if (isset($searchOpts->filters['type'])) {
+ $entityTypesToSearch = explode('|', $searchOpts->filters['type']);
}
$results = collect();
if (!in_array($entityType, $entityTypes)) {
continue;
}
- $search = $this->searchEntityTable($terms, $entityType, $page, $count, $action);
- $entityTotal = $this->searchEntityTable($terms, $entityType, $page, $count, $action, true);
+ $search = $this->searchEntityTable($searchOpts, $entityType, $page, $count, $action);
+ $entityTotal = $this->searchEntityTable($searchOpts, $entityType, $page, $count, $action, true);
if ($entityTotal > $page * $count) {
$hasMore = true;
}
'total' => $total,
'count' => count($results),
'has_more' => $hasMore,
- 'results' => $results->sortByDesc('score')->values()
+ 'results' => $results->sortByDesc('score')->values(),
];
}
/**
* Search a book for entities
- * @param integer $bookId
- * @param string $searchString
- * @return Collection
*/
- public function searchBook($bookId, $searchString)
+ public function searchBook(int $bookId, string $searchString): Collection
{
- $terms = $this->parseSearchString($searchString);
+ $opts = SearchOptions::fromString($searchString);
$entityTypes = ['page', 'chapter'];
- $entityTypesToSearch = isset($terms['filters']['type']) ? explode('|', $terms['filters']['type']) : $entityTypes;
+ $entityTypesToSearch = isset($opts->filters['type']) ? explode('|', $opts->filters['type']) : $entityTypes;
$results = collect();
foreach ($entityTypesToSearch as $entityType) {
if (!in_array($entityType, $entityTypes)) {
continue;
}
- $search = $this->buildEntitySearchQuery($terms, $entityType)->where('book_id', '=', $bookId)->take(20)->get();
+ $search = $this->buildEntitySearchQuery($opts, $entityType)->where('book_id', '=', $bookId)->take(20)->get();
$results = $results->merge($search);
}
return $results->sortByDesc('score')->take(20);
/**
* Search a book for entities
- * @param integer $chapterId
- * @param string $searchString
- * @return Collection
*/
- public function searchChapter($chapterId, $searchString)
+ public function searchChapter(int $chapterId, string $searchString): Collection
{
- $terms = $this->parseSearchString($searchString);
- $pages = $this->buildEntitySearchQuery($terms, 'page')->where('chapter_id', '=', $chapterId)->take(20)->get();
+ $opts = SearchOptions::fromString($searchString);
+ $pages = $this->buildEntitySearchQuery($opts, 'page')->where('chapter_id', '=', $chapterId)->take(20)->get();
return $pages->sortByDesc('score');
}
/**
* Search across a particular entity type.
- * @param array $terms
- * @param string $entityType
- * @param int $page
- * @param int $count
- * @param string $action
- * @param bool $getCount Return the total count of the search
+ * Setting getCount = true will return the total
+ * matching instead of the items themselves.
* @return \Illuminate\Database\Eloquent\Collection|int|static[]
*/
- public function searchEntityTable($terms, $entityType = 'page', $page = 1, $count = 20, $action = 'view', $getCount = false)
+ public function searchEntityTable(SearchOptions $searchOpts, string $entityType = 'page', int $page = 1, int $count = 20, string $action = 'view', bool $getCount = false)
{
- $query = $this->buildEntitySearchQuery($terms, $entityType, $action);
+ $query = $this->buildEntitySearchQuery($searchOpts, $entityType, $action);
if ($getCount) {
return $query->count();
}
/**
* Create a search query for an entity
- * @param array $terms
- * @param string $entityType
- * @param string $action
- * @return \Illuminate\Database\Eloquent\Builder
*/
- protected function buildEntitySearchQuery($terms, $entityType = 'page', $action = 'view')
+ protected function buildEntitySearchQuery(SearchOptions $searchOpts, string $entityType = 'page', string $action = 'view'): EloquentBuilder
{
- $entity = $this->getEntity($entityType);
+ $entity = $this->entityProvider->get($entityType);
$entitySelect = $entity->newQuery();
// Handle normal search terms
- if (count($terms['search']) > 0) {
+ if (count($searchOpts->searches) > 0) {
$subQuery = $this->db->table('search_terms')->select('entity_id', 'entity_type', \DB::raw('SUM(score) as score'));
- $subQuery->where('entity_type', '=', 'BookStack\\' . ucfirst($entityType));
- $subQuery->where(function (Builder $query) use ($terms) {
- foreach ($terms['search'] as $inputTerm) {
+ $subQuery->where('entity_type', '=', $entity->getMorphClass());
+ $subQuery->where(function (Builder $query) use ($searchOpts) {
+ foreach ($searchOpts->searches as $inputTerm) {
$query->orWhere('term', 'like', $inputTerm .'%');
}
})->groupBy('entity_type', 'entity_id');
}
// Handle exact term matching
- if (count($terms['exact']) > 0) {
- $entitySelect->where(function (\Illuminate\Database\Eloquent\Builder $query) use ($terms, $entity) {
- foreach ($terms['exact'] as $inputTerm) {
- $query->where(function (\Illuminate\Database\Eloquent\Builder $query) use ($inputTerm, $entity) {
+ if (count($searchOpts->exacts) > 0) {
+ $entitySelect->where(function (EloquentBuilder $query) use ($searchOpts, $entity) {
+ foreach ($searchOpts->exacts as $inputTerm) {
+ $query->where(function (EloquentBuilder $query) use ($inputTerm, $entity) {
$query->where('name', 'like', '%'.$inputTerm .'%')
->orWhere($entity->textField, 'like', '%'.$inputTerm .'%');
});
}
// Handle tag searches
- foreach ($terms['tags'] as $inputTerm) {
+ foreach ($searchOpts->tags as $inputTerm) {
$this->applyTagSearch($entitySelect, $inputTerm);
}
// Handle filters
- foreach ($terms['filters'] as $filterTerm => $filterValue) {
- $functionName = camel_case('filter_' . $filterTerm);
+ foreach ($searchOpts->filters as $filterTerm => $filterValue) {
+ $functionName = Str::camel('filter_' . $filterTerm);
if (method_exists($this, $functionName)) {
$this->$functionName($entitySelect, $entity, $filterValue);
}
return $this->permissionService->enforceEntityRestrictions($entityType, $entitySelect, $action);
}
-
- /**
- * Parse a search string into components.
- * @param $searchString
- * @return array
- */
- protected function parseSearchString($searchString)
- {
- $terms = [
- 'search' => [],
- 'exact' => [],
- 'tags' => [],
- 'filters' => []
- ];
-
- $patterns = [
- 'exact' => '/"(.*?)"/',
- 'tags' => '/\[(.*?)\]/',
- 'filters' => '/\{(.*?)\}/'
- ];
-
- // Parse special terms
- foreach ($patterns as $termType => $pattern) {
- $matches = [];
- preg_match_all($pattern, $searchString, $matches);
- if (count($matches) > 0) {
- $terms[$termType] = $matches[1];
- $searchString = preg_replace($pattern, '', $searchString);
- }
- }
-
- // Parse standard terms
- foreach (explode(' ', trim($searchString)) as $searchTerm) {
- if ($searchTerm !== '') {
- $terms['search'][] = $searchTerm;
- }
- }
-
- // Split filter values out
- $splitFilters = [];
- foreach ($terms['filters'] as $filter) {
- $explodedFilter = explode(':', $filter, 2);
- $splitFilters[$explodedFilter[0]] = (count($explodedFilter) > 1) ? $explodedFilter[1] : '';
- }
- $terms['filters'] = $splitFilters;
-
- return $terms;
- }
-
/**
* Get the available query operators as a regex escaped list.
- * @return mixed
*/
- protected function getRegexEscapedOperators()
+ protected function getRegexEscapedOperators(): string
{
$escapedOperators = [];
foreach ($this->queryOperators as $operator) {
/**
* Apply a tag search term onto a entity query.
- * @param \Illuminate\Database\Eloquent\Builder $query
- * @param string $tagTerm
- * @return mixed
*/
- protected function applyTagSearch(\Illuminate\Database\Eloquent\Builder $query, $tagTerm)
+ protected function applyTagSearch(EloquentBuilder $query, string $tagTerm): EloquentBuilder
{
preg_match("/^(.*?)((".$this->getRegexEscapedOperators().")(.*?))?$/", $tagTerm, $tagSplit);
- $query->whereHas('tags', function (\Illuminate\Database\Eloquent\Builder $query) use ($tagSplit) {
+ $query->whereHas('tags', function (EloquentBuilder $query) use ($tagSplit) {
$tagName = $tagSplit[1];
$tagOperator = count($tagSplit) > 2 ? $tagSplit[3] : '';
$tagValue = count($tagSplit) > 3 ? $tagSplit[4] : '';
return $query;
}
- /**
- * Get an entity instance via type.
- * @param $type
- * @return Entity
- */
- protected function getEntity($type)
- {
- return $this->entities[strtolower($type)];
- }
-
/**
* Index the given entity.
- * @param Entity $entity
*/
public function indexEntity(Entity $entity)
{
{
$this->searchTerm->truncate();
- foreach ($this->entities as $entityModel) {
+ foreach ($this->entityProvider->all() as $entityModel) {
$selectFields = ['id', 'name', $entityModel->textField];
$entityModel->newQuery()->select($selectFields)->chunk(1000, function ($entities) {
$this->indexEntities($entities);
* Custom entity search filters
*/
- protected function filterUpdatedAfter(\Illuminate\Database\Eloquent\Builder $query, Entity $model, $input)
+ protected function filterUpdatedAfter(EloquentBuilder $query, Entity $model, $input)
{
try {
$date = date_create($input);
$query->where('updated_at', '>=', $date);
}
- protected function filterUpdatedBefore(\Illuminate\Database\Eloquent\Builder $query, Entity $model, $input)
+ protected function filterUpdatedBefore(EloquentBuilder $query, Entity $model, $input)
{
try {
$date = date_create($input);
$query->where('updated_at', '<', $date);
}
- protected function filterCreatedAfter(\Illuminate\Database\Eloquent\Builder $query, Entity $model, $input)
+ protected function filterCreatedAfter(EloquentBuilder $query, Entity $model, $input)
{
try {
$date = date_create($input);
$query->where('created_at', '>=', $date);
}
- protected function filterCreatedBefore(\Illuminate\Database\Eloquent\Builder $query, Entity $model, $input)
+ protected function filterCreatedBefore(EloquentBuilder $query, Entity $model, $input)
{
try {
$date = date_create($input);
$query->where('created_at', '<', $date);
}
- protected function filterCreatedBy(\Illuminate\Database\Eloquent\Builder $query, Entity $model, $input)
+ protected function filterCreatedBy(EloquentBuilder $query, Entity $model, $input)
{
if (!is_numeric($input) && $input !== 'me') {
return;
$query->where('created_by', '=', $input);
}
- protected function filterUpdatedBy(\Illuminate\Database\Eloquent\Builder $query, Entity $model, $input)
+ protected function filterUpdatedBy(EloquentBuilder $query, Entity $model, $input)
{
if (!is_numeric($input) && $input !== 'me') {
return;
$query->where('updated_by', '=', $input);
}
- protected function filterInName(\Illuminate\Database\Eloquent\Builder $query, Entity $model, $input)
+ protected function filterInName(EloquentBuilder $query, Entity $model, $input)
{
$query->where('name', 'like', '%' .$input. '%');
}
- protected function filterInTitle(\Illuminate\Database\Eloquent\Builder $query, Entity $model, $input)
+ protected function filterInTitle(EloquentBuilder $query, Entity $model, $input)
{
$this->filterInName($query, $model, $input);
}
- protected function filterInBody(\Illuminate\Database\Eloquent\Builder $query, Entity $model, $input)
+ protected function filterInBody(EloquentBuilder $query, Entity $model, $input)
{
$query->where($model->textField, 'like', '%' .$input. '%');
}
- protected function filterIsRestricted(\Illuminate\Database\Eloquent\Builder $query, Entity $model, $input)
+ protected function filterIsRestricted(EloquentBuilder $query, Entity $model, $input)
{
$query->where('restricted', '=', true);
}
- protected function filterViewedByMe(\Illuminate\Database\Eloquent\Builder $query, Entity $model, $input)
+ protected function filterViewedByMe(EloquentBuilder $query, Entity $model, $input)
{
$query->whereHas('views', function ($query) {
$query->where('user_id', '=', user()->id);
});
}
- protected function filterNotViewedByMe(\Illuminate\Database\Eloquent\Builder $query, Entity $model, $input)
+ protected function filterNotViewedByMe(EloquentBuilder $query, Entity $model, $input)
{
$query->whereDoesntHave('views', function ($query) {
$query->where('user_id', '=', user()->id);
});
}
- protected function filterSortBy(\Illuminate\Database\Eloquent\Builder $query, Entity $model, $input)
+ protected function filterSortBy(EloquentBuilder $query, Entity $model, $input)
{
- $functionName = camel_case('sort_by_' . $input);
+ $functionName = Str::camel('sort_by_' . $input);
if (method_exists($this, $functionName)) {
$this->$functionName($query, $model);
}
* Sorting filter options
*/
- protected function sortByLastCommented(\Illuminate\Database\Eloquent\Builder $query, Entity $model)
+ protected function sortByLastCommented(EloquentBuilder $query, Entity $model)
{
$commentsTable = $this->db->getTablePrefix() . 'comments';
$morphClass = str_replace('\\', '\\\\', $model->getMorphClass());
projects / bookstack / blobdiff