mirror of
https://github.com/godotengine/godot-website.git
synced 2026-01-04 06:09:55 +03:00
539 lines
15 KiB
PHP
539 lines
15 KiB
PHP
<?php namespace RainLab\Blog\Models;
|
|
|
|
use Db;
|
|
use Url;
|
|
use App;
|
|
use Str;
|
|
use Html;
|
|
use Lang;
|
|
use Model;
|
|
use Markdown;
|
|
use BackendAuth;
|
|
use ValidationException;
|
|
use RainLab\Blog\Classes\TagProcessor;
|
|
use Backend\Models\User;
|
|
use Carbon\Carbon;
|
|
use Cms\Classes\Page as CmsPage;
|
|
use Cms\Classes\Theme;
|
|
|
|
class Post extends Model
|
|
{
|
|
use \October\Rain\Database\Traits\Validation;
|
|
|
|
public $table = 'rainlab_blog_posts';
|
|
public $implement = ['@RainLab.Translate.Behaviors.TranslatableModel'];
|
|
|
|
/*
|
|
* Validation
|
|
*/
|
|
public $rules = [
|
|
'title' => 'required',
|
|
'slug' => ['required', 'regex:/^[a-z0-9\/\:_\-\*\[\]\+\?\|]*$/i', 'unique:rainlab_blog_posts'],
|
|
'content' => 'required',
|
|
'excerpt' => ''
|
|
];
|
|
|
|
/**
|
|
* @var array Attributes that support translation, if available.
|
|
*/
|
|
public $translatable = [
|
|
'title',
|
|
'content',
|
|
'content_html',
|
|
'excerpt',
|
|
['slug', 'index' => true]
|
|
];
|
|
|
|
/**
|
|
* The attributes that should be mutated to dates.
|
|
* @var array
|
|
*/
|
|
protected $dates = ['published_at'];
|
|
|
|
/**
|
|
* The attributes on which the post list can be ordered
|
|
* @var array
|
|
*/
|
|
public static $allowedSortingOptions = [
|
|
'title asc' => 'Title (ascending)',
|
|
'title desc' => 'Title (descending)',
|
|
'created_at asc' => 'Created (ascending)',
|
|
'created_at desc' => 'Created (descending)',
|
|
'updated_at asc' => 'Updated (ascending)',
|
|
'updated_at desc' => 'Updated (descending)',
|
|
'published_at asc' => 'Published (ascending)',
|
|
'published_at desc' => 'Published (descending)',
|
|
'random' => 'Random'
|
|
];
|
|
|
|
/*
|
|
* Relations
|
|
*/
|
|
public $belongsTo = [
|
|
'user' => ['Backend\Models\User']
|
|
];
|
|
|
|
public $belongsToMany = [
|
|
'categories' => [
|
|
'RainLab\Blog\Models\Category',
|
|
'table' => 'rainlab_blog_posts_categories',
|
|
'order' => 'name'
|
|
]
|
|
];
|
|
|
|
public $attachMany = [
|
|
'featured_images' => ['System\Models\File', 'order' => 'sort_order'],
|
|
'content_images' => ['System\Models\File']
|
|
];
|
|
|
|
/**
|
|
* @var array The accessors to append to the model's array form.
|
|
*/
|
|
protected $appends = ['summary', 'has_summary'];
|
|
|
|
public $preview = null;
|
|
|
|
/**
|
|
* Limit visibility of the published-button
|
|
* @return void
|
|
*/
|
|
public function filterFields($fields, $context = null)
|
|
{
|
|
if (!isset($fields->published, $fields->published_at)) {
|
|
return;
|
|
}
|
|
|
|
$user = BackendAuth::getUser();
|
|
|
|
if (!$user->hasAnyAccess(['rainlab.blog.access_publish'])) {
|
|
$fields->published->hidden = true;
|
|
$fields->published_at->hidden = true;
|
|
}
|
|
else {
|
|
$fields->published->hidden = false;
|
|
$fields->published_at->hidden = false;
|
|
}
|
|
}
|
|
|
|
public function afterValidate()
|
|
{
|
|
if ($this->published && !$this->published_at) {
|
|
throw new ValidationException([
|
|
'published_at' => Lang::get('rainlab.blog::lang.post.published_validation')
|
|
]);
|
|
}
|
|
}
|
|
|
|
public function beforeSave()
|
|
{
|
|
$this->content_html = self::formatHtml($this->content);
|
|
}
|
|
|
|
/**
|
|
* Sets the "url" attribute with a URL to this object
|
|
* @param string $pageName
|
|
* @param Cms\Classes\Controller $controller
|
|
*/
|
|
public function setUrl($pageName, $controller)
|
|
{
|
|
$params = [
|
|
'id' => $this->id,
|
|
'slug' => $this->slug,
|
|
];
|
|
|
|
if (array_key_exists('categories', $this->getRelations())) {
|
|
$params['category'] = $this->categories->count() ? $this->categories->first()->slug : null;
|
|
}
|
|
|
|
//expose published year, month and day as URL parameters
|
|
if ($this->published) {
|
|
$params['year'] = $this->published_at->format('Y');
|
|
$params['month'] = $this->published_at->format('m');
|
|
$params['day'] = $this->published_at->format('d');
|
|
}
|
|
|
|
return $this->url = $controller->pageUrl($pageName, $params);
|
|
}
|
|
|
|
/**
|
|
* Used to test if a certain user has permission to edit post,
|
|
* returns TRUE if the user is the owner or has other posts access.
|
|
* @param User $user
|
|
* @return bool
|
|
*/
|
|
public function canEdit(User $user)
|
|
{
|
|
return ($this->user_id == $user->id) || $user->hasAnyAccess(['rainlab.blog.access_other_posts']);
|
|
}
|
|
|
|
public static function formatHtml($input, $preview = false)
|
|
{
|
|
$result = Markdown::parse(trim($input));
|
|
|
|
if ($preview) {
|
|
$result = str_replace('<pre>', '<pre class="prettyprint">', $result);
|
|
}
|
|
|
|
$result = TagProcessor::instance()->processTags($result, $preview);
|
|
|
|
return $result;
|
|
}
|
|
|
|
//
|
|
// Scopes
|
|
//
|
|
|
|
public function scopeIsPublished($query)
|
|
{
|
|
return $query
|
|
->whereNotNull('published')
|
|
->where('published', true)
|
|
->whereNotNull('published_at')
|
|
->where('published_at', '<', Carbon::now())
|
|
;
|
|
}
|
|
|
|
/**
|
|
* Lists posts for the front end
|
|
* @param array $options Display options
|
|
* @return self
|
|
*/
|
|
public function scopeListFrontEnd($query, $options)
|
|
{
|
|
/*
|
|
* Default options
|
|
*/
|
|
extract(array_merge([
|
|
'page' => 1,
|
|
'perPage' => 30,
|
|
'sort' => 'created_at',
|
|
'categories' => null,
|
|
'category' => null,
|
|
'search' => '',
|
|
'published' => true,
|
|
'exceptPost' => null,
|
|
], $options));
|
|
|
|
$searchableFields = ['title', 'slug', 'excerpt', 'content'];
|
|
|
|
if ($published) {
|
|
$query->isPublished();
|
|
}
|
|
|
|
/*
|
|
* Ignore a post
|
|
*/
|
|
if ($exceptPost) {
|
|
if (is_numeric($exceptPost)) {
|
|
$query->where('id', '<>', $exceptPost);
|
|
}
|
|
else {
|
|
$query->where('slug', '<>', $exceptPost);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Sorting
|
|
*/
|
|
if (!is_array($sort)) {
|
|
$sort = [$sort];
|
|
}
|
|
|
|
foreach ($sort as $_sort) {
|
|
|
|
if (in_array($_sort, array_keys(self::$allowedSortingOptions))) {
|
|
$parts = explode(' ', $_sort);
|
|
if (count($parts) < 2) {
|
|
array_push($parts, 'desc');
|
|
}
|
|
list($sortField, $sortDirection) = $parts;
|
|
if ($sortField == 'random') {
|
|
$sortField = Db::raw('RAND()');
|
|
}
|
|
$query->orderBy($sortField, $sortDirection);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Search
|
|
*/
|
|
$search = trim($search);
|
|
if (strlen($search)) {
|
|
$query->searchWhere($search, $searchableFields);
|
|
}
|
|
|
|
/*
|
|
* Categories
|
|
*/
|
|
if ($categories !== null) {
|
|
if (!is_array($categories)) $categories = [$categories];
|
|
$query->whereHas('categories', function($q) use ($categories) {
|
|
$q->whereIn('id', $categories);
|
|
});
|
|
}
|
|
|
|
/*
|
|
* Category, including children
|
|
*/
|
|
if ($category !== null) {
|
|
$category = Category::find($category);
|
|
|
|
$categories = $category->getAllChildrenAndSelf()->lists('id');
|
|
$query->whereHas('categories', function($q) use ($categories) {
|
|
$q->whereIn('id', $categories);
|
|
});
|
|
}
|
|
|
|
return $query->paginate($perPage, $page);
|
|
}
|
|
|
|
/**
|
|
* Allows filtering for specifc categories
|
|
* @param Illuminate\Query\Builder $query QueryBuilder
|
|
* @param array $categories List of category ids
|
|
* @return Illuminate\Query\Builder QueryBuilder
|
|
*/
|
|
public function scopeFilterCategories($query, $categories)
|
|
{
|
|
return $query->whereHas('categories', function($q) use ($categories) {
|
|
$q->whereIn('id', $categories);
|
|
});
|
|
}
|
|
|
|
//
|
|
// Summary / Excerpt
|
|
//
|
|
|
|
/**
|
|
* Used by "has_summary", returns true if this post uses a summary (more tag)
|
|
* @return boolean
|
|
*/
|
|
public function getHasSummaryAttribute()
|
|
{
|
|
$more = '<!-- more -->';
|
|
|
|
return (
|
|
!!strlen(trim($this->excerpt)) ||
|
|
strpos($this->content_html, $more) !== false ||
|
|
strlen(Html::strip($this->content_html)) > 600
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Used by "summary", if no excerpt is provided, generate one from the content.
|
|
* Returns the HTML content before the <!-- more --> tag or a limited 600
|
|
* character version.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getSummaryAttribute()
|
|
{
|
|
$excerpt = $this->excerpt;
|
|
if (strlen(trim($excerpt))) {
|
|
return $excerpt;
|
|
}
|
|
|
|
$more = '<!-- more -->';
|
|
if (strpos($this->content_html, $more) !== false) {
|
|
$parts = explode($more, $this->content_html);
|
|
return array_get($parts, 0);
|
|
}
|
|
|
|
return Html::limit($this->content_html, 600);
|
|
}
|
|
|
|
//
|
|
// Next / Previous
|
|
//
|
|
|
|
/**
|
|
* Returns the next post, if available.
|
|
* @return self
|
|
*/
|
|
public function nextPost()
|
|
{
|
|
return self::isPublished()
|
|
->where('id', '>' , $this->id)
|
|
->orderBy('id', 'asc')
|
|
->first()
|
|
;
|
|
}
|
|
|
|
/**
|
|
* Returns the previous post, if available.
|
|
* @return self
|
|
*/
|
|
public function previousPost()
|
|
{
|
|
return self::isPublished()
|
|
->where('id', '<' , $this->id)
|
|
->orderBy('id', 'desc')
|
|
->first()
|
|
;
|
|
}
|
|
|
|
//
|
|
// Menu helpers
|
|
//
|
|
|
|
/**
|
|
* Handler for the pages.menuitem.getTypeInfo event.
|
|
* Returns a menu item type information. The type information is returned as array
|
|
* with the following elements:
|
|
* - references - a list of the item type reference options. The options are returned in the
|
|
* ["key"] => "title" format for options that don't have sub-options, and in the format
|
|
* ["key"] => ["title"=>"Option title", "items"=>[...]] for options that have sub-options. Optional,
|
|
* required only if the menu item type requires references.
|
|
* - nesting - Boolean value indicating whether the item type supports nested items. Optional,
|
|
* false if omitted.
|
|
* - dynamicItems - Boolean value indicating whether the item type could generate new menu items.
|
|
* Optional, false if omitted.
|
|
* - cmsPages - a list of CMS pages (objects of the Cms\Classes\Page class), if the item type requires a CMS page reference to
|
|
* resolve the item URL.
|
|
* @param string $type Specifies the menu item type
|
|
* @return array Returns an array
|
|
*/
|
|
public static function getMenuTypeInfo($type)
|
|
{
|
|
$result = [];
|
|
|
|
if ($type == 'blog-post') {
|
|
|
|
$references = [];
|
|
$posts = self::orderBy('title')->get();
|
|
foreach ($posts as $post) {
|
|
$references[$post->id] = $post->title;
|
|
}
|
|
|
|
$result = [
|
|
'references' => $references,
|
|
'nesting' => false,
|
|
'dynamicItems' => false
|
|
];
|
|
}
|
|
|
|
if ($type == 'all-blog-posts') {
|
|
$result = [
|
|
'dynamicItems' => true
|
|
];
|
|
}
|
|
|
|
if ($result) {
|
|
$theme = Theme::getActiveTheme();
|
|
|
|
$pages = CmsPage::listInTheme($theme, true);
|
|
$cmsPages = [];
|
|
|
|
foreach ($pages as $page) {
|
|
if (!$page->hasComponent('blogPost')) {
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* Component must use a categoryPage filter with a routing parameter and post slug
|
|
* eg: categoryPage = "{{ :somevalue }}", slug = "{{ :somevalue }}"
|
|
*/
|
|
$properties = $page->getComponentProperties('blogPost');
|
|
if (!isset($properties['categoryPage']) || !preg_match('/{{\s*:/', $properties['slug'])) {
|
|
continue;
|
|
}
|
|
|
|
$cmsPages[] = $page;
|
|
}
|
|
|
|
$result['cmsPages'] = $cmsPages;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Handler for the pages.menuitem.resolveItem event.
|
|
* Returns information about a menu item. The result is an array
|
|
* with the following keys:
|
|
* - url - the menu item URL. Not required for menu item types that return all available records.
|
|
* The URL should be returned relative to the website root and include the subdirectory, if any.
|
|
* Use the Url::to() helper to generate the URLs.
|
|
* - isActive - determines whether the menu item is active. Not required for menu item types that
|
|
* return all available records.
|
|
* - items - an array of arrays with the same keys (url, isActive, items) + the title key.
|
|
* The items array should be added only if the $item's $nesting property value is TRUE.
|
|
* @param \RainLab\Pages\Classes\MenuItem $item Specifies the menu item.
|
|
* @param \Cms\Classes\Theme $theme Specifies the current theme.
|
|
* @param string $url Specifies the current page URL, normalized, in lower case
|
|
* The URL is specified relative to the website root, it includes the subdirectory name, if any.
|
|
* @return mixed Returns an array. Returns null if the item cannot be resolved.
|
|
*/
|
|
public static function resolveMenuItem($item, $url, $theme)
|
|
{
|
|
$result = null;
|
|
|
|
if ($item->type == 'blog-post') {
|
|
if (!$item->reference || !$item->cmsPage)
|
|
return;
|
|
|
|
$category = self::find($item->reference);
|
|
if (!$category)
|
|
return;
|
|
|
|
$pageUrl = self::getPostPageUrl($item->cmsPage, $category, $theme);
|
|
if (!$pageUrl)
|
|
return;
|
|
|
|
$pageUrl = Url::to($pageUrl);
|
|
|
|
$result = [];
|
|
$result['url'] = $pageUrl;
|
|
$result['isActive'] = $pageUrl == $url;
|
|
$result['mtime'] = $category->updated_at;
|
|
}
|
|
elseif ($item->type == 'all-blog-posts') {
|
|
$result = [
|
|
'items' => []
|
|
];
|
|
|
|
$posts = self::orderBy('title')->get();
|
|
foreach ($posts as $post) {
|
|
$postItem = [
|
|
'title' => $post->title,
|
|
'url' => self::getPostPageUrl($item->cmsPage, $post, $theme),
|
|
'mtime' => $post->updated_at,
|
|
];
|
|
|
|
$postItem['isActive'] = $postItem['url'] == $url;
|
|
|
|
$result['items'][] = $postItem;
|
|
}
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Returns URL of a post page.
|
|
*/
|
|
protected static function getPostPageUrl($pageCode, $category, $theme)
|
|
{
|
|
$page = CmsPage::loadCached($theme, $pageCode);
|
|
if (!$page) return;
|
|
|
|
$properties = $page->getComponentProperties('blogPost');
|
|
if (!isset($properties['slug'])) {
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Extract the routing parameter name from the category filter
|
|
* eg: {{ :someRouteParam }}
|
|
*/
|
|
if (!preg_match('/^\{\{([^\}]+)\}\}$/', $properties['slug'], $matches)) {
|
|
return;
|
|
}
|
|
|
|
$paramName = substr(trim($matches[1]), 1);
|
|
$url = CmsPage::url($page->getBaseFileName(), [$paramName => $category->slug]);
|
|
|
|
return $url;
|
|
}
|
|
}
|