wingsline / laravel-blog

src/Posts/Post.php

<?php

namespace Wingsline\Blog\Posts;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Auth;
use Spatie\Feed\Feedable;
use Spatie\Feed\FeedItem;
use Spatie\MediaLibrary\HasMedia;
use Spatie\MediaLibrary\InteractsWithMedia;
use Spatie\Sluggable\HasSlug;

The type Spatie\Sluggable\HasSlug was not found. Maybe you did not declare it correctly or list all dependencies?

use Spatie\Sluggable\SlugOptions;
use Spatie\Tags\HasTags;
use Wingsline\Blog\Markdown\Markdown;

class Post extends Model implements Feedable, HasMedia
{
    use HasSlug;
    use HasTags;
    use InteractsWithMedia;
    use PostPresenter;

    public $casts = [
        'text' => '',
        'published' => 'boolean',
        'original_content' => 'boolean',
    ];

    public $dates = ['publish_date'];
    public $with = ['tags'];

    /**
     * The table associated with the model.
     *
     * @var string
     */
    protected $table = 'posts';

    public static function getFeedItems()
    {
        return static::published()
            ->public()
            ->orderBy('publish_date', 'desc')
            ->limit(100)
            ->get();
    }

    /**
     * Markdown accessor.
     *
     * @return string
     */
    public function getMarkdownAttribute()
    {
        return $this->getRawOriginal('text');

The expression return $this->getRawOriginal('text') also could return the type array which is incompatible with the documented return type string.

    }

    /**
     * Slug options.
     */
    public function getSlugOptions(): SlugOptions
    {
        return SlugOptions::create()
            ->generateSlugsFrom('title')
            ->saveSlugsTo('slug');
    }

    /**
     * Text accessor.
     *
     * @param string $original
     *
     * @return string
     */
    public function getTextAttribute($original)
    {
        return Markdown::convertWithParser($original);
    }

    public function scopePublic(Builder $query)
    {
        $query->where('publish_date', '<=', now());
    }

    public function scopePublished(Builder $query)
    {
        $query->where('published', true);
    }

    /**
     * @return array|\Spatie\Feed\FeedItem
     */
    public function toFeedItem()
    {
        return FeedItem::create()
            ->id($this->id)
            ->title($this->formatted_title)

The property formatted_title does not exist on Wingsline\Blog\Posts\Post. Did you maybe forget to declare it?

            ->summary($this->text)
            ->updated($this->publish_date)
            ->link($this->url)

The property url does not exist on Wingsline\Blog\Posts\Post. Did you maybe forget to declare it?

            ->author($this->author);
    }

    /**
     * Update model attributes from the form.
     *
     * @return static
     */
    public function updateAttributes(array $attributes)
    {
        $this->title = $attributes['title'];

The property title does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->text = $attributes['text'];

The property text does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->publish_date = $attributes['publish_date'];

The property publish_date does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->published = $attributes['published'] ?? false;

The property published does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->original_content = $attributes['original_content'] ?? false;

The property original_content does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->external_url = $attributes['external_url'];

The property external_url does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->author = Auth::user()->name;

Accessing name on the interface Illuminate\Contracts\Auth\Authenticatable suggest that you code against a concrete implementation. How about adding an instanceof check?

The property author does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->save();

        if ($attributes['tags_text']) {
            $tags = array_map(function (string $tag) {
                return trim(strtolower($tag));
            }, explode(',', $attributes['tags_text']));

            $this->syncTags($tags);
        }

        return $this;
    }
}